eslint 8.55.0 → 9.0.0-alpha.0

package/lib/rules/index.js

@@ -273,7 +273,6 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     radix: () => require("./radix"),
     "require-atomic-updates": () => require("./require-atomic-updates"),
     "require-await": () => require("./require-await"),
-    "require-jsdoc": () => require("./require-jsdoc"),
     "require-unicode-regexp": () => require("./require-unicode-regexp"),
     "require-yield": () => require("./require-yield"),
     "rest-spread-spacing": () => require("./rest-spread-spacing"),
@@ -296,7 +295,6 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "template-tag-spacing": () => require("./template-tag-spacing"),
     "unicode-bom": () => require("./unicode-bom"),
     "use-isnan": () => require("./use-isnan"),
-    "valid-jsdoc": () => require("./valid-jsdoc"),
     "valid-typeof": () => require("./valid-typeof"),
     "vars-on-top": () => require("./vars-on-top"),
     "wrap-iife": () => require("./wrap-iife"),

package/lib/rules/no-constant-binary-expression.js

@@ -440,7 +440,7 @@ module.exports = {
         type: "problem",
         docs: {
             description: "Disallow expressions where the operation doesn't affect the value",
-            recommended: false,
+            recommended: true,
             url: "https://eslint.org/docs/latest/rules/no-constant-binary-expression"
         },
         schema: [],

package/lib/rules/no-constructor-return.js

@@ -20,7 +20,7 @@ module.exports = {
             url: "https://eslint.org/docs/latest/rules/no-constructor-return"
         },
 
-        schema: {},
+        schema: [],
 
         fixable: null,
 

package/lib/rules/no-empty-static-block.js

@@ -15,7 +15,7 @@ module.exports = {
 
         docs: {
             description: "Disallow empty static blocks",
-            recommended: false,
+            recommended: true,
             url: "https://eslint.org/docs/latest/rules/no-empty-static-block"
         },
 

package/lib/rules/no-extra-semi.js

@@ -26,7 +26,7 @@ module.exports = {
 
         docs: {
             description: "Disallow unnecessary semicolons",
-            recommended: true,
+            recommended: false,
             url: "https://eslint.org/docs/latest/rules/no-extra-semi"
         },
 

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

@@ -12,7 +12,7 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 const INDEX_OF_PATTERN = /^(?:i|lastI)ndexOf$/u;
-const ALLOWABLE_OPERATORS = ["~", "!!", "+", "*"];
+const ALLOWABLE_OPERATORS = ["~", "!!", "+", "- -", "-", "*"];
 
 /**
  * Parses and normalizes an option object.
@@ -300,6 +300,14 @@ module.exports = {
 
                     report(node, recommendation, true);
                 }
+
+                // -(-foo)
+                operatorAllowed = options.allow.includes("- -");
+                if (!operatorAllowed && options.number && node.operator === "-" && node.argument.type === "UnaryExpression" && node.argument.operator === "-" && !isNumeric(node.argument.argument)) {
+                    const recommendation = `Number(${sourceCode.getText(node.argument.argument)})`;
+
+                    report(node, recommendation, false);
+                }
             },
 
             // Use `:exit` to prevent double reporting
@@ -317,6 +325,14 @@ module.exports = {
                     report(node, recommendation, true);
                 }
 
+                // foo - 0
+                operatorAllowed = options.allow.includes("-");
+                if (!operatorAllowed && options.number && node.operator === "-" && node.right.type === "Literal" && node.right.value === 0 && !isNumeric(node.left)) {
+                    const recommendation = `Number(${sourceCode.getText(node.left)})`;
+
+                    report(node, recommendation, true);
+                }
+
                 // "" + foo
                 operatorAllowed = options.allow.includes("+");
                 if (!operatorAllowed && options.string && isConcatWithEmptyString(node)) {

package/lib/rules/no-inner-declarations.js

@@ -49,7 +49,7 @@ module.exports = {
 
         docs: {
             description: "Disallow variable or `function` declarations in nested blocks",
-            recommended: true,
+            recommended: false,
             url: "https://eslint.org/docs/latest/rules/no-inner-declarations"
         },
 

package/lib/rules/no-invalid-regexp.js

@@ -55,7 +55,7 @@ module.exports = {
             const temp = options.allowConstructorFlags.join("").replace(validFlags, "");
 
             if (temp) {
-                allowedFlags = new RegExp(`[${temp}]`, "giu");
+                allowedFlags = new RegExp(`[${temp}]`, "gu");
             }
         }
 

package/lib/rules/no-invalid-this.js

@@ -96,7 +96,7 @@ module.exports = {
 
                 if (codePath.origin === "program") {
                     const scope = sourceCode.getScope(node);
-                    const features = context.parserOptions.ecmaFeatures || {};
+                    const features = context.languageOptions.parserOptions.ecmaFeatures || {};
 
                     // `this` at the top level of scripts always refers to the global object
                     stack.push({

package/lib/rules/no-mixed-spaces-and-tabs.js

@@ -18,7 +18,7 @@ module.exports = {
 
         docs: {
             description: "Disallow mixed spaces and tabs for indentation",
-            recommended: true,
+            recommended: false,
             url: "https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs"
         },
 

package/lib/rules/no-new-native-nonconstructor.js

@@ -22,7 +22,7 @@ module.exports = {
 
         docs: {
             description: "Disallow `new` operators with global non-constructor functions",
-            recommended: false,
+            recommended: true,
             url: "https://eslint.org/docs/latest/rules/no-new-native-nonconstructor"
         },
 

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

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Rule to disallow use of the new operator with the `Symbol` object
  * @author Alberto Rodríguez
+ * @deprecated in ESLint v9.0.0
  */
 
 "use strict";
@@ -16,10 +17,16 @@ module.exports = {
 
         docs: {
             description: "Disallow `new` operators with the `Symbol` object",
-            recommended: true,
+            recommended: false,
             url: "https://eslint.org/docs/latest/rules/no-new-symbol"
         },
 
+        deprecated: true,
+
+        replacedBy: [
+            "no-new-native-nonconstructor"
+        ],
+
         schema: [],
 
         messages: {

package/lib/rules/no-promise-executor-return.js

@@ -209,12 +209,15 @@ module.exports = {
                         });
                     }
 
-                    suggest.push({
-                        messageId: "wrapBraces",
-                        fix(fixer) {
-                            return curlyWrapFixer(sourceCode, node, fixer);
-                        }
-                    });
+                    // Do not suggest wrapping an unnamed FunctionExpression in braces as that would be invalid syntax.
+                    if (!(node.body.type === "FunctionExpression" && !node.body.id)) {
+                        suggest.push({
+                            messageId: "wrapBraces",
+                            fix(fixer) {
+                                return curlyWrapFixer(sourceCode, node, fixer);
+                            }
+                        });
+                    }
 
                     context.report({
                         node: node.body,

package/lib/rules/no-restricted-properties.js

@@ -142,40 +142,27 @@ module.exports = {
             }
         }
 
-        /**
-         * Checks property accesses in a destructuring assignment expression, e.g. `var foo; ({foo} = bar);`
-         * @param {ASTNode} node An AssignmentExpression or AssignmentPattern node
-         * @returns {undefined}
-         */
-        function checkDestructuringAssignment(node) {
-            if (node.right.type === "Identifier") {
-                const objectName = node.right.name;
-
-                if (node.left.type === "ObjectPattern") {
-                    node.left.properties.forEach(property => {
-                        checkPropertyAccess(node.left, objectName, astUtils.getStaticPropertyName(property));
-                    });
-                }
-            }
-        }
-
         return {
             MemberExpression(node) {
                 checkPropertyAccess(node, node.object && node.object.name, astUtils.getStaticPropertyName(node));
             },
-            VariableDeclarator(node) {
-                if (node.init && node.init.type === "Identifier") {
-                    const objectName = node.init.name;
-
-                    if (node.id.type === "ObjectPattern") {
-                        node.id.properties.forEach(property => {
-                            checkPropertyAccess(node.id, objectName, astUtils.getStaticPropertyName(property));
-                        });
+            ObjectPattern(node) {
+                let objectName = null;
+
+                if (node.parent.type === "VariableDeclarator") {
+                    if (node.parent.init && node.parent.init.type === "Identifier") {
+                        objectName = node.parent.init.name;
+                    }
+                } else if (node.parent.type === "AssignmentExpression" || node.parent.type === "AssignmentPattern") {
+                    if (node.parent.right.type === "Identifier") {
+                        objectName = node.parent.right.name;
                     }
                 }
-            },
-            AssignmentExpression: checkDestructuringAssignment,
-            AssignmentPattern: checkDestructuringAssignment
+
+                node.properties.forEach(property => {
+                    checkPropertyAccess(node, objectName, astUtils.getStaticPropertyName(property));
+                });
+            }
         };
     }
 };

package/lib/rules/no-sequences.js

@@ -35,6 +35,7 @@ module.exports = {
         },
 
         schema: [{
+            type: "object",
             properties: {
                 allowInParentheses: {
                     type: "boolean",

package/lib/rules/no-unused-private-class-members.js

@@ -16,7 +16,7 @@ module.exports = {
 
         docs: {
             description: "Disallow unused private class members",
-            recommended: false,
+            recommended: true,
             url: "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
         },
 

package/lib/shared/config-validator.js

@@ -17,6 +17,23 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/** @typedef {import("../shared/types").Rule} Rule */
+
+//------------------------------------------------------------------------------
+// Private Members
+//------------------------------------------------------------------------------
+
+// JSON schema that disallows passing any options
+const noOptionsSchema = Object.freeze({
+    type: "array",
+    minItems: 0,
+    maxItems: 0
+});
+
 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------
@@ -49,17 +66,36 @@ const severityMap = {
 
 /**
  * Gets a complete options schema for a rule.
- * @param {{create: Function, schema: (Array|null)}} rule A new-style rule object
- * @returns {Object} JSON Schema for the rule's options.
+ * @param {Rule} rule A rule object
+ * @throws {TypeError} If `meta.schema` is specified but is not an array, object or `false`.
+ * @returns {Object|null} JSON Schema for the rule's options.
+ *      `null` if rule wasn't passed or its `meta.schema` is `false`.
  */
 function getRuleOptionsSchema(rule) {
     if (!rule) {
         return null;
     }
 
-    const schema = rule.schema || rule.meta && rule.meta.schema;
+    if (!rule.meta) {
+        return { ...noOptionsSchema }; // default if `meta.schema` is not specified
+    }
+
+    const schema = rule.meta.schema;
+
+    if (typeof schema === "undefined") {
+        return { ...noOptionsSchema }; // default if `meta.schema` is not specified
+    }
+
+    // `schema:false` is an allowed explicit opt-out of options validation for the rule
+    if (schema === false) {
+        return null;
+    }
+
+    if (typeof schema !== "object" || schema === null) {
+        throw new TypeError("Rule's `meta.schema` must be an array or object");
+    }
 
-    // Given a tuple of schemas, insert warning level at the beginning
+    // ESLint-specific array form needs to be converted into a valid JSON Schema definition
     if (Array.isArray(schema)) {
         if (schema.length) {
             return {
@@ -69,16 +105,13 @@ function getRuleOptionsSchema(rule) {
                 maxItems: schema.length
             };
         }
-        return {
-            type: "array",
-            minItems: 0,
-            maxItems: 0
-        };
 
+        // `schema:[]` is an explicit way to specify that the rule does not accept any options
+        return { ...noOptionsSchema };
     }
 
-    // Given a full schema, leave it alone
-    return schema || null;
+    // `schema:<object>` is assumed to be a valid JSON Schema definition
+    return schema;
 }
 
 /**

package/lib/shared/severity.js

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Helpers for severity values (e.g. normalizing different types).
+ * @author Bryan Mishkin
+ */
+
+"use strict";
+
+/**
+ * Convert severity value of different types to a string.
+ * @param {string|number} severity severity value
+ * @throws error if severity is invalid
+ * @returns {string} severity string
+ */
+function normalizeSeverityToString(severity) {
+    if ([2, "2", "error"].includes(severity)) {
+        return "error";
+    }
+    if ([1, "1", "warn"].includes(severity)) {
+        return "warn";
+    }
+    if ([0, "0", "off"].includes(severity)) {
+        return "off";
+    }
+    throw new Error(`Invalid severity value: ${severity}`);
+}
+
+/**
+ * Convert severity value of different types to a number.
+ * @param {string|number} severity severity value
+ * @throws error if severity is invalid
+ * @returns {number} severity number
+ */
+function normalizeSeverityToNumber(severity) {
+    if ([2, "2", "error"].includes(severity)) {
+        return 2;
+    }
+    if ([1, "1", "warn"].includes(severity)) {
+        return 1;
+    }
+    if ([0, "0", "off"].includes(severity)) {
+        return 0;
+    }
+    throw new Error(`Invalid severity value: ${severity}`);
+}
+
+module.exports = {
+    normalizeSeverityToString,
+    normalizeSeverityToNumber
+};

package/lib/shared/types.js

@@ -168,7 +168,7 @@ module.exports = {};
  * @property {Record<string, ConfigData>} [configs] The definition of plugin configs.
  * @property {Record<string, Environment>} [environments] The definition of plugin environments.
  * @property {Record<string, Processor>} [processors] The definition of plugin processors.
- * @property {Record<string, Function | Rule>} [rules] The definition of plugin rules.
+ * @property {Record<string, Rule>} [rules] The definition of plugin rules.
  */
 
 /**

package/lib/source-code/source-code.js

@@ -212,24 +212,6 @@ function isSpaceBetween(sourceCode, first, second, checkInsideOfJSXText) {
 // Directive Comments
 //-----------------------------------------------------------------------------
 
-/**
- * Extract the directive and the justification from a given directive comment and trim them.
- * @param {string} value The comment text to extract.
- * @returns {{directivePart: string, justificationPart: string}} The extracted directive and justification.
- */
-function extractDirectiveComment(value) {
-    const match = /\s-{2,}\s/u.exec(value);
-
-    if (!match) {
-        return { directivePart: value.trim(), justificationPart: "" };
-    }
-
-    const directive = value.slice(0, match.index).trim();
-    const justification = value.slice(match.index + match[0].length).trim();
-
-    return { directivePart: directive, justificationPart: justification };
-}
-
 /**
  * Ensures that variables representing built-in properties of the Global Object,
  * and any globals declared by special block comments, are present in the global
@@ -438,9 +420,6 @@ class SourceCode extends TokenStore {
         }
         this.lines.push(this.text.slice(this.lineStartIndices[this.lineStartIndices.length - 1]));
 
-        // Cache for comments found using getComments().
-        this._commentCache = new WeakMap();
-
         // don't allow further modification of this object
         Object.freeze(this);
         Object.freeze(this.lines);
@@ -490,81 +469,6 @@ class SourceCode extends TokenStore {
         return this.ast.comments;
     }
 
-    /**
-     * Gets all comments for the given node.
-     * @param {ASTNode} node The AST node to get the comments for.
-     * @returns {Object} An object containing a leading and trailing array
-     *      of comments indexed by their position.
-     * @public
-     * @deprecated replaced by getCommentsBefore(), getCommentsAfter(), and getCommentsInside().
-     */
-    getComments(node) {
-        if (this._commentCache.has(node)) {
-            return this._commentCache.get(node);
-        }
-
-        const comments = {
-            leading: [],
-            trailing: []
-        };
-
-        /*
-         * Return all comments as leading comments of the Program node when
-         * there is no executable code.
-         */
-        if (node.type === "Program") {
-            if (node.body.length === 0) {
-                comments.leading = node.comments;
-            }
-        } else {
-
-            /*
-             * Return comments as trailing comments of nodes that only contain
-             * comments (to mimic the comment attachment behavior present in Espree).
-             */
-            if ((node.type === "BlockStatement" || node.type === "ClassBody") && node.body.length === 0 ||
-                node.type === "ObjectExpression" && node.properties.length === 0 ||
-                node.type === "ArrayExpression" && node.elements.length === 0 ||
-                node.type === "SwitchStatement" && node.cases.length === 0
-            ) {
-                comments.trailing = this.getTokens(node, {
-                    includeComments: true,
-                    filter: isCommentToken
-                });
-            }
-
-            /*
-             * Iterate over tokens before and after node and collect comment tokens.
-             * Do not include comments that exist outside of the parent node
-             * to avoid duplication.
-             */
-            let currentToken = this.getTokenBefore(node, { includeComments: true });
-
-            while (currentToken && isCommentToken(currentToken)) {
-                if (node.parent && node.parent.type !== "Program" && (currentToken.start < node.parent.start)) {
-                    break;
-                }
-                comments.leading.push(currentToken);
-                currentToken = this.getTokenBefore(currentToken, { includeComments: true });
-            }
-
-            comments.leading.reverse();
-
-            currentToken = this.getTokenAfter(node, { includeComments: true });
-
-            while (currentToken && isCommentToken(currentToken)) {
-                if (node.parent && node.parent.type !== "Program" && (currentToken.end > node.parent.end)) {
-                    break;
-                }
-                comments.trailing.push(currentToken);
-                currentToken = this.getTokenAfter(currentToken, { includeComments: true });
-            }
-        }
-
-        this._commentCache.set(node, comments);
-        return comments;
-    }
-
     /**
      * Retrieves the JSDoc comment for a given node.
      * @param {ASTNode} node The AST node to get the comment for.
@@ -921,7 +825,7 @@ class SourceCode extends TokenStore {
                 return false;
             }
 
-            const { directivePart } = extractDirectiveComment(comment.value);
+            const { directivePart } = commentParser.extractDirectiveComment(comment.value);
 
             const directiveMatch = directivesPattern.exec(directivePart);
 
@@ -977,14 +881,11 @@ class SourceCode extends TokenStore {
 
         this.getInlineConfigNodes().forEach(comment => {
 
-            const { directivePart } = extractDirectiveComment(comment.value);
-            const match = directivesPattern.exec(directivePart);
-            const directiveText = match[1];
-            const directiveValue = directivePart.slice(match.index + directiveText.length);
+            const { directiveText, directiveValue } = commentParser.parseDirective(comment);
 
             switch (directiveText) {
                 case "exported":
-                    Object.assign(exportedVariables, commentParser.parseStringConfig(directiveValue, comment));
+                    Object.assign(exportedVariables, commentParser.parseListConfig(directiveValue, comment));
                     break;
 
                 case "globals":

package/lib/unsupported-api.js

@@ -12,9 +12,8 @@
 //-----------------------------------------------------------------------------
 
 const { FileEnumerator } = require("./cli-engine/file-enumerator");
-const { FlatESLint, shouldUseFlatConfig } = require("./eslint/flat-eslint");
-const FlatRuleTester = require("./rule-tester/flat-rule-tester");
-const { ESLint } = require("./eslint/eslint");
+const { ESLint: FlatESLint, shouldUseFlatConfig } = require("./eslint/eslint");
+const { LegacyESLint } = require("./eslint/legacy-eslint");
 
 //-----------------------------------------------------------------------------
 // Exports
@@ -24,7 +23,6 @@ module.exports = {
     builtinRules: require("./rules"),
     FlatESLint,
     shouldUseFlatConfig,
-    FlatRuleTester,
     FileEnumerator,
-    LegacyESLint: ESLint
+    LegacyESLint
 };