eslint 8.13.0 → 8.17.0

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;
                         }
 

package/lib/rules/quote-props.js

@@ -95,7 +95,7 @@ module.exports = {
          * @returns {boolean} `true` if it is an ES3 token.
          */
         function isKeyword(tokenStr) {
-            return keywords.indexOf(tokenStr) >= 0;
+            return keywords.includes(tokenStr);
         }
 
         /**
@@ -108,7 +108,7 @@ module.exports = {
          */
         function areQuotesRedundant(rawKey, tokens, skipNumberLiterals) {
             return tokens.length === 1 && tokens[0].start === 0 && tokens[0].end === rawKey.length &&
-                (["Identifier", "Keyword", "Null", "Boolean"].indexOf(tokens[0].type) >= 0 ||
+                (["Identifier", "Keyword", "Null", "Boolean"].includes(tokens[0].type) ||
                 (tokens[0].type === "Numeric" && !skipNumberLiterals && String(+tokens[0].value) === tokens[0].value));
         }
 

package/lib/rules/quotes.js

@@ -283,7 +283,7 @@ module.exports = {
                         astUtils.isSurroundedBy(rawVal, settings.quote);
 
                     if (!isValid && avoidEscape) {
-                        isValid = astUtils.isSurroundedBy(rawVal, settings.alternateQuote) && rawVal.indexOf(settings.quote) >= 0;
+                        isValid = astUtils.isSurroundedBy(rawVal, settings.alternateQuote) && rawVal.includes(settings.quote);
                     }
 
                     if (!isValid) {

package/lib/rules/spaced-comment.js

@@ -39,7 +39,7 @@ function escapeAndRepeat(s) {
 function parseMarkersOption(markers) {
 
     // `*` is a marker for JSDoc comments.
-    if (markers.indexOf("*") === -1) {
+    if (!markers.includes("*")) {
         return markers.concat("*");
     }
 

package/lib/rules/utils/ast-utils.js

@@ -32,6 +32,7 @@ const thisTagPattern = /^[\s*]*@this/mu;
 
 
 const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u;
+const ESLINT_DIRECTIVE_PATTERN = /^(?:eslint[- ]|(?:globals?|exported) )/u;
 const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]);
 
 // A set of node types that can contain a list of statements
@@ -788,6 +789,203 @@ function getModuleExportName(node) {
     return node.value;
 }
 
+/**
+ * Returns literal's value converted to the Boolean type
+ * @param {ASTNode} node any `Literal` node
+ * @returns {boolean | null} `true` when node is truthy, `false` when node is falsy,
+ *  `null` when it cannot be determined.
+ */
+function getBooleanValue(node) {
+    if (node.value === null) {
+
+        /*
+         * it might be a null literal or bigint/regex literal in unsupported environments .
+         * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es5.md#regexpliteral
+         * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es2020.md#bigintliteral
+         */
+
+        if (node.raw === "null") {
+            return false;
+        }
+
+        // regex is always truthy
+        if (typeof node.regex === "object") {
+            return true;
+        }
+
+        return null;
+    }
+
+    return !!node.value;
+}
+
+/**
+ * Checks if a branch node of LogicalExpression short circuits the whole condition
+ * @param {ASTNode} node The branch of main condition which needs to be checked
+ * @param {string} operator The operator of the main LogicalExpression.
+ * @returns {boolean} true when condition short circuits whole condition
+ */
+function isLogicalIdentity(node, operator) {
+    switch (node.type) {
+        case "Literal":
+            return (operator === "||" && getBooleanValue(node) === true) ||
+                  (operator === "&&" && getBooleanValue(node) === false);
+
+        case "UnaryExpression":
+            return (operator === "&&" && node.operator === "void");
+
+        case "LogicalExpression":
+
+            /*
+             * handles `a && false || b`
+             * `false` is an identity element of `&&` but not `||`
+             */
+            return operator === node.operator &&
+                    (
+                        isLogicalIdentity(node.left, operator) ||
+                        isLogicalIdentity(node.right, operator)
+                    );
+
+        case "AssignmentExpression":
+            return ["||=", "&&="].includes(node.operator) &&
+               operator === node.operator.slice(0, -1) &&
+               isLogicalIdentity(node.right, operator);
+
+       // no default
+    }
+    return false;
+}
+
+/**
+ * Checks if an identifier is a reference to a global variable.
+ * @param {Scope} scope The scope in which the identifier is referenced.
+ * @param {ASTNode} node An identifier node to check.
+ * @returns {boolean} `true` if the identifier is a reference to a global variable.
+ */
+function isReferenceToGlobalVariable(scope, node) {
+    const reference = scope.references.find(ref => ref.identifier === node);
+
+    return Boolean(
+        reference &&
+            reference.resolved &&
+            reference.resolved.scope.type === "global" &&
+            reference.resolved.defs.length === 0
+    );
+}
+
+
+/**
+ * Checks if a  node has a constant truthiness value.
+ * @param {Scope} scope Scope in which the node appears.
+ * @param {ASTNode} node The AST node to check.
+ * @param {boolean} inBooleanPosition `true` if checking the test of a
+ * condition. `false` in all other cases. When `false`, checks if -- for
+ * both string and number -- if coerced to that type, the value will
+ * be constant.
+ * @returns {boolean} true when node's truthiness is constant
+ * @private
+ */
+function isConstant(scope, node, inBooleanPosition) {
+
+    // node.elements can return null values in the case of sparse arrays ex. [,]
+    if (!node) {
+        return true;
+    }
+    switch (node.type) {
+        case "Literal":
+        case "ArrowFunctionExpression":
+        case "FunctionExpression":
+            return true;
+        case "ClassExpression":
+        case "ObjectExpression":
+
+            /**
+             * In theory objects like:
+             *
+             * `{toString: () => a}`
+             * `{valueOf: () => a}`
+             *
+             * Or a classes like:
+             *
+             * `class { static toString() { return a } }`
+             * `class { static valueOf() { return a } }`
+             *
+             * Are not constant verifiably when `inBooleanPosition` is
+             * false, but it's an edge case we've opted not to handle.
+             */
+            return true;
+        case "TemplateLiteral":
+            return (inBooleanPosition && node.quasis.some(quasi => quasi.value.cooked.length)) ||
+                        node.expressions.every(exp => isConstant(scope, exp, false));
+
+        case "ArrayExpression": {
+            if (!inBooleanPosition) {
+                return node.elements.every(element => isConstant(scope, element, false));
+            }
+            return true;
+        }
+
+        case "UnaryExpression":
+            if (
+                node.operator === "void" ||
+                        node.operator === "typeof" && inBooleanPosition
+            ) {
+                return true;
+            }
+
+            if (node.operator === "!") {
+                return isConstant(scope, node.argument, true);
+            }
+
+            return isConstant(scope, node.argument, false);
+
+        case "BinaryExpression":
+            return isConstant(scope, node.left, false) &&
+                            isConstant(scope, node.right, false) &&
+                            node.operator !== "in";
+
+        case "LogicalExpression": {
+            const isLeftConstant = isConstant(scope, node.left, inBooleanPosition);
+            const isRightConstant = isConstant(scope, node.right, inBooleanPosition);
+            const isLeftShortCircuit = (isLeftConstant && isLogicalIdentity(node.left, node.operator));
+            const isRightShortCircuit = (inBooleanPosition && isRightConstant && isLogicalIdentity(node.right, node.operator));
+
+            return (isLeftConstant && isRightConstant) ||
+                        isLeftShortCircuit ||
+                        isRightShortCircuit;
+        }
+        case "NewExpression":
+            return inBooleanPosition;
+        case "AssignmentExpression":
+            if (node.operator === "=") {
+                return isConstant(scope, node.right, inBooleanPosition);
+            }
+
+            if (["||=", "&&="].includes(node.operator) && inBooleanPosition) {
+                return isLogicalIdentity(node.right, node.operator.slice(0, -1));
+            }
+
+            return false;
+
+        case "SequenceExpression":
+            return isConstant(scope, node.expressions[node.expressions.length - 1], inBooleanPosition);
+        case "SpreadElement":
+            return isConstant(scope, node.argument, inBooleanPosition);
+        case "CallExpression":
+            if (node.callee.type === "Identifier" && node.callee.name === "Boolean") {
+                if (node.arguments.length === 0 || isConstant(scope, node.arguments[0], true)) {
+                    return isReferenceToGlobalVariable(scope, node.callee);
+                }
+            }
+            return false;
+        case "Identifier":
+            return node.name === "undefined" && isReferenceToGlobalVariable(scope, node);
+
+                // no default
+    }
+    return false;
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -908,12 +1106,8 @@ module.exports = {
         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
-            )
+            node.type === "Line" && comment.startsWith("eslint-") ||
+            node.type === "Block" && ESLINT_DIRECTIVE_PATTERN.test(comment)
         );
     },
 
@@ -1905,6 +2099,7 @@ module.exports = {
         return OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN.test(rawString);
     },
 
+    isReferenceToGlobalVariable,
     isLogicalExpression,
     isCoalesceExpression,
     isMixedLogicalAndCoalesceExpressions,
@@ -1918,5 +2113,6 @@ module.exports = {
     isSameReference,
     isLogicalAssignmentOperator,
     getSwitchCaseColonToken,
-    getModuleExportName
+    getModuleExportName,
+    isConstant
 };

package/lib/rules/valid-jsdoc.js

@@ -405,7 +405,7 @@ module.exports = {
                             loc: getAbsoluteRange(jsdocNode, param),
                             data: { name: param.name }
                         });
-                    } else if (param.name.indexOf(".") === -1) {
+                    } else if (!param.name.includes(".")) {
                         paramTagsByName[param.name] = param;
                     }
                 });

package/lib/rules/valid-typeof.js

@@ -42,8 +42,8 @@ module.exports = {
 
     create(context) {
 
-        const VALID_TYPES = ["symbol", "undefined", "object", "boolean", "number", "string", "function", "bigint"],
-            OPERATORS = ["==", "===", "!=", "!=="];
+        const VALID_TYPES = new Set(["symbol", "undefined", "object", "boolean", "number", "string", "function", "bigint"]),
+            OPERATORS = new Set(["==", "===", "!=", "!=="]);
 
         const requireStringLiterals = context.options[0] && context.options[0].requireStringLiterals;
 
@@ -85,13 +85,13 @@ module.exports = {
                 if (isTypeofExpression(node)) {
                     const parent = context.getAncestors().pop();
 
-                    if (parent.type === "BinaryExpression" && OPERATORS.indexOf(parent.operator) !== -1) {
+                    if (parent.type === "BinaryExpression" && OPERATORS.has(parent.operator)) {
                         const sibling = parent.left === node ? parent.right : parent.left;
 
                         if (sibling.type === "Literal" || sibling.type === "TemplateLiteral" && !sibling.expressions.length) {
                             const value = sibling.type === "Literal" ? sibling.value : sibling.quasis[0].value.cooked;
 
-                            if (VALID_TYPES.indexOf(value) === -1) {
+                            if (!VALID_TYPES.has(value)) {
                                 context.report({ node: sibling, messageId: "invalidValue" });
                             }
                         } else if (sibling.type === "Identifier" && sibling.name === "undefined" && isReferenceToGlobalVariable(sibling)) {

package/lib/rules/yoda.js

@@ -39,7 +39,7 @@ function isEqualityOperator(operator) {
  * @returns {boolean} Whether the operator is used in range tests.
  */
 function isRangeTestOperator(operator) {
-    return ["<", "<="].indexOf(operator) >= 0;
+    return ["<", "<="].includes(operator);
 }
 
 /**

package/lib/shared/types.js

@@ -136,7 +136,6 @@ module.exports = {};
 
 /**
  * @typedef {Object} RuleMetaDocs
- * @property {string} category The category of the rule.
  * @property {string} description The description of the rule.
  * @property {boolean} recommended If `true` then the rule is included in `eslint:recommended` preset.
  * @property {string} url The URL of the rule documentation.
@@ -147,6 +146,7 @@ module.exports = {};
  * @property {boolean} [deprecated] If `true` then the rule has been deprecated.
  * @property {RuleMetaDocs} docs The document information of the rule.
  * @property {"code"|"whitespace"} [fixable] The autofix type.
+ * @property {boolean} [hasSuggestions] If `true` then the rule provides suggestions.
  * @property {Record<string,string>} [messages] The messages the rule reports.
  * @property {string[]} [replacedBy] The IDs of the alternative rules.
  * @property {Array|Object} schema The option schema of the rule.