eslint 4.18.0 → 4.19.1

package/CHANGELOG.md

@@ -1,3 +1,43 @@
+v4.19.1 - March 21, 2018
+
+* 3ff5d11 Fix: no-invalid-regexp not understand variable for flags (fixes #10112) (#10113) (薛定谔的猫)
+* abc765c Fix: object-curly-newline minProperties w/default export (fixes #10101) (#10103) (Kevin Partington)
+* 6f9e155 Docs: Update ambiguous for...in example for guard-for-in (#10114) (CJ R)
+* 0360cc2 Chore: Adding debug logs on successful plugin loads (#10100) (Kevin Partington)
+* a717c5d Chore: Adding log at beginning of unit tests in Makefile.js (#10102) (Kevin Partington)
+
+v4.19.0 - March 16, 2018
+
+* 55a1593 Update: consecutive option for one-var (fixes #4680) (#9994) (薛定谔的猫)
+* 8d3814e Fix: false positive about ES2018 RegExp enhancements (fixes #9893) (#10062) (Toru Nagashima)
+* 935f4e4 Docs: Clarify default ignoring of node_modules (#10092) (Matijs Brinkhuis)
+* 72ed3db Docs: Wrap `Buffer()` in backticks in `no-buffer-constructor` rule description (#10084) (Stephen Edgar)
+* 3aded2f Docs: Fix lodash typos, make spacing consistent (#10073) (Josh Smith)
+* e33bb64 Chore: enable no-param-reassign on ESLint codebase (#10065) (Teddy Katz)
+* 66a1e9a Docs: fix possible typo (#10060) (Vse Mozhet Byt)
+* 2e68be6 Update: give a node at least the indentation of its parent (fixes #9995) (#10054) (Teddy Katz)
+* 72ca5b3 Update: Correctly indent JSXText with trailing linebreaks (fixes #9878) (#10055) (Teddy Katz)
+* 2a4c838 Docs: Update ECMAScript versions in FAQ (#10047) (alberto)
+
+v4.18.2 - March 2, 2018
+
+* 6b71fd0 Fix: table@4.0.2, because 4.0.3 needs "ajv": "^6.0.1" (#10022) (Mathieu Seiler)
+* 3c697de Chore: fix incorrect comment about linter.verify return value (#10030) (Teddy Katz)
+* 9df8653 Chore: refactor parser-loading out of linter.verify (#10028) (Teddy Katz)
+* f6901d0 Fix: remove catastrophic backtracking vulnerability (fixes #10002) (#10019) (Jamie Davis)
+* e4f52ce Chore: Simplify dataflow in linter.verify (#10020) (Teddy Katz)
+* 33177cd Chore: make library files non-executable (#10021) (Teddy Katz)
+* 558ccba Chore: refactor directive comment processing (#10007) (Teddy Katz)
+* 18e15d9 Chore: avoid useless catch clauses that just rethrow errors (#10010) (Teddy Katz)
+* a1c3759 Chore: refactor populating configs with defaults in linter (#10006) (Teddy Katz)
+* aea07dc Fix: Make max-len ignoreStrings ignore JSXText (fixes #9954) (#9985) (Rachael Sim)
+
+v4.18.1 - February 20, 2018
+
+* f417506 Fix: ensure no-await-in-loop reports the correct node (fixes #9992) (#9993) (Teddy Katz)
+* 3e99363 Docs: Fixed typo in key-spacing rule doc (#9987) (Jaid)
+* 7c2cd70 Docs: deprecate experimentalObjectRestSpread (#9986) (Toru Nagashima)
+
 v4.18.0 - February 16, 2018
 
 * 70f22f3 Chore: Apply memoization to config creation within glob utils (#9944) (Kenton Jacobsen)

package/README.md

@@ -227,9 +227,9 @@ In all cases, make sure your plugins' peerDependencies have been installed as we
 
 Yes, ESLint natively supports parsing JSX syntax (this must be enabled in [configuration](https://eslint.org/docs/user-guide/configuring)). Please note that supporting JSX syntax *is not* the same as supporting React. React applies specific semantics to JSX syntax that ESLint doesn't recognize. We recommend using [eslint-plugin-react](https://www.npmjs.com/package/eslint-plugin-react) if you are using React and want React semantics.
 
-### What about ECMAScript 6 support?
+### What ECMAScript versions does ESLint support?
 
-ESLint has full support for ECMAScript 6. By default, this support is off. You can enable ECMAScript 6 syntax and global variables through [configuration](https://eslint.org/docs/user-guide/configuring).
+ESLint has full support for ECMAScript 3, 5 (default), 2015, 2016, 2017, and 2018. You can set your desired ECMAScript syntax (and other settings, like global variables or your target environments) through [configuration](https://eslint.org/docs/user-guide/configuring).
 
 ### What about experimental features?
 

package/conf/environments.js

@@ -15,7 +15,9 @@ const globals = require("globals");
 //------------------------------------------------------------------------------
 
 module.exports = {
-    builtin: globals.es5,
+    builtin: {
+        globals: globals.es5
+    },
     browser: {
 
         /*

package/lib/ast-utils.js

@@ -84,11 +84,10 @@ function isES5Constructor(node) {
  * @returns {Node|null} A found function node.
  */
 function getUpperFunction(node) {
-    while (node) {
-        if (anyFunctionPattern.test(node.type)) {
-            return node;
+    for (let currentNode = node; currentNode; currentNode = currentNode.parent) {
+        if (anyFunctionPattern.test(currentNode.type)) {
+            return currentNode;
         }
-        node = node.parent;
     }
     return null;
 }
@@ -132,12 +131,10 @@ function isLoop(node) {
  * @returns {boolean} `true` if the node is in a loop.
  */
 function isInLoop(node) {
-    while (node && !isFunction(node)) {
-        if (isLoop(node)) {
+    for (let currentNode = node; currentNode && !isFunction(currentNode); currentNode = currentNode.parent) {
+        if (isLoop(currentNode)) {
             return true;
         }
-
-        node = node.parent;
     }
 
     return false;
@@ -204,16 +201,14 @@ function isArrayFromMethod(node) {
  * @returns {boolean} Whether or not the node is a method which has `thisArg`.
  */
 function isMethodWhichHasThisArg(node) {
-    while (node) {
-        if (node.type === "Identifier") {
-            return arrayMethodPattern.test(node.name);
-        }
-        if (node.type === "MemberExpression" && !node.computed) {
-            node = node.property;
-            continue;
+    for (
+        let currentNode = node;
+        currentNode.type === "MemberExpression" && !currentNode.computed;
+        currentNode = currentNode.property
+    ) {
+        if (currentNode.property.type === "Identifier") {
+            return arrayMethodPattern.test(currentNode.property.name);
         }
-
-        break;
     }
 
     return false;
@@ -631,9 +626,10 @@ module.exports = {
             return false;
         }
         const isAnonymous = node.id === null;
+        let currentNode = node;
 
-        while (node) {
-            const parent = node.parent;
+        while (currentNode) {
+            const parent = currentNode.parent;
 
             switch (parent.type) {
 
@@ -643,7 +639,7 @@ module.exports = {
                  */
                 case "LogicalExpression":
                 case "ConditionalExpression":
-                    node = parent;
+                    currentNode = parent;
                     break;
 
                 /*
@@ -663,14 +659,14 @@ module.exports = {
                     if (func === null || !isCallee(func)) {
                         return true;
                     }
-                    node = func.parent;
+                    currentNode = func.parent;
                     break;
                 }
                 case "ArrowFunctionExpression":
-                    if (node !== parent.body || !isCallee(parent)) {
+                    if (currentNode !== parent.body || !isCallee(parent)) {
                         return true;
                     }
-                    node = parent.parent;
+                    currentNode = parent.parent;
                     break;
 
                 /*
@@ -685,7 +681,7 @@ module.exports = {
                  */
                 case "Property":
                 case "MethodDefinition":
-                    return parent.value !== node;
+                    return parent.value !== currentNode;
 
                 /*
                  * e.g.
@@ -715,7 +711,7 @@ module.exports = {
                 case "VariableDeclarator":
                     return !(
                         isAnonymous &&
-                        parent.init === node &&
+                        parent.init === currentNode &&
                         parent.id.type === "Identifier" &&
                         startsWithUpperCase(parent.id.name)
                     );
@@ -728,7 +724,7 @@ module.exports = {
                  */
                 case "MemberExpression":
                     return (
-                        parent.object !== node ||
+                        parent.object !== currentNode ||
                         parent.property.type !== "Identifier" ||
                         !bindOrCallOrApplyPattern.test(parent.property.name) ||
                         !isCallee(parent) ||
@@ -746,21 +742,21 @@ module.exports = {
                     if (isReflectApply(parent.callee)) {
                         return (
                             parent.arguments.length !== 3 ||
-                            parent.arguments[0] !== node ||
+                            parent.arguments[0] !== currentNode ||
                             isNullOrUndefined(parent.arguments[1])
                         );
                     }
                     if (isArrayFromMethod(parent.callee)) {
                         return (
                             parent.arguments.length !== 3 ||
-                            parent.arguments[1] !== node ||
+                            parent.arguments[1] !== currentNode ||
                             isNullOrUndefined(parent.arguments[2])
                         );
                     }
                     if (isMethodWhichHasThisArg(parent.callee)) {
                         return (
                             parent.arguments.length !== 2 ||
-                            parent.arguments[0] !== node ||
+                            parent.arguments[0] !== currentNode ||
                             isNullOrUndefined(parent.arguments[1])
                         );
                     }

package/lib/cli-engine.js

@@ -157,8 +157,9 @@ function processText(text, configHelper, filename, fix, allowInlineConfig, repor
         fileExtension = path.extname(filename);
     }
 
-    filename = filename || "<text>";
-    debug(`Linting ${filename}`);
+    const effectiveFilename = filename || "<text>";
+
+    debug(`Linting ${effectiveFilename}`);
     const config = configHelper.getConfig(filePath);
 
     if (config.plugins) {
@@ -177,18 +178,18 @@ function processText(text, configHelper, filename, fix, allowInlineConfig, repor
     const autofixingEnabled = typeof fix !== "undefined" && (!processor || processor.supportsAutofix);
 
     const fixedResult = linter.verifyAndFix(text, config, {
-        filename,
+        filename: effectiveFilename,
         allowInlineConfig,
         reportUnusedDisableDirectives,
         fix: !!autofixingEnabled && fix,
-        preprocess: processor && (rawText => processor.preprocess(rawText, filename)),
-        postprocess: processor && (problemLists => processor.postprocess(problemLists, filename))
+        preprocess: processor && (rawText => processor.preprocess(rawText, effectiveFilename)),
+        postprocess: processor && (problemLists => processor.postprocess(problemLists, effectiveFilename))
     });
 
     const stats = calculateStatsPerFile(fixedResult.messages);
 
     const result = {
-        filePath: filename,
+        filePath: effectiveFilename,
         messages: fixedResult.messages,
         errorCount: stats.errorCount,
         warningCount: stats.warningCount,
@@ -302,10 +303,10 @@ function getCacheFile(cacheFile, cwd) {
      * make sure the path separators are normalized for the environment/os
      * keeping the trailing path separator if present
      */
-    cacheFile = path.normalize(cacheFile);
+    const normalizedCacheFile = path.normalize(cacheFile);
 
-    const resolvedCacheFile = path.resolve(cwd, cacheFile);
-    const looksLikeADirectory = cacheFile[cacheFile.length - 1] === path.sep;
+    const resolvedCacheFile = path.resolve(cwd, normalizedCacheFile);
+    const looksLikeADirectory = normalizedCacheFile.slice(-1) === path.sep;
 
     /**
      * return the name for the cache file in case the provided parameter is a directory
@@ -368,16 +369,16 @@ class CLIEngine {
 
     /**
      * Creates a new instance of the core CLI engine.
-     * @param {CLIEngineOptions} options The options for this instance.
+     * @param {CLIEngineOptions} providedOptions The options for this instance.
      * @constructor
      */
-    constructor(options) {
+    constructor(providedOptions) {
 
-        options = Object.assign(
+        const options = Object.assign(
             Object.create(null),
             defaultOptions,
             { cwd: process.cwd() },
-            options
+            providedOptions
         );
 
         /**
@@ -605,20 +606,21 @@ class CLIEngine {
             ignoredPaths = new IgnoredPaths(options);
 
         // resolve filename based on options.cwd (for reporting, ignoredPaths also resolves)
-        if (filename && !path.isAbsolute(filename)) {
-            filename = path.resolve(options.cwd, filename);
-        }
 
-        if (filename && ignoredPaths.contains(filename)) {
+        const resolvedFilename = filename && !path.isAbsolute(filename)
+            ? path.resolve(options.cwd, filename)
+            : filename;
+
+        if (resolvedFilename && ignoredPaths.contains(resolvedFilename)) {
             if (warnIgnored) {
-                results.push(createIgnoreResult(filename, options.cwd));
+                results.push(createIgnoreResult(resolvedFilename, options.cwd));
             }
         } else {
             results.push(
                 processText(
                     text,
                     configHelper,
-                    filename,
+                    resolvedFilename,
                     options.fix,
                     options.allowInlineConfig,
                     options.reportUnusedDisableDirectives,
@@ -672,31 +674,30 @@ class CLIEngine {
      */
     getFormatter(format) {
 
-
         // default is stylish
-        format = format || "stylish";
+        const resolvedFormatName = format || "stylish";
 
         // only strings are valid formatters
-        if (typeof format === "string") {
+        if (typeof resolvedFormatName === "string") {
 
             // replace \ with / for Windows compatibility
-            format = format.replace(/\\/g, "/");
+            const normalizedFormatName = resolvedFormatName.replace(/\\/g, "/");
 
             const cwd = this.options ? this.options.cwd : process.cwd();
-            const namespace = naming.getNamespaceFromTerm(format);
+            const namespace = naming.getNamespaceFromTerm(normalizedFormatName);
 
             let formatterPath;
 
             // if there's a slash, then it's a file
-            if (!namespace && format.indexOf("/") > -1) {
-                formatterPath = path.resolve(cwd, format);
+            if (!namespace && normalizedFormatName.indexOf("/") > -1) {
+                formatterPath = path.resolve(cwd, normalizedFormatName);
             } else {
                 try {
-                    const npmFormat = naming.normalizePackageName(format, "eslint-formatter");
+                    const npmFormat = naming.normalizePackageName(normalizedFormatName, "eslint-formatter");
 
                     formatterPath = resolver.resolve(npmFormat, `${cwd}/node_modules`);
                 } catch (e) {
-                    formatterPath = `./formatters/${format}`;
+                    formatterPath = `./formatters/${normalizedFormatName}`;
                 }
             }
 

package/lib/code-path-analysis/code-path-state.js

@@ -164,13 +164,13 @@ function removeConnection(prevSegments, nextSegments) {
  * Creates looping path.
  *
  * @param {CodePathState} state - The instance.
- * @param {CodePathSegment[]} fromSegments - Segments which are source.
- * @param {CodePathSegment[]} toSegments - Segments which are destination.
+ * @param {CodePathSegment[]} unflattenedFromSegments - Segments which are source.
+ * @param {CodePathSegment[]} unflattenedToSegments - Segments which are destination.
  * @returns {void}
  */
-function makeLooped(state, fromSegments, toSegments) {
-    fromSegments = CodePathSegment.flattenUnusedSegments(fromSegments);
-    toSegments = CodePathSegment.flattenUnusedSegments(toSegments);
+function makeLooped(state, unflattenedFromSegments, unflattenedToSegments) {
+    const fromSegments = CodePathSegment.flattenUnusedSegments(unflattenedFromSegments);
+    const toSegments = CodePathSegment.flattenUnusedSegments(unflattenedToSegments);
 
     const end = Math.min(fromSegments.length, toSegments.length);
 

package/lib/code-path-analysis/code-path.js

@@ -134,14 +134,19 @@ class CodePath {
      * @returns {void}
      */
     traverseSegments(options, callback) {
+        let resolvedOptions;
+        let resolvedCallback;
+
         if (typeof options === "function") {
-            callback = options;
-            options = null;
+            resolvedCallback = options;
+            resolvedOptions = {};
+        } else {
+            resolvedOptions = options || {};
+            resolvedCallback = callback;
         }
 
-        options = options || {};
-        const startSegment = options.first || this.internal.initialSegment;
-        const lastSegment = options.last;
+        const startSegment = resolvedOptions.first || this.internal.initialSegment;
+        const lastSegment = resolvedOptions.last;
 
         let item = null;
         let index = 0;
@@ -206,7 +211,7 @@ class CodePath {
 
                 // Call the callback when the first time.
                 if (!skippedSegment) {
-                    callback.call(this, segment, controller);
+                    resolvedCallback.call(this, segment, controller);
                     if (segment === lastSegment) {
                         controller.skip();
                     }

package/lib/code-path-analysis/fork-context.js

@@ -46,19 +46,15 @@ function isReachable(segment) {
 function makeSegments(context, begin, end, create) {
     const list = context.segmentsList;
 
-    if (begin < 0) {
-        begin = list.length + begin;
-    }
-    if (end < 0) {
-        end = list.length + end;
-    }
+    const normalizedBegin = begin >= 0 ? begin : list.length + begin;
+    const normalizedEnd = end >= 0 ? end : list.length + end;
 
     const segments = [];
 
     for (let i = 0; i < context.count; ++i) {
         const allPrevSegments = [];
 
-        for (let j = begin; j <= end; ++j) {
+        for (let j = normalizedBegin; j <= normalizedEnd; ++j) {
             allPrevSegments.push(list[j][i]);
         }
 
@@ -79,18 +75,20 @@ function makeSegments(context, begin, end, create) {
  * @returns {CodePathSegment[]} The merged segments.
  */
 function mergeExtraSegments(context, segments) {
-    while (segments.length > context.count) {
+    let currentSegments = segments;
+
+    while (currentSegments.length > context.count) {
         const merged = [];
 
-        for (let i = 0, length = segments.length / 2 | 0; i < length; ++i) {
+        for (let i = 0, length = currentSegments.length / 2 | 0; i < length; ++i) {
             merged.push(CodePathSegment.newNext(
                 context.idGenerator.next(),
-                [segments[i], segments[i + length]]
+                [currentSegments[i], currentSegments[i + length]]
             ));
         }
-        segments = merged;
+        currentSegments = merged;
     }
-    return segments;
+    return currentSegments;
 }
 
 //------------------------------------------------------------------------------

package/lib/config/config-file.js

@@ -400,25 +400,29 @@ function applyExtends(config, configContext, filePath, relativeTo) {
     }
 
     // Make the last element in an array take the highest precedence
-    config = configExtends.reduceRight((previousValue, parentPath) => {
+    return configExtends.reduceRight((previousValue, parentPath) => {
         try {
+            let extensionPath;
+
             if (parentPath.startsWith("eslint:")) {
-                parentPath = getEslintCoreConfigPath(parentPath);
+                extensionPath = getEslintCoreConfigPath(parentPath);
             } else if (isFilePath(parentPath)) {
 
                 /*
                  * If the `extends` path is relative, use the directory of the current configuration
                  * file as the reference point. Otherwise, use as-is.
                  */
-                parentPath = (path.isAbsolute(parentPath)
+                extensionPath = (path.isAbsolute(parentPath)
                     ? parentPath
                     : path.join(relativeTo || path.dirname(filePath), parentPath)
                 );
+            } else {
+                extensionPath = parentPath;
             }
-            debug(`Loading ${parentPath}`);
+            debug(`Loading ${extensionPath}`);
 
             // eslint-disable-next-line no-use-before-define
-            return ConfigOps.merge(load(parentPath, configContext, relativeTo), previousValue);
+            return ConfigOps.merge(load(extensionPath, configContext, relativeTo), previousValue);
         } catch (e) {
 
             /*
@@ -432,8 +436,6 @@ function applyExtends(config, configContext, filePath, relativeTo) {
         }
 
     }, config);
-
-    return config;
 }
 
 /**
@@ -463,13 +465,20 @@ function resolve(filePath, relativeTo) {
 
         normalizedPackageName = naming.normalizePackageName(pluginName, "eslint-plugin");
         debug(`Attempting to resolve ${normalizedPackageName}`);
-        filePath = resolver.resolve(normalizedPackageName, getLookupPath(relativeTo));
-        return { filePath, configName, configFullName };
+
+        return {
+            filePath: resolver.resolve(normalizedPackageName, getLookupPath(relativeTo)),
+            configName,
+            configFullName
+        };
     }
     normalizedPackageName = naming.normalizePackageName(filePath, "eslint-config");
     debug(`Attempting to resolve ${normalizedPackageName}`);
-    filePath = resolver.resolve(normalizedPackageName, getLookupPath(relativeTo));
-    return { filePath, configFullName: filePath };
+
+    return {
+        filePath: resolver.resolve(normalizedPackageName, getLookupPath(relativeTo)),
+        configFullName: filePath
+    };
 
 
 }

package/lib/config/config-ops.js

@@ -136,29 +136,27 @@ module.exports = {
         const array = Array.isArray(src) || Array.isArray(target);
         let dst = array && [] || {};
 
-        combine = !!combine;
-        isRule = !!isRule;
         if (array) {
-            target = target || [];
+            const resolvedTarget = target || [];
 
             // src could be a string, so check for array
             if (isRule && Array.isArray(src) && src.length > 1) {
                 dst = dst.concat(src);
             } else {
-                dst = dst.concat(target);
+                dst = dst.concat(resolvedTarget);
             }
-            if (typeof src !== "object" && !Array.isArray(src)) {
-                src = [src];
-            }
-            Object.keys(src).forEach((e, i) => {
-                e = src[i];
+            const resolvedSrc = typeof src === "object" ? src : [src];
+
+            Object.keys(resolvedSrc).forEach((_, i) => {
+                const e = resolvedSrc[i];
+
                 if (typeof dst[i] === "undefined") {
                     dst[i] = e;
                 } else if (typeof e === "object") {
                     if (isRule) {
                         dst[i] = e;
                     } else {
-                        dst[i] = deepmerge(target[i], e, combine, isRule);
+                        dst[i] = deepmerge(resolvedTarget[i], e, combine, isRule);
                     }
                 } else {
                     if (!combine) {

package/lib/config/config-rule.js

@@ -197,11 +197,10 @@ class RuleConfigSet {
      * Add a severity level to the front of all configs in the instance.
      * This should only be called after all configs have been added to the instance.
      *
-     * @param {number} [severity=2] The level of severity for the rule (0, 1, 2)
      * @returns {void}
      */
-    addErrorSeverity(severity) {
-        severity = severity || 2;
+    addErrorSeverity() {
+        const severity = 2;
 
         this.ruleConfigs = this.ruleConfigs.map(config => {
             config.unshift(severity);

package/lib/config/plugins.js

@@ -120,6 +120,26 @@ class Plugins {
                 throw pluginLoadErr;
             }
 
+            // This step is costly, so skip if debug is disabled
+            if (debug.enabled) {
+                const resolvedPath = require.resolve(longName);
+
+                let version = null;
+
+                try {
+                    version = require(`${longName}/package.json`).version;
+                } catch (e) {
+
+                    // Do nothing
+                }
+
+                const loadedPluginAndVersion = version
+                    ? `${longName}@${version}`
+                    : `${longName}, version unknown`;
+
+                debug(`Loaded plugin ${pluginName} (${loadedPluginAndVersion}) (from ${resolvedPath})`);
+            }
+
             this.define(pluginName, plugin);
         }
     }

package/lib/config.js

@@ -51,11 +51,11 @@ function hasRules(options) {
 class Config {
 
     /**
-     * @param {Object} options Options to be passed in
+     * @param {Object} providedOptions Options to be passed in
      * @param {Linter} linterContext Linter instance object
      */
-    constructor(options, linterContext) {
-        options = options || {};
+    constructor(providedOptions, linterContext) {
+        const options = providedOptions || {};
 
         this.linterContext = linterContext;
         this.plugins = new Plugins(linterContext.environments, linterContext.rules);
@@ -132,11 +132,10 @@ class Config {
                 isResolvable(`eslint-config-${config}`) ||
                 config.charAt(0) === "@";
 
-            if (!isNamedConfig) {
-                config = path.resolve(this.options.cwd, config);
-            }
-
-            this.specificConfig = ConfigFile.load(config, this);
+            this.specificConfig = ConfigFile.load(
+                isNamedConfig ? config : path.resolve(this.options.cwd, config),
+                this
+            );
         }
     }