eslint 6.5.1 → 6.6.0

package/lib/linter/linter.js

@@ -292,10 +292,15 @@ function getDirectiveComments(filename, ast, ruleMapper, warnInlineConfig) {
         if (!match) {
             return;
         }
-        const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(match[1]);
+        const directiveText = match[1];
+        const lineCommentSupported = /^eslint-disable-(next-)?line$/u.test(directiveText);
 
-        if (warnInlineConfig && (lineCommentSupported || comment.type === "Block")) {
-            const kind = comment.type === "Block" ? `/*${match[1]}*/` : `//${match[1]}`;
+        if (comment.type === "Line" && !lineCommentSupported) {
+            return;
+        }
+
+        if (warnInlineConfig) {
+            const kind = comment.type === "Block" ? `/*${directiveText}*/` : `//${directiveText}`;
 
             problems.push(createLintingProblem({
                 ruleId: null,
@@ -306,108 +311,101 @@ function getDirectiveComments(filename, ast, ruleMapper, warnInlineConfig) {
             return;
         }
 
-        const directiveValue = trimmedCommentText.slice(match.index + match[1].length);
-        let directiveType = "";
+        if (lineCommentSupported && comment.loc.start.line !== comment.loc.end.line) {
+            const message = `${directiveText} comment should not span multiple lines.`;
 
-        if (lineCommentSupported) {
-            if (comment.loc.start.line === comment.loc.end.line) {
-                directiveType = match[1].slice("eslint-".length);
-            } else {
-                const message = `${match[1]} comment should not span multiple lines.`;
+            problems.push(createLintingProblem({
+                ruleId: null,
+                message,
+                loc: comment.loc
+            }));
+            return;
+        }
 
-                problems.push(createLintingProblem({
-                    ruleId: null,
-                    message,
-                    loc: comment.loc
-                }));
+        const directiveValue = trimmedCommentText.slice(match.index + directiveText.length);
+
+        switch (directiveText) {
+            case "eslint-disable":
+            case "eslint-enable":
+            case "eslint-disable-next-line":
+            case "eslint-disable-line": {
+                const directiveType = directiveText.slice("eslint-".length);
+                const options = { type: directiveType, loc: comment.loc, value: directiveValue, ruleMapper };
+                const { directives, directiveProblems } = createDisableDirectives(options);
+
+                disableDirectives.push(...directives);
+                problems.push(...directiveProblems);
+                break;
             }
-        } else if (comment.type === "Block") {
-            switch (match[1]) {
-                case "exported":
-                    Object.assign(exportedVariables, commentParser.parseStringConfig(directiveValue, comment));
-                    break;
 
-                case "globals":
-                case "global":
-                    for (const [id, { value }] of Object.entries(commentParser.parseStringConfig(directiveValue, comment))) {
-                        let normalizedValue;
+            case "exported":
+                Object.assign(exportedVariables, commentParser.parseStringConfig(directiveValue, comment));
+                break;
+
+            case "globals":
+            case "global":
+                for (const [id, { value }] of Object.entries(commentParser.parseStringConfig(directiveValue, comment))) {
+                    let normalizedValue;
+
+                    try {
+                        normalizedValue = ConfigOps.normalizeConfigGlobal(value);
+                    } catch (err) {
+                        problems.push(createLintingProblem({
+                            ruleId: null,
+                            loc: comment.loc,
+                            message: err.message
+                        }));
+                        continue;
+                    }
+
+                    if (enabledGlobals[id]) {
+                        enabledGlobals[id].comments.push(comment);
+                        enabledGlobals[id].value = normalizedValue;
+                    } else {
+                        enabledGlobals[id] = {
+                            comments: [comment],
+                            value: normalizedValue
+                        };
+                    }
+                }
+                break;
+
+            case "eslint": {
+                const parseResult = commentParser.parseJsonConfig(directiveValue, comment.loc);
+
+                if (parseResult.success) {
+                    Object.keys(parseResult.config).forEach(name => {
+                        const rule = ruleMapper(name);
+                        const ruleValue = parseResult.config[name];
+
+                        if (rule === null) {
+                            problems.push(createLintingProblem({ ruleId: name, loc: comment.loc }));
+                            return;
+                        }
 
                         try {
-                            normalizedValue = ConfigOps.normalizeConfigGlobal(value);
+                            validator.validateRuleOptions(rule, name, ruleValue);
                         } catch (err) {
                             problems.push(createLintingProblem({
-                                ruleId: null,
-                                loc: comment.loc,
-                                message: err.message
+                                ruleId: name,
+                                message: err.message,
+                                loc: comment.loc
                             }));
-                            continue;
-                        }
 
-                        if (enabledGlobals[id]) {
-                            enabledGlobals[id].comments.push(comment);
-                            enabledGlobals[id].value = normalizedValue;
-                        } else {
-                            enabledGlobals[id] = {
-                                comments: [comment],
-                                value: normalizedValue
-                            };
+                            // do not apply the config, if found invalid options.
+                            return;
                         }
-                    }
-                    break;
-
-                case "eslint-disable":
-                    directiveType = "disable";
-                    break;
-
-                case "eslint-enable":
-                    directiveType = "enable";
-                    break;
-
-                case "eslint": {
-                    const parseResult = commentParser.parseJsonConfig(directiveValue, comment.loc);
-
-                    if (parseResult.success) {
-                        Object.keys(parseResult.config).forEach(name => {
-                            const rule = ruleMapper(name);
-                            const ruleValue = parseResult.config[name];
-
-                            if (rule === null) {
-                                problems.push(createLintingProblem({ ruleId: name, loc: comment.loc }));
-                                return;
-                            }
-
-                            try {
-                                validator.validateRuleOptions(rule, name, ruleValue);
-                            } catch (err) {
-                                problems.push(createLintingProblem({
-                                    ruleId: name,
-                                    message: err.message,
-                                    loc: comment.loc
-                                }));
-
-                                // do not apply the config, if found invalid options.
-                                return;
-                            }
-
-                            configuredRules[name] = ruleValue;
-                        });
-                    } else {
-                        problems.push(parseResult.error);
-                    }
 
-                    break;
+                        configuredRules[name] = ruleValue;
+                    });
+                } else {
+                    problems.push(parseResult.error);
                 }
 
-                // no default
+                break;
             }
-        }
-
-        if (directiveType !== "") {
-            const options = { type: directiveType, loc: comment.loc, value: directiveValue, ruleMapper };
-            const { directives, directiveProblems } = createDisableDirectives(options);
 
-            disableDirectives.push(...directives);
-            problems.push(...directiveProblems);
+            // no default
         }
     });
 
@@ -438,7 +436,7 @@ const eslintEnvPattern = /\/\*\s*eslint-env\s(.+?)\*\//gu;
 
 /**
  * Checks whether or not there is a comment which has "eslint-env *" in a given text.
- * @param {string} text - A source code text to check.
+ * @param {string} text A source code text to check.
  * @returns {Object|null} A result of parseListConfig() with "eslint-env *" comment.
  */
 function findEslintEnv(text) {
@@ -555,8 +553,7 @@ function resolveGlobals(providedGlobals, enabledEnvironments) {
 
 /**
  * Strips Unicode BOM from a given text.
- *
- * @param {string} text - A text to strip.
+ * @param {string} text A text to strip.
  * @returns {string} The stripped text.
  */
 function stripUnicodeBOM(text) {
@@ -669,6 +666,8 @@ function parse(text, parser, providedParserOptions, filePath) {
         // If the message includes a leading line number, strip it:
         const message = `Parsing error: ${ex.message.replace(/^line \d+:/iu, "").trim()}`;
 
+        debug("%s\n%s", message, ex.stack);
+
         return {
             success: false,
             error: {
@@ -813,9 +812,10 @@ const BASE_TRAVERSAL_CONTEXT = Object.freeze(
  * @param {Object} settings The settings that were enabled in the config
  * @param {string} filename The reported filename of the code
  * @param {boolean} disableFixes If true, it doesn't make `fix` properties.
+ * @param {string | undefined} cwd cwd of the cli
  * @returns {Problem[]} An array of reported problems
  */
-function runRules(sourceCode, configuredRules, ruleMapper, parserOptions, parserName, settings, filename, disableFixes) {
+function runRules(sourceCode, configuredRules, ruleMapper, parserOptions, parserName, settings, filename, disableFixes, cwd) {
     const emitter = createEmitter();
     const nodeQueue = [];
     let currentNode = sourceCode.ast;
@@ -842,6 +842,7 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserOptions, parser
             {
                 getAncestors: () => getAncestors(currentNode),
                 getDeclaredVariables: sourceCode.scopeManager.getDeclaredVariables.bind(sourceCode.scopeManager),
+                getCwd: () => cwd,
                 getFilename: () => filename,
                 getScope: () => getScope(sourceCode.scopeManager, currentNode),
                 getSourceCode: () => sourceCode,
@@ -988,6 +989,24 @@ function getRule(slots, ruleId) {
     );
 }
 
+/**
+ * Normalize the value of the cwd
+ * @param {string | undefined} cwd raw value of the cwd, path to a directory that should be considered as the current working directory, can be undefined.
+ * @returns {string | undefined} normalized cwd
+ */
+function normalizeCwd(cwd) {
+    if (cwd) {
+        return cwd;
+    }
+    if (typeof process === "object") {
+        return process.cwd();
+    }
+
+    // It's more explicit to assign the undefined
+    // eslint-disable-next-line no-undefined
+    return undefined;
+}
+
 /**
  * The map to store private data.
  * @type {WeakMap<Linter, LinterInternalSlots>}
@@ -1004,8 +1023,14 @@ const internalSlotsMap = new WeakMap();
  */
 class Linter {
 
-    constructor() {
+    /**
+     * Initialize the Linter.
+     * @param {Object} [config] the config object
+     * @param {string} [config.cwd]  path to a directory that should be considered as the current working directory, can be undefined.
+     */
+    constructor({ cwd } = {}) {
         internalSlotsMap.set(this, {
+            cwd: normalizeCwd(cwd),
             lastConfigArray: null,
             lastSourceCode: null,
             parserMap: new Map([["espree", espree]]),
@@ -1137,7 +1162,8 @@ class Linter {
                 parserName,
                 settings,
                 options.filename,
-                options.disableFixes
+                options.disableFixes,
+                slots.cwd
             );
         } catch (err) {
             err.message += `\nOccurred while linting ${options.filename}`;

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

@@ -202,6 +202,7 @@ const parseSelector = lodash.memoize(rawSelector => {
  */
 class NodeEventGenerator {
 
+    // eslint-disable-next-line jsdoc/require-description
     /**
      * @param {SafeEmitter} emitter
      * An SafeEmitter which is the destination of events. This emitter must already
@@ -286,7 +287,7 @@ class NodeEventGenerator {
 
     /**
      * Emits an event of entering AST node.
-     * @param {ASTNode} node - A node which was entered.
+     * @param {ASTNode} node A node which was entered.
      * @returns {void}
      */
     enterNode(node) {
@@ -298,7 +299,7 @@ class NodeEventGenerator {
 
     /**
      * Emits an event of leaving AST node.
-     * @param {ASTNode} node - A node which was left.
+     * @param {ASTNode} node A node which was left.
      * @returns {void}
      */
     leaveNode(node) {

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

@@ -78,8 +78,7 @@ const hasOwnProperty = Function.call.bind(Object.hasOwnProperty);
 /**
  * Clones a given value deeply.
  * Note: This ignores `parent` property.
- *
- * @param {any} x - A value to clone.
+ * @param {any} x A value to clone.
  * @returns {any} A cloned value.
  */
 function cloneDeeplyExcludesParent(x) {
@@ -104,8 +103,7 @@ function cloneDeeplyExcludesParent(x) {
 
 /**
  * Freezes a given value deeply.
- *
- * @param {any} x - A value to freeze.
+ * @param {any} x A value to freeze.
  * @returns {void}
  */
 function freezeDeeply(x) {
@@ -146,8 +144,8 @@ const IT = Symbol("it");
 /**
  * This is `it` default handler if `it` don't exist.
  * @this {Mocha}
- * @param {string} text - The description of the test case.
- * @param {Function} method - The logic of the test case.
+ * @param {string} text The description of the test case.
+ * @param {Function} method The logic of the test case.
  * @returns {any} Returned value of `method`.
  */
 function itDefaultHandler(text, method) {
@@ -164,8 +162,8 @@ function itDefaultHandler(text, method) {
 /**
  * This is `describe` default handler if `describe` don't exist.
  * @this {Mocha}
- * @param {string} text - The description of the test case.
- * @param {Function} method - The logic of the test case.
+ * @param {string} text The description of the test case.
+ * @param {Function} method The logic of the test case.
  * @returns {any} Returned value of `method`.
  */
 function describeDefaultHandler(text, method) {

package/lib/rules/accessor-pairs.js

@@ -79,7 +79,7 @@ function areEqualKeys(left, right) {
 
 /**
  * Checks whether or not a given node is of an accessor kind ('get' or 'set').
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node is of an accessor kind.
  */
 function isAccessorKind(node) {
@@ -88,8 +88,8 @@ function isAccessorKind(node) {
 
 /**
  * Checks whether or not a given node is an `Identifier` node which was named a given name.
- * @param {ASTNode} node - A node to check.
- * @param {string} name - An expected name of the node.
+ * @param {ASTNode} node A node to check.
+ * @param {string} name An expected name of the node.
  * @returns {boolean} `true` if the node is an `Identifier` node which was named as expected.
  */
 function isIdentifier(node, name) {
@@ -98,10 +98,10 @@ function isIdentifier(node, name) {
 
 /**
  * Checks whether or not a given node is an argument of a specified method call.
- * @param {ASTNode} node - A node to check.
- * @param {number} index - An expected index of the node in arguments.
- * @param {string} object - An expected name of the object of the method.
- * @param {string} property - An expected name of the method.
+ * @param {ASTNode} node A node to check.
+ * @param {number} index An expected index of the node in arguments.
+ * @param {string} object An expected name of the object of the method.
+ * @param {string} property An expected name of the method.
  * @returns {boolean} `true` if the node is an argument of the specified method call.
  */
 function isArgumentOfMethodCall(node, index, object, property) {
@@ -119,7 +119,7 @@ function isArgumentOfMethodCall(node, index, object, property) {
 
 /**
  * Checks whether or not a given node is a property descriptor.
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node is a property descriptor.
  */
 function isPropertyDescriptor(node) {

package/lib/rules/array-bracket-newline.js

@@ -65,8 +65,7 @@ module.exports = {
 
         /**
          * Normalizes a given option value.
-         *
-         * @param {string|Object|undefined} option - An option value to parse.
+         * @param {string|Object|undefined} option An option value to parse.
          * @returns {{multiline: boolean, minItems: number}} Normalized option object.
          */
         function normalizeOptionValue(option) {
@@ -97,8 +96,7 @@ module.exports = {
 
         /**
          * Normalizes a given option value.
-         *
-         * @param {string|Object|undefined} options - An option value to parse.
+         * @param {string|Object|undefined} options An option value to parse.
          * @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object.
          */
         function normalizeOptions(options) {
@@ -109,8 +107,8 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a linebreak after the first token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportNoBeginningLinebreak(node, token) {
@@ -132,8 +130,8 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a linebreak before the last token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportNoEndingLinebreak(node, token) {
@@ -155,8 +153,8 @@ module.exports = {
 
         /**
          * Reports that there should be a linebreak after the first token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredBeginningLinebreak(node, token) {
@@ -172,8 +170,8 @@ module.exports = {
 
         /**
          * Reports that there should be a linebreak before the last token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredEndingLinebreak(node, token) {
@@ -189,8 +187,7 @@ module.exports = {
 
         /**
          * Reports a given node if it violated this rule.
-         *
-         * @param {ASTNode} node - A node to check. This is an ArrayExpression node or an ArrayPattern node.
+         * @param {ASTNode} node A node to check. This is an ArrayExpression node or an ArrayPattern node.
          * @returns {void}
          */
         function check(node) {
@@ -219,7 +216,7 @@ module.exports = {
                 ) ||
                 (
                     options.consistent &&
-                    firstIncComment.loc.start.line !== openBracket.loc.end.line
+                    openBracket.loc.end.line !== first.loc.start.line
                 )
             );
 

package/lib/rules/array-bracket-spacing.js

@@ -59,7 +59,7 @@ module.exports = {
          * Determines whether an option is set, relative to the spacing option.
          * If spaced is "always", then check whether option is set to false.
          * If spaced is "never", then check whether option is set to true.
-         * @param {Object} option - The option to exclude.
+         * @param {Object} option The option to exclude.
          * @returns {boolean} Whether or not the property is excluded.
          */
         function isOptionSet(option) {
@@ -79,8 +79,8 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a space after the first token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportNoBeginningSpace(node, token) {
@@ -101,8 +101,8 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a space before the last token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportNoEndingSpace(node, token) {
@@ -123,8 +123,8 @@ module.exports = {
 
         /**
          * Reports that there should be a space after the first token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredBeginningSpace(node, token) {
@@ -143,8 +143,8 @@ module.exports = {
 
         /**
          * Reports that there should be a space before the last token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredEndingSpace(node, token) {
@@ -163,7 +163,7 @@ module.exports = {
 
         /**
          * Determines if a node is an object type
-         * @param {ASTNode} node - The node to check.
+         * @param {ASTNode} node The node to check.
          * @returns {boolean} Whether or not the node is an object type.
          */
         function isObjectType(node) {
@@ -172,7 +172,7 @@ module.exports = {
 
         /**
          * Determines if a node is an array type
-         * @param {ASTNode} node - The node to check.
+         * @param {ASTNode} node The node to check.
          * @returns {boolean} Whether or not the node is an array type.
          */
         function isArrayType(node) {
@@ -181,7 +181,7 @@ module.exports = {
 
         /**
          * Validates the spacing around array brackets
-         * @param {ASTNode} node - The node we're checking for spacing
+         * @param {ASTNode} node The node we're checking for spacing
          * @returns {void}
          */
         function validateArraySpacing(node) {

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

@@ -22,8 +22,7 @@ const TARGET_METHODS = /^(?:every|filter|find(?:Index)?|map|reduce(?:Right)?|som
 
 /**
  * Checks a given code path segment is reachable.
- *
- * @param {CodePathSegment} segment - A segment to check.
+ * @param {CodePathSegment} segment A segment to check.
  * @returns {boolean} `true` if the segment is reachable.
  */
 function isReachable(segment) {
@@ -35,9 +34,8 @@ function isReachable(segment) {
  *
  * - 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.
+ * @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) {
@@ -50,8 +48,7 @@ function getLocation(node, sourceCode) {
 /**
  * Checks a given node is a MemberExpression node which has the specified name's
  * property.
- *
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node is a MemberExpression node which has
  *      the specified name's property
  */
@@ -65,8 +62,7 @@ function isTargetMethod(node) {
 /**
  * Checks whether or not a given node is a function expression which is the
  * callback of an array method.
- *
- * @param {ASTNode} node - A node to check. This is one of
+ * @param {ASTNode} node A node to check. This is one of
  *      FunctionExpression or ArrowFunctionExpression.
  * @returns {boolean} `true` if the node is the callback of an array method.
  */
@@ -188,8 +184,7 @@ module.exports = {
          *
          * If the last code path segment is reachable, there are paths which are not
          * returned or thrown.
-         *
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {void}
          */
         function checkLastSegment(node) {

package/lib/rules/array-element-newline.js

@@ -62,8 +62,7 @@ module.exports = {
 
         /**
          * Normalizes a given option value.
-         *
-         * @param {string|Object|undefined} providedOption - An option value to parse.
+         * @param {string|Object|undefined} providedOption An option value to parse.
          * @returns {{multiline: boolean, minItems: number}} Normalized option object.
          */
         function normalizeOptionValue(providedOption) {
@@ -90,8 +89,7 @@ module.exports = {
 
         /**
          * Normalizes a given option value.
-         *
-         * @param {string|Object|undefined} options - An option value to parse.
+         * @param {string|Object|undefined} options An option value to parse.
          * @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object.
          */
         function normalizeOptions(options) {
@@ -102,7 +100,7 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a line break after the first token
-         * @param {Token} token - The token to use for the report.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportNoLineBreak(token) {
@@ -151,7 +149,7 @@ module.exports = {
 
         /**
          * Reports that there should be a line break after the first token
-         * @param {Token} token - The token to use for the report.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredLineBreak(token) {
@@ -171,8 +169,7 @@ module.exports = {
 
         /**
          * Reports a given node if it violated this rule.
-         *
-         * @param {ASTNode} node - A node to check. This is an ObjectExpression node or an ObjectPattern node.
+         * @param {ASTNode} node A node to check. This is an ObjectExpression node or an ObjectPattern node.
          * @returns {void}
          */
         function check(node) {