1 | /**
|
2 | * @fileoverview Common utils for AST.
|
3 | * @author Gyandeep Singh
|
4 | */
|
5 |
|
6 | ;
|
7 |
|
8 | //------------------------------------------------------------------------------
|
9 | // Requirements
|
10 | //------------------------------------------------------------------------------
|
11 |
|
12 | const esutils = require("esutils");
|
13 | const espree = require("espree");
|
14 | const lodash = require("lodash");
|
15 | const {
|
16 | breakableTypePattern,
|
17 | createGlobalLinebreakMatcher,
|
18 | lineBreakPattern,
|
19 | shebangPattern
|
20 | } = require("../../shared/ast-utils");
|
21 |
|
22 | //------------------------------------------------------------------------------
|
23 | // Helpers
|
24 | //------------------------------------------------------------------------------
|
25 |
|
26 | const anyFunctionPattern = /^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression)$/u;
|
27 | const anyLoopPattern = /^(?:DoWhile|For|ForIn|ForOf|While)Statement$/u;
|
28 | const arrayOrTypedArrayPattern = /Array$/u;
|
29 | const arrayMethodPattern = /^(?:every|filter|find|findIndex|forEach|map|some)$/u;
|
30 | const bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/u;
|
31 | const thisTagPattern = /^[\s*]*@this/mu;
|
32 |
|
33 |
|
34 | const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u;
|
35 | const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]);
|
36 |
|
37 | // A set of node types that can contain a list of statements
|
38 | const STATEMENT_LIST_PARENTS = new Set(["Program", "BlockStatement", "SwitchCase"]);
|
39 |
|
40 | const DECIMAL_INTEGER_PATTERN = /^(?:0|0[0-7]*[89]\d*|[1-9](?:_?\d)*)$/u;
|
41 |
|
42 | // Tests the presence of at least one LegacyOctalEscapeSequence or NonOctalDecimalEscapeSequence in a raw string
|
43 | const OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN = /^(?:[^\\]|\\.)*\\(?:[1-9]|0[0-9])/su;
|
44 |
|
45 | const LOGICAL_ASSIGNMENT_OPERATORS = new Set(["&&=", "||=", "??="]);
|
46 |
|
47 | /**
|
48 | * Checks reference if is non initializer and writable.
|
49 | * @param {Reference} reference A reference to check.
|
50 | * @param {int} index The index of the reference in the references.
|
51 | * @param {Reference[]} references The array that the reference belongs to.
|
52 | * @returns {boolean} Success/Failure
|
53 | * @private
|
54 | */
|
55 | function isModifyingReference(reference, index, references) {
|
56 | const identifier = reference.identifier;
|
57 |
|
58 | /*
|
59 | * Destructuring assignments can have multiple default value, so
|
60 | * possibly there are multiple writeable references for the same
|
61 | * identifier.
|
62 | */
|
63 | const modifyingDifferentIdentifier = index === 0 ||
|
64 | references[index - 1].identifier !== identifier;
|
65 |
|
66 | return (identifier &&
|
67 | reference.init === false &&
|
68 | reference.isWrite() &&
|
69 | modifyingDifferentIdentifier
|
70 | );
|
71 | }
|
72 |
|
73 | /**
|
74 | * Checks whether the given string starts with uppercase or not.
|
75 | * @param {string} s The string to check.
|
76 | * @returns {boolean} `true` if the string starts with uppercase.
|
77 | */
|
78 | function startsWithUpperCase(s) {
|
79 | return s[0] !== s[0].toLocaleLowerCase();
|
80 | }
|
81 |
|
82 | /**
|
83 | * Checks whether or not a node is a constructor.
|
84 | * @param {ASTNode} node A function node to check.
|
85 | * @returns {boolean} Whether or not a node is a constructor.
|
86 | */
|
87 | function isES5Constructor(node) {
|
88 | return (node.id && startsWithUpperCase(node.id.name));
|
89 | }
|
90 |
|
91 | /**
|
92 | * Finds a function node from ancestors of a node.
|
93 | * @param {ASTNode} node A start node to find.
|
94 | * @returns {Node|null} A found function node.
|
95 | */
|
96 | function getUpperFunction(node) {
|
97 | for (let currentNode = node; currentNode; currentNode = currentNode.parent) {
|
98 | if (anyFunctionPattern.test(currentNode.type)) {
|
99 | return currentNode;
|
100 | }
|
101 | }
|
102 | return null;
|
103 | }
|
104 |
|
105 | /**
|
106 | * Checks whether a given node is a function node or not.
|
107 | * The following types are function nodes:
|
108 | *
|
109 | * - ArrowFunctionExpression
|
110 | * - FunctionDeclaration
|
111 | * - FunctionExpression
|
112 | * @param {ASTNode|null} node A node to check.
|
113 | * @returns {boolean} `true` if the node is a function node.
|
114 | */
|
115 | function isFunction(node) {
|
116 | return Boolean(node && anyFunctionPattern.test(node.type));
|
117 | }
|
118 |
|
119 | /**
|
120 | * Checks whether a given node is a loop node or not.
|
121 | * The following types are loop nodes:
|
122 | *
|
123 | * - DoWhileStatement
|
124 | * - ForInStatement
|
125 | * - ForOfStatement
|
126 | * - ForStatement
|
127 | * - WhileStatement
|
128 | * @param {ASTNode|null} node A node to check.
|
129 | * @returns {boolean} `true` if the node is a loop node.
|
130 | */
|
131 | function isLoop(node) {
|
132 | return Boolean(node && anyLoopPattern.test(node.type));
|
133 | }
|
134 |
|
135 | /**
|
136 | * Checks whether the given node is in a loop or not.
|
137 | * @param {ASTNode} node The node to check.
|
138 | * @returns {boolean} `true` if the node is in a loop.
|
139 | */
|
140 | function isInLoop(node) {
|
141 | for (let currentNode = node; currentNode && !isFunction(currentNode); currentNode = currentNode.parent) {
|
142 | if (isLoop(currentNode)) {
|
143 | return true;
|
144 | }
|
145 | }
|
146 |
|
147 | return false;
|
148 | }
|
149 |
|
150 | /**
|
151 | * Determines whether the given node is a `null` literal.
|
152 | * @param {ASTNode} node The node to check
|
153 | * @returns {boolean} `true` if the node is a `null` literal
|
154 | */
|
155 | function isNullLiteral(node) {
|
156 |
|
157 | /*
|
158 | * Checking `node.value === null` does not guarantee that a literal is a null literal.
|
159 | * When parsing values that cannot be represented in the current environment (e.g. unicode
|
160 | * regexes in Node 4), `node.value` is set to `null` because it wouldn't be possible to
|
161 | * set `node.value` to a unicode regex. To make sure a literal is actually `null`, check
|
162 | * `node.regex` instead. Also see: https://github.com/eslint/eslint/issues/8020
|
163 | */
|
164 | return node.type === "Literal" && node.value === null && !node.regex && !node.bigint;
|
165 | }
|
166 |
|
167 | /**
|
168 | * Checks whether or not a node is `null` or `undefined`.
|
169 | * @param {ASTNode} node A node to check.
|
170 | * @returns {boolean} Whether or not the node is a `null` or `undefined`.
|
171 | * @public
|
172 | */
|
173 | function isNullOrUndefined(node) {
|
174 | return (
|
175 | isNullLiteral(node) ||
|
176 | (node.type === "Identifier" && node.name === "undefined") ||
|
177 | (node.type === "UnaryExpression" && node.operator === "void")
|
178 | );
|
179 | }
|
180 |
|
181 | /**
|
182 | * Checks whether or not a node is callee.
|
183 | * @param {ASTNode} node A node to check.
|
184 | * @returns {boolean} Whether or not the node is callee.
|
185 | */
|
186 | function isCallee(node) {
|
187 | return node.parent.type === "CallExpression" && node.parent.callee === node;
|
188 | }
|
189 |
|
190 | /**
|
191 | * Returns the result of the string conversion applied to the evaluated value of the given expression node,
|
192 | * if it can be determined statically.
|
193 | *
|
194 | * This function returns a `string` value for all `Literal` nodes and simple `TemplateLiteral` nodes only.
|
195 | * In all other cases, this function returns `null`.
|
196 | * @param {ASTNode} node Expression node.
|
197 | * @returns {string|null} String value if it can be determined. Otherwise, `null`.
|
198 | */
|
199 | function getStaticStringValue(node) {
|
200 | switch (node.type) {
|
201 | case "Literal":
|
202 | if (node.value === null) {
|
203 | if (isNullLiteral(node)) {
|
204 | return String(node.value); // "null"
|
205 | }
|
206 | if (node.regex) {
|
207 | return `/${node.regex.pattern}/${node.regex.flags}`;
|
208 | }
|
209 | if (node.bigint) {
|
210 | return node.bigint;
|
211 | }
|
212 |
|
213 | // Otherwise, this is an unknown literal. The function will return null.
|
214 |
|
215 | } else {
|
216 | return String(node.value);
|
217 | }
|
218 | break;
|
219 | case "TemplateLiteral":
|
220 | if (node.expressions.length === 0 && node.quasis.length === 1) {
|
221 | return node.quasis[0].value.cooked;
|
222 | }
|
223 | break;
|
224 |
|
225 | // no default
|
226 | }
|
227 |
|
228 | return null;
|
229 | }
|
230 |
|
231 | /**
|
232 | * Gets the property name of a given node.
|
233 | * The node can be a MemberExpression, a Property, or a MethodDefinition.
|
234 | *
|
235 | * If the name is dynamic, this returns `null`.
|
236 | *
|
237 | * For examples:
|
238 | *
|
239 | * a.b // => "b"
|
240 | * a["b"] // => "b"
|
241 | * a['b'] // => "b"
|
242 | * a[`b`] // => "b"
|
243 | * a[100] // => "100"
|
244 | * a[b] // => null
|
245 | * a["a" + "b"] // => null
|
246 | * a[tag`b`] // => null
|
247 | * a[`${b}`] // => null
|
248 | *
|
249 | * let a = {b: 1} // => "b"
|
250 | * let a = {["b"]: 1} // => "b"
|
251 | * let a = {['b']: 1} // => "b"
|
252 | * let a = {[`b`]: 1} // => "b"
|
253 | * let a = {[100]: 1} // => "100"
|
254 | * let a = {[b]: 1} // => null
|
255 | * let a = {["a" + "b"]: 1} // => null
|
256 | * let a = {[tag`b`]: 1} // => null
|
257 | * let a = {[`${b}`]: 1} // => null
|
258 | * @param {ASTNode} node The node to get.
|
259 | * @returns {string|null} The property name if static. Otherwise, null.
|
260 | */
|
261 | function getStaticPropertyName(node) {
|
262 | let prop;
|
263 |
|
264 | switch (node && node.type) {
|
265 | case "ChainExpression":
|
266 | return getStaticPropertyName(node.expression);
|
267 |
|
268 | case "Property":
|
269 | case "MethodDefinition":
|
270 | prop = node.key;
|
271 | break;
|
272 |
|
273 | case "MemberExpression":
|
274 | prop = node.property;
|
275 | break;
|
276 |
|
277 | // no default
|
278 | }
|
279 |
|
280 | if (prop) {
|
281 | if (prop.type === "Identifier" && !node.computed) {
|
282 | return prop.name;
|
283 | }
|
284 |
|
285 | return getStaticStringValue(prop);
|
286 | }
|
287 |
|
288 | return null;
|
289 | }
|
290 |
|
291 | /**
|
292 | * Retrieve `ChainExpression#expression` value if the given node a `ChainExpression` node. Otherwise, pass through it.
|
293 | * @param {ASTNode} node The node to address.
|
294 | * @returns {ASTNode} The `ChainExpression#expression` value if the node is a `ChainExpression` node. Otherwise, the node.
|
295 | */
|
296 | function skipChainExpression(node) {
|
297 | return node && node.type === "ChainExpression" ? node.expression : node;
|
298 | }
|
299 |
|
300 | /**
|
301 | * Check if the `actual` is an expected value.
|
302 | * @param {string} actual The string value to check.
|
303 | * @param {string | RegExp} expected The expected string value or pattern.
|
304 | * @returns {boolean} `true` if the `actual` is an expected value.
|
305 | */
|
306 | function checkText(actual, expected) {
|
307 | return typeof expected === "string"
|
308 | ? actual === expected
|
309 | : expected.test(actual);
|
310 | }
|
311 |
|
312 | /**
|
313 | * Check if a given node is an Identifier node with a given name.
|
314 | * @param {ASTNode} node The node to check.
|
315 | * @param {string | RegExp} name The expected name or the expected pattern of the object name.
|
316 | * @returns {boolean} `true` if the node is an Identifier node with the name.
|
317 | */
|
318 | function isSpecificId(node, name) {
|
319 | return node.type === "Identifier" && checkText(node.name, name);
|
320 | }
|
321 |
|
322 | /**
|
323 | * Check if a given node is member access with a given object name and property name pair.
|
324 | * This is regardless of optional or not.
|
325 | * @param {ASTNode} node The node to check.
|
326 | * @param {string | RegExp | null} objectName The expected name or the expected pattern of the object name. If this is nullish, this method doesn't check object.
|
327 | * @param {string | RegExp | null} propertyName The expected name or the expected pattern of the property name. If this is nullish, this method doesn't check property.
|
328 | * @returns {boolean} `true` if the node is member access with the object name and property name pair.
|
329 | * The node is a `MemberExpression` or `ChainExpression`.
|
330 | */
|
331 | function isSpecificMemberAccess(node, objectName, propertyName) {
|
332 | const checkNode = skipChainExpression(node);
|
333 |
|
334 | if (checkNode.type !== "MemberExpression") {
|
335 | return false;
|
336 | }
|
337 |
|
338 | if (objectName && !isSpecificId(checkNode.object, objectName)) {
|
339 | return false;
|
340 | }
|
341 |
|
342 | if (propertyName) {
|
343 | const actualPropertyName = getStaticPropertyName(checkNode);
|
344 |
|
345 | if (typeof actualPropertyName !== "string" || !checkText(actualPropertyName, propertyName)) {
|
346 | return false;
|
347 | }
|
348 | }
|
349 |
|
350 | return true;
|
351 | }
|
352 |
|
353 | /**
|
354 | * Check if two literal nodes are the same value.
|
355 | * @param {ASTNode} left The Literal node to compare.
|
356 | * @param {ASTNode} right The other Literal node to compare.
|
357 | * @returns {boolean} `true` if the two literal nodes are the same value.
|
358 | */
|
359 | function equalLiteralValue(left, right) {
|
360 |
|
361 | // RegExp literal.
|
362 | if (left.regex || right.regex) {
|
363 | return Boolean(
|
364 | left.regex &&
|
365 | right.regex &&
|
366 | left.regex.pattern === right.regex.pattern &&
|
367 | left.regex.flags === right.regex.flags
|
368 | );
|
369 | }
|
370 |
|
371 | // BigInt literal.
|
372 | if (left.bigint || right.bigint) {
|
373 | return left.bigint === right.bigint;
|
374 | }
|
375 |
|
376 | return left.value === right.value;
|
377 | }
|
378 |
|
379 | /**
|
380 | * Check if two expressions reference the same value. For example:
|
381 | * a = a
|
382 | * a.b = a.b
|
383 | * a[0] = a[0]
|
384 | * a['b'] = a['b']
|
385 | * @param {ASTNode} left The left side of the comparison.
|
386 | * @param {ASTNode} right The right side of the comparison.
|
387 | * @param {boolean} [disableStaticComputedKey] Don't address `a.b` and `a["b"]` are the same if `true`. For backward compatibility.
|
388 | * @returns {boolean} `true` if both sides match and reference the same value.
|
389 | */
|
390 | function isSameReference(left, right, disableStaticComputedKey = false) {
|
391 | if (left.type !== right.type) {
|
392 |
|
393 | // Handle `a.b` and `a?.b` are samely.
|
394 | if (left.type === "ChainExpression") {
|
395 | return isSameReference(left.expression, right, disableStaticComputedKey);
|
396 | }
|
397 | if (right.type === "ChainExpression") {
|
398 | return isSameReference(left, right.expression, disableStaticComputedKey);
|
399 | }
|
400 |
|
401 | return false;
|
402 | }
|
403 |
|
404 | switch (left.type) {
|
405 | case "Super":
|
406 | case "ThisExpression":
|
407 | return true;
|
408 |
|
409 | case "Identifier":
|
410 | return left.name === right.name;
|
411 | case "Literal":
|
412 | return equalLiteralValue(left, right);
|
413 |
|
414 | case "ChainExpression":
|
415 | return isSameReference(left.expression, right.expression, disableStaticComputedKey);
|
416 |
|
417 | case "MemberExpression": {
|
418 | if (!disableStaticComputedKey) {
|
419 | const nameA = getStaticPropertyName(left);
|
420 |
|
421 | // x.y = x["y"]
|
422 | if (nameA !== null) {
|
423 | return (
|
424 | isSameReference(left.object, right.object, disableStaticComputedKey) &&
|
425 | nameA === getStaticPropertyName(right)
|
426 | );
|
427 | }
|
428 | }
|
429 |
|
430 | /*
|
431 | * x[0] = x[0]
|
432 | * x[y] = x[y]
|
433 | * x.y = x.y
|
434 | */
|
435 | return (
|
436 | left.computed === right.computed &&
|
437 | isSameReference(left.object, right.object, disableStaticComputedKey) &&
|
438 | isSameReference(left.property, right.property, disableStaticComputedKey)
|
439 | );
|
440 | }
|
441 |
|
442 | default:
|
443 | return false;
|
444 | }
|
445 | }
|
446 |
|
447 | /**
|
448 | * Checks whether or not a node is `Reflect.apply`.
|
449 | * @param {ASTNode} node A node to check.
|
450 | * @returns {boolean} Whether or not the node is a `Reflect.apply`.
|
451 | */
|
452 | function isReflectApply(node) {
|
453 | return isSpecificMemberAccess(node, "Reflect", "apply");
|
454 | }
|
455 |
|
456 | /**
|
457 | * Checks whether or not a node is `Array.from`.
|
458 | * @param {ASTNode} node A node to check.
|
459 | * @returns {boolean} Whether or not the node is a `Array.from`.
|
460 | */
|
461 | function isArrayFromMethod(node) {
|
462 | return isSpecificMemberAccess(node, arrayOrTypedArrayPattern, "from");
|
463 | }
|
464 |
|
465 | /**
|
466 | * Checks whether or not a node is a method which has `thisArg`.
|
467 | * @param {ASTNode} node A node to check.
|
468 | * @returns {boolean} Whether or not the node is a method which has `thisArg`.
|
469 | */
|
470 | function isMethodWhichHasThisArg(node) {
|
471 | return isSpecificMemberAccess(node, null, arrayMethodPattern);
|
472 | }
|
473 |
|
474 | /**
|
475 | * Creates the negate function of the given function.
|
476 | * @param {Function} f The function to negate.
|
477 | * @returns {Function} Negated function.
|
478 | */
|
479 | function negate(f) {
|
480 | return token => !f(token);
|
481 | }
|
482 |
|
483 | /**
|
484 | * Checks whether or not a node has a `@this` tag in its comments.
|
485 | * @param {ASTNode} node A node to check.
|
486 | * @param {SourceCode} sourceCode A SourceCode instance to get comments.
|
487 | * @returns {boolean} Whether or not the node has a `@this` tag in its comments.
|
488 | */
|
489 | function hasJSDocThisTag(node, sourceCode) {
|
490 | const jsdocComment = sourceCode.getJSDocComment(node);
|
491 |
|
492 | if (jsdocComment && thisTagPattern.test(jsdocComment.value)) {
|
493 | return true;
|
494 | }
|
495 |
|
496 | // Checks `@this` in its leading comments for callbacks,
|
497 | // because callbacks don't have its JSDoc comment.
|
498 | // e.g.
|
499 | // sinon.test(/* @this sinon.Sandbox */function() { this.spy(); });
|
500 | return sourceCode.getCommentsBefore(node).some(comment => thisTagPattern.test(comment.value));
|
501 | }
|
502 |
|
503 | /**
|
504 | * Determines if a node is surrounded by parentheses.
|
505 | * @param {SourceCode} sourceCode The ESLint source code object
|
506 | * @param {ASTNode} node The node to be checked.
|
507 | * @returns {boolean} True if the node is parenthesised.
|
508 | * @private
|
509 | */
|
510 | function isParenthesised(sourceCode, node) {
|
511 | const previousToken = sourceCode.getTokenBefore(node),
|
512 | nextToken = sourceCode.getTokenAfter(node);
|
513 |
|
514 | return Boolean(previousToken && nextToken) &&
|
515 | previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
|
516 | nextToken.value === ")" && nextToken.range[0] >= node.range[1];
|
517 | }
|
518 |
|
519 | /**
|
520 | * Checks if the given token is an arrow token or not.
|
521 | * @param {Token} token The token to check.
|
522 | * @returns {boolean} `true` if the token is an arrow token.
|
523 | */
|
524 | function isArrowToken(token) {
|
525 | return token.value === "=>" && token.type === "Punctuator";
|
526 | }
|
527 |
|
528 | /**
|
529 | * Checks if the given token is a comma token or not.
|
530 | * @param {Token} token The token to check.
|
531 | * @returns {boolean} `true` if the token is a comma token.
|
532 | */
|
533 | function isCommaToken(token) {
|
534 | return token.value === "," && token.type === "Punctuator";
|
535 | }
|
536 |
|
537 | /**
|
538 | * Checks if the given token is a dot token or not.
|
539 | * @param {Token} token The token to check.
|
540 | * @returns {boolean} `true` if the token is a dot token.
|
541 | */
|
542 | function isDotToken(token) {
|
543 | return token.value === "." && token.type === "Punctuator";
|
544 | }
|
545 |
|
546 | /**
|
547 | * Checks if the given token is a `?.` token or not.
|
548 | * @param {Token} token The token to check.
|
549 | * @returns {boolean} `true` if the token is a `?.` token.
|
550 | */
|
551 | function isQuestionDotToken(token) {
|
552 | return token.value === "?." && token.type === "Punctuator";
|
553 | }
|
554 |
|
555 | /**
|
556 | * Checks if the given token is a semicolon token or not.
|
557 | * @param {Token} token The token to check.
|
558 | * @returns {boolean} `true` if the token is a semicolon token.
|
559 | */
|
560 | function isSemicolonToken(token) {
|
561 | return token.value === ";" && token.type === "Punctuator";
|
562 | }
|
563 |
|
564 | /**
|
565 | * Checks if the given token is a colon token or not.
|
566 | * @param {Token} token The token to check.
|
567 | * @returns {boolean} `true` if the token is a colon token.
|
568 | */
|
569 | function isColonToken(token) {
|
570 | return token.value === ":" && token.type === "Punctuator";
|
571 | }
|
572 |
|
573 | /**
|
574 | * Checks if the given token is an opening parenthesis token or not.
|
575 | * @param {Token} token The token to check.
|
576 | * @returns {boolean} `true` if the token is an opening parenthesis token.
|
577 | */
|
578 | function isOpeningParenToken(token) {
|
579 | return token.value === "(" && token.type === "Punctuator";
|
580 | }
|
581 |
|
582 | /**
|
583 | * Checks if the given token is a closing parenthesis token or not.
|
584 | * @param {Token} token The token to check.
|
585 | * @returns {boolean} `true` if the token is a closing parenthesis token.
|
586 | */
|
587 | function isClosingParenToken(token) {
|
588 | return token.value === ")" && token.type === "Punctuator";
|
589 | }
|
590 |
|
591 | /**
|
592 | * Checks if the given token is an opening square bracket token or not.
|
593 | * @param {Token} token The token to check.
|
594 | * @returns {boolean} `true` if the token is an opening square bracket token.
|
595 | */
|
596 | function isOpeningBracketToken(token) {
|
597 | return token.value === "[" && token.type === "Punctuator";
|
598 | }
|
599 |
|
600 | /**
|
601 | * Checks if the given token is a closing square bracket token or not.
|
602 | * @param {Token} token The token to check.
|
603 | * @returns {boolean} `true` if the token is a closing square bracket token.
|
604 | */
|
605 | function isClosingBracketToken(token) {
|
606 | return token.value === "]" && token.type === "Punctuator";
|
607 | }
|
608 |
|
609 | /**
|
610 | * Checks if the given token is an opening brace token or not.
|
611 | * @param {Token} token The token to check.
|
612 | * @returns {boolean} `true` if the token is an opening brace token.
|
613 | */
|
614 | function isOpeningBraceToken(token) {
|
615 | return token.value === "{" && token.type === "Punctuator";
|
616 | }
|
617 |
|
618 | /**
|
619 | * Checks if the given token is a closing brace token or not.
|
620 | * @param {Token} token The token to check.
|
621 | * @returns {boolean} `true` if the token is a closing brace token.
|
622 | */
|
623 | function isClosingBraceToken(token) {
|
624 | return token.value === "}" && token.type === "Punctuator";
|
625 | }
|
626 |
|
627 | /**
|
628 | * Checks if the given token is a comment token or not.
|
629 | * @param {Token} token The token to check.
|
630 | * @returns {boolean} `true` if the token is a comment token.
|
631 | */
|
632 | function isCommentToken(token) {
|
633 | return token.type === "Line" || token.type === "Block" || token.type === "Shebang";
|
634 | }
|
635 |
|
636 | /**
|
637 | * Checks if the given token is a keyword token or not.
|
638 | * @param {Token} token The token to check.
|
639 | * @returns {boolean} `true` if the token is a keyword token.
|
640 | */
|
641 | function isKeywordToken(token) {
|
642 | return token.type === "Keyword";
|
643 | }
|
644 |
|
645 | /**
|
646 | * Gets the `(` token of the given function node.
|
647 | * @param {ASTNode} node The function node to get.
|
648 | * @param {SourceCode} sourceCode The source code object to get tokens.
|
649 | * @returns {Token} `(` token.
|
650 | */
|
651 | function getOpeningParenOfParams(node, sourceCode) {
|
652 | return node.id
|
653 | ? sourceCode.getTokenAfter(node.id, isOpeningParenToken)
|
654 | : sourceCode.getFirstToken(node, isOpeningParenToken);
|
655 | }
|
656 |
|
657 | /**
|
658 | * Checks whether or not the tokens of two given nodes are same.
|
659 | * @param {ASTNode} left A node 1 to compare.
|
660 | * @param {ASTNode} right A node 2 to compare.
|
661 | * @param {SourceCode} sourceCode The ESLint source code object.
|
662 | * @returns {boolean} the source code for the given node.
|
663 | */
|
664 | function equalTokens(left, right, sourceCode) {
|
665 | const tokensL = sourceCode.getTokens(left);
|
666 | const tokensR = sourceCode.getTokens(right);
|
667 |
|
668 | if (tokensL.length !== tokensR.length) {
|
669 | return false;
|
670 | }
|
671 | for (let i = 0; i < tokensL.length; ++i) {
|
672 | if (tokensL[i].type !== tokensR[i].type ||
|
673 | tokensL[i].value !== tokensR[i].value
|
674 | ) {
|
675 | return false;
|
676 | }
|
677 | }
|
678 |
|
679 | return true;
|
680 | }
|
681 |
|
682 | /**
|
683 | * Check if the given node is a true logical expression or not.
|
684 | *
|
685 | * The three binary expressions logical-or (`||`), logical-and (`&&`), and
|
686 | * coalesce (`??`) are known as `ShortCircuitExpression`.
|
687 | * But ESTree represents those by `LogicalExpression` node.
|
688 | *
|
689 | * This function rejects coalesce expressions of `LogicalExpression` node.
|
690 | * @param {ASTNode} node The node to check.
|
691 | * @returns {boolean} `true` if the node is `&&` or `||`.
|
692 | * @see https://tc39.es/ecma262/#prod-ShortCircuitExpression
|
693 | */
|
694 | function isLogicalExpression(node) {
|
695 | return (
|
696 | node.type === "LogicalExpression" &&
|
697 | (node.operator === "&&" || node.operator === "||")
|
698 | );
|
699 | }
|
700 |
|
701 | /**
|
702 | * Check if the given node is a nullish coalescing expression or not.
|
703 | *
|
704 | * The three binary expressions logical-or (`||`), logical-and (`&&`), and
|
705 | * coalesce (`??`) are known as `ShortCircuitExpression`.
|
706 | * But ESTree represents those by `LogicalExpression` node.
|
707 | *
|
708 | * This function finds only coalesce expressions of `LogicalExpression` node.
|
709 | * @param {ASTNode} node The node to check.
|
710 | * @returns {boolean} `true` if the node is `??`.
|
711 | */
|
712 | function isCoalesceExpression(node) {
|
713 | return node.type === "LogicalExpression" && node.operator === "??";
|
714 | }
|
715 |
|
716 | /**
|
717 | * Check if given two nodes are the pair of a logical expression and a coalesce expression.
|
718 | * @param {ASTNode} left A node to check.
|
719 | * @param {ASTNode} right Another node to check.
|
720 | * @returns {boolean} `true` if the two nodes are the pair of a logical expression and a coalesce expression.
|
721 | */
|
722 | function isMixedLogicalAndCoalesceExpressions(left, right) {
|
723 | return (
|
724 | (isLogicalExpression(left) && isCoalesceExpression(right)) ||
|
725 | (isCoalesceExpression(left) && isLogicalExpression(right))
|
726 | );
|
727 | }
|
728 |
|
729 | /**
|
730 | * Checks if the given operator is a logical assignment operator.
|
731 | * @param {string} operator The operator to check.
|
732 | * @returns {boolean} `true` if the operator is a logical assignment operator.
|
733 | */
|
734 | function isLogicalAssignmentOperator(operator) {
|
735 | return LOGICAL_ASSIGNMENT_OPERATORS.has(operator);
|
736 | }
|
737 |
|
738 | //------------------------------------------------------------------------------
|
739 | // Public Interface
|
740 | //------------------------------------------------------------------------------
|
741 |
|
742 | module.exports = {
|
743 | COMMENTS_IGNORE_PATTERN,
|
744 | LINEBREAKS,
|
745 | LINEBREAK_MATCHER: lineBreakPattern,
|
746 | SHEBANG_MATCHER: shebangPattern,
|
747 | STATEMENT_LIST_PARENTS,
|
748 |
|
749 | /**
|
750 | * Determines whether two adjacent tokens are on the same line.
|
751 | * @param {Object} left The left token object.
|
752 | * @param {Object} right The right token object.
|
753 | * @returns {boolean} Whether or not the tokens are on the same line.
|
754 | * @public
|
755 | */
|
756 | isTokenOnSameLine(left, right) {
|
757 | return left.loc.end.line === right.loc.start.line;
|
758 | },
|
759 |
|
760 | isNullOrUndefined,
|
761 | isCallee,
|
762 | isES5Constructor,
|
763 | getUpperFunction,
|
764 | isFunction,
|
765 | isLoop,
|
766 | isInLoop,
|
767 | isArrayFromMethod,
|
768 | isParenthesised,
|
769 | createGlobalLinebreakMatcher,
|
770 | equalTokens,
|
771 |
|
772 | isArrowToken,
|
773 | isClosingBraceToken,
|
774 | isClosingBracketToken,
|
775 | isClosingParenToken,
|
776 | isColonToken,
|
777 | isCommaToken,
|
778 | isCommentToken,
|
779 | isDotToken,
|
780 | isQuestionDotToken,
|
781 | isKeywordToken,
|
782 | isNotClosingBraceToken: negate(isClosingBraceToken),
|
783 | isNotClosingBracketToken: negate(isClosingBracketToken),
|
784 | isNotClosingParenToken: negate(isClosingParenToken),
|
785 | isNotColonToken: negate(isColonToken),
|
786 | isNotCommaToken: negate(isCommaToken),
|
787 | isNotDotToken: negate(isDotToken),
|
788 | isNotQuestionDotToken: negate(isQuestionDotToken),
|
789 | isNotOpeningBraceToken: negate(isOpeningBraceToken),
|
790 | isNotOpeningBracketToken: negate(isOpeningBracketToken),
|
791 | isNotOpeningParenToken: negate(isOpeningParenToken),
|
792 | isNotSemicolonToken: negate(isSemicolonToken),
|
793 | isOpeningBraceToken,
|
794 | isOpeningBracketToken,
|
795 | isOpeningParenToken,
|
796 | isSemicolonToken,
|
797 |
|
798 | /**
|
799 | * Checks whether or not a given node is a string literal.
|
800 | * @param {ASTNode} node A node to check.
|
801 | * @returns {boolean} `true` if the node is a string literal.
|
802 | */
|
803 | isStringLiteral(node) {
|
804 | return (
|
805 | (node.type === "Literal" && typeof node.value === "string") ||
|
806 | node.type === "TemplateLiteral"
|
807 | );
|
808 | },
|
809 |
|
810 | /**
|
811 | * Checks whether a given node is a breakable statement or not.
|
812 | * The node is breakable if the node is one of the following type:
|
813 | *
|
814 | * - DoWhileStatement
|
815 | * - ForInStatement
|
816 | * - ForOfStatement
|
817 | * - ForStatement
|
818 | * - SwitchStatement
|
819 | * - WhileStatement
|
820 | * @param {ASTNode} node A node to check.
|
821 | * @returns {boolean} `true` if the node is breakable.
|
822 | */
|
823 | isBreakableStatement(node) {
|
824 | return breakableTypePattern.test(node.type);
|
825 | },
|
826 |
|
827 | /**
|
828 | * Gets references which are non initializer and writable.
|
829 | * @param {Reference[]} references An array of references.
|
830 | * @returns {Reference[]} An array of only references which are non initializer and writable.
|
831 | * @public
|
832 | */
|
833 | getModifyingReferences(references) {
|
834 | return references.filter(isModifyingReference);
|
835 | },
|
836 |
|
837 | /**
|
838 | * Validate that a string passed in is surrounded by the specified character
|
839 | * @param {string} val The text to check.
|
840 | * @param {string} character The character to see if it's surrounded by.
|
841 | * @returns {boolean} True if the text is surrounded by the character, false if not.
|
842 | * @private
|
843 | */
|
844 | isSurroundedBy(val, character) {
|
845 | return val[0] === character && val[val.length - 1] === character;
|
846 | },
|
847 |
|
848 | /**
|
849 | * Returns whether the provided node is an ESLint directive comment or not
|
850 | * @param {Line|Block} node The comment token to be checked
|
851 | * @returns {boolean} `true` if the node is an ESLint directive comment
|
852 | */
|
853 | isDirectiveComment(node) {
|
854 | const comment = node.value.trim();
|
855 |
|
856 | return (
|
857 | node.type === "Line" && comment.indexOf("eslint-") === 0 ||
|
858 | node.type === "Block" && (
|
859 | comment.indexOf("global ") === 0 ||
|
860 | comment.indexOf("eslint ") === 0 ||
|
861 | comment.indexOf("eslint-") === 0
|
862 | )
|
863 | );
|
864 | },
|
865 |
|
866 | /**
|
867 | * Gets the trailing statement of a given node.
|
868 | *
|
869 | * if (code)
|
870 | * consequent;
|
871 | *
|
872 | * When taking this `IfStatement`, returns `consequent;` statement.
|
873 | * @param {ASTNode} A node to get.
|
874 | * @returns {ASTNode|null} The trailing statement's node.
|
875 | */
|
876 | getTrailingStatement: esutils.ast.trailingStatement,
|
877 |
|
878 | /**
|
879 | * Finds the variable by a given name in a given scope and its upper scopes.
|
880 | * @param {eslint-scope.Scope} initScope A scope to start find.
|
881 | * @param {string} name A variable name to find.
|
882 | * @returns {eslint-scope.Variable|null} A found variable or `null`.
|
883 | */
|
884 | getVariableByName(initScope, name) {
|
885 | let scope = initScope;
|
886 |
|
887 | while (scope) {
|
888 | const variable = scope.set.get(name);
|
889 |
|
890 | if (variable) {
|
891 | return variable;
|
892 | }
|
893 |
|
894 | scope = scope.upper;
|
895 | }
|
896 |
|
897 | return null;
|
898 | },
|
899 |
|
900 | /**
|
901 | * Checks whether or not a given function node is the default `this` binding.
|
902 | *
|
903 | * First, this checks the node:
|
904 | *
|
905 | * - The function name does not start with uppercase. It's a convention to capitalize the names
|
906 | * of constructor functions. This check is not performed if `capIsConstructor` is set to `false`.
|
907 | * - The function does not have a JSDoc comment that has a @this tag.
|
908 | *
|
909 | * Next, this checks the location of the node.
|
910 | * If the location is below, this judges `this` is valid.
|
911 | *
|
912 | * - The location is not on an object literal.
|
913 | * - The location is not assigned to a variable which starts with an uppercase letter. Applies to anonymous
|
914 | * functions only, as the name of the variable is considered to be the name of the function in this case.
|
915 | * This check is not performed if `capIsConstructor` is set to `false`.
|
916 | * - The location is not on an ES2015 class.
|
917 | * - Its `bind`/`call`/`apply` method is not called directly.
|
918 | * - The function is not a callback of array methods (such as `.forEach()`) if `thisArg` is given.
|
919 | * @param {ASTNode} node A function node to check.
|
920 | * @param {SourceCode} sourceCode A SourceCode instance to get comments.
|
921 | * @param {boolean} [capIsConstructor = true] `false` disables the assumption that functions which name starts
|
922 | * with an uppercase or are assigned to a variable which name starts with an uppercase are constructors.
|
923 | * @returns {boolean} The function node is the default `this` binding.
|
924 | */
|
925 | isDefaultThisBinding(node, sourceCode, { capIsConstructor = true } = {}) {
|
926 | if (
|
927 | (capIsConstructor && isES5Constructor(node)) ||
|
928 | hasJSDocThisTag(node, sourceCode)
|
929 | ) {
|
930 | return false;
|
931 | }
|
932 | const isAnonymous = node.id === null;
|
933 | let currentNode = node;
|
934 |
|
935 | while (currentNode) {
|
936 | const parent = currentNode.parent;
|
937 |
|
938 | switch (parent.type) {
|
939 |
|
940 | /*
|
941 | * Looks up the destination.
|
942 | * e.g., obj.foo = nativeFoo || function foo() { ... };
|
943 | */
|
944 | case "LogicalExpression":
|
945 | case "ConditionalExpression":
|
946 | case "ChainExpression":
|
947 | currentNode = parent;
|
948 | break;
|
949 |
|
950 | /*
|
951 | * If the upper function is IIFE, checks the destination of the return value.
|
952 | * e.g.
|
953 | * obj.foo = (function() {
|
954 | * // setup...
|
955 | * return function foo() { ... };
|
956 | * })();
|
957 | * obj.foo = (() =>
|
958 | * function foo() { ... }
|
959 | * )();
|
960 | */
|
961 | case "ReturnStatement": {
|
962 | const func = getUpperFunction(parent);
|
963 |
|
964 | if (func === null || !isCallee(func)) {
|
965 | return true;
|
966 | }
|
967 | currentNode = func.parent;
|
968 | break;
|
969 | }
|
970 | case "ArrowFunctionExpression":
|
971 | if (currentNode !== parent.body || !isCallee(parent)) {
|
972 | return true;
|
973 | }
|
974 | currentNode = parent.parent;
|
975 | break;
|
976 |
|
977 | /*
|
978 | * e.g.
|
979 | * var obj = { foo() { ... } };
|
980 | * var obj = { foo: function() { ... } };
|
981 | * class A { constructor() { ... } }
|
982 | * class A { foo() { ... } }
|
983 | * class A { get foo() { ... } }
|
984 | * class A { set foo() { ... } }
|
985 | * class A { static foo() { ... } }
|
986 | */
|
987 | case "Property":
|
988 | case "MethodDefinition":
|
989 | return parent.value !== currentNode;
|
990 |
|
991 | /*
|
992 | * e.g.
|
993 | * obj.foo = function foo() { ... };
|
994 | * Foo = function() { ... };
|
995 | * [obj.foo = function foo() { ... }] = a;
|
996 | * [Foo = function() { ... }] = a;
|
997 | */
|
998 | case "AssignmentExpression":
|
999 | case "AssignmentPattern":
|
1000 | if (parent.left.type === "MemberExpression") {
|
1001 | return false;
|
1002 | }
|
1003 | if (
|
1004 | capIsConstructor &&
|
1005 | isAnonymous &&
|
1006 | parent.left.type === "Identifier" &&
|
1007 | startsWithUpperCase(parent.left.name)
|
1008 | ) {
|
1009 | return false;
|
1010 | }
|
1011 | return true;
|
1012 |
|
1013 | /*
|
1014 | * e.g.
|
1015 | * var Foo = function() { ... };
|
1016 | */
|
1017 | case "VariableDeclarator":
|
1018 | return !(
|
1019 | capIsConstructor &&
|
1020 | isAnonymous &&
|
1021 | parent.init === currentNode &&
|
1022 | parent.id.type === "Identifier" &&
|
1023 | startsWithUpperCase(parent.id.name)
|
1024 | );
|
1025 |
|
1026 | /*
|
1027 | * e.g.
|
1028 | * var foo = function foo() { ... }.bind(obj);
|
1029 | * (function foo() { ... }).call(obj);
|
1030 | * (function foo() { ... }).apply(obj, []);
|
1031 | */
|
1032 | case "MemberExpression":
|
1033 | if (
|
1034 | parent.object === currentNode &&
|
1035 | isSpecificMemberAccess(parent, null, bindOrCallOrApplyPattern)
|
1036 | ) {
|
1037 | const maybeCalleeNode = parent.parent.type === "ChainExpression"
|
1038 | ? parent.parent
|
1039 | : parent;
|
1040 |
|
1041 | return !(
|
1042 | isCallee(maybeCalleeNode) &&
|
1043 | maybeCalleeNode.parent.arguments.length >= 1 &&
|
1044 | !isNullOrUndefined(maybeCalleeNode.parent.arguments[0])
|
1045 | );
|
1046 | }
|
1047 | return true;
|
1048 |
|
1049 | /*
|
1050 | * e.g.
|
1051 | * Reflect.apply(function() {}, obj, []);
|
1052 | * Array.from([], function() {}, obj);
|
1053 | * list.forEach(function() {}, obj);
|
1054 | */
|
1055 | case "CallExpression":
|
1056 | if (isReflectApply(parent.callee)) {
|
1057 | return (
|
1058 | parent.arguments.length !== 3 ||
|
1059 | parent.arguments[0] !== currentNode ||
|
1060 | isNullOrUndefined(parent.arguments[1])
|
1061 | );
|
1062 | }
|
1063 | if (isArrayFromMethod(parent.callee)) {
|
1064 | return (
|
1065 | parent.arguments.length !== 3 ||
|
1066 | parent.arguments[1] !== currentNode ||
|
1067 | isNullOrUndefined(parent.arguments[2])
|
1068 | );
|
1069 | }
|
1070 | if (isMethodWhichHasThisArg(parent.callee)) {
|
1071 | return (
|
1072 | parent.arguments.length !== 2 ||
|
1073 | parent.arguments[0] !== currentNode ||
|
1074 | isNullOrUndefined(parent.arguments[1])
|
1075 | );
|
1076 | }
|
1077 | return true;
|
1078 |
|
1079 | // Otherwise `this` is default.
|
1080 | default:
|
1081 | return true;
|
1082 | }
|
1083 | }
|
1084 |
|
1085 | /* istanbul ignore next */
|
1086 | return true;
|
1087 | },
|
1088 |
|
1089 | /**
|
1090 | * Get the precedence level based on the node type
|
1091 | * @param {ASTNode} node node to evaluate
|
1092 | * @returns {int} precedence level
|
1093 | * @private
|
1094 | */
|
1095 | getPrecedence(node) {
|
1096 | switch (node.type) {
|
1097 | case "SequenceExpression":
|
1098 | return 0;
|
1099 |
|
1100 | case "AssignmentExpression":
|
1101 | case "ArrowFunctionExpression":
|
1102 | case "YieldExpression":
|
1103 | return 1;
|
1104 |
|
1105 | case "ConditionalExpression":
|
1106 | return 3;
|
1107 |
|
1108 | case "LogicalExpression":
|
1109 | switch (node.operator) {
|
1110 | case "||":
|
1111 | case "??":
|
1112 | return 4;
|
1113 | case "&&":
|
1114 | return 5;
|
1115 |
|
1116 | // no default
|
1117 | }
|
1118 |
|
1119 | /* falls through */
|
1120 |
|
1121 | case "BinaryExpression":
|
1122 |
|
1123 | switch (node.operator) {
|
1124 | case "|":
|
1125 | return 6;
|
1126 | case "^":
|
1127 | return 7;
|
1128 | case "&":
|
1129 | return 8;
|
1130 | case "==":
|
1131 | case "!=":
|
1132 | case "===":
|
1133 | case "!==":
|
1134 | return 9;
|
1135 | case "<":
|
1136 | case "<=":
|
1137 | case ">":
|
1138 | case ">=":
|
1139 | case "in":
|
1140 | case "instanceof":
|
1141 | return 10;
|
1142 | case "<<":
|
1143 | case ">>":
|
1144 | case ">>>":
|
1145 | return 11;
|
1146 | case "+":
|
1147 | case "-":
|
1148 | return 12;
|
1149 | case "*":
|
1150 | case "/":
|
1151 | case "%":
|
1152 | return 13;
|
1153 | case "**":
|
1154 | return 15;
|
1155 |
|
1156 | // no default
|
1157 | }
|
1158 |
|
1159 | /* falls through */
|
1160 |
|
1161 | case "UnaryExpression":
|
1162 | case "AwaitExpression":
|
1163 | return 16;
|
1164 |
|
1165 | case "UpdateExpression":
|
1166 | return 17;
|
1167 |
|
1168 | case "CallExpression":
|
1169 | case "ChainExpression":
|
1170 | case "ImportExpression":
|
1171 | return 18;
|
1172 |
|
1173 | case "NewExpression":
|
1174 | return 19;
|
1175 |
|
1176 | default:
|
1177 | return 20;
|
1178 | }
|
1179 | },
|
1180 |
|
1181 | /**
|
1182 | * Checks whether the given node is an empty block node or not.
|
1183 | * @param {ASTNode|null} node The node to check.
|
1184 | * @returns {boolean} `true` if the node is an empty block.
|
1185 | */
|
1186 | isEmptyBlock(node) {
|
1187 | return Boolean(node && node.type === "BlockStatement" && node.body.length === 0);
|
1188 | },
|
1189 |
|
1190 | /**
|
1191 | * Checks whether the given node is an empty function node or not.
|
1192 | * @param {ASTNode|null} node The node to check.
|
1193 | * @returns {boolean} `true` if the node is an empty function.
|
1194 | */
|
1195 | isEmptyFunction(node) {
|
1196 | return isFunction(node) && module.exports.isEmptyBlock(node.body);
|
1197 | },
|
1198 |
|
1199 | /**
|
1200 | * Get directives from directive prologue of a Program or Function node.
|
1201 | * @param {ASTNode} node The node to check.
|
1202 | * @returns {ASTNode[]} The directives found in the directive prologue.
|
1203 | */
|
1204 | getDirectivePrologue(node) {
|
1205 | const directives = [];
|
1206 |
|
1207 | // Directive prologues only occur at the top of files or functions.
|
1208 | if (
|
1209 | node.type === "Program" ||
|
1210 | node.type === "FunctionDeclaration" ||
|
1211 | node.type === "FunctionExpression" ||
|
1212 |
|
1213 | /*
|
1214 | * Do not check arrow functions with implicit return.
|
1215 | * `() => "use strict";` returns the string `"use strict"`.
|
1216 | */
|
1217 | (node.type === "ArrowFunctionExpression" && node.body.type === "BlockStatement")
|
1218 | ) {
|
1219 | const statements = node.type === "Program" ? node.body : node.body.body;
|
1220 |
|
1221 | for (const statement of statements) {
|
1222 | if (
|
1223 | statement.type === "ExpressionStatement" &&
|
1224 | statement.expression.type === "Literal"
|
1225 | ) {
|
1226 | directives.push(statement);
|
1227 | } else {
|
1228 | break;
|
1229 | }
|
1230 | }
|
1231 | }
|
1232 |
|
1233 | return directives;
|
1234 | },
|
1235 |
|
1236 |
|
1237 | /**
|
1238 | * Determines whether this node is a decimal integer literal. If a node is a decimal integer literal, a dot added
|
1239 | * after the node will be parsed as a decimal point, rather than a property-access dot.
|
1240 | * @param {ASTNode} node The node to check.
|
1241 | * @returns {boolean} `true` if this node is a decimal integer.
|
1242 | * @example
|
1243 | *
|
1244 | * 0 // true
|
1245 | * 5 // true
|
1246 | * 50 // true
|
1247 | * 5_000 // true
|
1248 | * 1_234_56 // true
|
1249 | * 08 // true
|
1250 | * 0192 // true
|
1251 | * 5. // false
|
1252 | * .5 // false
|
1253 | * 5.0 // false
|
1254 | * 5.00_00 // false
|
1255 | * 05 // false
|
1256 | * 0x5 // false
|
1257 | * 0b101 // false
|
1258 | * 0b11_01 // false
|
1259 | * 0o5 // false
|
1260 | * 5e0 // false
|
1261 | * 5e1_000 // false
|
1262 | * 5n // false
|
1263 | * 1_000n // false
|
1264 | * '5' // false
|
1265 | */
|
1266 | isDecimalInteger(node) {
|
1267 | return node.type === "Literal" && typeof node.value === "number" &&
|
1268 | DECIMAL_INTEGER_PATTERN.test(node.raw);
|
1269 | },
|
1270 |
|
1271 | /**
|
1272 | * Determines whether this token is a decimal integer numeric token.
|
1273 | * This is similar to isDecimalInteger(), but for tokens.
|
1274 | * @param {Token} token The token to check.
|
1275 | * @returns {boolean} `true` if this token is a decimal integer.
|
1276 | */
|
1277 | isDecimalIntegerNumericToken(token) {
|
1278 | return token.type === "Numeric" && DECIMAL_INTEGER_PATTERN.test(token.value);
|
1279 | },
|
1280 |
|
1281 | /**
|
1282 | * Gets the name and kind of the given function node.
|
1283 | *
|
1284 | * - `function foo() {}` .................... `function 'foo'`
|
1285 | * - `(function foo() {})` .................. `function 'foo'`
|
1286 | * - `(function() {})` ...................... `function`
|
1287 | * - `function* foo() {}` ................... `generator function 'foo'`
|
1288 | * - `(function* foo() {})` ................. `generator function 'foo'`
|
1289 | * - `(function*() {})` ..................... `generator function`
|
1290 | * - `() => {}` ............................. `arrow function`
|
1291 | * - `async () => {}` ....................... `async arrow function`
|
1292 | * - `({ foo: function foo() {} })` ......... `method 'foo'`
|
1293 | * - `({ foo: function() {} })` ............. `method 'foo'`
|
1294 | * - `({ ['foo']: function() {} })` ......... `method 'foo'`
|
1295 | * - `({ [foo]: function() {} })` ........... `method`
|
1296 | * - `({ foo() {} })` ....................... `method 'foo'`
|
1297 | * - `({ foo: function* foo() {} })` ........ `generator method 'foo'`
|
1298 | * - `({ foo: function*() {} })` ............ `generator method 'foo'`
|
1299 | * - `({ ['foo']: function*() {} })` ........ `generator method 'foo'`
|
1300 | * - `({ [foo]: function*() {} })` .......... `generator method`
|
1301 | * - `({ *foo() {} })` ...................... `generator method 'foo'`
|
1302 | * - `({ foo: async function foo() {} })` ... `async method 'foo'`
|
1303 | * - `({ foo: async function() {} })` ....... `async method 'foo'`
|
1304 | * - `({ ['foo']: async function() {} })` ... `async method 'foo'`
|
1305 | * - `({ [foo]: async function() {} })` ..... `async method`
|
1306 | * - `({ async foo() {} })` ................. `async method 'foo'`
|
1307 | * - `({ get foo() {} })` ................... `getter 'foo'`
|
1308 | * - `({ set foo(a) {} })` .................. `setter 'foo'`
|
1309 | * - `class A { constructor() {} }` ......... `constructor`
|
1310 | * - `class A { foo() {} }` ................. `method 'foo'`
|
1311 | * - `class A { *foo() {} }` ................ `generator method 'foo'`
|
1312 | * - `class A { async foo() {} }` ........... `async method 'foo'`
|
1313 | * - `class A { ['foo']() {} }` ............. `method 'foo'`
|
1314 | * - `class A { *['foo']() {} }` ............ `generator method 'foo'`
|
1315 | * - `class A { async ['foo']() {} }` ....... `async method 'foo'`
|
1316 | * - `class A { [foo]() {} }` ............... `method`
|
1317 | * - `class A { *[foo]() {} }` .............. `generator method`
|
1318 | * - `class A { async [foo]() {} }` ......... `async method`
|
1319 | * - `class A { get foo() {} }` ............. `getter 'foo'`
|
1320 | * - `class A { set foo(a) {} }` ............ `setter 'foo'`
|
1321 | * - `class A { static foo() {} }` .......... `static method 'foo'`
|
1322 | * - `class A { static *foo() {} }` ......... `static generator method 'foo'`
|
1323 | * - `class A { static async foo() {} }` .... `static async method 'foo'`
|
1324 | * - `class A { static get foo() {} }` ...... `static getter 'foo'`
|
1325 | * - `class A { static set foo(a) {} }` ..... `static setter 'foo'`
|
1326 | * @param {ASTNode} node The function node to get.
|
1327 | * @returns {string} The name and kind of the function node.
|
1328 | */
|
1329 | getFunctionNameWithKind(node) {
|
1330 | const parent = node.parent;
|
1331 | const tokens = [];
|
1332 |
|
1333 | if (parent.type === "MethodDefinition" && parent.static) {
|
1334 | tokens.push("static");
|
1335 | }
|
1336 | if (node.async) {
|
1337 | tokens.push("async");
|
1338 | }
|
1339 | if (node.generator) {
|
1340 | tokens.push("generator");
|
1341 | }
|
1342 |
|
1343 | if (node.type === "ArrowFunctionExpression") {
|
1344 | tokens.push("arrow", "function");
|
1345 | } else if (parent.type === "Property" || parent.type === "MethodDefinition") {
|
1346 | if (parent.kind === "constructor") {
|
1347 | return "constructor";
|
1348 | }
|
1349 | if (parent.kind === "get") {
|
1350 | tokens.push("getter");
|
1351 | } else if (parent.kind === "set") {
|
1352 | tokens.push("setter");
|
1353 | } else {
|
1354 | tokens.push("method");
|
1355 | }
|
1356 | } else {
|
1357 | tokens.push("function");
|
1358 | }
|
1359 |
|
1360 | if (node.id) {
|
1361 | tokens.push(`'${node.id.name}'`);
|
1362 | } else {
|
1363 | const name = getStaticPropertyName(parent);
|
1364 |
|
1365 | if (name !== null) {
|
1366 | tokens.push(`'${name}'`);
|
1367 | }
|
1368 | }
|
1369 |
|
1370 | return tokens.join(" ");
|
1371 | },
|
1372 |
|
1373 | /**
|
1374 | * Gets the location of the given function node for reporting.
|
1375 | *
|
1376 | * - `function foo() {}`
|
1377 | * ^^^^^^^^^^^^
|
1378 | * - `(function foo() {})`
|
1379 | * ^^^^^^^^^^^^
|
1380 | * - `(function() {})`
|
1381 | * ^^^^^^^^
|
1382 | * - `function* foo() {}`
|
1383 | * ^^^^^^^^^^^^^
|
1384 | * - `(function* foo() {})`
|
1385 | * ^^^^^^^^^^^^^
|
1386 | * - `(function*() {})`
|
1387 | * ^^^^^^^^^
|
1388 | * - `() => {}`
|
1389 | * ^^
|
1390 | * - `async () => {}`
|
1391 | * ^^
|
1392 | * - `({ foo: function foo() {} })`
|
1393 | * ^^^^^^^^^^^^^^^^^
|
1394 | * - `({ foo: function() {} })`
|
1395 | * ^^^^^^^^^^^^^
|
1396 | * - `({ ['foo']: function() {} })`
|
1397 | * ^^^^^^^^^^^^^^^^^
|
1398 | * - `({ [foo]: function() {} })`
|
1399 | * ^^^^^^^^^^^^^^^
|
1400 | * - `({ foo() {} })`
|
1401 | * ^^^
|
1402 | * - `({ foo: function* foo() {} })`
|
1403 | * ^^^^^^^^^^^^^^^^^^
|
1404 | * - `({ foo: function*() {} })`
|
1405 | * ^^^^^^^^^^^^^^
|
1406 | * - `({ ['foo']: function*() {} })`
|
1407 | * ^^^^^^^^^^^^^^^^^^
|
1408 | * - `({ [foo]: function*() {} })`
|
1409 | * ^^^^^^^^^^^^^^^^
|
1410 | * - `({ *foo() {} })`
|
1411 | * ^^^^
|
1412 | * - `({ foo: async function foo() {} })`
|
1413 | * ^^^^^^^^^^^^^^^^^^^^^^^
|
1414 | * - `({ foo: async function() {} })`
|
1415 | * ^^^^^^^^^^^^^^^^^^^
|
1416 | * - `({ ['foo']: async function() {} })`
|
1417 | * ^^^^^^^^^^^^^^^^^^^^^^^
|
1418 | * - `({ [foo]: async function() {} })`
|
1419 | * ^^^^^^^^^^^^^^^^^^^^^
|
1420 | * - `({ async foo() {} })`
|
1421 | * ^^^^^^^^^
|
1422 | * - `({ get foo() {} })`
|
1423 | * ^^^^^^^
|
1424 | * - `({ set foo(a) {} })`
|
1425 | * ^^^^^^^
|
1426 | * - `class A { constructor() {} }`
|
1427 | * ^^^^^^^^^^^
|
1428 | * - `class A { foo() {} }`
|
1429 | * ^^^
|
1430 | * - `class A { *foo() {} }`
|
1431 | * ^^^^
|
1432 | * - `class A { async foo() {} }`
|
1433 | * ^^^^^^^^^
|
1434 | * - `class A { ['foo']() {} }`
|
1435 | * ^^^^^^^
|
1436 | * - `class A { *['foo']() {} }`
|
1437 | * ^^^^^^^^
|
1438 | * - `class A { async ['foo']() {} }`
|
1439 | * ^^^^^^^^^^^^^
|
1440 | * - `class A { [foo]() {} }`
|
1441 | * ^^^^^
|
1442 | * - `class A { *[foo]() {} }`
|
1443 | * ^^^^^^
|
1444 | * - `class A { async [foo]() {} }`
|
1445 | * ^^^^^^^^^^^
|
1446 | * - `class A { get foo() {} }`
|
1447 | * ^^^^^^^
|
1448 | * - `class A { set foo(a) {} }`
|
1449 | * ^^^^^^^
|
1450 | * - `class A { static foo() {} }`
|
1451 | * ^^^^^^^^^^
|
1452 | * - `class A { static *foo() {} }`
|
1453 | * ^^^^^^^^^^^
|
1454 | * - `class A { static async foo() {} }`
|
1455 | * ^^^^^^^^^^^^^^^^
|
1456 | * - `class A { static get foo() {} }`
|
1457 | * ^^^^^^^^^^^^^^
|
1458 | * - `class A { static set foo(a) {} }`
|
1459 | * ^^^^^^^^^^^^^^
|
1460 | * @param {ASTNode} node The function node to get.
|
1461 | * @param {SourceCode} sourceCode The source code object to get tokens.
|
1462 | * @returns {string} The location of the function node for reporting.
|
1463 | */
|
1464 | getFunctionHeadLoc(node, sourceCode) {
|
1465 | const parent = node.parent;
|
1466 | let start = null;
|
1467 | let end = null;
|
1468 |
|
1469 | if (node.type === "ArrowFunctionExpression") {
|
1470 | const arrowToken = sourceCode.getTokenBefore(node.body, isArrowToken);
|
1471 |
|
1472 | start = arrowToken.loc.start;
|
1473 | end = arrowToken.loc.end;
|
1474 | } else if (parent.type === "Property" || parent.type === "MethodDefinition") {
|
1475 | start = parent.loc.start;
|
1476 | end = getOpeningParenOfParams(node, sourceCode).loc.start;
|
1477 | } else {
|
1478 | start = node.loc.start;
|
1479 | end = getOpeningParenOfParams(node, sourceCode).loc.start;
|
1480 | }
|
1481 |
|
1482 | return {
|
1483 | start: Object.assign({}, start),
|
1484 | end: Object.assign({}, end)
|
1485 | };
|
1486 | },
|
1487 |
|
1488 | /**
|
1489 | * Gets next location when the result is not out of bound, otherwise returns null.
|
1490 | *
|
1491 | * Assumptions:
|
1492 | *
|
1493 | * - The given location represents a valid location in the given source code.
|
1494 | * - Columns are 0-based.
|
1495 | * - Lines are 1-based.
|
1496 | * - Column immediately after the last character in a line (not incl. linebreaks) is considered to be a valid location.
|
1497 | * - If the source code ends with a linebreak, `sourceCode.lines` array will have an extra element (empty string) at the end.
|
1498 | * The start (column 0) of that extra line is considered to be a valid location.
|
1499 | *
|
1500 | * Examples of successive locations (line, column):
|
1501 | *
|
1502 | * code: foo
|
1503 | * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> null
|
1504 | *
|
1505 | * code: foo<LF>
|
1506 | * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null
|
1507 | *
|
1508 | * code: foo<CR><LF>
|
1509 | * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null
|
1510 | *
|
1511 | * code: a<LF>b
|
1512 | * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> null
|
1513 | *
|
1514 | * code: a<LF>b<LF>
|
1515 | * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null
|
1516 | *
|
1517 | * code: a<CR><LF>b<CR><LF>
|
1518 | * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null
|
1519 | *
|
1520 | * code: a<LF><LF>
|
1521 | * locations: (1, 0) -> (1, 1) -> (2, 0) -> (3, 0) -> null
|
1522 | *
|
1523 | * code: <LF>
|
1524 | * locations: (1, 0) -> (2, 0) -> null
|
1525 | *
|
1526 | * code:
|
1527 | * locations: (1, 0) -> null
|
1528 | * @param {SourceCode} sourceCode The sourceCode
|
1529 | * @param {{line: number, column: number}} location The location
|
1530 | * @returns {{line: number, column: number} | null} Next location
|
1531 | */
|
1532 | getNextLocation(sourceCode, { line, column }) {
|
1533 | if (column < sourceCode.lines[line - 1].length) {
|
1534 | return {
|
1535 | line,
|
1536 | column: column + 1
|
1537 | };
|
1538 | }
|
1539 |
|
1540 | if (line < sourceCode.lines.length) {
|
1541 | return {
|
1542 | line: line + 1,
|
1543 | column: 0
|
1544 | };
|
1545 | }
|
1546 |
|
1547 | return null;
|
1548 | },
|
1549 |
|
1550 | /**
|
1551 | * Gets the parenthesized text of a node. This is similar to sourceCode.getText(node), but it also includes any parentheses
|
1552 | * surrounding the node.
|
1553 | * @param {SourceCode} sourceCode The source code object
|
1554 | * @param {ASTNode} node An expression node
|
1555 | * @returns {string} The text representing the node, with all surrounding parentheses included
|
1556 | */
|
1557 | getParenthesisedText(sourceCode, node) {
|
1558 | let leftToken = sourceCode.getFirstToken(node);
|
1559 | let rightToken = sourceCode.getLastToken(node);
|
1560 |
|
1561 | while (
|
1562 | sourceCode.getTokenBefore(leftToken) &&
|
1563 | sourceCode.getTokenBefore(leftToken).type === "Punctuator" &&
|
1564 | sourceCode.getTokenBefore(leftToken).value === "(" &&
|
1565 | sourceCode.getTokenAfter(rightToken) &&
|
1566 | sourceCode.getTokenAfter(rightToken).type === "Punctuator" &&
|
1567 | sourceCode.getTokenAfter(rightToken).value === ")"
|
1568 | ) {
|
1569 | leftToken = sourceCode.getTokenBefore(leftToken);
|
1570 | rightToken = sourceCode.getTokenAfter(rightToken);
|
1571 | }
|
1572 |
|
1573 | return sourceCode.getText().slice(leftToken.range[0], rightToken.range[1]);
|
1574 | },
|
1575 |
|
1576 | /*
|
1577 | * Determine if a node has a possibility to be an Error object
|
1578 | * @param {ASTNode} node ASTNode to check
|
1579 | * @returns {boolean} True if there is a chance it contains an Error obj
|
1580 | */
|
1581 | couldBeError(node) {
|
1582 | switch (node.type) {
|
1583 | case "Identifier":
|
1584 | case "CallExpression":
|
1585 | case "NewExpression":
|
1586 | case "MemberExpression":
|
1587 | case "TaggedTemplateExpression":
|
1588 | case "YieldExpression":
|
1589 | case "AwaitExpression":
|
1590 | case "ChainExpression":
|
1591 | return true; // possibly an error object.
|
1592 |
|
1593 | case "AssignmentExpression":
|
1594 | if (["=", "&&="].includes(node.operator)) {
|
1595 | return module.exports.couldBeError(node.right);
|
1596 | }
|
1597 |
|
1598 | if (["||=", "??="].includes(node.operator)) {
|
1599 | return module.exports.couldBeError(node.left) || module.exports.couldBeError(node.right);
|
1600 | }
|
1601 |
|
1602 | /**
|
1603 | * All other assignment operators are mathematical assignment operators (arithmetic or bitwise).
|
1604 | * An assignment expression with a mathematical operator can either evaluate to a primitive value,
|
1605 | * or throw, depending on the operands. Thus, it cannot evaluate to an `Error` object.
|
1606 | */
|
1607 | return false;
|
1608 |
|
1609 | case "SequenceExpression": {
|
1610 | const exprs = node.expressions;
|
1611 |
|
1612 | return exprs.length !== 0 && module.exports.couldBeError(exprs[exprs.length - 1]);
|
1613 | }
|
1614 |
|
1615 | case "LogicalExpression":
|
1616 |
|
1617 | /*
|
1618 | * If the && operator short-circuits, the left side was falsy and therefore not an error, and if it
|
1619 | * doesn't short-circuit, it takes the value from the right side, so the right side must always be
|
1620 | * a plausible error. A future improvement could verify that the left side could be truthy by
|
1621 | * excluding falsy literals.
|
1622 | */
|
1623 | if (node.operator === "&&") {
|
1624 | return module.exports.couldBeError(node.right);
|
1625 | }
|
1626 |
|
1627 | return module.exports.couldBeError(node.left) || module.exports.couldBeError(node.right);
|
1628 |
|
1629 | case "ConditionalExpression":
|
1630 | return module.exports.couldBeError(node.consequent) || module.exports.couldBeError(node.alternate);
|
1631 |
|
1632 | default:
|
1633 | return false;
|
1634 | }
|
1635 | },
|
1636 |
|
1637 | /**
|
1638 | * Check if a given node is a numeric literal or not.
|
1639 | * @param {ASTNode} node The node to check.
|
1640 | * @returns {boolean} `true` if the node is a number or bigint literal.
|
1641 | */
|
1642 | isNumericLiteral(node) {
|
1643 | return (
|
1644 | node.type === "Literal" &&
|
1645 | (typeof node.value === "number" || Boolean(node.bigint))
|
1646 | );
|
1647 | },
|
1648 |
|
1649 | /**
|
1650 | * Determines whether two tokens can safely be placed next to each other without merging into a single token
|
1651 | * @param {Token|string} leftValue The left token. If this is a string, it will be tokenized and the last token will be used.
|
1652 | * @param {Token|string} rightValue The right token. If this is a string, it will be tokenized and the first token will be used.
|
1653 | * @returns {boolean} If the tokens cannot be safely placed next to each other, returns `false`. If the tokens can be placed
|
1654 | * next to each other, behavior is undefined (although it should return `true` in most cases).
|
1655 | */
|
1656 | canTokensBeAdjacent(leftValue, rightValue) {
|
1657 | const espreeOptions = {
|
1658 | ecmaVersion: espree.latestEcmaVersion,
|
1659 | comment: true,
|
1660 | range: true
|
1661 | };
|
1662 |
|
1663 | let leftToken;
|
1664 |
|
1665 | if (typeof leftValue === "string") {
|
1666 | let tokens;
|
1667 |
|
1668 | try {
|
1669 | tokens = espree.tokenize(leftValue, espreeOptions);
|
1670 | } catch {
|
1671 | return false;
|
1672 | }
|
1673 |
|
1674 | const comments = tokens.comments;
|
1675 |
|
1676 | leftToken = tokens[tokens.length - 1];
|
1677 | if (comments.length) {
|
1678 | const lastComment = comments[comments.length - 1];
|
1679 |
|
1680 | if (lastComment.range[0] > leftToken.range[0]) {
|
1681 | leftToken = lastComment;
|
1682 | }
|
1683 | }
|
1684 | } else {
|
1685 | leftToken = leftValue;
|
1686 | }
|
1687 |
|
1688 | if (leftToken.type === "Shebang") {
|
1689 | return false;
|
1690 | }
|
1691 |
|
1692 | let rightToken;
|
1693 |
|
1694 | if (typeof rightValue === "string") {
|
1695 | let tokens;
|
1696 |
|
1697 | try {
|
1698 | tokens = espree.tokenize(rightValue, espreeOptions);
|
1699 | } catch {
|
1700 | return false;
|
1701 | }
|
1702 |
|
1703 | const comments = tokens.comments;
|
1704 |
|
1705 | rightToken = tokens[0];
|
1706 | if (comments.length) {
|
1707 | const firstComment = comments[0];
|
1708 |
|
1709 | if (firstComment.range[0] < rightToken.range[0]) {
|
1710 | rightToken = firstComment;
|
1711 | }
|
1712 | }
|
1713 | } else {
|
1714 | rightToken = rightValue;
|
1715 | }
|
1716 |
|
1717 | if (leftToken.type === "Punctuator" || rightToken.type === "Punctuator") {
|
1718 | if (leftToken.type === "Punctuator" && rightToken.type === "Punctuator") {
|
1719 | const PLUS_TOKENS = new Set(["+", "++"]);
|
1720 | const MINUS_TOKENS = new Set(["-", "--"]);
|
1721 |
|
1722 | return !(
|
1723 | PLUS_TOKENS.has(leftToken.value) && PLUS_TOKENS.has(rightToken.value) ||
|
1724 | MINUS_TOKENS.has(leftToken.value) && MINUS_TOKENS.has(rightToken.value)
|
1725 | );
|
1726 | }
|
1727 | if (leftToken.type === "Punctuator" && leftToken.value === "/") {
|
1728 | return !["Block", "Line", "RegularExpression"].includes(rightToken.type);
|
1729 | }
|
1730 | return true;
|
1731 | }
|
1732 |
|
1733 | if (
|
1734 | leftToken.type === "String" || rightToken.type === "String" ||
|
1735 | leftToken.type === "Template" || rightToken.type === "Template"
|
1736 | ) {
|
1737 | return true;
|
1738 | }
|
1739 |
|
1740 | if (leftToken.type !== "Numeric" && rightToken.type === "Numeric" && rightToken.value.startsWith(".")) {
|
1741 | return true;
|
1742 | }
|
1743 |
|
1744 | if (leftToken.type === "Block" || rightToken.type === "Block" || rightToken.type === "Line") {
|
1745 | return true;
|
1746 | }
|
1747 |
|
1748 | return false;
|
1749 | },
|
1750 |
|
1751 | /**
|
1752 | * Get the `loc` object of a given name in a `/*globals` directive comment.
|
1753 | * @param {SourceCode} sourceCode The source code to convert index to loc.
|
1754 | * @param {Comment} comment The `/*globals` directive comment which include the name.
|
1755 | * @param {string} name The name to find.
|
1756 | * @returns {SourceLocation} The `loc` object.
|
1757 | */
|
1758 | getNameLocationInGlobalDirectiveComment(sourceCode, comment, name) {
|
1759 | const namePattern = new RegExp(`[\\s,]${lodash.escapeRegExp(name)}(?:$|[\\s,:])`, "gu");
|
1760 |
|
1761 | // To ignore the first text "global".
|
1762 | namePattern.lastIndex = comment.value.indexOf("global") + 6;
|
1763 |
|
1764 | // Search a given variable name.
|
1765 | const match = namePattern.exec(comment.value);
|
1766 |
|
1767 | // Convert the index to loc.
|
1768 | const start = sourceCode.getLocFromIndex(
|
1769 | comment.range[0] +
|
1770 | "/*".length +
|
1771 | (match ? match.index + 1 : 0)
|
1772 | );
|
1773 | const end = {
|
1774 | line: start.line,
|
1775 | column: start.column + (match ? name.length : 1)
|
1776 | };
|
1777 |
|
1778 | return { start, end };
|
1779 | },
|
1780 |
|
1781 | /**
|
1782 | * Determines whether the given raw string contains an octal escape sequence
|
1783 | * or a non-octal decimal escape sequence ("\8", "\9").
|
1784 | *
|
1785 | * "\1", "\2" ... "\7", "\8", "\9"
|
1786 | * "\00", "\01" ... "\07", "\08", "\09"
|
1787 | *
|
1788 | * "\0", when not followed by a digit, is not an octal escape sequence.
|
1789 | * @param {string} rawString A string in its raw representation.
|
1790 | * @returns {boolean} `true` if the string contains at least one octal escape sequence
|
1791 | * or at least one non-octal decimal escape sequence.
|
1792 | */
|
1793 | hasOctalOrNonOctalDecimalEscapeSequence(rawString) {
|
1794 | return OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN.test(rawString);
|
1795 | },
|
1796 |
|
1797 | isLogicalExpression,
|
1798 | isCoalesceExpression,
|
1799 | isMixedLogicalAndCoalesceExpressions,
|
1800 | isNullLiteral,
|
1801 | getStaticStringValue,
|
1802 | getStaticPropertyName,
|
1803 | skipChainExpression,
|
1804 | isSpecificId,
|
1805 | isSpecificMemberAccess,
|
1806 | equalLiteralValue,
|
1807 | isSameReference,
|
1808 | isLogicalAssignmentOperator
|
1809 | };
|