SecurityOps
/
securityos
mirror of https://codeberg.org/berkeley/securityos.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
securityos/node_modules/eslint-plugin-sort-keys-fix/lib/util/ast-utils.js

1329 lines
41 KiB
JavaScript
Raw Permalink Blame History

/**
* @fileoverview Common utils for AST.
* @author Gyandeep Singh
*/
'use strict'
// ------------------------------------------------------------------------------
// Requirements
// ------------------------------------------------------------------------------
const esutils = require('esutils')
const espree = require('espree')
// ------------------------------------------------------------------------------
// Helpers
// ------------------------------------------------------------------------------
const anyFunctionPattern = /^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression)$/
const anyLoopPattern = /^(?:DoWhile|For|ForIn|ForOf|While)Statement$/
const arrayOrTypedArrayPattern = /Array$/
const arrayMethodPattern = /^(?:every|filter|find|findIndex|forEach|map|some)$/
const bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/
const breakableTypePattern = /^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/
const thisTagPattern = /^[\s*]*@this/m
const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/
const LINEBREAKS = new Set(['\r\n', '\r', '\n', '\u2028', '\u2029'])
const LINEBREAK_MATCHER = /\r\n|[\r\n\u2028\u2029]/
const SHEBANG_MATCHER = /^#!([^\r\n]+)/
// A set of node types that can contain a list of statements
const STATEMENT_LIST_PARENTS = new Set(['Program', 'BlockStatement', 'SwitchCase'])
/**
* 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} Wehether 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
}
/**
* 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 (
module.exports.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
}
/**
* 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 (
node.type === 'MemberExpression' &&
node.object.type === 'Identifier' &&
node.object.name === 'Reflect' &&
node.property.type === 'Identifier' &&
node.property.name === 'apply' &&
node.computed === false
)
}
/**
* 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 (
node.type === 'MemberExpression' &&
node.object.type === 'Identifier' &&
arrayOrTypedArrayPattern.test(node.object.name) &&
node.property.type === 'Identifier' &&
node.property.name === 'from' &&
node.computed === false
)
}
/**
* 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) {
for (
let currentNode = node;
currentNode.type === 'MemberExpression' && !currentNode.computed;
currentNode = currentNode.property
) {
if (currentNode.property.type === 'Identifier') {
return arrayMethodPattern.test(currentNode.property.name)
}
}
return false
}
/**
* 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)
const 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 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 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) {
return node.id
? sourceCode.getTokenAfter(node.id, isOpeningParenToken)
: sourceCode.getFirstToken(node, isOpeningParenToken)
}
/**
* Creates a version of the LINEBREAK_MATCHER regex with the global flag.
* Global regexes are mutable, so this needs to be a function instead of a constant.
* @returns {RegExp} A global regular expression that matches line terminators
*/
function createGlobalLinebreakMatcher() {
return new RegExp(LINEBREAK_MATCHER.source, 'g')
}
/**
* 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
}
// ------------------------------------------------------------------------------
// Public Interface
// ------------------------------------------------------------------------------
module.exports = {
COMMENTS_IGNORE_PATTERN,
LINEBREAKS,
LINEBREAK_MATCHER,
SHEBANG_MATCHER,
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,
isKeywordToken,
isNotClosingBraceToken: negate(isClosingBraceToken),
isNotClosingBracketToken: negate(isClosingBracketToken),
isNotClosingParenToken: negate(isClosingParenToken),
isNotColonToken: negate(isColonToken),
isNotCommaToken: negate(isCommaToken),
isNotOpeningBraceToken: negate(isOpeningBraceToken),
isNotOpeningBracketToken: negate(isOpeningBracketToken),
isNotOpeningParenToken: negate(isOpeningParenToken),
isNotSemicolonToken: negate(isSemicolonToken),
isOpeningBraceToken,
isOpeningBracketToken,
isOpeningParenToken,
isSemicolonToken,
/**
* 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 the label if the parent node of a given node is a LabeledStatement.
*
* @param {ASTNode} node - A node to get.
* @returns {string|null} The label or `null`.
*/
getLabel(node) {
if (node.parent.type === 'LabeledStatement') {
return node.parent.label.name
}
return null
},
/**
* 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.indexOf('eslint-') === 0) ||
(node.type === 'Block' &&
(comment.indexOf('global ') === 0 || comment.indexOf('eslint ') === 0 || comment.indexOf('eslint-') === 0))
)
},
/**
* 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 function name does not start with uppercase (it's a constructor).
* - 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.
* - 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.
* @param {SourceCode} sourceCode - A SourceCode instance to get comments.
* @returns {boolean} The function node is the default `this` binding.
*/
isDefaultThisBinding(node, sourceCode) {
if (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':
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() { ... } }
*/
case 'Property':
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 (isAnonymous && parent.left.type === 'Identifier' && startsWithUpperCase(parent.left.name)) {
return false
}
return true
/*
* e.g.
* var Foo = function() { ... };
*/
case 'VariableDeclarator':
return !(
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':
return (
parent.object !== currentNode ||
parent.property.type !== 'Identifier' ||
!bindOrCallOrApplyPattern.test(parent.property.name) ||
!isCallee(parent) ||
parent.parent.arguments.length === 0 ||
isNullOrUndefined(parent.parent.arguments[0])
)
/*
* 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
}
}
/* istanbul 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 '||':
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':
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)
},
/**
* 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.
*/
getStaticPropertyName(node) {
let prop
switch (node && node.type) {
case 'Property':
case 'MethodDefinition':
prop = node.key
break
case 'MemberExpression':
prop = node.property
break
// no default
}
switch (prop && prop.type) {
case 'Literal':
return String(prop.value)
case 'TemplateLiteral':
if (prop.expressions.length === 0 && prop.quasis.length === 1) {
return prop.quasis[0].value.cooked
}
break
case 'Identifier':
if (!node.computed) {
return prop.name
}
break
// no default
}
return null
},
/**
* 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
*
* 5 // true
* 5. // false
* 5.0 // false
* 05 // false
* 0x5 // false
* 0b101 // false
* 0o5 // false
* 5e0 // false
* '5' // false
*/
isDecimalInteger(node) {
return node.type === 'Literal' && typeof node.value === 'number' && /^(0|[1-9]\d*)$/.test(node.raw)
},
/**
* 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'`
*
* @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.static) {
tokens.push('static')
}
if (node.async) {
tokens.push('async')
}
if (node.generator) {
tokens.push('generator')
}
if (node.type === 'ArrowFunctionExpression') {
tokens.push('arrow', 'function')
} else 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 {
tokens.push('function')
}
if (node.id) {
tokens.push(`'${node.id.name}'`)
} else {
const name = module.exports.getStaticPropertyName(parent)
if (name) {
tokens.push(`'${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) {} }`
* ^^^^^^^^^^^^^^
*
* @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 (node.type === 'ArrowFunctionExpression') {
const arrowToken = sourceCode.getTokenBefore(node.body, isArrowToken)
start = arrowToken.loc.start
end = arrowToken.loc.end
} else if (parent.type === 'Property' || parent.type === 'MethodDefinition') {
start = parent.loc.start
end = getOpeningParenOfParams(node, sourceCode).loc.start
} else {
start = node.loc.start
end = getOpeningParenOfParams(node, sourceCode).loc.start
}
return {
start: Object.assign({}, start),
end: Object.assign({}, end),
}
},
/**
* 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 possiblity 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':
return true // possibly an error object.
case 'AssignmentExpression':
return module.exports.couldBeError(node.right)
case 'SequenceExpression': {
const exprs = node.expressions
return exprs.length !== 0 && module.exports.couldBeError(exprs[exprs.length - 1])
}
case 'LogicalExpression':
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
}
},
/**
* 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
*/
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
},
/**
* 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) {
let leftToken
if (typeof leftValue === 'string') {
const leftTokens = espree.tokenize(leftValue, { ecmaVersion: 2015 })
leftToken = leftTokens[leftTokens.length - 1]
} else {
leftToken = leftValue
}
const rightToken =
typeof rightValue === 'string' ? espree.tokenize(rightValue, { ecmaVersion: 2015 })[0] : 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))
)
}
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
}
return false
},
}
Reference in New Issue View Git Blame Copy Permalink