--- /dev/null
+/**
+ * @fileoverview A rule to suggest using of const declaration for variables that are never reassigned after declared.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const PATTERN_TYPE = /^(?:.+?Pattern|RestElement|SpreadProperty|ExperimentalRestProperty|Property)$/u;
+const DECLARATION_HOST_TYPE = /^(?:Program|BlockStatement|SwitchCase)$/u;
+const DESTRUCTURING_HOST_TYPE = /^(?:VariableDeclarator|AssignmentExpression)$/u;
+
+/**
+ * Checks whether a given node is located at `ForStatement.init` or not.
+ * @param {ASTNode} node A node to check.
+ * @returns {boolean} `true` if the node is located at `ForStatement.init`.
+ */
+function isInitOfForStatement(node) {
+ return node.parent.type === "ForStatement" && node.parent.init === node;
+}
+
+/**
+ * Checks whether a given Identifier node becomes a VariableDeclaration or not.
+ * @param {ASTNode} identifier An Identifier node to check.
+ * @returns {boolean} `true` if the node can become a VariableDeclaration.
+ */
+function canBecomeVariableDeclaration(identifier) {
+ let node = identifier.parent;
+
+ while (PATTERN_TYPE.test(node.type)) {
+ node = node.parent;
+ }
+
+ return (
+ node.type === "VariableDeclarator" ||
+ (
+ node.type === "AssignmentExpression" &&
+ node.parent.type === "ExpressionStatement" &&
+ DECLARATION_HOST_TYPE.test(node.parent.parent.type)
+ )
+ );
+}
+
+/**
+ * Checks if an property or element is from outer scope or function parameters
+ * in destructing pattern.
+ * @param {string} name A variable name to be checked.
+ * @param {eslint-scope.Scope} initScope A scope to start find.
+ * @returns {boolean} Indicates if the variable is from outer scope or function parameters.
+ */
+function isOuterVariableInDestructing(name, initScope) {
+
+ if (initScope.through.find(ref => ref.resolved && ref.resolved.name === name)) {
+ return true;
+ }
+
+ const variable = astUtils.getVariableByName(initScope, name);
+
+ if (variable !== null) {
+ return variable.defs.some(def => def.type === "Parameter");
+ }
+
+ return false;
+}
+
+/**
+ * Gets the VariableDeclarator/AssignmentExpression node that a given reference
+ * belongs to.
+ * This is used to detect a mix of reassigned and never reassigned in a
+ * destructuring.
+ * @param {eslint-scope.Reference} reference A reference to get.
+ * @returns {ASTNode|null} A VariableDeclarator/AssignmentExpression node or
+ * null.
+ */
+function getDestructuringHost(reference) {
+ if (!reference.isWrite()) {
+ return null;
+ }
+ let node = reference.identifier.parent;
+
+ while (PATTERN_TYPE.test(node.type)) {
+ node = node.parent;
+ }
+
+ if (!DESTRUCTURING_HOST_TYPE.test(node.type)) {
+ return null;
+ }
+ return node;
+}
+
+/**
+ * Determines if a destructuring assignment node contains
+ * any MemberExpression nodes. This is used to determine if a
+ * variable that is only written once using destructuring can be
+ * safely converted into a const declaration.
+ * @param {ASTNode} node The ObjectPattern or ArrayPattern node to check.
+ * @returns {boolean} True if the destructuring pattern contains
+ * a MemberExpression, false if not.
+ */
+function hasMemberExpressionAssignment(node) {
+ switch (node.type) {
+ case "ObjectPattern":
+ return node.properties.some(prop => {
+ if (prop) {
+
+ /*
+ * Spread elements have an argument property while
+ * others have a value property. Because different
+ * parsers use different node types for spread elements,
+ * we just check if there is an argument property.
+ */
+ return hasMemberExpressionAssignment(prop.argument || prop.value);
+ }
+
+ return false;
+ });
+
+ case "ArrayPattern":
+ return node.elements.some(element => {
+ if (element) {
+ return hasMemberExpressionAssignment(element);
+ }
+
+ return false;
+ });
+
+ case "AssignmentPattern":
+ return hasMemberExpressionAssignment(node.left);
+
+ case "MemberExpression":
+ return true;
+
+ // no default
+ }
+
+ return false;
+}
+
+/**
+ * Gets an identifier node of a given variable.
+ *
+ * If the initialization exists or one or more reading references exist before
+ * the first assignment, the identifier node is the node of the declaration.
+ * Otherwise, the identifier node is the node of the first assignment.
+ *
+ * If the variable should not change to const, this function returns null.
+ * - If the variable is reassigned.
+ * - If the variable is never initialized nor assigned.
+ * - If the variable is initialized in a different scope from the declaration.
+ * - If the unique assignment of the variable cannot change to a declaration.
+ * e.g. `if (a) b = 1` / `return (b = 1)`
+ * - If the variable is declared in the global scope and `eslintUsed` is `true`.
+ * `/*exported foo` directive comment makes such variables. This rule does not
+ * warn such variables because this rule cannot distinguish whether the
+ * exported variables are reassigned or not.
+ * @param {eslint-scope.Variable} variable A variable to get.
+ * @param {boolean} ignoreReadBeforeAssign
+ * The value of `ignoreReadBeforeAssign` option.
+ * @returns {ASTNode|null}
+ * An Identifier node if the variable should change to const.
+ * Otherwise, null.
+ */
+function getIdentifierIfShouldBeConst(variable, ignoreReadBeforeAssign) {
+ if (variable.eslintUsed && variable.scope.type === "global") {
+ return null;
+ }
+
+ // Finds the unique WriteReference.
+ let writer = null;
+ let isReadBeforeInit = false;
+ const references = variable.references;
+
+ for (let i = 0; i < references.length; ++i) {
+ const reference = references[i];
+
+ if (reference.isWrite()) {
+ const isReassigned = (
+ writer !== null &&
+ writer.identifier !== reference.identifier
+ );
+
+ if (isReassigned) {
+ return null;
+ }
+
+ const destructuringHost = getDestructuringHost(reference);
+
+ if (destructuringHost !== null && destructuringHost.left !== void 0) {
+ const leftNode = destructuringHost.left;
+ let hasOuterVariables = false,
+ hasNonIdentifiers = false;
+
+ if (leftNode.type === "ObjectPattern") {
+ const properties = leftNode.properties;
+
+ hasOuterVariables = properties
+ .filter(prop => prop.value)
+ .map(prop => prop.value.name)
+ .some(name => isOuterVariableInDestructing(name, variable.scope));
+
+ hasNonIdentifiers = hasMemberExpressionAssignment(leftNode);
+
+ } else if (leftNode.type === "ArrayPattern") {
+ const elements = leftNode.elements;
+
+ hasOuterVariables = elements
+ .map(element => element && element.name)
+ .some(name => isOuterVariableInDestructing(name, variable.scope));
+
+ hasNonIdentifiers = hasMemberExpressionAssignment(leftNode);
+ }
+
+ if (hasOuterVariables || hasNonIdentifiers) {
+ return null;
+ }
+
+ }
+
+ writer = reference;
+
+ } else if (reference.isRead() && writer === null) {
+ if (ignoreReadBeforeAssign) {
+ return null;
+ }
+ isReadBeforeInit = true;
+ }
+ }
+
+ /*
+ * If the assignment is from a different scope, ignore it.
+ * If the assignment cannot change to a declaration, ignore it.
+ */
+ const shouldBeConst = (
+ writer !== null &&
+ writer.from === variable.scope &&
+ canBecomeVariableDeclaration(writer.identifier)
+ );
+
+ if (!shouldBeConst) {
+ return null;
+ }
+
+ if (isReadBeforeInit) {
+ return variable.defs[0].name;
+ }
+
+ return writer.identifier;
+}
+
+/**
+ * Groups by the VariableDeclarator/AssignmentExpression node that each
+ * reference of given variables belongs to.
+ * This is used to detect a mix of reassigned and never reassigned in a
+ * destructuring.
+ * @param {eslint-scope.Variable[]} variables Variables to group by destructuring.
+ * @param {boolean} ignoreReadBeforeAssign
+ * The value of `ignoreReadBeforeAssign` option.
+ * @returns {Map<ASTNode, ASTNode[]>} Grouped identifier nodes.
+ */
+function groupByDestructuring(variables, ignoreReadBeforeAssign) {
+ const identifierMap = new Map();
+
+ for (let i = 0; i < variables.length; ++i) {
+ const variable = variables[i];
+ const references = variable.references;
+ const identifier = getIdentifierIfShouldBeConst(variable, ignoreReadBeforeAssign);
+ let prevId = null;
+
+ for (let j = 0; j < references.length; ++j) {
+ const reference = references[j];
+ const id = reference.identifier;
+
+ /*
+ * Avoid counting a reference twice or more for default values of
+ * destructuring.
+ */
+ if (id === prevId) {
+ continue;
+ }
+ prevId = id;
+
+ // Add the identifier node into the destructuring group.
+ const group = getDestructuringHost(reference);
+
+ if (group) {
+ if (identifierMap.has(group)) {
+ identifierMap.get(group).push(identifier);
+ } else {
+ identifierMap.set(group, [identifier]);
+ }
+ }
+ }
+ }
+
+ return identifierMap;
+}
+
+/**
+ * Finds the nearest parent of node with a given type.
+ * @param {ASTNode} node The node to search from.
+ * @param {string} type The type field of the parent node.
+ * @param {Function} shouldStop A predicate that returns true if the traversal should stop, and false otherwise.
+ * @returns {ASTNode} The closest ancestor with the specified type; null if no such ancestor exists.
+ */
+function findUp(node, type, shouldStop) {
+ if (!node || shouldStop(node)) {
+ return null;
+ }
+ if (node.type === type) {
+ return node;
+ }
+ return findUp(node.parent, type, shouldStop);
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+ meta: {
+ type: "suggestion",
+
+ docs: {
+ description: "require `const` declarations for variables that are never reassigned after declared",
+ category: "ECMAScript 6",
+ recommended: false,
+ url: "https://eslint.org/docs/rules/prefer-const"
+ },
+
+ fixable: "code",
+
+ schema: [
+ {
+ type: "object",
+ properties: {
+ destructuring: { enum: ["any", "all"], default: "any" },
+ ignoreReadBeforeAssign: { type: "boolean", default: false }
+ },
+ additionalProperties: false
+ }
+ ],
+ messages: {
+ useConst: "'{{name}}' is never reassigned. Use 'const' instead."
+ }
+ },
+
+ create(context) {
+ const options = context.options[0] || {};
+ const sourceCode = context.getSourceCode();
+ const shouldMatchAnyDestructuredVariable = options.destructuring !== "all";
+ const ignoreReadBeforeAssign = options.ignoreReadBeforeAssign === true;
+ const variables = [];
+ let reportCount = 0;
+ let checkedId = null;
+ let checkedName = "";
+
+
+ /**
+ * Reports given identifier nodes if all of the nodes should be declared
+ * as const.
+ *
+ * The argument 'nodes' is an array of Identifier nodes.
+ * This node is the result of 'getIdentifierIfShouldBeConst()', so it's
+ * nullable. In simple declaration or assignment cases, the length of
+ * the array is 1. In destructuring cases, the length of the array can
+ * be 2 or more.
+ * @param {(eslint-scope.Reference|null)[]} nodes
+ * References which are grouped by destructuring to report.
+ * @returns {void}
+ */
+ function checkGroup(nodes) {
+ const nodesToReport = nodes.filter(Boolean);
+
+ if (nodes.length && (shouldMatchAnyDestructuredVariable || nodesToReport.length === nodes.length)) {
+ const varDeclParent = findUp(nodes[0], "VariableDeclaration", parentNode => parentNode.type.endsWith("Statement"));
+ const isVarDecParentNull = varDeclParent === null;
+
+ if (!isVarDecParentNull && varDeclParent.declarations.length > 0) {
+ const firstDeclaration = varDeclParent.declarations[0];
+
+ if (firstDeclaration.init) {
+ const firstDecParent = firstDeclaration.init.parent;
+
+ /*
+ * First we check the declaration type and then depending on
+ * if the type is a "VariableDeclarator" or its an "ObjectPattern"
+ * we compare the name and id from the first identifier, if the names are different
+ * we assign the new name, id and reset the count of reportCount and nodeCount in
+ * order to check each block for the number of reported errors and base our fix
+ * based on comparing nodes.length and nodesToReport.length.
+ */
+
+ if (firstDecParent.type === "VariableDeclarator") {
+
+ if (firstDecParent.id.name !== checkedName) {
+ checkedName = firstDecParent.id.name;
+ reportCount = 0;
+ }
+
+ if (firstDecParent.id.type === "ObjectPattern") {
+ if (firstDecParent.init.name !== checkedName) {
+ checkedName = firstDecParent.init.name;
+ reportCount = 0;
+ }
+ }
+
+ if (firstDecParent.id !== checkedId) {
+ checkedId = firstDecParent.id;
+ reportCount = 0;
+ }
+ }
+ }
+ }
+
+ let shouldFix = varDeclParent &&
+
+ // Don't do a fix unless all variables in the declarations are initialized (or it's in a for-in or for-of loop)
+ (varDeclParent.parent.type === "ForInStatement" || varDeclParent.parent.type === "ForOfStatement" ||
+ varDeclParent.declarations.every(declaration => declaration.init)) &&
+
+ /*
+ * If options.destructuring is "all", then this warning will not occur unless
+ * every assignment in the destructuring should be const. In that case, it's safe
+ * to apply the fix.
+ */
+ nodesToReport.length === nodes.length;
+
+ if (!isVarDecParentNull && varDeclParent.declarations && varDeclParent.declarations.length !== 1) {
+
+ if (varDeclParent && varDeclParent.declarations && varDeclParent.declarations.length >= 1) {
+
+ /*
+ * Add nodesToReport.length to a count, then comparing the count to the length
+ * of the declarations in the current block.
+ */
+
+ reportCount += nodesToReport.length;
+
+ shouldFix = shouldFix && (reportCount === varDeclParent.declarations.length);
+ }
+ }
+
+ nodesToReport.forEach(node => {
+ context.report({
+ node,
+ messageId: "useConst",
+ data: node,
+ fix: shouldFix
+ ? fixer => fixer.replaceText(
+ sourceCode.getFirstToken(varDeclParent, t => t.value === varDeclParent.kind),
+ "const"
+ )
+ : null
+ });
+ });
+ }
+ }
+
+ return {
+ "Program:exit"() {
+ groupByDestructuring(variables, ignoreReadBeforeAssign).forEach(checkGroup);
+ },
+
+ VariableDeclaration(node) {
+ if (node.kind === "let" && !isInitOfForStatement(node)) {
+ variables.push(...context.getDeclaredVariables(node));
+ }
+ }
+ };
+ }
+};
projects / dotfiles / .git / blobdiff