eslint 4.5.0 → 4.7.1

package/CHANGELOG.md

@@ -1,3 +1,101 @@
+v4.7.1 - September 18, 2017
+
+* 08656db Fix: Handle nested disable directive correctly (fixes #9318) (#9322) (Gyandeep Singh)
+* 9226495 Revert "Chore: rewrite parseListConfig for a small perf gain." (#9325) (薛定谔的猫)
+
+v4.7.0 - September 15, 2017
+
+* 787b78b Upgrade: Espree v3.5.1 (fixes #9153) (#9314) (Brandon Mills)
+* 1488b51 Update: run rules after `node.parent` is already set (fixes #9122) (#9283) (Teddy Katz)
+* 4431d68 Docs: fix wrong config in max-len example. (#9309) (薛定谔的猫)
+* 7d24dde Docs: Fix code snippet to refer to the correct option (#9313) (Ruben Tytgat)
+* 12388d4 Chore: rewrite parseListConfig for a small perf gain. (#9300) (薛定谔的猫)
+* ce1f084 Update: fix MemberExpression handling in no-extra-parens (fixes #9156) (jackyho112)
+* 0c720a3 Update: allow autofixing when using processors (fixes #7510) (#9090) (Teddy Katz)
+* 838df76 Chore: upgrade deps. (#9289) (薛定谔的猫)
+* f12def6 Update: indent flatTernary option to handle `return` (fixes #9285) (#9296) (Teddy Katz)
+* e220687 Fix: remove autofix for var undef inits (fixes #9231) (#9288) (Victor Hom)
+* 002e199 Docs: fix no-restricted-globals wrong config. (#9305) (薛定谔的猫)
+* fcfe91a Docs: fix wrong config in id-length example. (#9303) (薛定谔的猫)
+* 2731f94 Update: make newline-per-chained-call fixable (#9149) (João Granado)
+* 61f1093 Chore: avoid monkeypatching Linter instances in RuleTester (#9276) (Teddy Katz)
+* 28929cb Chore: remove Linter#reset (refs #9161) (#9268) (Teddy Katz)
+* abc8634 Build: re-run browserify when generating site (#9275) (Teddy Katz)
+* 7685fed Fix: IIFE and arrow functions in no-invalid-this (fixes #9126) (#9258) (Toru Nagashima)
+* 2b1eba2 Chore: enable eslint-plugin/no-deprecated-context-methods (#9279) (Teddy Katz)
+* 981f933 Fix: reuse the AST of source code object in verify (#9256) (Toru Nagashima)
+* cd698ba Docs: move RuleTester documentation to Node.js API page (#9273) (Teddy Katz)
+* 4ae7ad3 Docs: fix inaccuracy in `npm run perf` description (#9274) (Teddy Katz)
+* cad45bd Docs: improve documentation for rule contexts (#9272) (Teddy Katz)
+* 3b0c6fd Chore: remove extraneous linter properties (refs #9161) (#9267) (Teddy Katz)
+* c3231b3 Docs: Fix typo in array-bracket-newline.md (#9269) (宋文强)
+* 51132d6 Fix: Formatters keep trailing '.' if preceded by a space (fixes #9154) (#9247) (i-ron-y)
+* 88d5d4d Chore: remove undocumented Linter#markVariableAsUsed method (refs #9161) (#9266) (Teddy Katz)
+* 09414cf Chore: remove internal Linter#getDeclaredVariables method (refs #9161) (#9264) (Teddy Katz)
+* f31f59d Chore: prefer smaller scope for variables in codebase (#9265) (Teddy Katz)
+* 3693e4e Chore: remove undocumented Linter#getScope method (#9253) (Teddy Katz)
+* 5d7eb81 Chore: refactor config hash caching in CLIEngine (#9260) (Teddy Katz)
+* 1a76c4d Chore: remove SourceCode passthroughs from Linter.prototype (refs #9161) (#9263) (Teddy Katz)
+* 40ae27b Chore: avoid relying on Linter#getScope/markVariableAsUsed in tests (#9252) (Teddy Katz)
+* b383d81 Chore: make executeOnFile a pure function in CLIEngine (#9262) (Teddy Katz)
+* 5e0e579 Chore: avoid internal SourceCode methods in Linter tests (refs #9161) (#9223) (Teddy Katz)
+* adab827 Chore: remove unused eslint-disable comment (#9251) (Teddy Katz)
+* 31e4ec8 Chore: use consistent names for apply-disable-directives in tests (#9246) (Teddy Katz)
+* 7ba46e6 Fix: shebang error in eslint-disable-new-line; add tests (fixes #9238) (#9240) (i-ron-y)
+* 8f6546c Chore: remove undocumented defaults() method (refs #9161) (#9237) (Teddy Katz)
+* 82d8b73 Docs: Fix error in example code for sort-imports (fixes #8734) (#9245) (i-ron-y)
+* a32ec36 Update: refactor eslint-disable comment processing (#9216) (Teddy Katz)
+* 583f0b8 Chore: avoid using globals in CLIEngine tests (#9242) (Teddy Katz)
+* c8bf687 Chore: upgrade eslint-plugin-eslint-plugin@1.0.0 (#9234) (薛定谔的猫)
+* 3c41a05 Chore: always normalize rules to new API in rules.js (#9236) (Teddy Katz)
+* c5f4227 Chore: move logic for handling missing rules to rules.js (#9235) (Teddy Katz)
+* bf1e344 Chore: create report translators lazily (#9221) (Teddy Katz)
+* 2eedc1f Chore: remove currentFilename prop from Linter instances (refs #9161) (#9219) (Teddy Katz)
+* 5566e94 Docs: Replace misleading CLA links (#9133) (#9232) (i-ron-y)
+* c991630 Chore: remove ConfigOps.normalize in favor of ConfigOps.getRuleSeverity (#9224) (Teddy Katz)
+* 171962a Chore: remove internal Linter#getAncestors helper (refs #9161) (#9222) (Teddy Katz)
+* a567499 Chore: avoid storing list of problems on Linter instance (refs #9161) (#9214) (Teddy Katz)
+* ed6d088 Chore: avoid relying on undocumented Linter#getFilename API in tests (#9218) (Teddy Katz)
+
+v4.6.1 - September 3, 2017
+
+* bdec46d Build: avoid process leak when generating website (#9217) (Teddy Katz)
+* cb74b87 Fix: avoid adding globals when an env is used with `false` (fixes #9202) (#9203) (Teddy Katz)
+* f9b7544 Docs: Correct a typo in generator-star-spacing documentation (#9205) (Ethan Rutherford)
+* e5c5e83 Build: Fixing issue with docs generation (Fixes #9199) (#9200) (Ilya Volodin)
+
+v4.6.0 - September 1, 2017
+
+* 56dd769 Docs: fix link format in prefer-arrow-callback.md (#9198) (Vse Mozhet Byt)
+* 6becf91 Update: add eslint version to error output. (fixes #9037) (#9071) (薛定谔的猫)
+* 0e09973 New: function-paren-newline rule (fixes #6074) (#8102) (Teddy Katz)
+* 88a64cc Chore: Make parseJsonConfig() a pure function in Linter (#9186) (Teddy Katz)
+* 1bbac51 Fix: avoid breaking eslint-plugin-eslint-comments (fixes #9193) (#9196) (Teddy Katz)
+* 3e8b70a Fix: off-by-one error in eslint-disable comment checking (#9195) (Teddy Katz)
+* 73815f6 Docs: rewrite prefer-arrow-callback documentation (fixes #8950) (#9077) (Charles E. Morgan)
+* 0d3a854 Chore: avoid mutating report descriptors in report-translator (#9189) (Teddy Katz)
+* 2db356b Update: no-unused-vars Improve message to include the allowed patterns (#9176) (Eli White)
+* 8fbaf0a Update: Add configurability to generator-star-spacing (#8985) (Ethan Rutherford)
+* 8ed779c Chore: remove currentScopes property from Linter instances (refs #9161) (#9187) (Teddy Katz)
+* af4ad60 Fix: Handle error when running init without npm (#9169) (Gabriel Aumala)
+* 4b94c6c Chore: make parse() a pure function in Linter (refs #9161) (#9183) (Teddy Katz)
+* 1be5634 Chore: don't make Linter a subclass of EventEmitter (refs #9161) (#9177) (Teddy Katz)
+* e95af9b Chore: don't include internal test helpers in npm package (#9160) (Teddy Katz)
+* 6fb32e1 Chore: avoid using private Linter APIs in astUtils tests (refs #9161) (#9173) (Teddy Katz)
+* de6dccd Docs: add documentation for Linter methods (refs #6525) (#9151) (Teddy Katz)
+* 2d90030 Chore: remove unused assignment. (#9182) (薛定谔的猫)
+* d672aef Chore: refactor reporting logic (refs #9161) (#9168) (Teddy Katz)
+* 5ab0434 Fix: indent crash on sparse arrays with "off" option (fixes #9157) (#9166) (Teddy Katz)
+* c147b97 Chore: Make SourceCodeFixer accept text instead of a SourceCode instance (#9178) (Teddy Katz)
+* f127423 Chore: avoid using private Linter APIs in Linter tests (refs #9161) (#9175) (Teddy Katz)
+* 2334335 Chore: avoid using private Linter APIs in SourceCode tests (refs #9161) (#9174) (Teddy Katz)
+* 2dc243a Chore: avoid using internal Linter APIs in RuleTester (refs #9161) (#9172) (Teddy Katz)
+* d6e436f Fix: no-extra-parens reported some parenthesized IIFEs (fixes #9140) (#9158) (Teddy Katz)
+* e6b115c Build: Add an edit link to the rule docs’ metadata (#9049) (Jed Fox)
+* fcb7bb4 Chore: avoid unnecessarily complex forEach calls in no-extra-parens (#9159) (Teddy Katz)
+* ffa021e Docs: quotes rule - when does \n require backticks (#9135) (avimar)
+* 60c5148 Chore: improve coverage in lib/*.js (#9130) (Teddy Katz)
+
 v4.5.0 - August 18, 2017
 
 * decdd2c Update: allow arbitrary nodes to be ignored in `indent` (fixes #8594) (#9105) (Teddy Katz)

package/bin/eslint.js

@@ -43,9 +43,10 @@ process.once("uncaughtException", err => {
 
     if (typeof err.messageTemplate === "string" && err.messageTemplate.length > 0) {
         const template = lodash.template(fs.readFileSync(path.resolve(__dirname, `../messages/${err.messageTemplate}.txt`), "utf-8"));
+        const pkg = require("../package.json");
 
         console.error("\nOops! Something went wrong! :(");
-        console.error(`\n${template(err.messageData || {})}`);
+        console.error(`\nESLint: ${pkg.version}.\n${template(err.messageData || {})}`);
     } else {
 
         console.error(err.message);

package/conf/eslint-recommended.js

@@ -44,6 +44,7 @@ module.exports = {
         "func-name-matching": "off",
         "func-names": "off",
         "func-style": "off",
+        "function-paren-newline": "off",
         "generator-star-spacing": "off",
         "getter-return": "off",
         "global-require": "off",

package/lib/ast-utils.js

@@ -626,6 +626,9 @@ module.exports = {
                 //     // setup...
                 //     return function foo() { ... };
                 //   })();
+                //   obj.foo = (() =>
+                //     function foo() { ... }
+                //   )();
                 case "ReturnStatement": {
                     const func = getUpperFunction(parent);
 
@@ -635,6 +638,12 @@ module.exports = {
                     node = func.parent;
                     break;
                 }
+                case "ArrowFunctionExpression":
+                    if (node !== parent.body || !isCallee(parent)) {
+                        return true;
+                    }
+                    node = parent.parent;
+                    break;
 
                 // e.g.
                 //   var obj = { foo() { ... } };
@@ -655,16 +664,15 @@ module.exports = {
                 //   [Foo = function() { ... }] = a;
                 case "AssignmentExpression":
                 case "AssignmentPattern":
-                    if (parent.right === node) {
-                        if (parent.left.type === "MemberExpression") {
-                            return false;
-                        }
-                        if (isAnonymous &&
-                            parent.left.type === "Identifier" &&
-                            startsWithUpperCase(parent.left.name)
-                        ) {
-                            return false;
-                        }
+                    if (parent.left.type === "MemberExpression") {
+                        return false;
+                    }
+                    if (
+                        isAnonymous &&
+                        parent.left.type === "Identifier" &&
+                        startsWithUpperCase(parent.left.name)
+                    ) {
+                        return false;
                     }
                     return true;
 
@@ -809,19 +817,14 @@ module.exports = {
                 return 17;
 
             case "CallExpression":
-
-                // IIFE is allowed to have parens in any position (#655)
-                if (node.callee.type === "FunctionExpression") {
-                    return -1;
-                }
                 return 18;
 
             case "NewExpression":
                 return 19;
 
-            // no default
+            default:
+                return 20;
         }
-        return 20;
     },
 
     /**

package/lib/cli-engine.js

@@ -142,15 +142,9 @@ function calculateStatsPerRun(results) {
  * @private
  */
 function processText(text, configHelper, filename, fix, allowInlineConfig, linter) {
-
-    // clear all existing settings for a new file
-    linter.reset();
-
     let filePath,
-        messages,
         fileExtension,
-        processor,
-        fixedResult;
+        processor;
 
     if (filename) {
         filePath = path.resolve(filename);
@@ -174,51 +168,28 @@ function processText(text, configHelper, filename, fix, allowInlineConfig, linte
         }
     }
 
-    if (processor) {
-        debug("Using processor");
-        const parsedBlocks = processor.preprocess(text, filename);
-        const unprocessedMessages = [];
-
-        parsedBlocks.forEach(block => {
-            unprocessedMessages.push(linter.verify(block, config, {
-                filename,
-                allowInlineConfig
-            }));
-        });
-
-        // TODO(nzakas): Figure out how fixes might work for processors
-
-        messages = processor.postprocess(unprocessedMessages, filename);
-
-    } else {
+    const autofixingEnabled = typeof fix !== "undefined" && (!processor || processor.supportsAutofix);
 
-        if (fix) {
-            fixedResult = linter.verifyAndFix(text, config, {
-                filename,
-                allowInlineConfig,
-                fix
-            });
-            messages = fixedResult.messages;
-        } else {
-            messages = linter.verify(text, config, {
-                filename,
-                allowInlineConfig
-            });
-        }
-    }
+    const fixedResult = linter.verifyAndFix(text, config, {
+        filename,
+        allowInlineConfig,
+        fix: !!autofixingEnabled && fix,
+        preprocess: processor && (rawText => processor.preprocess(rawText, filename)),
+        postprocess: processor && (problemLists => processor.postprocess(problemLists, filename))
+    });
 
-    const stats = calculateStatsPerFile(messages);
+    const stats = calculateStatsPerFile(fixedResult.messages);
 
     const result = {
         filePath: filename,
-        messages,
+        messages: fixedResult.messages,
         errorCount: stats.errorCount,
         warningCount: stats.warningCount,
         fixableErrorCount: stats.fixableErrorCount,
         fixableWarningCount: stats.fixableWarningCount
     };
 
-    if (fixedResult && fixedResult.fixed) {
+    if (fixedResult.fixed) {
         result.output = fixedResult.output;
     }
 
@@ -372,6 +343,8 @@ function getCacheFile(cacheFile, cwd) {
     return resolvedCacheFile;
 }
 
+const configHashCache = new WeakMap();
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -493,11 +466,9 @@ class CLIEngine {
      * @returns {Object} The results for all files that were linted.
      */
     executeOnFiles(patterns) {
-        const results = [],
-            options = this.options,
+        const options = this.options,
             fileCache = this._fileCache,
             configHelper = this.config;
-        let prevConfig; // the previous configuration used
         const cacheFile = getCacheFile(this.options.cacheLocation || this.options.cacheFile, this.options.cwd);
 
         if (!options.cache && fs.existsSync(cacheFile)) {
@@ -512,42 +483,18 @@ class CLIEngine {
         function hashOfConfigFor(filename) {
             const config = configHelper.getConfig(filename);
 
-            if (!prevConfig) {
-                prevConfig = {};
-            }
-
-            // reuse the previously hashed config if the config hasn't changed
-            if (prevConfig.config !== config) {
-
-                /*
-                 * config changed so we need to calculate the hash of the config
-                 * and the hash of the plugins being used
-                 */
-                prevConfig.config = config;
-
-                const eslintVersion = pkg.version;
-
-                prevConfig.hash = hash(`${eslintVersion}_${stringify(config)}`);
+            if (!configHashCache.has(config)) {
+                configHashCache.set(config, hash(`${pkg.version}_${stringify(config)}`));
             }
 
-            return prevConfig.hash;
+            return configHashCache.get(config);
         }
 
-        /**
-         * Executes the linter on a file defined by the `filename`. Skips
-         * unsupported file extensions and any files that are already linted.
-         * @param {string} filename The resolved filename of the file to be linted
-         * @param {boolean} warnIgnored always warn when a file is ignored
-         * @param {Linter} linter Linter context
-         * @returns {void}
-         */
-        function executeOnFile(filename, warnIgnored, linter) {
-            let hashOfConfig,
-                descriptor;
-
-            if (warnIgnored) {
-                results.push(createIgnoreResult(filename, options.cwd));
-                return;
+        const startTime = Date.now();
+        const fileList = globUtil.listFilesToProcess(this.resolveFileGlobPatterns(patterns), options);
+        const results = fileList.map(fileInfo => {
+            if (fileInfo.ignored) {
+                return createIgnoreResult(fileInfo.filename, options.cwd);
             }
 
             if (options.cache) {
@@ -557,15 +504,12 @@ class CLIEngine {
                  * with the metadata and the flag that determines if
                  * the file has changed
                  */
-                descriptor = fileCache.getFileDescriptor(filename);
-                const meta = descriptor.meta || {};
-
-                hashOfConfig = hashOfConfigFor(filename);
-
-                const changed = descriptor.changed || meta.hashOfConfig !== hashOfConfig;
+                const descriptor = fileCache.getFileDescriptor(fileInfo.filename);
+                const hashOfConfig = hashOfConfigFor(fileInfo.filename);
+                const changed = descriptor.changed || descriptor.meta.hashOfConfig !== hashOfConfig;
 
                 if (!changed) {
-                    debug(`Skipping file since hasn't changed: ${filename}`);
+                    debug(`Skipping file since hasn't changed: ${fileInfo.filename}`);
 
                     /*
                      * Add the the cached results (always will be 0 error and
@@ -573,63 +517,45 @@ class CLIEngine {
                      * failed, in order to guarantee that next execution will
                      * process those files as well.
                      */
-                    results.push(descriptor.meta.results);
-
-                    // move to the next file
-                    return;
+                    return descriptor.meta.results;
                 }
             }
 
-            debug(`Processing ${filename}`);
+            debug(`Processing ${fileInfo.filename}`);
 
-            const res = processFile(filename, configHelper, options, linter);
-
-            if (options.cache) {
+            return processFile(fileInfo.filename, configHelper, options, this.linter);
+        });
 
-                /*
-                 * if a file contains errors or warnings we don't want to
-                 * store the file in the cache so we can guarantee that
-                 * next execution will also operate on this file
-                 */
-                if (res.errorCount > 0 || res.warningCount > 0) {
-                    debug(`File has problems, skipping it: ${filename}`);
+        if (options.cache) {
+            results.forEach(result => {
+                if (result.messages.length) {
 
-                    // remove the entry from the cache
-                    fileCache.removeEntry(filename);
+                    /*
+                    * if a file contains errors or warnings we don't want to
+                    * store the file in the cache so we can guarantee that
+                    * next execution will also operate on this file
+                    */
+                    fileCache.removeEntry(result.filePath);
                 } else {
 
                     /*
                      * since the file passed we store the result here
-                     * TODO: check this as we might not need to store the
-                     * successful runs as it will always should be 0 errors and
-                     * 0 warnings.
+                     * TODO: it might not be necessary to store the results list in the cache,
+                     * since it should always be 0 errors/warnings
                      */
-                    descriptor.meta.hashOfConfig = hashOfConfig;
-                    descriptor.meta.results = res;
-                }
-            }
-
-            results.push(res);
-        }
+                    const descriptor = fileCache.getFileDescriptor(result.filePath);
 
-        const startTime = Date.now();
-
-
-        patterns = this.resolveFileGlobPatterns(patterns);
-        const fileList = globUtil.listFilesToProcess(patterns, options);
-
-        fileList.forEach(fileInfo => {
-            executeOnFile(fileInfo.filename, fileInfo.ignored, this.linter);
-        });
-
-        const stats = calculateStatsPerRun(results);
-
-        if (options.cache) {
+                    descriptor.meta.hashOfConfig = hashOfConfigFor(result.filePath);
+                    descriptor.meta.results = result;
+                }
+            });
 
             // persist the cache to disk
             fileCache.reconcile();
         }
 
+        const stats = calculateStatsPerRun(results);
+
         debug(`Linting complete in: ${Date.now() - startTime}ms`);
 
         return {
@@ -713,7 +639,6 @@ class CLIEngine {
      */
     getFormatter(format) {
 
-        let formatterPath;
 
         // default is stylish
         format = format || "stylish";
@@ -724,6 +649,8 @@ class CLIEngine {
             // replace \ with / for Windows compatibility
             format = format.replace(/\\/g, "/");
 
+            let formatterPath;
+
             // if there's a slash, then it's a file
             if (format.indexOf("/") > -1) {
                 const cwd = this.options ? this.options.cwd : process.cwd();

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

@@ -154,7 +154,8 @@ function forwardCurrentToHead(analyzer, node) {
                 analyzer.emitter.emit(
                     "onCodePathSegmentEnd",
                     currentSegment,
-                    node);
+                    node
+                );
             }
         }
     }
@@ -175,7 +176,8 @@ function forwardCurrentToHead(analyzer, node) {
                 analyzer.emitter.emit(
                     "onCodePathSegmentStart",
                     headSegment,
-                    node);
+                    node
+                );
             }
         }
     }
@@ -202,7 +204,8 @@ function leaveFromCurrentSegment(analyzer, node) {
             analyzer.emitter.emit(
                 "onCodePathSegmentEnd",
                 currentSegment,
-                node);
+                node
+            );
         }
     }
 
@@ -369,7 +372,8 @@ function processCodePathToEnter(analyzer, node) {
         case "SwitchStatement":
             state.pushSwitchContext(
                 node.cases.some(isCaseNode),
-                astUtils.getLabel(node));
+                astUtils.getLabel(node)
+            );
             break;
 
         case "TryStatement":

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

@@ -164,7 +164,8 @@ class CodePathSegment {
         return new CodePathSegment(
             id,
             flattenUnusedSegments(allPrevSegments),
-            allPrevSegments.some(isReachable));
+            allPrevSegments.some(isReachable)
+        );
     }
 
     /**

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

@@ -843,21 +843,23 @@ class CodePathState {
          * This segment will leave at the end of this finally block.
          */
         const segments = forkContext.makeNext(-1, -1);
-        let j;
 
         for (let i = 0; i < forkContext.count; ++i) {
             const prevSegsOfLeavingSegment = [headOfLeavingSegments[i]];
 
-            for (j = 0; j < returned.segmentsList.length; ++j) {
+            for (let j = 0; j < returned.segmentsList.length; ++j) {
                 prevSegsOfLeavingSegment.push(returned.segmentsList[j][i]);
             }
-            for (j = 0; j < thrown.segmentsList.length; ++j) {
+            for (let j = 0; j < thrown.segmentsList.length; ++j) {
                 prevSegsOfLeavingSegment.push(thrown.segmentsList[j][i]);
             }
 
-            segments.push(CodePathSegment.newNext(
-                this.idGenerator.next(),
-                prevSegsOfLeavingSegment));
+            segments.push(
+                CodePathSegment.newNext(
+                    this.idGenerator.next(),
+                    prevSegsOfLeavingSegment
+                )
+            );
         }
 
         this.pushForkContext(true);
@@ -982,7 +984,6 @@ class CodePathState {
 
         const forkContext = this.forkContext;
         const brokenForkContext = this.popBreakContext().brokenForkContext;
-        let choiceContext;
 
         // Creates a looped path.
         switch (context.type) {
@@ -992,11 +993,12 @@ class CodePathState {
                 makeLooped(
                     this,
                     forkContext.head,
-                    context.continueDestSegments);
+                    context.continueDestSegments
+                );
                 break;
 
             case "DoWhileStatement": {
-                choiceContext = this.popChoiceContext();
+                const choiceContext = this.popChoiceContext();
 
                 if (!choiceContext.processed) {
                     choiceContext.trueForkContext.add(forkContext.head);
@@ -1013,7 +1015,8 @@ class CodePathState {
                     makeLooped(
                         this,
                         segmentsList[i],
-                        context.entrySegments);
+                        context.entrySegments
+                    );
                 }
                 break;
             }
@@ -1024,7 +1027,8 @@ class CodePathState {
                 makeLooped(
                     this,
                     forkContext.head,
-                    context.leftSegments);
+                    context.leftSegments
+                );
                 break;
 
             /* istanbul ignore next */
@@ -1149,7 +1153,8 @@ class CodePathState {
             finalizeTestSegmentsOfFor(
                 context,
                 choiceContext,
-                forkContext.head);
+                forkContext.head
+            );
         } else {
             context.endOfInitSegments = forkContext.head;
         }
@@ -1180,13 +1185,15 @@ class CodePathState {
                 makeLooped(
                     this,
                     context.endOfUpdateSegments,
-                    context.testSegments);
+                    context.testSegments
+                );
             }
         } else if (context.testSegments) {
             finalizeTestSegmentsOfFor(
                 context,
                 choiceContext,
-                forkContext.head);
+                forkContext.head
+            );
         } else {
             context.endOfInitSegments = forkContext.head;
         }

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

@@ -51,7 +51,8 @@ class CodePath {
         Object.defineProperty(
             this,
             "internal",
-            { value: new CodePathState(new IdGenerator(`${id}_`), onLooped) });
+            { value: new CodePathState(new IdGenerator(`${id}_`), onLooped) }
+        );
 
         // Adds this into `childCodePaths` of `upper`.
         if (upper) {
@@ -205,7 +206,7 @@ class CodePath {
 
                 // Call the callback when the first time.
                 if (!skippedSegment) {
-                    callback.call(this, segment, controller); // eslint-disable-line callback-return
+                    callback.call(this, segment, controller);
                     if (segment === lastSegment) {
                         controller.skip();
                     }

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

@@ -254,7 +254,8 @@ class ForkContext {
         return new ForkContext(
             parentContext.idGenerator,
             parentContext,
-            (forkLeavingPath ? 2 : 1) * parentContext.count);
+            (forkLeavingPath ? 2 : 1) * parentContext.count
+        );
     }
 }
 

package/lib/config/autoconfig.js

@@ -269,10 +269,8 @@ class Registry {
      * @returns {Registry}              New registry with errorCount populated
      */
     lintSourceCode(sourceCodes, config, cb) {
-        let ruleSetIdx,
-            lintedRegistry;
+        let lintedRegistry = new Registry();
 
-        lintedRegistry = new Registry();
         lintedRegistry.rules = Object.assign({}, this.rules);
 
         const ruleSets = lintedRegistry.buildRuleSets();
@@ -287,7 +285,7 @@ class Registry {
         filenames.forEach(filename => {
             debug(`Linting file: ${filename}`);
 
-            ruleSetIdx = 0;
+            let ruleSetIdx = 0;
 
             ruleSets.forEach(ruleSet => {
                 const lintConfig = Object.assign({}, config, { rules: ruleSet });