eslint 8.14.0 → 8.17.0

package/lib/rules/no-global-assign.js

@@ -78,7 +78,7 @@ module.exports = {
          * @returns {void}
          */
         function checkVariable(variable) {
-            if (variable.writeable === false && exceptions.indexOf(variable.name) === -1) {
+            if (variable.writeable === false && !exceptions.includes(variable.name)) {
                 variable.references.forEach(checkReference);
             }
         }

package/lib/rules/no-implicit-coercion.js

@@ -30,9 +30,9 @@ function parseOptions(options) {
 }
 
 /**
- * Checks whether or not a node is a double logical nigating.
+ * Checks whether or not a node is a double logical negating.
  * @param {ASTNode} node An UnaryExpression node to check.
- * @returns {boolean} Whether or not the node is a double logical nigating.
+ * @returns {boolean} Whether or not the node is a double logical negating.
  */
 function isDoubleLogicalNegating(node) {
     return (
@@ -257,7 +257,7 @@ module.exports = {
                 let operatorAllowed;
 
                 // !!foo
-                operatorAllowed = options.allow.indexOf("!!") >= 0;
+                operatorAllowed = options.allow.includes("!!");
                 if (!operatorAllowed && options.boolean && isDoubleLogicalNegating(node)) {
                     const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;
 
@@ -265,7 +265,7 @@ module.exports = {
                 }
 
                 // ~foo.indexOf(bar)
-                operatorAllowed = options.allow.indexOf("~") >= 0;
+                operatorAllowed = options.allow.includes("~");
                 if (!operatorAllowed && options.boolean && isBinaryNegatingOfIndexOf(node)) {
 
                     // `foo?.indexOf(bar) !== -1` will be true (== found) if the `foo` is nullish. So use `>= 0` in that case.
@@ -276,7 +276,7 @@ module.exports = {
                 }
 
                 // +foo
-                operatorAllowed = options.allow.indexOf("+") >= 0;
+                operatorAllowed = options.allow.includes("+");
                 if (!operatorAllowed && options.number && node.operator === "+" && !isNumeric(node.argument)) {
                     const recommendation = `Number(${sourceCode.getText(node.argument)})`;
 
@@ -289,7 +289,7 @@ module.exports = {
                 let operatorAllowed;
 
                 // 1 * foo
-                operatorAllowed = options.allow.indexOf("*") >= 0;
+                operatorAllowed = options.allow.includes("*");
                 const nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && getNonNumericOperand(node);
 
                 if (nonNumericOperand) {
@@ -299,7 +299,7 @@ module.exports = {
                 }
 
                 // "" + foo
-                operatorAllowed = options.allow.indexOf("+") >= 0;
+                operatorAllowed = options.allow.includes("+");
                 if (!operatorAllowed && options.string && isConcatWithEmptyString(node)) {
                     const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;
 
@@ -310,7 +310,7 @@ module.exports = {
             AssignmentExpression(node) {
 
                 // foo += ""
-                const operatorAllowed = options.allow.indexOf("+") >= 0;
+                const operatorAllowed = options.allow.includes("+");
 
                 if (!operatorAllowed && options.string && isAppendEmptyString(node)) {
                     const code = sourceCode.getText(getNonEmptyOperand(node));

package/lib/rules/no-loop-func.js

@@ -125,7 +125,7 @@ function isSafe(loopNode, reference) {
      * The reference is every reference of the upper scope's variable we are
      * looking now.
      *
-     * It's safeafe if the reference matches one of the following condition.
+     * It's safe if the reference matches one of the following condition.
      * - is readonly.
      * - doesn't exist inside a local function and after the border.
      * @param {eslint-scope.Reference} upperRef A reference to check.

package/lib/rules/no-magic-numbers.js

@@ -80,7 +80,7 @@ module.exports = {
         const config = context.options[0] || {},
             detectObjects = !!config.detectObjects,
             enforceConst = !!config.enforceConst,
-            ignore = (config.ignore || []).map(normalizeIgnoreValue),
+            ignore = new Set((config.ignore || []).map(normalizeIgnoreValue)),
             ignoreArrayIndexes = !!config.ignoreArrayIndexes,
             ignoreDefaultValues = !!config.ignoreDefaultValues;
 
@@ -92,7 +92,7 @@ module.exports = {
          * @returns {boolean} true if the value is ignored
          */
         function isIgnoredValue(value) {
-            return ignore.indexOf(value) !== -1;
+            return ignore.has(value);
         }
 
         /**
@@ -209,7 +209,7 @@ module.exports = {
                         });
                     }
                 } else if (
-                    okTypes.indexOf(parent.type) === -1 ||
+                    !okTypes.includes(parent.type) ||
                     (parent.type === "AssignmentExpression" && parent.left.type === "Identifier")
                 ) {
                     context.report({

package/lib/rules/no-misleading-character-class.js

@@ -4,13 +4,16 @@
 "use strict";
 
 const { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require("eslint-utils");
-const { RegExpParser, visitRegExpAST } = require("regexpp");
+const { RegExpValidator, RegExpParser, visitRegExpAST } = require("regexpp");
 const { isCombiningCharacter, isEmojiModifier, isRegionalIndicatorSymbol, isSurrogatePair } = require("./utils/unicode");
+const astUtils = require("./utils/ast-utils.js");
 
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
 
+const REGEXPP_LATEST_ECMA_VERSION = 2022;
+
 /**
  * Iterate character sequences of a given nodes.
  *
@@ -109,6 +112,8 @@ module.exports = {
             url: "https://eslint.org/docs/rules/no-misleading-character-class"
         },
 
+        hasSuggestions: true,
+
         schema: [],
 
         messages: {
@@ -116,10 +121,12 @@ module.exports = {
             combiningClass: "Unexpected combined character in character class.",
             emojiModifier: "Unexpected modified Emoji in character class.",
             regionalIndicatorSymbol: "Unexpected national flag in character class.",
-            zwj: "Unexpected joined character sequence in character class."
+            zwj: "Unexpected joined character sequence in character class.",
+            suggestUnicodeFlag: "Add unicode 'u' flag to regex."
         }
     },
     create(context) {
+        const sourceCode = context.getSourceCode();
         const parser = new RegExpParser();
 
         /**
@@ -127,17 +134,10 @@ module.exports = {
          * @param {Node} node The node to report.
          * @param {string} pattern The regular expression pattern to verify.
          * @param {string} flags The flags of the regular expression.
+         * @param {Function} unicodeFixer Fixer for missing "u" flag.
          * @returns {void}
          */
-        function verify(node, pattern, flags) {
-            const has = {
-                surrogatePairWithoutUFlag: false,
-                combiningClass: false,
-                variationSelector: false,
-                emojiModifier: false,
-                regionalIndicatorSymbol: false,
-                zwj: false
-            };
+        function verify(node, pattern, flags, unicodeFixer) {
             let patternNode;
 
             try {
@@ -153,26 +153,75 @@ module.exports = {
                 return;
             }
 
+            const foundKinds = new Set();
+
             visitRegExpAST(patternNode, {
                 onCharacterClassEnter(ccNode) {
                     for (const chars of iterateCharacterSequence(ccNode.elements)) {
                         for (const kind of kinds) {
-                            has[kind] = has[kind] || hasCharacterSequence[kind](chars);
+                            if (hasCharacterSequence[kind](chars)) {
+                                foundKinds.add(kind);
+                            }
                         }
                     }
                 }
             });
 
-            for (const kind of kinds) {
-                if (has[kind]) {
-                    context.report({ node, messageId: kind });
+            for (const kind of foundKinds) {
+                let suggest;
+
+                if (kind === "surrogatePairWithoutUFlag") {
+                    suggest = [{
+                        messageId: "suggestUnicodeFlag",
+                        fix: unicodeFixer
+                    }];
                 }
+
+                context.report({
+                    node,
+                    messageId: kind,
+                    suggest
+                });
             }
         }
 
+        /**
+         * Checks if the given regular expression pattern would be valid with the `u` flag.
+         * @param {string} pattern The regular expression pattern to verify.
+         * @returns {boolean} `true` if the pattern would be valid with the `u` flag.
+         * `false` if the pattern would be invalid with the `u` flag or the configured
+         * ecmaVersion doesn't support the `u` flag.
+         */
+        function isValidWithUnicodeFlag(pattern) {
+            const { ecmaVersion } = context.parserOptions;
+
+            // ecmaVersion is unknown or it doesn't support the 'u' flag
+            if (typeof ecmaVersion !== "number" || ecmaVersion <= 5) {
+                return false;
+            }
+
+            const validator = new RegExpValidator({
+                ecmaVersion: Math.min(ecmaVersion + 2009, REGEXPP_LATEST_ECMA_VERSION)
+            });
+
+            try {
+                validator.validatePattern(pattern, void 0, void 0, /* uFlag = */ true);
+            } catch {
+                return false;
+            }
+
+            return true;
+        }
+
         return {
             "Literal[regex]"(node) {
-                verify(node, node.regex.pattern, node.regex.flags);
+                verify(node, node.regex.pattern, node.regex.flags, fixer => {
+                    if (!isValidWithUnicodeFlag(node.regex.pattern)) {
+                        return null;
+                    }
+
+                    return fixer.insertTextAfter(node, "u");
+                });
             },
             "Program"() {
                 const scope = context.getScope();
@@ -191,7 +240,31 @@ module.exports = {
                     const flags = getStringIfConstant(flagsNode, scope);
 
                     if (typeof pattern === "string") {
-                        verify(node, pattern, flags || "");
+                        verify(node, pattern, flags || "", fixer => {
+
+                            if (!isValidWithUnicodeFlag(pattern)) {
+                                return null;
+                            }
+
+                            if (node.arguments.length === 1) {
+                                const penultimateToken = sourceCode.getLastToken(node, { skip: 1 }); // skip closing parenthesis
+
+                                return fixer.insertTextAfter(
+                                    penultimateToken,
+                                    astUtils.isCommaToken(penultimateToken)
+                                        ? ' "u",'
+                                        : ', "u"'
+                                );
+                            }
+
+                            if ((flagsNode.type === "Literal" && typeof flagsNode.value === "string") || flagsNode.type === "TemplateLiteral") {
+                                const range = [flagsNode.range[0], flagsNode.range[1] - 1];
+
+                                return fixer.insertTextAfterRange(range, "u");
+                            }
+
+                            return null;
+                        });
                     }
                 }
             }

package/lib/rules/no-mixed-operators.js

@@ -64,7 +64,7 @@ function normalizeOptions(options = {}) {
  * @returns {boolean} `true` if such group existed.
  */
 function includesBothInAGroup(groups, left, right) {
-    return groups.some(group => group.indexOf(left) !== -1 && group.indexOf(right) !== -1);
+    return groups.some(group => group.includes(left) && group.includes(right));
 }
 
 /**

package/lib/rules/no-mixed-requires.js

@@ -160,7 +160,7 @@ module.exports = {
                 return REQ_COMPUTED;
             }
 
-            if (BUILTIN_MODULES.indexOf(arg.value) !== -1) {
+            if (BUILTIN_MODULES.includes(arg.value)) {
 
                 // "var fs = require('fs');"
                 return REQ_CORE;

package/lib/rules/no-multi-spaces.js

@@ -56,7 +56,7 @@ module.exports = {
         const options = context.options[0] || {};
         const ignoreEOLComments = options.ignoreEOLComments;
         const exceptions = Object.assign({ Property: true }, options.exceptions);
-        const hasExceptions = Object.keys(exceptions).filter(key => exceptions[key]).length > 0;
+        const hasExceptions = Object.keys(exceptions).some(key => exceptions[key]);
 
         /**
          * Formats value of given comment token for error message by truncating its length.

package/lib/rules/no-native-reassign.js

@@ -81,7 +81,7 @@ module.exports = {
          * @returns {void}
          */
         function checkVariable(variable) {
-            if (variable.writeable === false && exceptions.indexOf(variable.name) === -1) {
+            if (variable.writeable === false && !exceptions.includes(variable.name)) {
                 variable.references.forEach(checkReference);
             }
         }

package/lib/rules/no-new-object.js

@@ -29,7 +29,7 @@ module.exports = {
         schema: [],
 
         messages: {
-            preferLiteral: "The object literal notation {} is preferrable."
+            preferLiteral: "The object literal notation {} is preferable."
         }
     },
 

package/lib/rules/no-new-wrappers.js

@@ -34,7 +34,7 @@ module.exports = {
             NewExpression(node) {
                 const wrapperObjects = ["String", "Number", "Boolean"];
 
-                if (wrapperObjects.indexOf(node.callee.name) > -1) {
+                if (wrapperObjects.includes(node.callee.name)) {
                     context.report({
                         node,
                         messageId: "noConstructor",

package/lib/rules/no-octal.js

@@ -23,7 +23,7 @@ module.exports = {
         schema: [],
 
         messages: {
-            noOcatal: "Octal literals should not be used."
+            noOctal: "Octal literals should not be used."
         }
     },
 
@@ -35,7 +35,7 @@ module.exports = {
                 if (typeof node.value === "number" && /^0[0-9]/u.test(node.raw)) {
                     context.report({
                         node,
-                        messageId: "noOcatal"
+                        messageId: "noOctal"
                     });
                 }
             }

package/lib/rules/no-prototype-builtins.js

@@ -33,11 +33,11 @@ module.exports = {
     },
 
     create(context) {
-        const DISALLOWED_PROPS = [
+        const DISALLOWED_PROPS = new Set([
             "hasOwnProperty",
             "isPrototypeOf",
             "propertyIsEnumerable"
-        ];
+        ]);
 
         /**
          * Reports if a disallowed property is used in a CallExpression
@@ -54,7 +54,7 @@ module.exports = {
 
             const propName = astUtils.getStaticPropertyName(callee);
 
-            if (propName !== null && DISALLOWED_PROPS.indexOf(propName) > -1) {
+            if (propName !== null && DISALLOWED_PROPS.has(propName)) {
                 context.report({
                     messageId: "prototypeBuildIn",
                     loc: callee.property.loc,

package/lib/rules/no-shadow.js

@@ -15,8 +15,8 @@ const astUtils = require("./utils/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
-const FUNC_EXPR_NODE_TYPES = ["ArrowFunctionExpression", "FunctionExpression"];
-const CALL_EXPR_NODE_TYPE = ["CallExpression"];
+const FUNC_EXPR_NODE_TYPES = new Set(["ArrowFunctionExpression", "FunctionExpression"]);
+const CALL_EXPR_NODE_TYPE = new Set(["CallExpression"]);
 const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u;
 const SENTINEL_TYPE = /^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/u;
 
@@ -123,7 +123,7 @@ module.exports = {
             const { variableScope } = variable.scope;
 
 
-            if (!(FUNC_EXPR_NODE_TYPES.includes(variableScope.block.type) && getOuterScope(variableScope) === shadowedVariable.scope)) {
+            if (!(FUNC_EXPR_NODE_TYPES.has(variableScope.block.type) && getOuterScope(variableScope) === shadowedVariable.scope)) {
                 return false;
             }
 
@@ -132,7 +132,7 @@ module.exports = {
 
             const callExpression = findSelfOrAncestor(
                 parent,
-                node => CALL_EXPR_NODE_TYPE.includes(node.type)
+                node => CALL_EXPR_NODE_TYPE.has(node.type)
             );
 
             if (!callExpression) {
@@ -173,7 +173,7 @@ module.exports = {
          * @returns {boolean} Whether or not the variable name is allowed.
          */
         function isAllowed(variable) {
-            return options.allow.indexOf(variable.name) !== -1;
+            return options.allow.includes(variable.name);
         }
 
         /**

package/lib/rules/no-sparse-arrays.js

@@ -37,7 +37,7 @@ module.exports = {
 
             ArrayExpression(node) {
 
-                const emptySpot = node.elements.indexOf(null) > -1;
+                const emptySpot = node.elements.includes(null);
 
                 if (emptySpot) {
                     context.report({ node, messageId: "unexpectedSparseArray" });

package/lib/rules/no-underscore-dangle.js

@@ -49,6 +49,10 @@ module.exports = {
                     allowFunctionParams: {
                         type: "boolean",
                         default: true
+                    },
+                    enforceInClassFields: {
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -68,6 +72,7 @@ module.exports = {
         const allowAfterSuper = typeof options.allowAfterSuper !== "undefined" ? options.allowAfterSuper : false;
         const allowAfterThisConstructor = typeof options.allowAfterThisConstructor !== "undefined" ? options.allowAfterThisConstructor : false;
         const enforceInMethodNames = typeof options.enforceInMethodNames !== "undefined" ? options.enforceInMethodNames : false;
+        const enforceInClassFields = typeof options.enforceInClassFields !== "undefined" ? options.enforceInClassFields : false;
         const allowFunctionParams = typeof options.allowFunctionParams !== "undefined" ? options.allowFunctionParams : true;
 
         //-------------------------------------------------------------------------
@@ -81,7 +86,7 @@ module.exports = {
          * @private
          */
         function isAllowed(identifier) {
-            return ALLOWED_VARIABLES.some(ident => ident === identifier);
+            return ALLOWED_VARIABLES.includes(identifier);
         }
 
         /**
@@ -261,6 +266,30 @@ module.exports = {
             }
         }
 
+        /**
+         * Check if a class field has a dangling underscore
+         * @param {ASTNode} node node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function checkForDanglingUnderscoreInClassField(node) {
+            const identifier = node.key.name;
+
+            if (typeof identifier !== "undefined" && hasDanglingUnderscore(identifier) &&
+                enforceInClassFields &&
+                !isAllowed(identifier)) {
+                context.report({
+                    node,
+                    messageId: "unexpectedUnderscore",
+                    data: {
+                        identifier: node.key.type === "PrivateIdentifier"
+                            ? `#${identifier}`
+                            : identifier
+                    }
+                });
+            }
+        }
+
         //--------------------------------------------------------------------------
         // Public API
         //--------------------------------------------------------------------------
@@ -270,7 +299,7 @@ module.exports = {
             VariableDeclarator: checkForDanglingUnderscoreInVariableExpression,
             MemberExpression: checkForDanglingUnderscoreInMemberExpression,
             MethodDefinition: checkForDanglingUnderscoreInMethod,
-            PropertyDefinition: checkForDanglingUnderscoreInMethod,
+            PropertyDefinition: checkForDanglingUnderscoreInClassField,
             Property: checkForDanglingUnderscoreInMethod,
             FunctionExpression: checkForDanglingUnderscoreInFunction,
             ArrowFunctionExpression: checkForDanglingUnderscoreInFunction

package/lib/rules/no-unused-expressions.js

@@ -124,7 +124,7 @@ module.exports = {
              */
             return (parent.type === "Program" || parent.type === "BlockStatement" &&
                     (/Function/u.test(grandparent.type))) &&
-                    directives(parent).indexOf(node) >= 0;
+                    directives(parent).includes(node);
         }
 
         /**

package/lib/rules/no-unused-vars.js

@@ -259,7 +259,7 @@ module.exports = {
             let scope = ref.from;
 
             while (scope) {
-                if (nodes.indexOf(scope.block) >= 0) {
+                if (nodes.includes(scope.block)) {
                     return true;
                 }
 

package/lib/rules/no-use-before-define.js

@@ -21,6 +21,7 @@ function parseOptions(options) {
     let functions = true;
     let classes = true;
     let variables = true;
+    let allowNamedExports = false;
 
     if (typeof options === "string") {
         functions = (options !== "nofunc");
@@ -28,9 +29,10 @@ function parseOptions(options) {
         functions = options.functions !== false;
         classes = options.classes !== false;
         variables = options.variables !== false;
+        allowNamedExports = !!options.allowNamedExports;
     }
 
-    return { functions, classes, variables };
+    return { functions, classes, variables, allowNamedExports };
 }
 
 /**
@@ -240,7 +242,8 @@ module.exports = {
                         properties: {
                             functions: { type: "boolean" },
                             classes: { type: "boolean" },
-                            variables: { type: "boolean" }
+                            variables: { type: "boolean" },
+                            allowNamedExports: { type: "boolean" }
                         },
                         additionalProperties: false
                     }
@@ -273,6 +276,16 @@ module.exports = {
                 return false;
             }
 
+            const { identifier } = reference;
+
+            if (
+                options.allowNamedExports &&
+                identifier.parent.type === "ExportSpecifier" &&
+                identifier.parent.local === identifier
+            ) {
+                return false;
+            }
+
             const variable = reference.resolved;
 
             if (!variable || variable.defs.length === 0) {

package/lib/rules/operator-assignment.js

@@ -22,7 +22,7 @@ const astUtils = require("./utils/ast-utils");
  *     shorthand form.
  */
 function isCommutativeOperatorWithShorthand(operator) {
-    return ["*", "&", "^", "|"].indexOf(operator) >= 0;
+    return ["*", "&", "^", "|"].includes(operator);
 }
 
 /**
@@ -33,7 +33,7 @@ function isCommutativeOperatorWithShorthand(operator) {
  *     a shorthand form.
  */
 function isNonCommutativeOperatorWithShorthand(operator) {
-    return ["+", "-", "/", "%", "<<", ">>", ">>>", "**"].indexOf(operator) >= 0;
+    return ["+", "-", "/", "%", "<<", ">>", ">>>", "**"].includes(operator);
 }
 
 //------------------------------------------------------------------------------

package/lib/rules/prefer-const.js

@@ -60,7 +60,7 @@ function canBecomeVariableDeclaration(identifier) {
  */
 function isOuterVariableInDestructing(name, initScope) {
 
-    if (initScope.through.find(ref => ref.resolved && ref.resolved.name === name)) {
+    if (initScope.through.some(ref => ref.resolved && ref.resolved.name === name)) {
         return true;
     }
 

package/lib/rules/prefer-reflect.js

@@ -106,7 +106,7 @@ module.exports = {
                 const methodName = (node.callee.property || {}).name;
                 const isReflectCall = (node.callee.object || {}).name === "Reflect";
                 const hasReflectSubstitute = Object.prototype.hasOwnProperty.call(reflectSubstitutes, methodName);
-                const userConfiguredException = exceptions.indexOf(methodName) !== -1;
+                const userConfiguredException = exceptions.includes(methodName);
 
                 if (hasReflectSubstitute && !isReflectCall && !userConfiguredException) {
                     report(node, existingNames[methodName], reflectSubstitutes[methodName]);
@@ -115,7 +115,7 @@ module.exports = {
             UnaryExpression(node) {
                 const isDeleteOperator = node.operator === "delete";
                 const targetsIdentifier = node.argument.type === "Identifier";
-                const userConfiguredException = exceptions.indexOf("delete") !== -1;
+                const userConfiguredException = exceptions.includes("delete");
 
                 if (isDeleteOperator && !targetsIdentifier && !userConfiguredException) {
                     report(node, "the delete keyword", "Reflect.deleteProperty");

package/lib/rules/prefer-regex-literals.js

@@ -47,7 +47,7 @@ function isStaticTemplateLiteral(node) {
     return node.type === "TemplateLiteral" && node.expressions.length === 0;
 }
 
-const validPrecedingTokens = [
+const validPrecedingTokens = new Set([
     "(",
     ";",
     "[",
@@ -110,7 +110,7 @@ const validPrecedingTokens = [
     "debugger",
     "case",
     "throw"
-];
+]);
 
 
 //------------------------------------------------------------------------------
@@ -334,7 +334,7 @@ module.exports = {
 
                         const tokenBefore = sourceCode.getTokenBefore(node);
 
-                        if (tokenBefore && !validPrecedingTokens.includes(tokenBefore.value)) {
+                        if (tokenBefore && !validPrecedingTokens.has(tokenBefore.value)) {
                             noFix = true;
                         }