/** * @fileoverview Common utils for AST. * @author Gyandeep Singh */ "use strict"; //------------------------------------------------------------------------------ // Requirements //------------------------------------------------------------------------------ const esutils = require("esutils"); const espree = require("espree"); const escapeRegExp = require("escape-string-regexp"); const { breakableTypePattern, createGlobalLinebreakMatcher, lineBreakPattern, shebangPattern } = require("../../shared/ast-utils"); //------------------------------------------------------------------------------ // Helpers //------------------------------------------------------------------------------ const anyFunctionPattern = /^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression)$/u; const anyLoopPattern = /^(?:DoWhile|For|ForIn|ForOf|While)Statement$/u; const arrayOrTypedArrayPattern = /Array$/u; const arrayMethodPattern = /^(?:every|filter|find|findIndex|forEach|map|some)$/u; const bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/u; const thisTagPattern = /^[\s*]*@this/mu; const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u; const ESLINT_DIRECTIVE_PATTERN = /^(?:eslint[- ]|(?:globals?|exported) )/u; const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]); // A set of node types that can contain a list of statements const STATEMENT_LIST_PARENTS = new Set(["Program", "BlockStatement", "StaticBlock", "SwitchCase"]); const DECIMAL_INTEGER_PATTERN = /^(?:0|0[0-7]*[89]\d*|[1-9](?:_?\d)*)$/u; // Tests the presence of at least one LegacyOctalEscapeSequence or NonOctalDecimalEscapeSequence in a raw string const OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN = /^(?:[^\\]|\\.)*\\(?:[1-9]|0[0-9])/su; const LOGICAL_ASSIGNMENT_OPERATORS = new Set(["&&=", "||=", "??="]); /** * Checks reference if is non initializer and writable. * @param {Reference} reference A reference to check. * @param {int} index The index of the reference in the references. * @param {Reference[]} references The array that the reference belongs to. * @returns {boolean} Success/Failure * @private */ function isModifyingReference(reference, index, references) { const identifier = reference.identifier; /* * Destructuring assignments can have multiple default value, so * possibly there are multiple writeable references for the same * identifier. */ const modifyingDifferentIdentifier = index === 0 || references[index - 1].identifier !== identifier; return (identifier && reference.init === false && reference.isWrite() && modifyingDifferentIdentifier ); } /** * Checks whether the given string starts with uppercase or not. * @param {string} s The string to check. * @returns {boolean} `true` if the string starts with uppercase. */ function startsWithUpperCase(s) { return s[0] !== s[0].toLocaleLowerCase(); } /** * Checks whether or not a node is a constructor. * @param {ASTNode} node A function node to check. * @returns {boolean} Whether or not a node is a constructor. */ function isES5Constructor(node) { return (node.id && startsWithUpperCase(node.id.name)); } /** * Finds a function node from ancestors of a node. * @param {ASTNode} node A start node to find. * @returns {Node|null} A found function node. */ function getUpperFunction(node) { for (let currentNode = node; currentNode; currentNode = currentNode.parent) { if (anyFunctionPattern.test(currentNode.type)) { return currentNode; } } return null; } /** * Checks whether a given node is a function node or not. * The following types are function nodes: * * - ArrowFunctionExpression * - FunctionDeclaration * - FunctionExpression * @param {ASTNode|null} node A node to check. * @returns {boolean} `true` if the node is a function node. */ function isFunction(node) { return Boolean(node && anyFunctionPattern.test(node.type)); } /** * Checks whether a given node is a loop node or not. * The following types are loop nodes: * * - DoWhileStatement * - ForInStatement * - ForOfStatement * - ForStatement * - WhileStatement * @param {ASTNode|null} node A node to check. * @returns {boolean} `true` if the node is a loop node. */ function isLoop(node) { return Boolean(node && anyLoopPattern.test(node.type)); } /** * Checks whether the given node is in a loop or not. * @param {ASTNode} node The node to check. * @returns {boolean} `true` if the node is in a loop. */ function isInLoop(node) { for (let currentNode = node; currentNode && !isFunction(currentNode); currentNode = currentNode.parent) { if (isLoop(currentNode)) { return true; } } return false; } /** * Determines whether the given node is a `null` literal. * @param {ASTNode} node The node to check * @returns {boolean} `true` if the node is a `null` literal */ function isNullLiteral(node) { /* * Checking `node.value === null` does not guarantee that a literal is a null literal. * When parsing values that cannot be represented in the current environment (e.g. unicode * regexes in Node 4), `node.value` is set to `null` because it wouldn't be possible to * set `node.value` to a unicode regex. To make sure a literal is actually `null`, check * `node.regex` instead. Also see: https://github.com/eslint/eslint/issues/8020 */ return node.type === "Literal" && node.value === null && !node.regex && !node.bigint; } /** * Checks whether or not a node is `null` or `undefined`. * @param {ASTNode} node A node to check. * @returns {boolean} Whether or not the node is a `null` or `undefined`. * @public */ function isNullOrUndefined(node) { return ( isNullLiteral(node) || (node.type === "Identifier" && node.name === "undefined") || (node.type === "UnaryExpression" && node.operator === "void") ); } /** * Checks whether or not a node is callee. * @param {ASTNode} node A node to check. * @returns {boolean} Whether or not the node is callee. */ function isCallee(node) { return node.parent.type === "CallExpression" && node.parent.callee === node; } /** * Returns the result of the string conversion applied to the evaluated value of the given expression node, * if it can be determined statically. * * This function returns a `string` value for all `Literal` nodes and simple `TemplateLiteral` nodes only. * In all other cases, this function returns `null`. * @param {ASTNode} node Expression node. * @returns {string|null} String value if it can be determined. Otherwise, `null`. */ function getStaticStringValue(node) { switch (node.type) { case "Literal": if (node.value === null) { if (isNullLiteral(node)) { return String(node.value); // "null" } if (node.regex) { return `/${node.regex.pattern}/${node.regex.flags}`; } if (node.bigint) { return node.bigint; } // Otherwise, this is an unknown literal. The function will return null. } else { return String(node.value); } break; case "TemplateLiteral": if (node.expressions.length === 0 && node.quasis.length === 1) { return node.quasis[0].value.cooked; } break; // no default } return null; } /** * Gets the property name of a given node. * The node can be a MemberExpression, a Property, or a MethodDefinition. * * If the name is dynamic, this returns `null`. * * For examples: * * a.b // => "b" * a["b"] // => "b" * a['b'] // => "b" * a[`b`] // => "b" * a[100] // => "100" * a[b] // => null * a["a" + "b"] // => null * a[tag`b`] // => null * a[`${b}`] // => null * * let a = {b: 1} // => "b" * let a = {["b"]: 1} // => "b" * let a = {['b']: 1} // => "b" * let a = {[`b`]: 1} // => "b" * let a = {[100]: 1} // => "100" * let a = {[b]: 1} // => null * let a = {["a" + "b"]: 1} // => null * let a = {[tag`b`]: 1} // => null * let a = {[`${b}`]: 1} // => null * @param {ASTNode} node The node to get. * @returns {string|null} The property name if static. Otherwise, null. */ function getStaticPropertyName(node) { let prop; switch (node && node.type) { case "ChainExpression": return getStaticPropertyName(node.expression); case "Property": case "PropertyDefinition": case "MethodDefinition": prop = node.key; break; case "MemberExpression": prop = node.property; break; // no default } if (prop) { if (prop.type === "Identifier" && !node.computed) { return prop.name; } return getStaticStringValue(prop); } return null; } /** * Retrieve `ChainExpression#expression` value if the given node a `ChainExpression` node. Otherwise, pass through it. * @param {ASTNode} node The node to address. * @returns {ASTNode} The `ChainExpression#expression` value if the node is a `ChainExpression` node. Otherwise, the node. */ function skipChainExpression(node) { return node && node.type === "ChainExpression" ? node.expression : node; } /** * Check if the `actual` is an expected value. * @param {string} actual The string value to check. * @param {string | RegExp} expected The expected string value or pattern. * @returns {boolean} `true` if the `actual` is an expected value. */ function checkText(actual, expected) { return typeof expected === "string" ? actual === expected : expected.test(actual); } /** * Check if a given node is an Identifier node with a given name. * @param {ASTNode} node The node to check. * @param {string | RegExp} name The expected name or the expected pattern of the object name. * @returns {boolean} `true` if the node is an Identifier node with the name. */ function isSpecificId(node, name) { return node.type === "Identifier" && checkText(node.name, name); } /** * Check if a given node is member access with a given object name and property name pair. * This is regardless of optional or not. * @param {ASTNode} node The node to check. * @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. * @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. * @returns {boolean} `true` if the node is member access with the object name and property name pair. * The node is a `MemberExpression` or `ChainExpression`. */ function isSpecificMemberAccess(node, objectName, propertyName) { const checkNode = skipChainExpression(node); if (checkNode.type !== "MemberExpression") { return false; } if (objectName && !isSpecificId(checkNode.object, objectName)) { return false; } if (propertyName) { const actualPropertyName = getStaticPropertyName(checkNode); if (typeof actualPropertyName !== "string" || !checkText(actualPropertyName, propertyName)) { return false; } } return true; } /** * Check if two literal nodes are the same value. * @param {ASTNode} left The Literal node to compare. * @param {ASTNode} right The other Literal node to compare. * @returns {boolean} `true` if the two literal nodes are the same value. */ function equalLiteralValue(left, right) { // RegExp literal. if (left.regex || right.regex) { return Boolean( left.regex && right.regex && left.regex.pattern === right.regex.pattern && left.regex.flags === right.regex.flags ); } // BigInt literal. if (left.bigint || right.bigint) { return left.bigint === right.bigint; } return left.value === right.value; } /** * Check if two expressions reference the same value. For example: * a = a * a.b = a.b * a[0] = a[0] * a['b'] = a['b'] * @param {ASTNode} left The left side of the comparison. * @param {ASTNode} right The right side of the comparison. * @param {boolean} [disableStaticComputedKey] Don't address `a.b` and `a["b"]` are the same if `true`. For backward compatibility. * @returns {boolean} `true` if both sides match and reference the same value. */ function isSameReference(left, right, disableStaticComputedKey = false) { if (left.type !== right.type) { // Handle `a.b` and `a?.b` are samely. if (left.type === "ChainExpression") { return isSameReference(left.expression, right, disableStaticComputedKey); } if (right.type === "ChainExpression") { return isSameReference(left, right.expression, disableStaticComputedKey); } return false; } switch (left.type) { case "Super": case "ThisExpression": return true; case "Identifier": case "PrivateIdentifier": return left.name === right.name; case "Literal": return equalLiteralValue(left, right); case "ChainExpression": return isSameReference(left.expression, right.expression, disableStaticComputedKey); case "MemberExpression": { if (!disableStaticComputedKey) { const nameA = getStaticPropertyName(left); // x.y = x["y"] if (nameA !== null) { return ( isSameReference(left.object, right.object, disableStaticComputedKey) && nameA === getStaticPropertyName(right) ); } } /* * x[0] = x[0] * x[y] = x[y] * x.y = x.y */ return ( left.computed === right.computed && isSameReference(left.object, right.object, disableStaticComputedKey) && isSameReference(left.property, right.property, disableStaticComputedKey) ); } default: return false; } } /** * Checks whether or not a node is `Reflect.apply`. * @param {ASTNode} node A node to check. * @returns {boolean} Whether or not the node is a `Reflect.apply`. */ function isReflectApply(node) { return isSpecificMemberAccess(node, "Reflect", "apply"); } /** * Checks whether or not a node is `Array.from`. * @param {ASTNode} node A node to check. * @returns {boolean} Whether or not the node is a `Array.from`. */ function isArrayFromMethod(node) { return isSpecificMemberAccess(node, arrayOrTypedArrayPattern, "from"); } /** * Checks whether or not a node is a method which has `thisArg`. * @param {ASTNode} node A node to check. * @returns {boolean} Whether or not the node is a method which has `thisArg`. */ function isMethodWhichHasThisArg(node) { return isSpecificMemberAccess(node, null, arrayMethodPattern); } /** * Creates the negate function of the given function. * @param {Function} f The function to negate. * @returns {Function} Negated function. */ function negate(f) { return token => !f(token); } /** * Checks whether or not a node has a `@this` tag in its comments. * @param {ASTNode} node A node to check. * @param {SourceCode} sourceCode A SourceCode instance to get comments. * @returns {boolean} Whether or not the node has a `@this` tag in its comments. */ function hasJSDocThisTag(node, sourceCode) { const jsdocComment = sourceCode.getJSDocComment(node); if (jsdocComment && thisTagPattern.test(jsdocComment.value)) { return true; } // Checks `@this` in its leading comments for callbacks, // because callbacks don't have its JSDoc comment. // e.g. // sinon.test(/* @this sinon.Sandbox */function() { this.spy(); }); return sourceCode.getCommentsBefore(node).some(comment => thisTagPattern.test(comment.value)); } /** * Determines if a node is surrounded by parentheses. * @param {SourceCode} sourceCode The ESLint source code object * @param {ASTNode} node The node to be checked. * @returns {boolean} True if the node is parenthesised. * @private */ function isParenthesised(sourceCode, node) { const previousToken = sourceCode.getTokenBefore(node), nextToken = sourceCode.getTokenAfter(node); return Boolean(previousToken && nextToken) && previousToken.value === "(" && previousToken.range[1] <= node.range[0] && nextToken.value === ")" && nextToken.range[0] >= node.range[1]; } /** * Checks if the given token is a `=` token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is a `=` token. */ function isEqToken(token) { return token.value === "=" && token.type === "Punctuator"; } /** * Checks if the given token is an arrow token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is an arrow token. */ function isArrowToken(token) { return token.value === "=>" && token.type === "Punctuator"; } /** * Checks if the given token is a comma token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is a comma token. */ function isCommaToken(token) { return token.value === "," && token.type === "Punctuator"; } /** * Checks if the given token is a dot token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is a dot token. */ function isDotToken(token) { return token.value === "." && token.type === "Punctuator"; } /** * Checks if the given token is a `?.` token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is a `?.` token. */ function isQuestionDotToken(token) { return token.value === "?." && token.type === "Punctuator"; } /** * Checks if the given token is a semicolon token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is a semicolon token. */ function isSemicolonToken(token) { return token.value === ";" && token.type === "Punctuator"; } /** * Checks if the given token is a colon token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is a colon token. */ function isColonToken(token) { return token.value === ":" && token.type === "Punctuator"; } /** * Checks if the given token is an opening parenthesis token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is an opening parenthesis token. */ function isOpeningParenToken(token) { return token.value === "(" && token.type === "Punctuator"; } /** * Checks if the given token is a closing parenthesis token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is a closing parenthesis token. */ function isClosingParenToken(token) { return token.value === ")" && token.type === "Punctuator"; } /** * Checks if the given token is an opening square bracket token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is an opening square bracket token. */ function isOpeningBracketToken(token) { return token.value === "[" && token.type === "Punctuator"; } /** * Checks if the given token is a closing square bracket token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is a closing square bracket token. */ function isClosingBracketToken(token) { return token.value === "]" && token.type === "Punctuator"; } /** * Checks if the given token is an opening brace token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is an opening brace token. */ function isOpeningBraceToken(token) { return token.value === "{" && token.type === "Punctuator"; } /** * Checks if the given token is a closing brace token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is a closing brace token. */ function isClosingBraceToken(token) { return token.value === "}" && token.type === "Punctuator"; } /** * Checks if the given token is a comment token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is a comment token. */ function isCommentToken(token) { return token.type === "Line" || token.type === "Block" || token.type === "Shebang"; } /** * Checks if the given token is a keyword token or not. * @param {Token} token The token to check. * @returns {boolean} `true` if the token is a keyword token. */ function isKeywordToken(token) { return token.type === "Keyword"; } /** * Gets the `(` token of the given function node. * @param {ASTNode} node The function node to get. * @param {SourceCode} sourceCode The source code object to get tokens. * @returns {Token} `(` token. */ function getOpeningParenOfParams(node, sourceCode) { // If the node is an arrow function and doesn't have parens, this returns the identifier of the first param. if (node.type === "ArrowFunctionExpression" && node.params.length === 1) { const argToken = sourceCode.getFirstToken(node.params[0]); const maybeParenToken = sourceCode.getTokenBefore(argToken); return isOpeningParenToken(maybeParenToken) ? maybeParenToken : argToken; } // Otherwise, returns paren. return node.id ? sourceCode.getTokenAfter(node.id, isOpeningParenToken) : sourceCode.getFirstToken(node, isOpeningParenToken); } /** * Checks whether or not the tokens of two given nodes are same. * @param {ASTNode} left A node 1 to compare. * @param {ASTNode} right A node 2 to compare. * @param {SourceCode} sourceCode The ESLint source code object. * @returns {boolean} the source code for the given node. */ function equalTokens(left, right, sourceCode) { const tokensL = sourceCode.getTokens(left); const tokensR = sourceCode.getTokens(right); if (tokensL.length !== tokensR.length) { return false; } for (let i = 0; i < tokensL.length; ++i) { if (tokensL[i].type !== tokensR[i].type || tokensL[i].value !== tokensR[i].value ) { return false; } } return true; } /** * Check if the given node is a true logical expression or not. * * The three binary expressions logical-or (`||`), logical-and (`&&`), and * coalesce (`??`) are known as `ShortCircuitExpression`. * But ESTree represents those by `LogicalExpression` node. * * This function rejects coalesce expressions of `LogicalExpression` node. * @param {ASTNode} node The node to check. * @returns {boolean} `true` if the node is `&&` or `||`. * @see https://tc39.es/ecma262/#prod-ShortCircuitExpression */ function isLogicalExpression(node) { return ( node.type === "LogicalExpression" && (node.operator === "&&" || node.operator === "||") ); } /** * Check if the given node is a nullish coalescing expression or not. * * The three binary expressions logical-or (`||`), logical-and (`&&`), and * coalesce (`??`) are known as `ShortCircuitExpression`. * But ESTree represents those by `LogicalExpression` node. * * This function finds only coalesce expressions of `LogicalExpression` node. * @param {ASTNode} node The node to check. * @returns {boolean} `true` if the node is `??`. */ function isCoalesceExpression(node) { return node.type === "LogicalExpression" && node.operator === "??"; } /** * Check if given two nodes are the pair of a logical expression and a coalesce expression. * @param {ASTNode} left A node to check. * @param {ASTNode} right Another node to check. * @returns {boolean} `true` if the two nodes are the pair of a logical expression and a coalesce expression. */ function isMixedLogicalAndCoalesceExpressions(left, right) { return ( (isLogicalExpression(left) && isCoalesceExpression(right)) || (isCoalesceExpression(left) && isLogicalExpression(right)) ); } /** * Checks if the given operator is a logical assignment operator. * @param {string} operator The operator to check. * @returns {boolean} `true` if the operator is a logical assignment operator. */ function isLogicalAssignmentOperator(operator) { return LOGICAL_ASSIGNMENT_OPERATORS.has(operator); } /** * Get the colon token of the given SwitchCase node. * @param {ASTNode} node The SwitchCase node to get. * @param {SourceCode} sourceCode The source code object to get tokens. * @returns {Token} The colon token of the node. */ function getSwitchCaseColonToken(node, sourceCode) { if (node.test) { return sourceCode.getTokenAfter(node.test, isColonToken); } return sourceCode.getFirstToken(node, 1); } /** * Gets ESM module export name represented by the given node. * @param {ASTNode} node `Identifier` or string `Literal` node in a position * that represents a module export name: * - `ImportSpecifier#imported` * - `ExportSpecifier#local` (if it is a re-export from another module) * - `ExportSpecifier#exported` * - `ExportAllDeclaration#exported` * @returns {string} The module export name. */ function getModuleExportName(node) { if (node.type === "Identifier") { return node.name; } // string literal return node.value; } /** * Returns literal's value converted to the Boolean type * @param {ASTNode} node any `Literal` node * @returns {boolean | null} `true` when node is truthy, `false` when node is falsy, * `null` when it cannot be determined. */ function getBooleanValue(node) { if (node.value === null) { /* * it might be a null literal or bigint/regex literal in unsupported environments . * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es5.md#regexpliteral * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es2020.md#bigintliteral */ if (node.raw === "null") { return false; } // regex is always truthy if (typeof node.regex === "object") { return true; } return null; } return !!node.value; } /** * Checks if a branch node of LogicalExpression short circuits the whole condition * @param {ASTNode} node The branch of main condition which needs to be checked * @param {string} operator The operator of the main LogicalExpression. * @returns {boolean} true when condition short circuits whole condition */ function isLogicalIdentity(node, operator) { switch (node.type) { case "Literal": return (operator === "||" && getBooleanValue(node) === true) || (operator === "&&" && getBooleanValue(node) === false); case "UnaryExpression": return (operator === "&&" && node.operator === "void"); case "LogicalExpression": /* * handles `a && false || b` * `false` is an identity element of `&&` but not `||` */ return operator === node.operator && ( isLogicalIdentity(node.left, operator) || isLogicalIdentity(node.right, operator) ); case "AssignmentExpression": return ["||=", "&&="].includes(node.operator) && operator === node.operator.slice(0, -1) && isLogicalIdentity(node.right, operator); // no default } return false; } /** * Checks if an identifier is a reference to a global variable. * @param {Scope} scope The scope in which the identifier is referenced. * @param {ASTNode} node An identifier node to check. * @returns {boolean} `true` if the identifier is a reference to a global variable. */ function isReferenceToGlobalVariable(scope, node) { const reference = scope.references.find(ref => ref.identifier === node); return Boolean( reference && reference.resolved && reference.resolved.scope.type === "global" && reference.resolved.defs.length === 0 ); } /** * Checks if a node has a constant truthiness value. * @param {Scope} scope Scope in which the node appears. * @param {ASTNode} node The AST node to check. * @param {boolean} inBooleanPosition `true` if checking the test of a * condition. `false` in all other cases. When `false`, checks if -- for * both string and number -- if coerced to that type, the value will * be constant. * @returns {boolean} true when node's truthiness is constant * @private */ function isConstant(scope, node, inBooleanPosition) { // node.elements can return null values in the case of sparse arrays ex. [,] if (!node) { return true; } switch (node.type) { case "Literal": case "ArrowFunctionExpression": case "FunctionExpression": return true; case "ClassExpression": case "ObjectExpression": /** * In theory objects like: * * `{toString: () => a}` * `{valueOf: () => a}` * * Or a classes like: * * `class { static toString() { return a } }` * `class { static valueOf() { return a } }` * * Are not constant verifiably when `inBooleanPosition` is * false, but it's an edge case we've opted not to handle. */ return true; case "TemplateLiteral": return (inBooleanPosition && node.quasis.some(quasi => quasi.value.cooked.length)) || node.expressions.every(exp => isConstant(scope, exp, false)); case "ArrayExpression": { if (!inBooleanPosition) { return node.elements.every(element => isConstant(scope, element, false)); } return true; } case "UnaryExpression": if ( node.operator === "void" || node.operator === "typeof" && inBooleanPosition ) { return true; } if (node.operator === "!") { return isConstant(scope, node.argument, true); } return isConstant(scope, node.argument, false); case "BinaryExpression": return isConstant(scope, node.left, false) && isConstant(scope, node.right, false) && node.operator !== "in"; case "LogicalExpression": { const isLeftConstant = isConstant(scope, node.left, inBooleanPosition); const isRightConstant = isConstant(scope, node.right, inBooleanPosition); const isLeftShortCircuit = (isLeftConstant && isLogicalIdentity(node.left, node.operator)); const isRightShortCircuit = (inBooleanPosition && isRightConstant && isLogicalIdentity(node.right, node.operator)); return (isLeftConstant && isRightConstant) || isLeftShortCircuit || isRightShortCircuit; } case "NewExpression": return inBooleanPosition; case "AssignmentExpression": if (node.operator === "=") { return isConstant(scope, node.right, inBooleanPosition); } if (["||=", "&&="].includes(node.operator) && inBooleanPosition) { return isLogicalIdentity(node.right, node.operator.slice(0, -1)); } return false; case "SequenceExpression": return isConstant(scope, node.expressions[node.expressions.length - 1], inBooleanPosition); case "SpreadElement": return isConstant(scope, node.argument, inBooleanPosition); case "CallExpression": if (node.callee.type === "Identifier" && node.callee.name === "Boolean") { if (node.arguments.length === 0 || isConstant(scope, node.arguments[0], true)) { return isReferenceToGlobalVariable(scope, node.callee); } } return false; case "Identifier": return node.name === "undefined" && isReferenceToGlobalVariable(scope, node); // no default } return false; } //------------------------------------------------------------------------------ // Public Interface //------------------------------------------------------------------------------ module.exports = { COMMENTS_IGNORE_PATTERN, LINEBREAKS, LINEBREAK_MATCHER: lineBreakPattern, SHEBANG_MATCHER: shebangPattern, STATEMENT_LIST_PARENTS, /** * Determines whether two adjacent tokens are on the same line. * @param {Object} left The left token object. * @param {Object} right The right token object. * @returns {boolean} Whether or not the tokens are on the same line. * @public */ isTokenOnSameLine(left, right) { return left.loc.end.line === right.loc.start.line; }, isNullOrUndefined, isCallee, isES5Constructor, getUpperFunction, isFunction, isLoop, isInLoop, isArrayFromMethod, isParenthesised, createGlobalLinebreakMatcher, equalTokens, isArrowToken, isClosingBraceToken, isClosingBracketToken, isClosingParenToken, isColonToken, isCommaToken, isCommentToken, isDotToken, isQuestionDotToken, isKeywordToken, isNotClosingBraceToken: negate(isClosingBraceToken), isNotClosingBracketToken: negate(isClosingBracketToken), isNotClosingParenToken: negate(isClosingParenToken), isNotColonToken: negate(isColonToken), isNotCommaToken: negate(isCommaToken), isNotDotToken: negate(isDotToken), isNotQuestionDotToken: negate(isQuestionDotToken), isNotOpeningBraceToken: negate(isOpeningBraceToken), isNotOpeningBracketToken: negate(isOpeningBracketToken), isNotOpeningParenToken: negate(isOpeningParenToken), isNotSemicolonToken: negate(isSemicolonToken), isOpeningBraceToken, isOpeningBracketToken, isOpeningParenToken, isSemicolonToken, isEqToken, /** * Checks whether or not a given node is a string literal. * @param {ASTNode} node A node to check. * @returns {boolean} `true` if the node is a string literal. */ isStringLiteral(node) { return ( (node.type === "Literal" && typeof node.value === "string") || node.type === "TemplateLiteral" ); }, /** * Checks whether a given node is a breakable statement or not. * The node is breakable if the node is one of the following type: * * - DoWhileStatement * - ForInStatement * - ForOfStatement * - ForStatement * - SwitchStatement * - WhileStatement * @param {ASTNode} node A node to check. * @returns {boolean} `true` if the node is breakable. */ isBreakableStatement(node) { return breakableTypePattern.test(node.type); }, /** * Gets references which are non initializer and writable. * @param {Reference[]} references An array of references. * @returns {Reference[]} An array of only references which are non initializer and writable. * @public */ getModifyingReferences(references) { return references.filter(isModifyingReference); }, /** * Validate that a string passed in is surrounded by the specified character * @param {string} val The text to check. * @param {string} character The character to see if it's surrounded by. * @returns {boolean} True if the text is surrounded by the character, false if not. * @private */ isSurroundedBy(val, character) { return val[0] === character && val[val.length - 1] === character; }, /** * Returns whether the provided node is an ESLint directive comment or not * @param {Line|Block} node The comment token to be checked * @returns {boolean} `true` if the node is an ESLint directive comment */ isDirectiveComment(node) { const comment = node.value.trim(); return ( node.type === "Line" && comment.startsWith("eslint-") || node.type === "Block" && ESLINT_DIRECTIVE_PATTERN.test(comment) ); }, /** * Gets the trailing statement of a given node. * * if (code) * consequent; * * When taking this `IfStatement`, returns `consequent;` statement. * @param {ASTNode} A node to get. * @returns {ASTNode|null} The trailing statement's node. */ getTrailingStatement: esutils.ast.trailingStatement, /** * Finds the variable by a given name in a given scope and its upper scopes. * @param {eslint-scope.Scope} initScope A scope to start find. * @param {string} name A variable name to find. * @returns {eslint-scope.Variable|null} A found variable or `null`. */ getVariableByName(initScope, name) { let scope = initScope; while (scope) { const variable = scope.set.get(name); if (variable) { return variable; } scope = scope.upper; } return null; }, /** * Checks whether or not a given function node is the default `this` binding. * * First, this checks the node: * * - The given node is not in `PropertyDefinition#value` position. * - The given node is not `StaticBlock`. * - The function name does not start with uppercase. It's a convention to capitalize the names * of constructor functions. This check is not performed if `capIsConstructor` is set to `false`. * - The function does not have a JSDoc comment that has a @this tag. * * Next, this checks the location of the node. * If the location is below, this judges `this` is valid. * * - The location is not on an object literal. * - The location is not assigned to a variable which starts with an uppercase letter. Applies to anonymous * functions only, as the name of the variable is considered to be the name of the function in this case. * This check is not performed if `capIsConstructor` is set to `false`. * - The location is not on an ES2015 class. * - Its `bind`/`call`/`apply` method is not called directly. * - The function is not a callback of array methods (such as `.forEach()`) if `thisArg` is given. * @param {ASTNode} node A function node to check. It also can be an implicit function, like `StaticBlock` * or any expression that is `PropertyDefinition#value` node. * @param {SourceCode} sourceCode A SourceCode instance to get comments. * @param {boolean} [capIsConstructor = true] `false` disables the assumption that functions which name starts * with an uppercase or are assigned to a variable which name starts with an uppercase are constructors. * @returns {boolean} The function node is the default `this` binding. */ isDefaultThisBinding(node, sourceCode, { capIsConstructor = true } = {}) { /* * Class field initializers are implicit functions, but ESTree doesn't have the AST node of field initializers. * Therefore, A expression node at `PropertyDefinition#value` is a function. * In this case, `this` is always not default binding. */ if (node.parent.type === "PropertyDefinition" && node.parent.value === node) { return false; } // Class static blocks are implicit functions. In this case, `this` is always not default binding. if (node.type === "StaticBlock") { return false; } if ( (capIsConstructor && isES5Constructor(node)) || hasJSDocThisTag(node, sourceCode) ) { return false; } const isAnonymous = node.id === null; let currentNode = node; while (currentNode) { const parent = currentNode.parent; switch (parent.type) { /* * Looks up the destination. * e.g., obj.foo = nativeFoo || function foo() { ... }; */ case "LogicalExpression": case "ConditionalExpression": case "ChainExpression": currentNode = parent; break; /* * If the upper function is IIFE, checks the destination of the return value. * e.g. * obj.foo = (function() { * // setup... * return function foo() { ... }; * })(); * obj.foo = (() => * function foo() { ... } * )(); */ case "ReturnStatement": { const func = getUpperFunction(parent); if (func === null || !isCallee(func)) { return true; } currentNode = func.parent; break; } case "ArrowFunctionExpression": if (currentNode !== parent.body || !isCallee(parent)) { return true; } currentNode = parent.parent; break; /* * e.g. * var obj = { foo() { ... } }; * var obj = { foo: function() { ... } }; * class A { constructor() { ... } } * class A { foo() { ... } } * class A { get foo() { ... } } * class A { set foo() { ... } } * class A { static foo() { ... } } * class A { foo = function() { ... } } */ case "Property": case "PropertyDefinition": case "MethodDefinition": return parent.value !== currentNode; /* * e.g. * obj.foo = function foo() { ... }; * Foo = function() { ... }; * [obj.foo = function foo() { ... }] = a; * [Foo = function() { ... }] = a; */ case "AssignmentExpression": case "AssignmentPattern": if (parent.left.type === "MemberExpression") { return false; } if ( capIsConstructor && isAnonymous && parent.left.type === "Identifier" && startsWithUpperCase(parent.left.name) ) { return false; } return true; /* * e.g. * var Foo = function() { ... }; */ case "VariableDeclarator": return !( capIsConstructor && isAnonymous && parent.init === currentNode && parent.id.type === "Identifier" && startsWithUpperCase(parent.id.name) ); /* * e.g. * var foo = function foo() { ... }.bind(obj); * (function foo() { ... }).call(obj); * (function foo() { ... }).apply(obj, []); */ case "MemberExpression": if ( parent.object === currentNode && isSpecificMemberAccess(parent, null, bindOrCallOrApplyPattern) ) { const maybeCalleeNode = parent.parent.type === "ChainExpression" ? parent.parent : parent; return !( isCallee(maybeCalleeNode) && maybeCalleeNode.parent.arguments.length >= 1 && !isNullOrUndefined(maybeCalleeNode.parent.arguments[0]) ); } return true; /* * e.g. * Reflect.apply(function() {}, obj, []); * Array.from([], function() {}, obj); * list.forEach(function() {}, obj); */ case "CallExpression": if (isReflectApply(parent.callee)) { return ( parent.arguments.length !== 3 || parent.arguments[0] !== currentNode || isNullOrUndefined(parent.arguments[1]) ); } if (isArrayFromMethod(parent.callee)) { return ( parent.arguments.length !== 3 || parent.arguments[1] !== currentNode || isNullOrUndefined(parent.arguments[2]) ); } if (isMethodWhichHasThisArg(parent.callee)) { return ( parent.arguments.length !== 2 || parent.arguments[0] !== currentNode || isNullOrUndefined(parent.arguments[1]) ); } return true; // Otherwise `this` is default. default: return true; } } /* c8 ignore next */ return true; }, /** * Get the precedence level based on the node type * @param {ASTNode} node node to evaluate * @returns {int} precedence level * @private */ getPrecedence(node) { switch (node.type) { case "SequenceExpression": return 0; case "AssignmentExpression": case "ArrowFunctionExpression": case "YieldExpression": return 1; case "ConditionalExpression": return 3; case "LogicalExpression": switch (node.operator) { case "||": case "??": return 4; case "&&": return 5; // no default } /* falls through */ case "BinaryExpression": switch (node.operator) { case "|": return 6; case "^": return 7; case "&": return 8; case "==": case "!=": case "===": case "!==": return 9; case "<": case "<=": case ">": case ">=": case "in": case "instanceof": return 10; case "<<": case ">>": case ">>>": return 11; case "+": case "-": return 12; case "*": case "/": case "%": return 13; case "**": return 15; // no default } /* falls through */ case "UnaryExpression": case "AwaitExpression": return 16; case "UpdateExpression": return 17; case "CallExpression": case "ChainExpression": case "ImportExpression": return 18; case "NewExpression": return 19; default: return 20; } }, /** * Checks whether the given node is an empty block node or not. * @param {ASTNode|null} node The node to check. * @returns {boolean} `true` if the node is an empty block. */ isEmptyBlock(node) { return Boolean(node && node.type === "BlockStatement" && node.body.length === 0); }, /** * Checks whether the given node is an empty function node or not. * @param {ASTNode|null} node The node to check. * @returns {boolean} `true` if the node is an empty function. */ isEmptyFunction(node) { return isFunction(node) && module.exports.isEmptyBlock(node.body); }, /** * Get directives from directive prologue of a Program or Function node. * @param {ASTNode} node The node to check. * @returns {ASTNode[]} The directives found in the directive prologue. */ getDirectivePrologue(node) { const directives = []; // Directive prologues only occur at the top of files or functions. if ( node.type === "Program" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || /* * Do not check arrow functions with implicit return. * `() => "use strict";` returns the string `"use strict"`. */ (node.type === "ArrowFunctionExpression" && node.body.type === "BlockStatement") ) { const statements = node.type === "Program" ? node.body : node.body.body; for (const statement of statements) { if ( statement.type === "ExpressionStatement" && statement.expression.type === "Literal" ) { directives.push(statement); } else { break; } } } return directives; }, /** * Determines whether this node is a decimal integer literal. If a node is a decimal integer literal, a dot added * after the node will be parsed as a decimal point, rather than a property-access dot. * @param {ASTNode} node The node to check. * @returns {boolean} `true` if this node is a decimal integer. * @example * * 0 // true * 5 // true * 50 // true * 5_000 // true * 1_234_56 // true * 08 // true * 0192 // true * 5. // false * .5 // false * 5.0 // false * 5.00_00 // false * 05 // false * 0x5 // false * 0b101 // false * 0b11_01 // false * 0o5 // false * 5e0 // false * 5e1_000 // false * 5n // false * 1_000n // false * "5" // false * */ isDecimalInteger(node) { return node.type === "Literal" && typeof node.value === "number" && DECIMAL_INTEGER_PATTERN.test(node.raw); }, /** * Determines whether this token is a decimal integer numeric token. * This is similar to isDecimalInteger(), but for tokens. * @param {Token} token The token to check. * @returns {boolean} `true` if this token is a decimal integer. */ isDecimalIntegerNumericToken(token) { return token.type === "Numeric" && DECIMAL_INTEGER_PATTERN.test(token.value); }, /** * Gets the name and kind of the given function node. * * - `function foo() {}` .................... `function 'foo'` * - `(function foo() {})` .................. `function 'foo'` * - `(function() {})` ...................... `function` * - `function* foo() {}` ................... `generator function 'foo'` * - `(function* foo() {})` ................. `generator function 'foo'` * - `(function*() {})` ..................... `generator function` * - `() => {}` ............................. `arrow function` * - `async () => {}` ....................... `async arrow function` * - `({ foo: function foo() {} })` ......... `method 'foo'` * - `({ foo: function() {} })` ............. `method 'foo'` * - `({ ['foo']: function() {} })` ......... `method 'foo'` * - `({ [foo]: function() {} })` ........... `method` * - `({ foo() {} })` ....................... `method 'foo'` * - `({ foo: function* foo() {} })` ........ `generator method 'foo'` * - `({ foo: function*() {} })` ............ `generator method 'foo'` * - `({ ['foo']: function*() {} })` ........ `generator method 'foo'` * - `({ [foo]: function*() {} })` .......... `generator method` * - `({ *foo() {} })` ...................... `generator method 'foo'` * - `({ foo: async function foo() {} })` ... `async method 'foo'` * - `({ foo: async function() {} })` ....... `async method 'foo'` * - `({ ['foo']: async function() {} })` ... `async method 'foo'` * - `({ [foo]: async function() {} })` ..... `async method` * - `({ async foo() {} })` ................. `async method 'foo'` * - `({ get foo() {} })` ................... `getter 'foo'` * - `({ set foo(a) {} })` .................. `setter 'foo'` * - `class A { constructor() {} }` ......... `constructor` * - `class A { foo() {} }` ................. `method 'foo'` * - `class A { *foo() {} }` ................ `generator method 'foo'` * - `class A { async foo() {} }` ........... `async method 'foo'` * - `class A { ['foo']() {} }` ............. `method 'foo'` * - `class A { *['foo']() {} }` ............ `generator method 'foo'` * - `class A { async ['foo']() {} }` ....... `async method 'foo'` * - `class A { [foo]() {} }` ............... `method` * - `class A { *[foo]() {} }` .............. `generator method` * - `class A { async [foo]() {} }` ......... `async method` * - `class A { get foo() {} }` ............. `getter 'foo'` * - `class A { set foo(a) {} }` ............ `setter 'foo'` * - `class A { static foo() {} }` .......... `static method 'foo'` * - `class A { static *foo() {} }` ......... `static generator method 'foo'` * - `class A { static async foo() {} }` .... `static async method 'foo'` * - `class A { static get foo() {} }` ...... `static getter 'foo'` * - `class A { static set foo(a) {} }` ..... `static setter 'foo'` * - `class A { foo = () => {}; }` .......... `method 'foo'` * - `class A { foo = function() {}; }` ..... `method 'foo'` * - `class A { foo = function bar() {}; }` . `method 'foo'` * - `class A { static foo = () => {}; }` ... `static method 'foo'` * - `class A { '#foo' = () => {}; }` ....... `method '#foo'` * - `class A { #foo = () => {}; }` ......... `private method #foo` * - `class A { static #foo = () => {}; }` .. `static private method #foo` * - `class A { '#foo'() {} }` .............. `method '#foo'` * - `class A { #foo() {} }` ................ `private method #foo` * - `class A { static #foo() {} }` ......... `static private method #foo` * @param {ASTNode} node The function node to get. * @returns {string} The name and kind of the function node. */ getFunctionNameWithKind(node) { const parent = node.parent; const tokens = []; if (parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") { // The proposal uses `static` word consistently before visibility words: https://github.com/tc39/proposal-static-class-features if (parent.static) { tokens.push("static"); } if (!parent.computed && parent.key.type === "PrivateIdentifier") { tokens.push("private"); } } if (node.async) { tokens.push("async"); } if (node.generator) { tokens.push("generator"); } if (parent.type === "Property" || parent.type === "MethodDefinition") { if (parent.kind === "constructor") { return "constructor"; } if (parent.kind === "get") { tokens.push("getter"); } else if (parent.kind === "set") { tokens.push("setter"); } else { tokens.push("method"); } } else if (parent.type === "PropertyDefinition") { tokens.push("method"); } else { if (node.type === "ArrowFunctionExpression") { tokens.push("arrow"); } tokens.push("function"); } if (parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") { if (!parent.computed && parent.key.type === "PrivateIdentifier") { tokens.push(`#${parent.key.name}`); } else { const name = getStaticPropertyName(parent); if (name !== null) { tokens.push(`'${name}'`); } else if (node.id) { tokens.push(`'${node.id.name}'`); } } } else if (node.id) { tokens.push(`'${node.id.name}'`); } return tokens.join(" "); }, /** * Gets the location of the given function node for reporting. * * - `function foo() {}` * ^^^^^^^^^^^^ * - `(function foo() {})` * ^^^^^^^^^^^^ * - `(function() {})` * ^^^^^^^^ * - `function* foo() {}` * ^^^^^^^^^^^^^ * - `(function* foo() {})` * ^^^^^^^^^^^^^ * - `(function*() {})` * ^^^^^^^^^ * - `() => {}` * ^^ * - `async () => {}` * ^^ * - `({ foo: function foo() {} })` * ^^^^^^^^^^^^^^^^^ * - `({ foo: function() {} })` * ^^^^^^^^^^^^^ * - `({ ['foo']: function() {} })` * ^^^^^^^^^^^^^^^^^ * - `({ [foo]: function() {} })` * ^^^^^^^^^^^^^^^ * - `({ foo() {} })` * ^^^ * - `({ foo: function* foo() {} })` * ^^^^^^^^^^^^^^^^^^ * - `({ foo: function*() {} })` * ^^^^^^^^^^^^^^ * - `({ ['foo']: function*() {} })` * ^^^^^^^^^^^^^^^^^^ * - `({ [foo]: function*() {} })` * ^^^^^^^^^^^^^^^^ * - `({ *foo() {} })` * ^^^^ * - `({ foo: async function foo() {} })` * ^^^^^^^^^^^^^^^^^^^^^^^ * - `({ foo: async function() {} })` * ^^^^^^^^^^^^^^^^^^^ * - `({ ['foo']: async function() {} })` * ^^^^^^^^^^^^^^^^^^^^^^^ * - `({ [foo]: async function() {} })` * ^^^^^^^^^^^^^^^^^^^^^ * - `({ async foo() {} })` * ^^^^^^^^^ * - `({ get foo() {} })` * ^^^^^^^ * - `({ set foo(a) {} })` * ^^^^^^^ * - `class A { constructor() {} }` * ^^^^^^^^^^^ * - `class A { foo() {} }` * ^^^ * - `class A { *foo() {} }` * ^^^^ * - `class A { async foo() {} }` * ^^^^^^^^^ * - `class A { ['foo']() {} }` * ^^^^^^^ * - `class A { *['foo']() {} }` * ^^^^^^^^ * - `class A { async ['foo']() {} }` * ^^^^^^^^^^^^^ * - `class A { [foo]() {} }` * ^^^^^ * - `class A { *[foo]() {} }` * ^^^^^^ * - `class A { async [foo]() {} }` * ^^^^^^^^^^^ * - `class A { get foo() {} }` * ^^^^^^^ * - `class A { set foo(a) {} }` * ^^^^^^^ * - `class A { static foo() {} }` * ^^^^^^^^^^ * - `class A { static *foo() {} }` * ^^^^^^^^^^^ * - `class A { static async foo() {} }` * ^^^^^^^^^^^^^^^^ * - `class A { static get foo() {} }` * ^^^^^^^^^^^^^^ * - `class A { static set foo(a) {} }` * ^^^^^^^^^^^^^^ * - `class A { foo = function() {} }` * ^^^^^^^^^^^^^^ * - `class A { static foo = function() {} }` * ^^^^^^^^^^^^^^^^^^^^^ * - `class A { foo = (a, b) => {} }` * ^^^^^^ * @param {ASTNode} node The function node to get. * @param {SourceCode} sourceCode The source code object to get tokens. * @returns {string} The location of the function node for reporting. */ getFunctionHeadLoc(node, sourceCode) { const parent = node.parent; let start = null; let end = null; if (parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") { start = parent.loc.start; end = getOpeningParenOfParams(node, sourceCode).loc.start; } else if (node.type === "ArrowFunctionExpression") { const arrowToken = sourceCode.getTokenBefore(node.body, isArrowToken); start = arrowToken.loc.start; end = arrowToken.loc.end; } else { start = node.loc.start; end = getOpeningParenOfParams(node, sourceCode).loc.start; } return { start: Object.assign({}, start), end: Object.assign({}, end) }; }, /** * Gets next location when the result is not out of bound, otherwise returns null. * * Assumptions: * * - The given location represents a valid location in the given source code. * - Columns are 0-based. * - Lines are 1-based. * - Column immediately after the last character in a line (not incl. linebreaks) is considered to be a valid location. * - If the source code ends with a linebreak, `sourceCode.lines` array will have an extra element (empty string) at the end. * The start (column 0) of that extra line is considered to be a valid location. * * Examples of successive locations (line, column): * * code: foo * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> null * * code: foo * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null * * code: foo * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null * * code: ab * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> null * * code: ab * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null * * code: ab * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null * * code: a * locations: (1, 0) -> (1, 1) -> (2, 0) -> (3, 0) -> null * * code: * locations: (1, 0) -> (2, 0) -> null * * code: * locations: (1, 0) -> null * @param {SourceCode} sourceCode The sourceCode * @param {{line: number, column: number}} location The location * @returns {{line: number, column: number} | null} Next location */ getNextLocation(sourceCode, { line, column }) { if (column < sourceCode.lines[line - 1].length) { return { line, column: column + 1 }; } if (line < sourceCode.lines.length) { return { line: line + 1, column: 0 }; } return null; }, /** * Gets the parenthesized text of a node. This is similar to sourceCode.getText(node), but it also includes any parentheses * surrounding the node. * @param {SourceCode} sourceCode The source code object * @param {ASTNode} node An expression node * @returns {string} The text representing the node, with all surrounding parentheses included */ getParenthesisedText(sourceCode, node) { let leftToken = sourceCode.getFirstToken(node); let rightToken = sourceCode.getLastToken(node); while ( sourceCode.getTokenBefore(leftToken) && sourceCode.getTokenBefore(leftToken).type === "Punctuator" && sourceCode.getTokenBefore(leftToken).value === "(" && sourceCode.getTokenAfter(rightToken) && sourceCode.getTokenAfter(rightToken).type === "Punctuator" && sourceCode.getTokenAfter(rightToken).value === ")" ) { leftToken = sourceCode.getTokenBefore(leftToken); rightToken = sourceCode.getTokenAfter(rightToken); } return sourceCode.getText().slice(leftToken.range[0], rightToken.range[1]); }, /** * Determine if a node has a possibility to be an Error object * @param {ASTNode} node ASTNode to check * @returns {boolean} True if there is a chance it contains an Error obj */ couldBeError(node) { switch (node.type) { case "Identifier": case "CallExpression": case "NewExpression": case "MemberExpression": case "TaggedTemplateExpression": case "YieldExpression": case "AwaitExpression": case "ChainExpression": return true; // possibly an error object. case "AssignmentExpression": if (["=", "&&="].includes(node.operator)) { return module.exports.couldBeError(node.right); } if (["||=", "??="].includes(node.operator)) { return module.exports.couldBeError(node.left) || module.exports.couldBeError(node.right); } /** * All other assignment operators are mathematical assignment operators (arithmetic or bitwise). * An assignment expression with a mathematical operator can either evaluate to a primitive value, * or throw, depending on the operands. Thus, it cannot evaluate to an `Error` object. */ return false; case "SequenceExpression": { const exprs = node.expressions; return exprs.length !== 0 && module.exports.couldBeError(exprs[exprs.length - 1]); } case "LogicalExpression": /* * If the && operator short-circuits, the left side was falsy and therefore not an error, and if it * doesn't short-circuit, it takes the value from the right side, so the right side must always be * a plausible error. A future improvement could verify that the left side could be truthy by * excluding falsy literals. */ if (node.operator === "&&") { return module.exports.couldBeError(node.right); } return module.exports.couldBeError(node.left) || module.exports.couldBeError(node.right); case "ConditionalExpression": return module.exports.couldBeError(node.consequent) || module.exports.couldBeError(node.alternate); default: return false; } }, /** * Check if a given node is a numeric literal or not. * @param {ASTNode} node The node to check. * @returns {boolean} `true` if the node is a number or bigint literal. */ isNumericLiteral(node) { return ( node.type === "Literal" && (typeof node.value === "number" || Boolean(node.bigint)) ); }, /** * Determines whether two tokens can safely be placed next to each other without merging into a single token * @param {Token|string} leftValue The left token. If this is a string, it will be tokenized and the last token will be used. * @param {Token|string} rightValue The right token. If this is a string, it will be tokenized and the first token will be used. * @returns {boolean} If the tokens cannot be safely placed next to each other, returns `false`. If the tokens can be placed * next to each other, behavior is undefined (although it should return `true` in most cases). */ canTokensBeAdjacent(leftValue, rightValue) { const espreeOptions = { ecmaVersion: espree.latestEcmaVersion, comment: true, range: true }; let leftToken; if (typeof leftValue === "string") { let tokens; try { tokens = espree.tokenize(leftValue, espreeOptions); } catch { return false; } const comments = tokens.comments; leftToken = tokens[tokens.length - 1]; if (comments.length) { const lastComment = comments[comments.length - 1]; if (!leftToken || lastComment.range[0] > leftToken.range[0]) { leftToken = lastComment; } } } else { leftToken = leftValue; } /* * If a hashbang comment was passed as a token object from SourceCode, * its type will be "Shebang" because of the way ESLint itself handles hashbangs. * If a hashbang comment was passed in a string and then tokenized in this function, * its type will be "Hashbang" because of the way Espree tokenizes hashbangs. */ if (leftToken.type === "Shebang" || leftToken.type === "Hashbang") { return false; } let rightToken; if (typeof rightValue === "string") { let tokens; try { tokens = espree.tokenize(rightValue, espreeOptions); } catch { return false; } const comments = tokens.comments; rightToken = tokens[0]; if (comments.length) { const firstComment = comments[0]; if (!rightToken || firstComment.range[0] < rightToken.range[0]) { rightToken = firstComment; } } } else { rightToken = rightValue; } if (leftToken.type === "Punctuator" || rightToken.type === "Punctuator") { if (leftToken.type === "Punctuator" && rightToken.type === "Punctuator") { const PLUS_TOKENS = new Set(["+", "++"]); const MINUS_TOKENS = new Set(["-", "--"]); return !( PLUS_TOKENS.has(leftToken.value) && PLUS_TOKENS.has(rightToken.value) || MINUS_TOKENS.has(leftToken.value) && MINUS_TOKENS.has(rightToken.value) ); } if (leftToken.type === "Punctuator" && leftToken.value === "/") { return !["Block", "Line", "RegularExpression"].includes(rightToken.type); } return true; } if ( leftToken.type === "String" || rightToken.type === "String" || leftToken.type === "Template" || rightToken.type === "Template" ) { return true; } if (leftToken.type !== "Numeric" && rightToken.type === "Numeric" && rightToken.value.startsWith(".")) { return true; } if (leftToken.type === "Block" || rightToken.type === "Block" || rightToken.type === "Line") { return true; } if (rightToken.type === "PrivateIdentifier") { return true; } return false; }, /** * Get the `loc` object of a given name in a `/*globals` directive comment. * @param {SourceCode} sourceCode The source code to convert index to loc. * @param {Comment} comment The `/*globals` directive comment which include the name. * @param {string} name The name to find. * @returns {SourceLocation} The `loc` object. */ getNameLocationInGlobalDirectiveComment(sourceCode, comment, name) { const namePattern = new RegExp(`[\\s,]${escapeRegExp(name)}(?:$|[\\s,:])`, "gu"); // To ignore the first text "global". namePattern.lastIndex = comment.value.indexOf("global") + 6; // Search a given variable name. const match = namePattern.exec(comment.value); // Convert the index to loc. const start = sourceCode.getLocFromIndex( comment.range[0] + "/*".length + (match ? match.index + 1 : 0) ); const end = { line: start.line, column: start.column + (match ? name.length : 1) }; return { start, end }; }, /** * Determines whether the given raw string contains an octal escape sequence * or a non-octal decimal escape sequence ("\8", "\9"). * * "\1", "\2" ... "\7", "\8", "\9" * "\00", "\01" ... "\07", "\08", "\09" * * "\0", when not followed by a digit, is not an octal escape sequence. * @param {string} rawString A string in its raw representation. * @returns {boolean} `true` if the string contains at least one octal escape sequence * or at least one non-octal decimal escape sequence. */ hasOctalOrNonOctalDecimalEscapeSequence(rawString) { return OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN.test(rawString); }, isReferenceToGlobalVariable, isLogicalExpression, isCoalesceExpression, isMixedLogicalAndCoalesceExpressions, isNullLiteral, getStaticStringValue, getStaticPropertyName, skipChainExpression, isSpecificId, isSpecificMemberAccess, equalLiteralValue, isSameReference, isLogicalAssignmentOperator, getSwitchCaseColonToken, getModuleExportName, isConstant };