eslint 7.0.0-alpha.2 → 7.1.0

package/lib/init/config-file.js

@@ -45,7 +45,7 @@ function sortByKey(a, b) {
 function writeJSONConfigFile(config, filePath) {
     debug(`Writing JSON config file: ${filePath}`);
 
-    const content = stringify(config, { cmp: sortByKey, space: 4 });
+    const content = `${stringify(config, { cmp: sortByKey, space: 4 })}\n`;
 
     fs.writeFileSync(filePath, content, "utf8");
 }
@@ -80,7 +80,7 @@ function writeJSConfigFile(config, filePath) {
     debug(`Writing JS config file: ${filePath}`);
 
     let contentToWrite;
-    const stringifiedContent = `module.exports = ${stringify(config, { cmp: sortByKey, space: 4 })};`;
+    const stringifiedContent = `module.exports = ${stringify(config, { cmp: sortByKey, space: 4 })};\n`;
 
     try {
         const { CLIEngine } = require("../cli-engine");

package/lib/init/config-initializer.js

@@ -15,6 +15,7 @@ const util = require("util"),
     inquirer = require("inquirer"),
     ProgressBar = require("progress"),
     semver = require("semver"),
+    espree = require("espree"),
     recConfig = require("../../conf/eslint-recommended"),
     ConfigOps = require("../shared/config-ops"),
     log = require("../shared/logging"),
@@ -31,8 +32,6 @@ const debug = require("debug")("eslint:config-initializer");
 // Private
 //------------------------------------------------------------------------------
 
-const DEFAULT_ECMA_VERSION = 2018;
-
 /* istanbul ignore next: hard to test fs function */
 /**
  * Create .eslintrc file in the current working directory
@@ -265,8 +264,7 @@ function processAnswers(answers) {
         extends: []
     };
 
-    // set the latest ECMAScript version
-    config.parserOptions.ecmaVersion = DEFAULT_ECMA_VERSION;
+    config.parserOptions.ecmaVersion = espree.latestEcmaVersion;
     config.env.es6 = true;
     config.globals = {
         Atomics: "readonly",
@@ -328,6 +326,7 @@ function processAnswers(answers) {
     }
     if (answers.typescript && config.extends.includes("eslint:recommended")) {
         config.extends.push("plugin:@typescript-eslint/eslint-recommended");
+        config.extends.push("plugin:@typescript-eslint/recommended");
     }
 
     // normalize extends

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

@@ -23,7 +23,7 @@ const { CLIEngine } = require("../cli-engine");
  * TODO1: Expose the API that enumerates target files.
  * TODO2: Extract the creation logic of `SourceCode` from `Linter` class.
  */
-const { getCLIEngineInternalSlots } = require("../cli-engine/cli-engine"); // eslint-disable-line no-restricted-modules
+const { getCLIEngineInternalSlots } = require("../cli-engine/cli-engine"); // eslint-disable-line node/no-restricted-require
 
 const debug = require("debug")("eslint:source-code-utils");
 
@@ -97,7 +97,7 @@ function getSourceCodeOfFiles(patterns, options, callback) {
             sourceCodes[filename] = sourceCode;
         }
         if (callback) {
-            callback(filenames.length); // eslint-disable-line callback-return
+            callback(filenames.length); // eslint-disable-line node/callback-return
         }
     });
 

package/lib/linter/linter.js

@@ -938,7 +938,8 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserOptions, parser
         });
     });
 
-    const eventGenerator = new CodePathAnalyzer(new NodeEventGenerator(emitter));
+    // only run code path analyzer if the top level node is "Program", skip otherwise
+    const eventGenerator = nodeQueue[0].node.type === "Program" ? new CodePathAnalyzer(new NodeEventGenerator(emitter)) : new NodeEventGenerator(emitter);
 
     nodeQueue.forEach(traversalInfo => {
         currentNode = traversalInfo.node;

package/lib/linter/node-event-generator.js

@@ -159,8 +159,8 @@ function tryParseSelector(rawSelector) {
     try {
         return esquery.parse(rawSelector.replace(/:exit$/u, ""));
     } catch (err) {
-        if (typeof err.offset === "number") {
-            throw new SyntaxError(`Syntax error in selector "${rawSelector}" at position ${err.offset}: ${err.message}`);
+        if (err.location && err.location.start && typeof err.location.start.offset === "number") {
+            throw new SyntaxError(`Syntax error in selector "${rawSelector}" at position ${err.location.start.offset}: ${err.message}`);
         }
         throw err;
     }

package/lib/options.js

@@ -46,7 +46,6 @@ module.exports = optionator({
         {
             option: "ext",
             type: "[String]",
-            default: ".js",
             description: "Specify JavaScript file extensions"
         },
         {

package/lib/rule-tester/rule-tester.js

@@ -45,16 +45,20 @@ const
     path = require("path"),
     util = require("util"),
     lodash = require("lodash"),
+    Traverser = require("../../lib/shared/traverser"),
     { getRuleOptionsSchema, validate } = require("../shared/config-validator"),
     { Linter, SourceCodeFixer, interpolate } = require("../linter");
 
 const ajv = require("../shared/ajv")({ strictDefaults: true });
 
+const espreePath = require.resolve("espree");
 
 //------------------------------------------------------------------------------
 // Typedefs
 //------------------------------------------------------------------------------
 
+/** @typedef {import("../shared/types").Parser} Parser */
+
 /**
  * A test case that is expected to pass lint.
  * @typedef {Object} ValidTestCase
@@ -141,6 +145,7 @@ const friendlyErrorObjectParameterList = `[${[...errorObjectParameters].map(key
 const suggestionObjectParameters = new Set([
     "desc",
     "messageId",
+    "data",
     "output"
 ]);
 const friendlySuggestionObjectParameterList = `[${[...suggestionObjectParameters].map(key => `'${key}'`).join(", ")}]`;
@@ -205,6 +210,70 @@ function sanitize(text) {
     );
 }
 
+/**
+ * Define `start`/`end` properties as throwing error.
+ * @param {string} objName Object name used for error messages.
+ * @param {ASTNode} node The node to define.
+ * @returns {void}
+ */
+function defineStartEndAsError(objName, node) {
+    Object.defineProperties(node, {
+        start: {
+            get() {
+                throw new Error(`Use ${objName}.range[0] instead of ${objName}.start`);
+            },
+            configurable: true,
+            enumerable: false
+        },
+        end: {
+            get() {
+                throw new Error(`Use ${objName}.range[1] instead of ${objName}.end`);
+            },
+            configurable: true,
+            enumerable: false
+        }
+    });
+}
+
+/**
+ * Define `start`/`end` properties of all nodes of the given AST as throwing error.
+ * @param {ASTNode} ast The root node to errorize `start`/`end` properties.
+ * @param {Object} [visitorKeys] Visitor keys to be used for traversing the given ast.
+ * @returns {void}
+ */
+function defineStartEndAsErrorInTree(ast, visitorKeys) {
+    Traverser.traverse(ast, { visitorKeys, enter: defineStartEndAsError.bind(null, "node") });
+    ast.tokens.forEach(defineStartEndAsError.bind(null, "token"));
+    ast.comments.forEach(defineStartEndAsError.bind(null, "token"));
+}
+
+/**
+ * Wraps the given parser in order to intercept and modify return values from the `parse` and `parseForESLint` methods, for test purposes.
+ * In particular, to modify ast nodes, tokens and comments to throw on access to their `start` and `end` properties.
+ * @param {Parser} parser Parser object.
+ * @returns {Parser} Wrapped parser object.
+ */
+function wrapParser(parser) {
+    if (typeof parser.parseForESLint === "function") {
+        return {
+            parseForESLint(...args) {
+                const ret = parser.parseForESLint(...args);
+
+                defineStartEndAsErrorInTree(ret.ast, ret.visitorKeys);
+                return ret;
+            }
+        };
+    }
+    return {
+        parse(...args) {
+            const ast = parser.parse(...args);
+
+            defineStartEndAsErrorInTree(ast);
+            return ast;
+        }
+    };
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -449,9 +518,12 @@ class RuleTester {
 
             if (typeof config.parser === "string") {
                 assert(path.isAbsolute(config.parser), "Parsers provided as strings to RuleTester must be absolute paths");
-                linter.defineParser(config.parser, require(config.parser));
+            } else {
+                config.parser = espreePath;
             }
 
+            linter.defineParser(config.parser, wrapParser(require(config.parser)));
+
             if (schema) {
                 ajv.validateSchema(schema);
 
@@ -482,20 +554,21 @@ class RuleTester {
 
             // Verify the code.
             const messages = linter.verify(code, config, filename);
+            const fatalErrorMessage = messages.find(m => m.fatal);
 
-            // Ignore syntax errors for backward compatibility if `errors` is a number.
-            if (typeof item.errors !== "number") {
-                const errorMessage = messages.find(m => m.fatal);
-
-                assert(!errorMessage, `A fatal parsing error occurred: ${errorMessage && errorMessage.message}`);
-            }
+            assert(!fatalErrorMessage, `A fatal parsing error occurred: ${fatalErrorMessage && fatalErrorMessage.message}`);
 
             // Verify if autofix makes a syntax error or not.
             if (messages.some(m => m.fix)) {
                 output = SourceCodeFixer.applyFixes(code, messages).output;
                 const errorMessageInFix = linter.verify(output, config, filename).find(m => m.fatal);
 
-                assert(!errorMessageInFix, `A fatal parsing error occurred in autofix: ${errorMessageInFix && errorMessageInFix.message}`);
+                assert(!errorMessageInFix, [
+                    "A fatal parsing error occurred in autofix.",
+                    `Error: ${errorMessageInFix && errorMessageInFix.message}`,
+                    "Autofix output:",
+                    output
+                ].join("\n"));
             } else {
                 output = code;
             }
@@ -571,10 +644,12 @@ class RuleTester {
             assert.ok(item.errors || item.errors === 0,
                 `Did not specify errors for an invalid test of ${ruleName}`);
 
+            const ruleHasMetaMessages = hasOwnProperty(rule, "meta") && hasOwnProperty(rule.meta, "messages");
+            const friendlyIDList = ruleHasMetaMessages ? `[${Object.keys(rule.meta.messages).map(key => `'${key}'`).join(", ")}]` : null;
+
             const result = runRuleForItem(item);
             const messages = result.messages;
 
-
             if (typeof item.errors === "number") {
                 assert.strictEqual(messages.length, item.errors, util.format("Should have %d error%s but had %d: %s",
                     item.errors, item.errors === 1 ? "" : "s", messages.length, util.inspect(messages)));
@@ -620,12 +695,10 @@ class RuleTester {
                             assertMessageMatches(message.message, error.message);
                         } else if (hasOwnProperty(error, "messageId")) {
                             assert.ok(
-                                hasOwnProperty(rule, "meta") && hasOwnProperty(rule.meta, "messages"),
+                                ruleHasMetaMessages,
                                 "Error can not use 'messageId' if rule under test doesn't define 'meta.messages'."
                             );
                             if (!hasOwnProperty(rule.meta.messages, error.messageId)) {
-                                const friendlyIDList = `[${Object.keys(rule.meta.messages).map(key => `'${key}'`).join(", ")}]`;
-
                                 assert(false, `Invalid messageId '${error.messageId}'. Expected one of ${friendlyIDList}.`);
                             }
                             assert.strictEqual(
@@ -700,19 +773,50 @@ class RuleTester {
                                     });
 
                                     const actualSuggestion = message.suggestions[index];
+                                    const suggestionPrefix = `Error Suggestion at index ${index} :`;
+
+                                    if (hasOwnProperty(expectedSuggestion, "desc")) {
+                                        assert.ok(
+                                            !hasOwnProperty(expectedSuggestion, "data"),
+                                            `${suggestionPrefix} Test should not specify both 'desc' and 'data'.`
+                                        );
+                                        assert.strictEqual(
+                                            actualSuggestion.desc,
+                                            expectedSuggestion.desc,
+                                            `${suggestionPrefix} desc should be "${expectedSuggestion.desc}" but got "${actualSuggestion.desc}" instead.`
+                                        );
+                                    }
 
-                                    /**
-                                     * Tests equality of a suggestion key if that key is defined in the expected output.
-                                     * @param {string} key Key to validate from the suggestion object
-                                     * @returns {void}
-                                     */
-                                    function assertSuggestionKeyEquals(key) {
-                                        if (hasOwnProperty(expectedSuggestion, key)) {
-                                            assert.deepStrictEqual(actualSuggestion[key], expectedSuggestion[key], `Error suggestion at index: ${index} should have desc of: "${actualSuggestion[key]}"`);
+                                    if (hasOwnProperty(expectedSuggestion, "messageId")) {
+                                        assert.ok(
+                                            ruleHasMetaMessages,
+                                            `${suggestionPrefix} Test can not use 'messageId' if rule under test doesn't define 'meta.messages'.`
+                                        );
+                                        assert.ok(
+                                            hasOwnProperty(rule.meta.messages, expectedSuggestion.messageId),
+                                            `${suggestionPrefix} Test has invalid messageId '${expectedSuggestion.messageId}', the rule under test allows only one of ${friendlyIDList}.`
+                                        );
+                                        assert.strictEqual(
+                                            actualSuggestion.messageId,
+                                            expectedSuggestion.messageId,
+                                            `${suggestionPrefix} messageId should be '${expectedSuggestion.messageId}' but got '${actualSuggestion.messageId}' instead.`
+                                        );
+                                        if (hasOwnProperty(expectedSuggestion, "data")) {
+                                            const unformattedMetaMessage = rule.meta.messages[expectedSuggestion.messageId];
+                                            const rehydratedDesc = interpolate(unformattedMetaMessage, expectedSuggestion.data);
+
+                                            assert.strictEqual(
+                                                actualSuggestion.desc,
+                                                rehydratedDesc,
+                                                `${suggestionPrefix} Hydrated test desc "${rehydratedDesc}" does not match received desc "${actualSuggestion.desc}".`
+                                            );
                                         }
+                                    } else {
+                                        assert.ok(
+                                            !hasOwnProperty(expectedSuggestion, "data"),
+                                            `${suggestionPrefix} Test must specify 'messageId' if 'data' is used.`
+                                        );
                                     }
-                                    assertSuggestionKeyEquals("desc");
-                                    assertSuggestionKeyEquals("messageId");
 
                                     if (hasOwnProperty(expectedSuggestion, "output")) {
                                         const codeWithAppliedSuggestion = SourceCodeFixer.applyFixes(item.code, [actualSuggestion]).output;
@@ -740,6 +844,12 @@ class RuleTester {
                 } else {
                     assert.strictEqual(result.output, item.output, "Output is incorrect.");
                 }
+            } else {
+                assert.strictEqual(
+                    result.output,
+                    item.code,
+                    "The rule fixed the code. Please add 'output' property."
+                );
             }
 
             assertASTDidntChange(result.beforeAST, result.afterAST);

package/lib/rules/accessor-pairs.js

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Rule to flag wrapping non-iife in parens
+ * @fileoverview Rule to enforce getter and setter pairs in objects and classes.
  * @author Gyandeep Singh
  */
 

package/lib/rules/array-callback-return.js

@@ -29,22 +29,6 @@ function isReachable(segment) {
     return segment.reachable;
 }
 
-/**
- * Gets a readable location.
- *
- * - FunctionExpression -> the function name or `function` keyword.
- * - ArrowFunctionExpression -> `=>` token.
- * @param {ASTNode} node A function node to get.
- * @param {SourceCode} sourceCode A source code to get tokens.
- * @returns {ASTNode|Token} The node or the token of a location.
- */
-function getLocation(node, sourceCode) {
-    if (node.type === "ArrowFunctionExpression") {
-        return sourceCode.getTokenBefore(node.body);
-    }
-    return node.id || node;
-}
-
 /**
  * Checks a given node is a MemberExpression node which has the specified name's
  * property.
@@ -179,6 +163,7 @@ module.exports = {
     create(context) {
 
         const options = context.options[0] || { allowImplicit: false, checkForEach: false };
+        const sourceCode = context.getSourceCode();
 
         let funcInfo = {
             arrayMethodName: null,
@@ -217,12 +202,12 @@ module.exports = {
             }
 
             if (messageId) {
-                let name = astUtils.getFunctionNameWithKind(funcInfo.node);
+                let name = astUtils.getFunctionNameWithKind(node);
 
                 name = messageId === "expectedNoReturnValue" ? lodash.upperFirst(name) : name;
                 context.report({
                     node,
-                    loc: getLocation(node, context.getSourceCode()).loc.start,
+                    loc: astUtils.getFunctionHeadLoc(node, sourceCode),
                     messageId,
                     data: { name }
                 });

package/lib/rules/arrow-parens.js

@@ -105,10 +105,27 @@ module.exports = {
                 ], `${shouldAddSpaceForAsync ? " " : ""}${paramToken.value}`);
             }
 
+            /**
+             * Checks whether there are comments inside the params or not.
+             * @returns {boolean} `true` if there are comments inside of parens, else `false`
+             */
+            function hasCommentsInParens() {
+                if (astUtils.isOpeningParenToken(firstTokenOfParam)) {
+                    const closingParenToken = sourceCode.getTokenAfter(node.params[0], astUtils.isClosingParenToken);
+
+                    return closingParenToken && sourceCode.commentsExistBetween(firstTokenOfParam, closingParenToken);
+                }
+                return false;
+
+            }
+
+            if (hasCommentsInParens()) {
+                return;
+            }
+
             // "as-needed", { "requireForBlockBody": true }: x => x
             if (
                 requireForBlockBody &&
-                node.params.length === 1 &&
                 node.params[0].type === "Identifier" &&
                 !node.params[0].typeAnnotation &&
                 node.body.type !== "BlockStatement" &&
@@ -144,7 +161,6 @@ module.exports = {
 
             // "as-needed": x => x
             if (asNeeded &&
-                node.params.length === 1 &&
                 node.params[0].type === "Identifier" &&
                 !node.params[0].typeAnnotation &&
                 !node.returnType
@@ -178,7 +194,7 @@ module.exports = {
         }
 
         return {
-            ArrowFunctionExpression: parens
+            "ArrowFunctionExpression[params.length=1]": parens
         };
     }
 };

package/lib/rules/block-spacing.js

@@ -102,9 +102,18 @@ module.exports = {
 
             // Check.
             if (!isValid(openBrace, firstToken)) {
+                let loc = openBrace.loc;
+
+                if (messageId === "extra") {
+                    loc = {
+                        start: openBrace.loc.end,
+                        end: firstToken.loc.start
+                    };
+                }
+
                 context.report({
                     node,
-                    loc: openBrace.loc.start,
+                    loc,
                     messageId,
                     data: {
                         location: "after",
@@ -120,9 +129,17 @@ module.exports = {
                 });
             }
             if (!isValid(lastToken, closeBrace)) {
+                let loc = closeBrace.loc;
+
+                if (messageId === "extra") {
+                    loc = {
+                        start: lastToken.loc.end,
+                        end: closeBrace.loc.start
+                    };
+                }
                 context.report({
                     node,
-                    loc: closeBrace.loc.start,
+                    loc,
                     messageId,
                     data: {
                         location: "before",

package/lib/rules/callback-return.js

@@ -10,6 +10,10 @@
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: [],
+
         type: "suggestion",
 
         docs: {

package/lib/rules/camelcase.js

@@ -125,6 +125,40 @@ module.exports = {
             return false;
         }
 
+        /**
+         * Checks whether the given node represents assignment target property in destructuring.
+         *
+         * For examples:
+         *    ({a: b.foo} = c);  // => true for `foo`
+         *    ([a.foo] = b);     // => true for `foo`
+         *    ([a.foo = 1] = b); // => true for `foo`
+         *    ({...a.foo} = b);  // => true for `foo`
+         * @param {ASTNode} node An Identifier node to check
+         * @returns {boolean} True if the node is an assignment target property in destructuring.
+         */
+        function isAssignmentTargetPropertyInDestructuring(node) {
+            if (
+                node.parent.type === "MemberExpression" &&
+                node.parent.property === node &&
+                !node.parent.computed
+            ) {
+                const effectiveParent = node.parent.parent;
+
+                return (
+                    effectiveParent.type === "Property" &&
+                    effectiveParent.value === node.parent &&
+                    effectiveParent.parent.type === "ObjectPattern" ||
+                    effectiveParent.type === "ArrayPattern" ||
+                    effectiveParent.type === "RestElement" ||
+                    (
+                        effectiveParent.type === "AssignmentPattern" &&
+                        effectiveParent.left === node.parent
+                    )
+                );
+            }
+            return false;
+        }
+
         /**
          * Reports an AST node as a rule violation.
          * @param {ASTNode} node The node to report.
@@ -170,6 +204,9 @@ module.exports = {
                     // Report AssignmentExpressions only if they are the left side of the assignment
                     } else if (effectiveParent.type === "AssignmentExpression" && nameIsUnderscored && (effectiveParent.right.type !== "MemberExpression" || effectiveParent.left.type === "MemberExpression" && effectiveParent.left.property.name === node.name)) {
                         report(node);
+
+                    } else if (isAssignmentTargetPropertyInDestructuring(node) && nameIsUnderscored) {
+                        report(node);
                     }
 
                 /*
@@ -186,7 +223,7 @@ module.exports = {
 
                         const assignmentKeyEqualsValue = node.parent.key.name === node.parent.value.name;
 
-                        if (isUnderscored(name) && node.parent.computed) {
+                        if (nameIsUnderscored && node.parent.computed) {
                             report(node);
                         }
 

package/lib/rules/comma-style.js

@@ -146,10 +146,7 @@ module.exports = {
                 // lone comma
                 context.report({
                     node: reportItem,
-                    loc: {
-                        line: commaToken.loc.end.line,
-                        column: commaToken.loc.start.column
-                    },
+                    loc: commaToken.loc,
                     messageId: "unexpectedLineBeforeAndAfterComma",
                     fix: getFixerFunction(styleType, previousItemToken, commaToken, currentItemToken)
                 });
@@ -158,6 +155,7 @@ module.exports = {
 
                 context.report({
                     node: reportItem,
+                    loc: commaToken.loc,
                     messageId: "expectedCommaFirst",
                     fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken)
                 });
@@ -166,10 +164,7 @@ module.exports = {
 
                 context.report({
                     node: reportItem,
-                    loc: {
-                        line: commaToken.loc.end.line,
-                        column: commaToken.loc.end.column
-                    },
+                    loc: commaToken.loc,
                     messageId: "expectedCommaLast",
                     fix: getFixerFunction(style, previousItemToken, commaToken, currentItemToken)
                 });

package/lib/rules/func-call-spacing.js

@@ -63,7 +63,8 @@ module.exports = {
         },
 
         messages: {
-            unexpected: "Unexpected newline between function name and paren.",
+            unexpectedWhitespace: "Unexpected whitespace between function name and paren.",
+            unexpectedNewline: "Unexpected newline between function name and paren.",
             missing: "Missing space between function name and paren."
         }
     },
@@ -116,7 +117,7 @@ module.exports = {
                 context.report({
                     node,
                     loc: leftToken.loc.start,
-                    messageId: "unexpected",
+                    messageId: "unexpectedWhitespace",
                     fix(fixer) {
 
                         /*
@@ -143,7 +144,7 @@ module.exports = {
                 context.report({
                     node,
                     loc: leftToken.loc.start,
-                    messageId: "unexpected",
+                    messageId: "unexpectedNewline",
                     fix(fixer) {
                         return fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], " ");
                     }

package/lib/rules/getter-return.js

@@ -25,17 +25,6 @@ function isReachable(segment) {
     return segment.reachable;
 }
 
-/**
- * Gets a readable location.
- *
- * - FunctionExpression -> the function name or `function` keyword.
- * @param {ASTNode} node A function node to get.
- * @returns {ASTNode|Token} The node or the token of a location.
- */
-function getId(node) {
-    return node.id || node;
-}
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -75,6 +64,7 @@ module.exports = {
     create(context) {
 
         const options = context.options[0] || { allowImplicit: false };
+        const sourceCode = context.getSourceCode();
 
         let funcInfo = {
             upper: null,
@@ -99,7 +89,7 @@ module.exports = {
             ) {
                 context.report({
                     node,
-                    loc: getId(node).loc.start,
+                    loc: astUtils.getFunctionHeadLoc(node, sourceCode),
                     messageId: funcInfo.hasReturn ? "expectedAlways" : "expected",
                     data: {
                         name: astUtils.getFunctionNameWithKind(funcInfo.node)

package/lib/rules/global-require.js

@@ -48,6 +48,10 @@ function isShadowed(scope, node) {
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: [],
+
         type: "suggestion",
 
         docs: {