eslint 6.0.0-alpha.1 → 6.0.1

package/lib/{linter.js → linter/linter.js}

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Main Linter Class
  * @author Gyandeep Singh
+ * @author aladdin-add
  */
 
 "use strict";
@@ -9,44 +10,49 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const path = require("path"),
+const
+    path = require("path"),
     eslintScope = require("eslint-scope"),
     evk = require("eslint-visitor-keys"),
     espree = require("espree"),
     lodash = require("lodash"),
+    BuiltInEnvironments = require("../../conf/environments"),
+    pkg = require("../../package.json"),
+    astUtils = require("../shared/ast-utils"),
+    ConfigOps = require("../shared/config-ops"),
+    validator = require("../shared/config-validator"),
+    Traverser = require("../shared/traverser"),
+    { SourceCode } = require("../source-code"),
     CodePathAnalyzer = require("./code-path-analysis/code-path-analyzer"),
-    ConfigOps = require("./config/config-ops"),
-    validator = require("./config/config-validator"),
-    BuiltInEnvironments = require("../conf/environments"),
-    applyDisableDirectives = require("./util/apply-disable-directives"),
-    createEmitter = require("./util/safe-emitter"),
-    NodeEventGenerator = require("./util/node-event-generator"),
-    SourceCode = require("./util/source-code"),
-    Traverser = require("./util/traverser"),
-    createReportTranslator = require("./util/report-translator"),
+    applyDisableDirectives = require("./apply-disable-directives"),
+    ConfigCommentParser = require("./config-comment-parser"),
+    NodeEventGenerator = require("./node-event-generator"),
+    createReportTranslator = require("./report-translator"),
     Rules = require("./rules"),
-    timing = require("./util/timing"),
-    ConfigCommentParser = require("./util/config-comment-parser"),
-    astUtils = require("./util/ast-utils"),
-    pkg = require("../package.json"),
-    SourceCodeFixer = require("./util/source-code-fixer");
+    createEmitter = require("./safe-emitter"),
+    SourceCodeFixer = require("./source-code-fixer"),
+    timing = require("./timing"),
+    ruleReplacements = require("../../conf/replacements.json");
 
 const debug = require("debug")("eslint:linter");
 const MAX_AUTOFIX_PASSES = 10;
 const DEFAULT_PARSER_NAME = "espree";
 const commentParser = new ConfigCommentParser();
+const DEFAULT_ERROR_LOC = { start: { line: 1, column: 0 }, end: { line: 1, column: 1 } };
 
 //------------------------------------------------------------------------------
 // Typedefs
 //------------------------------------------------------------------------------
 
-/** @typedef {InstanceType<import("./cli-engine/config-array")["ConfigArray"]>} ConfigArray */
-/** @typedef {import("./util/types").ConfigData} ConfigData */
-/** @typedef {import("./util/types").Environment} Environment */
-/** @typedef {import("./util/types").GlobalConf} GlobalConf */
-/** @typedef {import("./util/types").LintMessage} LintMessage */
-/** @typedef {import("./util/types").ParserOptions} ParserOptions */
-/** @typedef {import("./util/types").Rule} Rule */
+/** @typedef {InstanceType<import("../cli-engine/config-array")["ConfigArray"]>} ConfigArray */
+/** @typedef {InstanceType<import("../cli-engine/config-array")["ExtractedConfig"]>} ExtractedConfig */
+/** @typedef {import("../shared/types").ConfigData} ConfigData */
+/** @typedef {import("../shared/types").Environment} Environment */
+/** @typedef {import("../shared/types").GlobalConf} GlobalConf */
+/** @typedef {import("../shared/types").LintMessage} LintMessage */
+/** @typedef {import("../shared/types").ParserOptions} ParserOptions */
+/** @typedef {import("../shared/types").Processor} Processor */
+/** @typedef {import("../shared/types").Rule} Rule */
 
 /**
  * @typedef {Object} DisableDirective
@@ -65,6 +71,38 @@ const commentParser = new ConfigCommentParser();
  * @property {Rules} ruleMap The loaded rules.
  */
 
+/**
+ * @typedef {Object} VerifyOptions
+ * @property {boolean} [allowInlineConfig] Allow/disallow inline comments' ability
+ *      to change config once it is set. Defaults to true if not supplied.
+ *      Useful if you want to validate JS without comments overriding rules.
+ * @property {boolean} [disableFixes] if `true` then the linter doesn't make `fix`
+ *      properties into the lint result.
+ * @property {string} [filename] the filename of the source code.
+ * @property {boolean} [reportUnusedDisableDirectives] Adds reported errors for
+ *      unused `eslint-disable` directives.
+ */
+
+/**
+ * @typedef {Object} ProcessorOptions
+ * @property {(filename:string, text:string) => boolean} [filterCodeBlock] the
+ *      predicate function that selects adopt code blocks.
+ * @property {Processor["postprocess"]} [postprocess] postprocessor for report
+ *      messages. If provided, this should accept an array of the message lists
+ *      for each code block returned from the preprocessor, apply a mapping to
+ *      the messages as appropriate, and return a one-dimensional array of
+ *      messages.
+ * @property {Processor["preprocess"]} [preprocess] preprocessor for source text.
+ *      If provided, this should accept a string of source text, and return an
+ *      array of code blocks to lint.
+ */
+
+/**
+ * @typedef {Object} FixOptions
+ * @property {boolean | ((message: LintMessage) => boolean)} [fix] Determines
+ *      whether fixes should be applied.
+ */
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -145,19 +183,71 @@ function addDeclaredGlobals(globalScope, configGlobals, { exportedVariables, ena
     });
 }
 
+/**
+ * creates a missing-rule message.
+ * @param {string} ruleId the ruleId to create
+ * @returns {string} created error message
+ * @private
+ */
+function createMissingRuleMessage(ruleId) {
+    return Object.prototype.hasOwnProperty.call(ruleReplacements.rules, ruleId)
+        ? `Rule '${ruleId}' was removed and replaced by: ${ruleReplacements.rules[ruleId].join(", ")}`
+        : `Definition for rule '${ruleId}' was not found.`;
+}
+
+/**
+ * creates a linting problem
+ * @param {Object} options to create linting error
+ * @param {string} options.ruleId the ruleId to report
+ * @param {Object} options.loc the loc to report
+ * @param {string} options.message the error message to report
+ * @returns {Problem} created problem, returns a missing-rule problem if only provided ruleId.
+ * @private
+ */
+function createLintingProblem(options) {
+    const { ruleId, loc = DEFAULT_ERROR_LOC, message = createMissingRuleMessage(options.ruleId) } = options;
+
+    return {
+        ruleId,
+        message,
+        line: loc.start.line,
+        column: loc.start.column + 1,
+        endLine: loc.end.line,
+        endColumn: loc.end.column + 1,
+        severity: 2,
+        nodeType: null
+    };
+}
+
 /**
  * Creates a collection of disable directives from a comment
- * @param {("disable"|"enable"|"disable-line"|"disable-next-line")} type The type of directive comment
- * @param {{line: number, column: number}} loc The 0-based location of the comment token
- * @param {string} value The value after the directive in the comment
+ * @param {Object} options to create disable directives
+ * @param {("disable"|"enable"|"disable-line"|"disable-next-line")} options.type The type of directive comment
+ * @param {{line: number, column: number}} options.loc The 0-based location of the comment token
+ * @param {string} options.value The value after the directive in the comment
  * comment specified no specific rules, so it applies to all rules (e.g. `eslint-disable`)
- * @returns {DisableDirective[]} Directives from the comment
+ * @param {function(string): {create: Function}} options.ruleMapper A map from rule IDs to defined rules
+ * @returns {Object} Directives and problems from the comment
  */
-function createDisableDirectives(type, loc, value) {
+function createDisableDirectives(options) {
+    const { type, loc, value, ruleMapper } = options;
     const ruleIds = Object.keys(commentParser.parseListConfig(value));
     const directiveRules = ruleIds.length ? ruleIds : [null];
+    const result = {
+        directives: [], // valid disable directives
+        directiveProblems: [] // problems in directives
+    };
+
+    for (const ruleId of directiveRules) {
 
-    return directiveRules.map(ruleId => ({ type, line: loc.line, column: loc.column + 1, ruleId }));
+        // push to directives, if the rule is defined(including null, e.g. /*eslint enable*/)
+        if (ruleId === null || ruleMapper(ruleId) !== null) {
+            result.directives.push({ type, line: loc.start.line, column: loc.start.column + 1, ruleId });
+        } else {
+            result.directiveProblems.push(createLintingProblem({ ruleId, loc }));
+        }
+    }
+    return result;
 }
 
 /**
@@ -186,23 +276,19 @@ function getDirectiveComments(filename, ast, ruleMapper) {
         }
 
         const directiveValue = trimmedCommentText.slice(match.index + match[1].length);
+        let directiveType = "";
 
         if (/^eslint-disable-(next-)?line$/u.test(match[1])) {
             if (comment.loc.start.line === comment.loc.end.line) {
-                const directiveType = match[1].slice("eslint-".length);
-
-                disableDirectives.push(...createDisableDirectives(directiveType, comment.loc.start, directiveValue));
+                directiveType = match[1].slice("eslint-".length);
             } else {
-                problems.push({
+                const message = `${match[1]} comment should not span multiple lines.`;
+
+                problems.push(createLintingProblem({
                     ruleId: null,
-                    severity: 2,
-                    message: `${match[1]} comment should not span multiple lines.`,
-                    line: comment.loc.start.line,
-                    column: comment.loc.start.column + 1,
-                    endLine: comment.loc.end.line,
-                    endColumn: comment.loc.end.column + 1,
-                    nodeType: null
-                });
+                    message,
+                    loc: comment.loc
+                }));
             }
         } else if (comment.type === "Block") {
             switch (match[1]) {
@@ -218,16 +304,11 @@ function getDirectiveComments(filename, ast, ruleMapper) {
                         try {
                             normalizedValue = ConfigOps.normalizeConfigGlobal(value);
                         } catch (err) {
-                            problems.push({
+                            problems.push(createLintingProblem({
                                 ruleId: null,
-                                severity: 2,
-                                message: err.message,
-                                line: comment.loc.start.line,
-                                column: comment.loc.start.column + 1,
-                                endLine: comment.loc.end.line,
-                                endColumn: comment.loc.end.column + 1,
-                                nodeType: null
-                            });
+                                loc: comment.loc,
+                                message: err.message
+                            }));
                             continue;
                         }
 
@@ -244,11 +325,11 @@ function getDirectiveComments(filename, ast, ruleMapper) {
                     break;
 
                 case "eslint-disable":
-                    disableDirectives.push(...createDisableDirectives("disable", comment.loc.start, directiveValue));
+                    directiveType = "disable";
                     break;
 
                 case "eslint-enable":
-                    disableDirectives.push(...createDisableDirectives("enable", comment.loc.start, directiveValue));
+                    directiveType = "enable";
                     break;
 
                 case "eslint": {
@@ -256,22 +337,27 @@ function getDirectiveComments(filename, ast, ruleMapper) {
 
                     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(ruleMapper(name), name, ruleValue);
+                                validator.validateRuleOptions(rule, name, ruleValue);
                             } catch (err) {
-                                problems.push({
+                                problems.push(createLintingProblem({
                                     ruleId: name,
-                                    severity: 2,
                                     message: err.message,
-                                    line: comment.loc.start.line,
-                                    column: comment.loc.start.column + 1,
-                                    endLine: comment.loc.end.line,
-                                    endColumn: comment.loc.end.column + 1,
-                                    nodeType: null
-                                });
+                                    loc: comment.loc
+                                }));
+
+                                // do not apply the config, if found invalid options.
+                                return;
                             }
+
                             configuredRules[name] = ruleValue;
                         });
                     } else {
@@ -284,6 +370,14 @@ function getDirectiveComments(filename, ast, ruleMapper) {
                 // no default
             }
         }
+
+        if (directiveType !== "") {
+            const options = { type: directiveType, loc: comment.loc, value: directiveValue, ruleMapper };
+            const { directives, directiveProblems } = createDisableDirectives(options);
+
+            disableDirectives.push(...directives);
+            problems.push(...directiveProblems);
+        }
     });
 
     return {
@@ -328,21 +422,37 @@ function findEslintEnv(text) {
     return retv;
 }
 
+/**
+ * Convert "/path/to/<text>" to "<text>".
+ * `CLIEngine#executeOnText()` method gives "/path/to/<text>" if the filename
+ * was omitted because `configArray.extractConfig()` requires an absolute path.
+ * But the linter should pass `<text>` to `RuleContext#getFilename()` in that
+ * case.
+ * Also, code blocks can have their virtual filename. If the parent filename was
+ * `<text>`, the virtual filename is `<text>/0_foo.js` or something like (i.e.,
+ * it's not an absolute path).
+ * @param {string} filename The filename to normalize.
+ * @returns {string} The normalized filename.
+ */
+function normalizeFilename(filename) {
+    const parts = filename.split(path.sep);
+    const index = parts.lastIndexOf("<text>");
+
+    return index === -1 ? filename : parts.slice(index).join(path.sep);
+}
+
 /**
  * Normalizes the possible options for `linter.verify` and `linter.verifyAndFix` to a
  * consistent shape.
- * @param {(string|{reportUnusedDisableDirectives: boolean, filename: string, allowInlineConfig: boolean})} providedOptions Options
- * @returns {{reportUnusedDisableDirectives: boolean, filename: string, allowInlineConfig: boolean}} Normalized options
+ * @param {VerifyOptions} providedOptions Options
+ * @returns {Required<VerifyOptions>} Normalized options
  */
 function normalizeVerifyOptions(providedOptions) {
-    const isObjectOptions = typeof providedOptions === "object";
-    const providedFilename = isObjectOptions ? providedOptions.filename : providedOptions;
-
     return {
-        filename: typeof providedFilename === "string" ? providedFilename : "<input>",
-        allowInlineConfig: !isObjectOptions || providedOptions.allowInlineConfig !== false,
-        reportUnusedDisableDirectives: isObjectOptions && !!providedOptions.reportUnusedDisableDirectives,
-        disableFixes: Boolean(providedOptions && providedOptions.disableFixes)
+        filename: normalizeFilename(providedOptions.filename || "<input>"),
+        allowInlineConfig: providedOptions.allowInlineConfig !== false,
+        reportUnusedDisableDirectives: Boolean(providedOptions.reportUnusedDisableDirectives),
+        disableFixes: Boolean(providedOptions.disableFixes)
     };
 }
 
@@ -460,7 +570,7 @@ function analyzeScope(ast, parserOptions, visitorKeys) {
  * @private
  */
 function parse(text, parser, providedParserOptions, filePath) {
-    const textToParse = stripUnicodeBOM(text).replace(astUtils.SHEBANG_MATCHER, (match, captured) => `//${captured}`);
+    const textToParse = stripUnicodeBOM(text).replace(astUtils.shebangPattern, (match, captured) => `//${captured}`);
     const parserOptions = Object.assign({}, providedParserOptions, {
         loc: true,
         range: true,
@@ -700,11 +810,18 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserOptions, parser
     Object.keys(configuredRules).forEach(ruleId => {
         const severity = ConfigOps.getRuleSeverity(configuredRules[ruleId]);
 
+        // not load disabled rules
         if (severity === 0) {
             return;
         }
 
         const rule = ruleMapper(ruleId);
+
+        if (rule === null) {
+            lintingProblems.push(createLintingProblem({ ruleId }));
+            return;
+        }
+
         const messageIds = rule.meta && rule.meta.messages;
         let reportTranslator = null;
         const ruleContext = Object.freeze(
@@ -778,6 +895,22 @@ function runRules(sourceCode, configuredRules, ruleMapper, parserOptions, parser
     return lintingProblems;
 }
 
+/**
+ * Ensure the source code to be a string.
+ * @param {string|SourceCode} textOrSourceCode The text or source code object.
+ * @returns {string} The source code text.
+ */
+function ensureText(textOrSourceCode) {
+    if (typeof textOrSourceCode === "object") {
+        const { hasBOM, text } = textOrSourceCode;
+        const bom = hasBOM ? "\uFEFF" : "";
+
+        return bom + text;
+    }
+
+    return String(textOrSourceCode);
+}
+
 /**
  * Get an environment.
  * @param {LinterInternalSlots} slots The internal slots of Linter.
@@ -796,13 +929,11 @@ function getEnv(slots, envId) {
  * Get a rule.
  * @param {LinterInternalSlots} slots The internal slots of Linter.
  * @param {string} ruleId The rule ID to get.
- * @returns {Rule} The rule.
+ * @returns {Rule|null} The rule.
  */
 function getRule(slots, ruleId) {
     return (
         (slots.lastConfigArray && slots.lastConfigArray.pluginRules.get(ruleId)) ||
-
-        // This returns the stub for missing rules if the rule does not exist.
         slots.ruleMap.get(ruleId)
     );
 }
@@ -847,19 +978,13 @@ class Linter {
      * Same as linter.verify, except without support for processors.
      * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.
      * @param {ConfigData} providedConfig An ESLintConfig instance to configure everything.
-     * @param {(string|Object)} [filenameOrOptions] The optional filename of the file being checked.
-     *      If this is not set, the filename will default to '<input>' in the rule context. If
-     *      an object, then it has "filename", "saveState", and "allowInlineConfig" properties.
-     * @param {boolean} [filenameOrOptions.allowInlineConfig=true] Allow/disallow inline comments' ability to change config once it is set. Defaults to true if not supplied.
-     *      Useful if you want to validate JS without comments overriding rules.
-     * @param {boolean} [filenameOrOptions.reportUnusedDisableDirectives=false] Adds reported errors for unused
-     *      eslint-disable directives
+     * @param {VerifyOptions} [providedOptions] The optional filename of the file being checked.
      * @returns {LintMessage[]} The results as an array of messages or an empty array if no messages.
      */
-    _verifyWithoutProcessors(textOrSourceCode, providedConfig, filenameOrOptions) {
+    _verifyWithoutProcessors(textOrSourceCode, providedConfig, providedOptions) {
         const slots = internalSlotsMap.get(this);
         const config = providedConfig || {};
-        const options = normalizeVerifyOptions(filenameOrOptions);
+        const options = normalizeVerifyOptions(providedOptions);
         let text;
 
         // evaluate arguments
@@ -991,91 +1116,121 @@ class Linter {
      * Verifies the text against the rules specified by the second argument.
      * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.
      * @param {ConfigData|ConfigArray} config An ESLintConfig instance to configure everything.
-     * @param {(string|Object)} [filenameOrOptions] The optional filename of the file being checked.
+     * @param {(string|(VerifyOptions&ProcessorOptions))} [filenameOrOptions] The optional filename of the file being checked.
      *      If this is not set, the filename will default to '<input>' in the rule context. If
-     *      an object, then it has "filename", "saveState", and "allowInlineConfig" properties.
-     * @param {boolean} [filenameOrOptions.allowInlineConfig] Allow/disallow inline comments' ability to change config once it is set. Defaults to true if not supplied.
-     *      Useful if you want to validate JS without comments overriding rules.
-     * @param {function(string): string[]} [filenameOrOptions.preprocess] preprocessor for source text. If provided,
-     *      this should accept a string of source text, and return an array of code blocks to lint.
-     * @param {function(Array<LintMessage[]>): LintMessage[]} [filenameOrOptions.postprocess] postprocessor for report messages. If provided,
-     *      this should accept an array of the message lists for each code block returned from the preprocessor,
-     *      apply a mapping to the messages as appropriate, and return a one-dimensional array of messages
+     *      an object, then it has "filename", "allowInlineConfig", and some properties.
      * @returns {LintMessage[]} The results as an array of messages or an empty array if no messages.
      */
     verify(textOrSourceCode, config, filenameOrOptions) {
+        debug("Verify");
+        const options = typeof filenameOrOptions === "string"
+            ? { filename: filenameOrOptions }
+            : filenameOrOptions || {};
+
+        // CLIEngine passes a `ConfigArray` object.
         if (config && typeof config.extractConfig === "function") {
-            return this._verifyWithConfigArray(
-                textOrSourceCode,
-                config,
-                typeof filenameOrOptions === "string"
-                    ? { filename: filenameOrOptions }
-                    : filenameOrOptions || {}
-            );
+            return this._verifyWithConfigArray(textOrSourceCode, config, options);
         }
 
-        const preprocess = filenameOrOptions && filenameOrOptions.preprocess || (rawText => [rawText]);
-        const postprocess = filenameOrOptions && filenameOrOptions.postprocess || lodash.flatten;
-
-        return postprocess(
-            preprocess(textOrSourceCode).map(
-                textBlock => this._verifyWithoutProcessors(textBlock, config, filenameOrOptions)
-            )
-        );
+        /*
+         * `Linter` doesn't support `overrides` property in configuration.
+         * So we cannot apply multiple processors.
+         */
+        if (options.preprocess || options.postprocess) {
+            return this._verifyWithProcessor(textOrSourceCode, config, options);
+        }
+        return this._verifyWithoutProcessors(textOrSourceCode, config, options);
     }
 
     /**
      * Verify a given code with `ConfigArray`.
-     * @param {string} text The source code string.
+     * @param {string|SourceCode} textOrSourceCode The source code.
      * @param {ConfigArray} configArray The config array.
-     * @param {Object} providedOptions The options.
+     * @param {VerifyOptions&ProcessorOptions} options The options.
      * @returns {LintMessage[]} The found problems.
      */
-    _verifyWithConfigArray(text, configArray, providedOptions) {
-        debug("Verify with ConfigArray");
+    _verifyWithConfigArray(textOrSourceCode, configArray, options) {
+        debug("With ConfigArray: %s", options.filename);
 
         // Store the config array in order to get plugin envs and rules later.
         internalSlotsMap.get(this).lastConfigArray = configArray;
 
-        /*
-         * TODO: implement https://github.com/eslint/rfcs/tree/master/designs/2018-processors-improvements here.
-         */
-
         // Extract the final config for this file.
-        const config = configArray.extractConfig(providedOptions.filename);
+        const config = configArray.extractConfig(options.filename);
+        const processor =
+            config.processor &&
+            configArray.pluginProcessors.get(config.processor);
 
-        /*
-         * Convert "/path/to/<text>" to "<text>".
-         * `CLIEngine#executeOnText()` method gives "/path/to/<text>" if the
-         * filename was omitted because `configArray.extractConfig()` requires
-         * an absolute path. But linter should pass `<text>` to
-         * `RuleContext#getFilename()` in that case.
-         */
-        const filename = path.basename(providedOptions.filename) === "<text>"
-            ? "<text>"
-            : providedOptions.filename;
-
-        // Make options.
-        const options = {
-            ...providedOptions,
-            filename
-        };
+        // Verify.
+        if (processor) {
+            debug("Apply the processor: %o", config.processor);
+            const { preprocess, postprocess, supportsAutofix } = processor;
+            const disableFixes = options.disableFixes || !supportsAutofix;
 
-        // Apply processor.
-        if (config.processor) {
-            const processor = configArray.pluginProcessors.get(config.processor);
+            return this._verifyWithProcessor(
+                textOrSourceCode,
+                config,
+                { ...options, disableFixes, postprocess, preprocess },
+                configArray
+            );
+        }
+        return this._verifyWithoutProcessors(textOrSourceCode, config, options);
+    }
 
-            options.preprocess = processor.preprocess;
-            options.postprocess = processor.postprocess;
-            if (!processor.supportsAutofix) {
+    /**
+     * Verify with a processor.
+     * @param {string|SourceCode} textOrSourceCode The source code.
+     * @param {ConfigData|ExtractedConfig} config The config array.
+     * @param {VerifyOptions&ProcessorOptions} options The options.
+     * @param {ConfigArray} [configForRecursive] The `CofnigArray` object to apply multiple processors recursively.
+     * @returns {LintMessage[]} The found problems.
+     */
+    _verifyWithProcessor(textOrSourceCode, config, options, configForRecursive) {
+        const filename = options.filename || "<input>";
+        const filenameToExpose = normalizeFilename(filename);
+        const text = ensureText(textOrSourceCode);
+        const preprocess = options.preprocess || (rawText => [rawText]);
+        const postprocess = options.postprocess || lodash.flatten;
+        const filterCodeBlock =
+            options.filterCodeBlock ||
+            (blockFilename => blockFilename.endsWith(".js"));
+        const originalExtname = path.extname(filename);
+        const messageLists = preprocess(text, filenameToExpose).map((block, i) => {
+            debug("A code block was found: %o", block.filename || "(unnamed)");
+
+            // Keep the legacy behavior.
+            if (typeof block === "string") {
+                return this._verifyWithoutProcessors(block, config, options);
+            }
+
+            const blockText = block.text;
+            const blockName = path.join(filename, `${i}_${block.filename}`);
 
-                // Use `disableFixes` of https://github.com/eslint/rfcs/tree/master/designs/2018-processors-improvements
-                options.disableFixes = true;
+            // Skip this block if filtered.
+            if (!filterCodeBlock(blockName, blockText)) {
+                debug("This code block was skipped.");
+                return [];
             }
-        }
 
-        // Verify.
-        return this.verify(text, config, options);
+            // Resolve configuration again if the file extension was changed.
+            if (configForRecursive && path.extname(blockName) !== originalExtname) {
+                debug("Resolving configuration again because the file extension was changed.");
+                return this._verifyWithConfigArray(
+                    blockText,
+                    configForRecursive,
+                    { ...options, filename: blockName }
+                );
+            }
+
+            // Does lint.
+            return this._verifyWithoutProcessors(
+                blockText,
+                config,
+                { ...options, filename: blockName }
+            );
+        });
+
+        return postprocess(messageLists, filenameToExpose);
     }
 
     /**
@@ -1138,16 +1293,7 @@ class Linter {
      * have been applied.
      * @param {string} text The source text to apply fixes to.
      * @param {ConfigData|ConfigArray} config The ESLint config object to use.
-     * @param {Object} options The ESLint options object to use.
-     * @param {string} options.filename The filename from which the text was read.
-     * @param {boolean} options.allowInlineConfig Flag indicating if inline comments
-     *      should be allowed.
-     * @param {boolean|Function} options.fix Determines whether fixes should be applied
-     * @param {Function} options.preprocess preprocessor for source text. If provided, this should
-     *      accept a string of source text, and return an array of code blocks to lint.
-     * @param {Function} options.postprocess postprocessor for report messages. If provided,
-     *      this should accept an array of the message lists for each code block returned from the preprocessor,
-     *      apply a mapping to the messages as appropriate, and return a one-dimensional array of messages
+     * @param {VerifyOptions&ProcessorOptions&FixOptions} options The ESLint options object to use.
      * @returns {{fixed:boolean,messages:LintMessage[],output:string}} The result of the fix operation as returned from the
      *      SourceCodeFixer.
      */