1 | "use strict";
|
2 | var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
|
3 | if (k2 === undefined) k2 = k;
|
4 | Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
|
5 | }) : (function(o, m, k, k2) {
|
6 | if (k2 === undefined) k2 = k;
|
7 | o[k2] = m[k];
|
8 | }));
|
9 | var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
|
10 | Object.defineProperty(o, "default", { enumerable: true, value: v });
|
11 | }) : function(o, v) {
|
12 | o["default"] = v;
|
13 | });
|
14 | var __importStar = (this && this.__importStar) || function (mod) {
|
15 | if (mod && mod.__esModule) return mod;
|
16 | var result = {};
|
17 | if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
|
18 | __setModuleDefault(result, mod);
|
19 | return result;
|
20 | };
|
21 | Object.defineProperty(exports, "__esModule", { value: true });
|
22 | const utils_1 = require("@typescript-eslint/utils");
|
23 | const ts = __importStar(require("typescript"));
|
24 | const util = __importStar(require("../util"));
|
25 | var Usefulness;
|
26 | (function (Usefulness) {
|
27 | Usefulness[Usefulness["Always"] = 0] = "Always";
|
28 | Usefulness["Never"] = "will";
|
29 | Usefulness["Sometimes"] = "may";
|
30 | })(Usefulness || (Usefulness = {}));
|
31 | exports.default = util.createRule({
|
32 | name: 'no-base-to-string',
|
33 | meta: {
|
34 | docs: {
|
35 | description: 'Requires that `.toString()` is only called on objects which provide useful information when stringified',
|
36 | recommended: false,
|
37 | requiresTypeChecking: true,
|
38 | },
|
39 | messages: {
|
40 | baseToString: "'{{name}} {{certainty}} evaluate to '[object Object]' when stringified.",
|
41 | },
|
42 | schema: [
|
43 | {
|
44 | type: 'object',
|
45 | properties: {
|
46 | ignoredTypeNames: {
|
47 | type: 'array',
|
48 | items: {
|
49 | type: 'string',
|
50 | },
|
51 | },
|
52 | },
|
53 | additionalProperties: false,
|
54 | },
|
55 | ],
|
56 | type: 'suggestion',
|
57 | },
|
58 | defaultOptions: [
|
59 | {
|
60 | ignoredTypeNames: ['RegExp'],
|
61 | },
|
62 | ],
|
63 | create(context, [option]) {
|
64 | var _a;
|
65 | const parserServices = util.getParserServices(context);
|
66 | const typeChecker = parserServices.program.getTypeChecker();
|
67 | const ignoredTypeNames = (_a = option.ignoredTypeNames) !== null && _a !== void 0 ? _a : [];
|
68 | function checkExpression(node, type) {
|
69 | if (node.type === utils_1.AST_NODE_TYPES.Literal) {
|
70 | return;
|
71 | }
|
72 | const certainty = collectToStringCertainty(type !== null && type !== void 0 ? type : typeChecker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(node)));
|
73 | if (certainty === Usefulness.Always) {
|
74 | return;
|
75 | }
|
76 | context.report({
|
77 | data: {
|
78 | certainty,
|
79 | name: context.getSourceCode().getText(node),
|
80 | },
|
81 | messageId: 'baseToString',
|
82 | node,
|
83 | });
|
84 | }
|
85 | function collectToStringCertainty(type) {
|
86 | const toString = typeChecker.getPropertyOfType(type, 'toString');
|
87 | const declarations = toString === null || toString === void 0 ? void 0 : toString.getDeclarations();
|
88 | if (!toString || !declarations || declarations.length === 0) {
|
89 | return Usefulness.Always;
|
90 | }
|
91 |
|
92 | if (type.flags & ts.TypeFlags.Boolean ||
|
93 | type.flags & ts.TypeFlags.BooleanLiteral) {
|
94 | return Usefulness.Always;
|
95 | }
|
96 | if (ignoredTypeNames.includes(util.getTypeName(typeChecker, type))) {
|
97 | return Usefulness.Always;
|
98 | }
|
99 | if (declarations.every(({ parent }) => !ts.isInterfaceDeclaration(parent) || parent.name.text !== 'Object')) {
|
100 | return Usefulness.Always;
|
101 | }
|
102 | if (type.isIntersection()) {
|
103 | for (const subType of type.types) {
|
104 | const subtypeUsefulness = collectToStringCertainty(subType);
|
105 | if (subtypeUsefulness === Usefulness.Always) {
|
106 | return Usefulness.Always;
|
107 | }
|
108 | }
|
109 | return Usefulness.Never;
|
110 | }
|
111 | if (!type.isUnion()) {
|
112 | return Usefulness.Never;
|
113 | }
|
114 | let allSubtypesUseful = true;
|
115 | let someSubtypeUseful = false;
|
116 | for (const subType of type.types) {
|
117 | const subtypeUsefulness = collectToStringCertainty(subType);
|
118 | if (subtypeUsefulness !== Usefulness.Always && allSubtypesUseful) {
|
119 | allSubtypesUseful = false;
|
120 | }
|
121 | if (subtypeUsefulness !== Usefulness.Never && !someSubtypeUseful) {
|
122 | someSubtypeUseful = true;
|
123 | }
|
124 | }
|
125 | if (allSubtypesUseful && someSubtypeUseful) {
|
126 | return Usefulness.Always;
|
127 | }
|
128 | if (someSubtypeUseful) {
|
129 | return Usefulness.Sometimes;
|
130 | }
|
131 | return Usefulness.Never;
|
132 | }
|
133 | return {
|
134 | 'AssignmentExpression[operator = "+="], BinaryExpression[operator = "+"]'(node) {
|
135 | const leftType = typeChecker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(node.left));
|
136 | const rightType = typeChecker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(node.right));
|
137 | if (util.getTypeName(typeChecker, leftType) === 'string') {
|
138 | checkExpression(node.right, rightType);
|
139 | }
|
140 | else if (util.getTypeName(typeChecker, rightType) === 'string' &&
|
141 | node.left.type !== utils_1.AST_NODE_TYPES.PrivateIdentifier) {
|
142 | checkExpression(node.left, leftType);
|
143 | }
|
144 | },
|
145 | 'CallExpression > MemberExpression.callee > Identifier[name = "toString"].property'(node) {
|
146 | const memberExpr = node.parent;
|
147 | checkExpression(memberExpr.object);
|
148 | },
|
149 | TemplateLiteral(node) {
|
150 | if (node.parent &&
|
151 | node.parent.type === utils_1.AST_NODE_TYPES.TaggedTemplateExpression) {
|
152 | return;
|
153 | }
|
154 | for (const expression of node.expressions) {
|
155 | checkExpression(expression);
|
156 | }
|
157 | },
|
158 | };
|
159 | },
|
160 | });
|
161 |
|
\ | No newline at end of file |