553 lines
24 KiB
Plaintext
553 lines
24 KiB
Plaintext
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const scope_manager_1 = require("@typescript-eslint/scope-manager");
|
|
const utils_1 = require("@typescript-eslint/utils");
|
|
const util_1 = require("../util");
|
|
const isTypeImport_1 = require("../util/isTypeImport");
|
|
const allowedFunctionVariableDefTypes = new Set([
|
|
utils_1.AST_NODE_TYPES.TSCallSignatureDeclaration,
|
|
utils_1.AST_NODE_TYPES.TSFunctionType,
|
|
utils_1.AST_NODE_TYPES.TSMethodSignature,
|
|
utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression,
|
|
utils_1.AST_NODE_TYPES.TSDeclareFunction,
|
|
utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration,
|
|
utils_1.AST_NODE_TYPES.TSConstructorType,
|
|
]);
|
|
const functionsHoistedNodes = new Set([utils_1.AST_NODE_TYPES.FunctionDeclaration]);
|
|
const typesHoistedNodes = new Set([
|
|
utils_1.AST_NODE_TYPES.TSInterfaceDeclaration,
|
|
utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration,
|
|
]);
|
|
exports.default = (0, util_1.createRule)({
|
|
name: 'no-shadow',
|
|
meta: {
|
|
type: 'suggestion',
|
|
docs: {
|
|
description: 'Disallow variable declarations from shadowing variables declared in the outer scope',
|
|
extendsBaseRule: true,
|
|
},
|
|
messages: {
|
|
noEnumShadow: "Enum members are added to the enum scope, so references to '{{name}}' in enum member initializers resolve to this member instead of the declaration in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.",
|
|
noShadow: "'{{name}}' is already declared in the upper scope on line {{shadowedLine}} column {{shadowedColumn}}.",
|
|
noShadowGlobal: "'{{name}}' is already a global variable.",
|
|
},
|
|
schema: [
|
|
{
|
|
type: 'object',
|
|
additionalProperties: false,
|
|
properties: {
|
|
allow: {
|
|
type: 'array',
|
|
description: 'Identifier names for which shadowing is allowed.',
|
|
items: {
|
|
type: 'string',
|
|
},
|
|
},
|
|
builtinGlobals: {
|
|
type: 'boolean',
|
|
description: 'Whether to report shadowing of built-in global variables.',
|
|
},
|
|
hoist: {
|
|
type: 'string',
|
|
description: 'Whether to report shadowing before outer functions or variables are defined.',
|
|
enum: ['all', 'functions', 'functions-and-types', 'never', 'types'],
|
|
},
|
|
ignoreFunctionTypeParameterNameValueShadow: {
|
|
type: 'boolean',
|
|
description: 'Whether to ignore function parameters named the same as a variable.',
|
|
},
|
|
ignoreOnInitialization: {
|
|
type: 'boolean',
|
|
description: 'Whether to ignore the variable initializers when the shadowed variable is presumably still uninitialized.',
|
|
},
|
|
ignoreTypeValueShadow: {
|
|
type: 'boolean',
|
|
description: 'Whether to ignore types named the same as a variable.',
|
|
},
|
|
},
|
|
},
|
|
],
|
|
},
|
|
defaultOptions: [
|
|
{
|
|
allow: [],
|
|
builtinGlobals: false,
|
|
hoist: 'functions-and-types',
|
|
ignoreFunctionTypeParameterNameValueShadow: true,
|
|
ignoreOnInitialization: false,
|
|
ignoreTypeValueShadow: true,
|
|
},
|
|
],
|
|
create(context, [options]) {
|
|
/**
|
|
* Check if a scope is a TypeScript module augmenting the global namespace.
|
|
*/
|
|
function isGlobalAugmentation(scope) {
|
|
return ((scope.type === scope_manager_1.ScopeType.tsModule && scope.block.kind === 'global') ||
|
|
(!!scope.upper && isGlobalAugmentation(scope.upper)));
|
|
}
|
|
/**
|
|
* Check if variable is a `this` parameter.
|
|
*/
|
|
function isThisParam(variable) {
|
|
return (variable.defs[0].type === scope_manager_1.DefinitionType.Parameter &&
|
|
variable.name === 'this');
|
|
}
|
|
function isTypeValueShadow(variable, shadowed) {
|
|
if (options.ignoreTypeValueShadow !== true) {
|
|
return false;
|
|
}
|
|
if (!('isValueVariable' in variable)) {
|
|
// this shouldn't happen...
|
|
return false;
|
|
}
|
|
const firstDefinition = shadowed.defs.at(0);
|
|
const isShadowedValue = !('isValueVariable' in shadowed) ||
|
|
!firstDefinition ||
|
|
(!(0, isTypeImport_1.isTypeImport)(firstDefinition) && shadowed.isValueVariable);
|
|
return variable.isValueVariable !== isShadowedValue;
|
|
}
|
|
function isFunctionTypeParameterNameValueShadow(variable, shadowed) {
|
|
if (options.ignoreFunctionTypeParameterNameValueShadow !== true) {
|
|
return false;
|
|
}
|
|
if (!('isValueVariable' in variable)) {
|
|
// this shouldn't happen...
|
|
return false;
|
|
}
|
|
const isShadowedValue = 'isValueVariable' in shadowed ? shadowed.isValueVariable : true;
|
|
if (!isShadowedValue) {
|
|
return false;
|
|
}
|
|
return variable.defs.every(def => allowedFunctionVariableDefTypes.has(def.node.type));
|
|
}
|
|
function isGenericOfStaticMethod(variable) {
|
|
if (!('isTypeVariable' in variable)) {
|
|
// this shouldn't happen...
|
|
return false;
|
|
}
|
|
if (!variable.isTypeVariable) {
|
|
return false;
|
|
}
|
|
if (variable.identifiers.length === 0) {
|
|
return false;
|
|
}
|
|
const typeParameter = variable.identifiers[0].parent;
|
|
if (typeParameter.type !== utils_1.AST_NODE_TYPES.TSTypeParameter) {
|
|
return false;
|
|
}
|
|
const typeParameterDecl = typeParameter.parent;
|
|
if (typeParameterDecl.type !== utils_1.AST_NODE_TYPES.TSTypeParameterDeclaration) {
|
|
return false;
|
|
}
|
|
const functionExpr = typeParameterDecl.parent;
|
|
if (functionExpr.type !== utils_1.AST_NODE_TYPES.FunctionExpression &&
|
|
functionExpr.type !== utils_1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression) {
|
|
return false;
|
|
}
|
|
const methodDefinition = functionExpr.parent;
|
|
if (methodDefinition.type !== utils_1.AST_NODE_TYPES.MethodDefinition) {
|
|
return false;
|
|
}
|
|
return methodDefinition.static;
|
|
}
|
|
function isGenericOfClass(variable) {
|
|
if (!('isTypeVariable' in variable)) {
|
|
// this shouldn't happen...
|
|
return false;
|
|
}
|
|
if (!variable.isTypeVariable) {
|
|
return false;
|
|
}
|
|
if (variable.identifiers.length === 0) {
|
|
return false;
|
|
}
|
|
const typeParameter = variable.identifiers[0].parent;
|
|
if (typeParameter.type !== utils_1.AST_NODE_TYPES.TSTypeParameter) {
|
|
return false;
|
|
}
|
|
const typeParameterDecl = typeParameter.parent;
|
|
if (typeParameterDecl.type !== utils_1.AST_NODE_TYPES.TSTypeParameterDeclaration) {
|
|
return false;
|
|
}
|
|
const classDecl = typeParameterDecl.parent;
|
|
return (classDecl.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
|
|
classDecl.type === utils_1.AST_NODE_TYPES.ClassExpression);
|
|
}
|
|
function isGenericOfAStaticMethodShadow(variable, shadowed) {
|
|
return isGenericOfStaticMethod(variable) && isGenericOfClass(shadowed);
|
|
}
|
|
function isImportDeclaration(definition) {
|
|
return definition.type === utils_1.AST_NODE_TYPES.ImportDeclaration;
|
|
}
|
|
function isExternalModuleDeclarationWithName(scope, name) {
|
|
return (scope.type === scope_manager_1.ScopeType.tsModule &&
|
|
scope.block.id.type === utils_1.AST_NODE_TYPES.Literal &&
|
|
scope.block.id.value === name);
|
|
}
|
|
function isExternalDeclarationMerging(scope, variable, shadowed) {
|
|
const [firstDefinition] = shadowed.defs;
|
|
const [secondDefinition] = variable.defs;
|
|
return ((0, isTypeImport_1.isTypeImport)(firstDefinition) &&
|
|
isImportDeclaration(firstDefinition.parent) &&
|
|
isExternalModuleDeclarationWithName(scope, firstDefinition.parent.source.value) &&
|
|
(secondDefinition.node.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration ||
|
|
secondDefinition.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration));
|
|
}
|
|
/**
|
|
* Check if variable name is allowed.
|
|
* @param variable The variable to check.
|
|
* @returns Whether or not the variable name is allowed.
|
|
*/
|
|
function isAllowed(variable) {
|
|
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
|
return options.allow.includes(variable.name);
|
|
}
|
|
/**
|
|
* Checks if a variable of the class name in the class scope of ClassDeclaration.
|
|
*
|
|
* ClassDeclaration creates two variables of its name into its outer scope and its class scope.
|
|
* So we should ignore the variable in the class scope.
|
|
* @param variable The variable to check.
|
|
* @returns Whether or not the variable of the class name in the class scope of ClassDeclaration.
|
|
*/
|
|
function isDuplicatedClassNameVariable(variable) {
|
|
const block = variable.scope.block;
|
|
return (block.type === utils_1.AST_NODE_TYPES.ClassDeclaration &&
|
|
block.id === variable.identifiers[0]);
|
|
}
|
|
/**
|
|
* Checks if a variable of the class name in the class scope of TSEnumDeclaration.
|
|
*
|
|
* TSEnumDeclaration creates two variables of its name into its outer scope and its class scope.
|
|
* So we should ignore the variable in the class scope.
|
|
* @param variable The variable to check.
|
|
* @returns Whether or not the variable of the class name in the class scope of TSEnumDeclaration.
|
|
*/
|
|
function isDuplicatedEnumNameVariable(variable) {
|
|
const block = variable.scope.block;
|
|
return (block.type === utils_1.AST_NODE_TYPES.TSEnumDeclaration &&
|
|
block.id === variable.identifiers[0]);
|
|
}
|
|
/**
|
|
* Checks whether or not a given location is inside of the range of a given node.
|
|
* @param node An node to check.
|
|
* @param location A location to check.
|
|
* @returns `true` if the location is inside of the range of the node.
|
|
*/
|
|
function isInRange(node, location) {
|
|
return node && node.range[0] <= location && location <= node.range[1];
|
|
}
|
|
/**
|
|
* Searches from the current node through its ancestry to find a matching node.
|
|
* @param node a node to get.
|
|
* @param match a callback that checks whether or not the node verifies its condition or not.
|
|
* @returns the matching node.
|
|
*/
|
|
function findSelfOrAncestor(node, match) {
|
|
let currentNode = node;
|
|
while (currentNode && !match(currentNode)) {
|
|
currentNode = currentNode.parent;
|
|
}
|
|
return currentNode;
|
|
}
|
|
/**
|
|
* Finds function's outer scope.
|
|
* @param scope Function's own scope.
|
|
* @returns Function's outer scope.
|
|
*/
|
|
function getOuterScope(scope) {
|
|
const upper = scope.upper;
|
|
if (upper?.type === scope_manager_1.ScopeType.functionExpressionName) {
|
|
return upper.upper;
|
|
}
|
|
return upper;
|
|
}
|
|
/**
|
|
* Checks if a variable and a shadowedVariable have the same init pattern ancestor.
|
|
* @param variable a variable to check.
|
|
* @param shadowedVariable a shadowedVariable to check.
|
|
* @returns Whether or not the variable and the shadowedVariable have the same init pattern ancestor.
|
|
*/
|
|
function isInitPatternNode(variable, shadowedVariable) {
|
|
const outerDef = shadowedVariable.defs.at(0);
|
|
if (!outerDef) {
|
|
return false;
|
|
}
|
|
const { variableScope } = variable.scope;
|
|
if (!((variableScope.block.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
|
|
variableScope.block.type === utils_1.AST_NODE_TYPES.FunctionExpression) &&
|
|
getOuterScope(variableScope) === shadowedVariable.scope)) {
|
|
return false;
|
|
}
|
|
const fun = variableScope.block;
|
|
const { parent } = fun;
|
|
const callExpression = findSelfOrAncestor(parent, node => node.type === utils_1.AST_NODE_TYPES.CallExpression);
|
|
if (!callExpression) {
|
|
return false;
|
|
}
|
|
let node = outerDef.name;
|
|
const location = callExpression.range[1];
|
|
while (node) {
|
|
if (node.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
|
|
if (isInRange(node.init, location)) {
|
|
return true;
|
|
}
|
|
if ((node.parent.parent.type === utils_1.AST_NODE_TYPES.ForInStatement ||
|
|
node.parent.parent.type === utils_1.AST_NODE_TYPES.ForOfStatement) &&
|
|
isInRange(node.parent.parent.right, location)) {
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
else if (node.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
|
|
if (isInRange(node.right, location)) {
|
|
return true;
|
|
}
|
|
}
|
|
else if ([
|
|
utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
|
|
utils_1.AST_NODE_TYPES.CatchClause,
|
|
utils_1.AST_NODE_TYPES.ClassDeclaration,
|
|
utils_1.AST_NODE_TYPES.ClassExpression,
|
|
utils_1.AST_NODE_TYPES.ExportNamedDeclaration,
|
|
utils_1.AST_NODE_TYPES.FunctionDeclaration,
|
|
utils_1.AST_NODE_TYPES.FunctionExpression,
|
|
utils_1.AST_NODE_TYPES.ImportDeclaration,
|
|
].includes(node.type)) {
|
|
break;
|
|
}
|
|
node = node.parent;
|
|
}
|
|
return false;
|
|
}
|
|
/**
|
|
* Finds the uppermost expression node that can evaluate to the given one,
|
|
* unwrapping through LogicalExpression and non-test ConditionalExpression branches.
|
|
* @param node The node to unwrap.
|
|
* @returns The topmost unwrapped node.
|
|
*/
|
|
function unwrapExpression(node) {
|
|
const { parent } = node;
|
|
if (parent?.type === utils_1.AST_NODE_TYPES.LogicalExpression ||
|
|
(parent?.type === utils_1.AST_NODE_TYPES.ConditionalExpression &&
|
|
parent.test !== node)) {
|
|
return unwrapExpression(parent);
|
|
}
|
|
return node;
|
|
}
|
|
/**
|
|
* Checks if a variable is the name of a function or class expression that is
|
|
* directly assigned (or transparently through `||`/`?:`) as the initializer
|
|
* of scopeVar.
|
|
*
|
|
* Allows `var a = function a() {}` but reports `var a = wrap(function a() {})`.
|
|
* @param variable The variable to check.
|
|
* @param scopeVar The scope variable to look for.
|
|
* @returns Whether or not the variable is the direct initializer name of scopeVar.
|
|
*/
|
|
function isOnInitializer(variable, scopeVar) {
|
|
const outerDef = scopeVar.defs.at(0);
|
|
const innerDef = variable.defs.at(0);
|
|
if (!outerDef || !innerDef) {
|
|
return false;
|
|
}
|
|
if (!((innerDef.type === scope_manager_1.DefinitionType.FunctionName &&
|
|
innerDef.node.type === utils_1.AST_NODE_TYPES.FunctionExpression) ||
|
|
(innerDef.type === scope_manager_1.DefinitionType.ClassName &&
|
|
innerDef.node.type === utils_1.AST_NODE_TYPES.ClassExpression))) {
|
|
return false;
|
|
}
|
|
const outerIdentifier = outerDef.name;
|
|
let initializerNode;
|
|
if (outerIdentifier.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
|
|
initializerNode = outerIdentifier.parent.init;
|
|
}
|
|
else if (outerIdentifier.parent.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
|
|
initializerNode = outerIdentifier.parent.right;
|
|
}
|
|
if (!initializerNode) {
|
|
return false;
|
|
}
|
|
const nodeToCheck = innerDef.node;
|
|
if (!(initializerNode.range[0] <= nodeToCheck.range[0] &&
|
|
nodeToCheck.range[1] <= initializerNode.range[1])) {
|
|
return false;
|
|
}
|
|
return initializerNode === unwrapExpression(nodeToCheck);
|
|
}
|
|
/**
|
|
* Get a range of a variable's identifier node.
|
|
* @param variable The variable to get.
|
|
* @returns The range of the variable's identifier node.
|
|
*/
|
|
function getNameRange(variable) {
|
|
const def = variable.defs.at(0);
|
|
return def?.name.range;
|
|
}
|
|
/**
|
|
* Checks if a variable is in TDZ of scopeVar.
|
|
* @param variable The variable to check.
|
|
* @param scopeVar The variable of TDZ.
|
|
* @returns Whether or not the variable is in TDZ of scopeVar.
|
|
*/
|
|
function isInTdz(variable, scopeVar) {
|
|
const outerDef = scopeVar.defs.at(0);
|
|
const inner = getNameRange(variable);
|
|
const outer = getNameRange(scopeVar);
|
|
if (!inner || !outer || inner[1] >= outer[0]) {
|
|
return false;
|
|
}
|
|
if (!outerDef) {
|
|
return true;
|
|
}
|
|
if (options.hoist === 'functions') {
|
|
return !functionsHoistedNodes.has(outerDef.node.type);
|
|
}
|
|
if (options.hoist === 'types') {
|
|
return !typesHoistedNodes.has(outerDef.node.type);
|
|
}
|
|
if (options.hoist === 'functions-and-types') {
|
|
return (!functionsHoistedNodes.has(outerDef.node.type) &&
|
|
!typesHoistedNodes.has(outerDef.node.type));
|
|
}
|
|
return true;
|
|
}
|
|
/**
|
|
* Get declared line and column of a variable.
|
|
* @param variable The variable to get.
|
|
* @returns The declared line and column of the variable.
|
|
*/
|
|
function getDeclaredLocation(variable) {
|
|
const identifier = variable.identifiers.at(0);
|
|
if (identifier) {
|
|
return {
|
|
column: identifier.loc.start.column + 1,
|
|
global: false,
|
|
line: identifier.loc.start.line,
|
|
};
|
|
}
|
|
return {
|
|
global: true,
|
|
};
|
|
}
|
|
/**
|
|
* Checks if the initialization of a variable has the declare modifier in a
|
|
* definition file.
|
|
*/
|
|
function isDeclareInDTSFile(variable) {
|
|
const fileName = context.filename;
|
|
if (!(0, util_1.isDefinitionFile)(fileName)) {
|
|
return false;
|
|
}
|
|
return variable.defs.some(def => {
|
|
return ((def.type === scope_manager_1.DefinitionType.Variable && def.parent.declare) ||
|
|
(def.type === scope_manager_1.DefinitionType.ClassName && def.node.declare) ||
|
|
(def.type === scope_manager_1.DefinitionType.TSEnumName && def.node.declare) ||
|
|
(def.type === scope_manager_1.DefinitionType.TSModuleName && def.node.declare));
|
|
});
|
|
}
|
|
/**
|
|
* Checks the current context for shadowed variables.
|
|
* @param scope Fixme
|
|
*/
|
|
function checkForShadows(scope) {
|
|
// ignore global augmentation
|
|
if (isGlobalAugmentation(scope)) {
|
|
return;
|
|
}
|
|
const variables = scope.variables;
|
|
for (const variable of variables) {
|
|
// ignore "arguments"
|
|
if (variable.identifiers.length === 0) {
|
|
continue;
|
|
}
|
|
// this params are pseudo-params that cannot be shadowed
|
|
if (isThisParam(variable)) {
|
|
continue;
|
|
}
|
|
// ignore variables of a class name in the class scope of ClassDeclaration
|
|
if (isDuplicatedClassNameVariable(variable)) {
|
|
continue;
|
|
}
|
|
// ignore variables of a class name in the class scope of ClassDeclaration
|
|
if (isDuplicatedEnumNameVariable(variable)) {
|
|
continue;
|
|
}
|
|
// ignore configured allowed names
|
|
if (isAllowed(variable)) {
|
|
continue;
|
|
}
|
|
// ignore variables with the declare keyword in .d.ts files
|
|
if (isDeclareInDTSFile(variable)) {
|
|
continue;
|
|
}
|
|
// Gets shadowed variable.
|
|
const shadowed = scope.upper
|
|
? utils_1.ASTUtils.findVariable(scope.upper, variable.name)
|
|
: null;
|
|
if (!shadowed) {
|
|
continue;
|
|
}
|
|
// ignore type value variable shadowing if configured
|
|
if (isTypeValueShadow(variable, shadowed)) {
|
|
continue;
|
|
}
|
|
// ignore function type parameter name shadowing if configured
|
|
if (isFunctionTypeParameterNameValueShadow(variable, shadowed)) {
|
|
continue;
|
|
}
|
|
// ignore static class method generic shadowing class generic
|
|
// this is impossible for the scope analyser to understand
|
|
// so we have to handle this manually in this rule
|
|
if (isGenericOfAStaticMethodShadow(variable, shadowed)) {
|
|
continue;
|
|
}
|
|
if (isExternalDeclarationMerging(scope, variable, shadowed)) {
|
|
continue;
|
|
}
|
|
const isESLintGlobal = 'writeable' in shadowed;
|
|
if ((shadowed.identifiers.length > 0 ||
|
|
(options.builtinGlobals && isESLintGlobal)) &&
|
|
!isOnInitializer(variable, shadowed) &&
|
|
!(options.ignoreOnInitialization &&
|
|
isInitPatternNode(variable, shadowed)) &&
|
|
!(options.hoist !== 'all' && isInTdz(variable, shadowed))) {
|
|
const location = getDeclaredLocation(shadowed);
|
|
const isEnumDeclaration = shadowed.defs.some(def => def.type === scope_manager_1.DefinitionType.TSEnumName);
|
|
context.report({
|
|
node: variable.identifiers[0],
|
|
...(location.global
|
|
? {
|
|
messageId: 'noShadowGlobal',
|
|
data: {
|
|
name: variable.name,
|
|
},
|
|
}
|
|
: {
|
|
messageId: isEnumDeclaration ? 'noEnumShadow' : 'noShadow',
|
|
data: {
|
|
name: variable.name,
|
|
shadowedColumn: location.column,
|
|
shadowedLine: location.line,
|
|
},
|
|
}),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
'Program:exit'(node) {
|
|
const globalScope = context.sourceCode.getScope(node);
|
|
const stack = [...globalScope.childScopes];
|
|
while (stack.length) {
|
|
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
|
const scope = stack.pop();
|
|
stack.push(...scope.childScopes);
|
|
checkForShadows(scope);
|
|
}
|
|
},
|
|
};
|
|
},
|
|
});
|