eslint 6.6.0 → 6.8.0

package/lib/cli-engine/config-array/ignore-pattern.js

@@ -0,0 +1,231 @@
+/**
+ * @fileoverview `IgnorePattern` class.
+ *
+ * `IgnorePattern` class has the set of glob patterns and the base path.
+ *
+ * It provides two static methods.
+ *
+ * - `IgnorePattern.createDefaultIgnore(cwd)`
+ *      Create the default predicate function.
+ * - `IgnorePattern.createIgnore(ignorePatterns)`
+ *      Create the predicate function from multiple `IgnorePattern` objects.
+ *
+ * It provides two properties and a method.
+ *
+ * - `patterns`
+ *      The glob patterns that ignore to lint.
+ * - `basePath`
+ *      The base path of the glob patterns. If absolute paths existed in the
+ *      glob patterns, those are handled as relative paths to the base path.
+ * - `getPatternsRelativeTo(basePath)`
+ *      Get `patterns` as modified for a given base path. It modifies the
+ *      absolute paths in the patterns as prepending the difference of two base
+ *      paths.
+ *
+ * `ConfigArrayFactory` creates `IgnorePattern` objects when it processes
+ * `ignorePatterns` properties.
+ *
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const assert = require("assert");
+const path = require("path");
+const ignore = require("ignore");
+const debug = require("debug")("eslint:ignore-pattern");
+
+/** @typedef {ReturnType<import("ignore").default>} Ignore */
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Get the path to the common ancestor directory of given paths.
+ * @param {string[]} sourcePaths The paths to calculate the common ancestor.
+ * @returns {string} The path to the common ancestor directory.
+ */
+function getCommonAncestorPath(sourcePaths) {
+    let result = sourcePaths[0];
+
+    for (let i = 1; i < sourcePaths.length; ++i) {
+        const a = result;
+        const b = sourcePaths[i];
+
+        // Set the shorter one (it's the common ancestor if one includes the other).
+        result = a.length < b.length ? a : b;
+
+        // Set the common ancestor.
+        for (let j = 0, lastSepPos = 0; j < a.length && j < b.length; ++j) {
+            if (a[j] !== b[j]) {
+                result = a.slice(0, lastSepPos);
+                break;
+            }
+            if (a[j] === path.sep) {
+                lastSepPos = j;
+            }
+        }
+    }
+
+    return result || path.sep;
+}
+
+/**
+ * Make relative path.
+ * @param {string} from The source path to get relative path.
+ * @param {string} to The destination path to get relative path.
+ * @returns {string} The relative path.
+ */
+function relative(from, to) {
+    const relPath = path.relative(from, to);
+
+    if (path.sep === "/") {
+        return relPath;
+    }
+    return relPath.split(path.sep).join("/");
+}
+
+/**
+ * Get the trailing slash if existed.
+ * @param {string} filePath The path to check.
+ * @returns {string} The trailing slash if existed.
+ */
+function dirSuffix(filePath) {
+    const isDir = (
+        filePath.endsWith(path.sep) ||
+        (process.platform === "win32" && filePath.endsWith("/"))
+    );
+
+    return isDir ? "/" : "";
+}
+
+const DefaultPatterns = Object.freeze(["/node_modules/*", "/bower_components/*"]);
+const DotPatterns = Object.freeze([".*", "!../"]);
+
+//------------------------------------------------------------------------------
+// Public
+//------------------------------------------------------------------------------
+
+class IgnorePattern {
+
+    /**
+     * The default patterns.
+     * @type {string[]}
+     */
+    static get DefaultPatterns() {
+        return DefaultPatterns;
+    }
+
+    /**
+     * Create the default predicate function.
+     * @param {string} cwd The current working directory.
+     * @returns {((filePath:string, dot:boolean) => boolean) & {basePath:string; patterns:string[]}}
+     * The preficate function.
+     * The first argument is an absolute path that is checked.
+     * The second argument is the flag to not ignore dotfiles.
+     * If the predicate function returned `true`, it means the path should be ignored.
+     */
+    static createDefaultIgnore(cwd) {
+        return this.createIgnore([new IgnorePattern(DefaultPatterns, cwd)]);
+    }
+
+    /**
+     * Create the predicate function from multiple `IgnorePattern` objects.
+     * @param {IgnorePattern[]} ignorePatterns The list of ignore patterns.
+     * @returns {((filePath:string, dot?:boolean) => boolean) & {basePath:string; patterns:string[]}}
+     * The preficate function.
+     * The first argument is an absolute path that is checked.
+     * The second argument is the flag to not ignore dotfiles.
+     * If the predicate function returned `true`, it means the path should be ignored.
+     */
+    static createIgnore(ignorePatterns) {
+        debug("Create with: %o", ignorePatterns);
+
+        const basePath = getCommonAncestorPath(ignorePatterns.map(p => p.basePath));
+        const patterns = [].concat(
+            ...ignorePatterns.map(p => p.getPatternsRelativeTo(basePath))
+        );
+        const ig = ignore().add([...DotPatterns, ...patterns]);
+        const dotIg = ignore().add(patterns);
+
+        debug("  processed: %o", { basePath, patterns });
+
+        return Object.assign(
+            (filePath, dot = false) => {
+                assert(path.isAbsolute(filePath), "'filePath' should be an absolute path.");
+                const relPathRaw = relative(basePath, filePath);
+                const relPath = relPathRaw && (relPathRaw + dirSuffix(filePath));
+                const adoptedIg = dot ? dotIg : ig;
+                const result = relPath !== "" && adoptedIg.ignores(relPath);
+
+                debug("Check", { filePath, dot, relativePath: relPath, result });
+                return result;
+            },
+            { basePath, patterns }
+        );
+    }
+
+    /**
+     * Initialize a new `IgnorePattern` instance.
+     * @param {string[]} patterns The glob patterns that ignore to lint.
+     * @param {string} basePath The base path of `patterns`.
+     */
+    constructor(patterns, basePath) {
+        assert(path.isAbsolute(basePath), "'basePath' should be an absolute path.");
+
+        /**
+         * The glob patterns that ignore to lint.
+         * @type {string[]}
+         */
+        this.patterns = patterns;
+
+        /**
+         * The base path of `patterns`.
+         * @type {string}
+         */
+        this.basePath = basePath;
+
+        /**
+         * If `true` then patterns which don't start with `/` will match the paths to the outside of `basePath`. Defaults to `false`.
+         *
+         * It's set `true` for `.eslintignore`, `package.json`, and `--ignore-path` for backward compatibility.
+         * It's `false` as-is for `ignorePatterns` property in config files.
+         * @type {boolean}
+         */
+        this.loose = false;
+    }
+
+    /**
+     * Get `patterns` as modified for a given base path. It modifies the
+     * absolute paths in the patterns as prepending the difference of two base
+     * paths.
+     * @param {string} newBasePath The base path.
+     * @returns {string[]} Modifired patterns.
+     */
+    getPatternsRelativeTo(newBasePath) {
+        assert(path.isAbsolute(newBasePath), "'newBasePath' should be an absolute path.");
+        const { basePath, loose, patterns } = this;
+
+        if (newBasePath === basePath) {
+            return patterns;
+        }
+        const prefix = `/${relative(newBasePath, basePath)}`;
+
+        return patterns.map(pattern => {
+            const negative = pattern.startsWith("!");
+            const head = negative ? "!" : "";
+            const body = negative ? pattern.slice(1) : pattern;
+
+            if (body.startsWith("/") || body.startsWith("../")) {
+                return `${head}${prefix}${body}`;
+            }
+            return loose ? pattern : `${head}${prefix}/**/${body}`;
+        });
+    }
+}
+
+module.exports = { IgnorePattern };

package/lib/cli-engine/config-array/index.js

@@ -7,12 +7,14 @@
 const { ConfigArray, getUsedExtractedConfigs } = require("./config-array");
 const { ConfigDependency } = require("./config-dependency");
 const { ExtractedConfig } = require("./extracted-config");
+const { IgnorePattern } = require("./ignore-pattern");
 const { OverrideTester } = require("./override-tester");
 
 module.exports = {
     ConfigArray,
     ConfigDependency,
     ExtractedConfig,
+    IgnorePattern,
     OverrideTester,
     getUsedExtractedConfigs
 };

package/lib/cli-engine/config-array-factory.js

@@ -17,6 +17,12 @@
  *     Create a `ConfigArray` instance from a config file which is on a given
  *     directory. This tries to load `.eslintrc.*` or `package.json`. If not
  *     found, returns an empty `ConfigArray`.
+ * - `loadESLintIgnore(filePath)`
+ *     Create a `ConfigArray` instance from a config file that is `.eslintignore`
+ *     format. This is to handle `--ignore-path` option.
+ * - `loadDefaultESLintIgnore()`
+ *     Create a `ConfigArray` instance from `.eslintignore` or `package.json` in
+ *     the current working directory.
  *
  * `ConfigArrayFactory` class has the responsibility that loads configuration
  * files, including loading `extends`, `parser`, and `plugins`. The created
@@ -40,7 +46,12 @@ const stripComments = require("strip-json-comments");
 const { validateConfigSchema } = require("../shared/config-validator");
 const naming = require("../shared/naming");
 const ModuleResolver = require("../shared/relative-module-resolver");
-const { ConfigArray, ConfigDependency, OverrideTester } = require("./config-array");
+const {
+    ConfigArray,
+    ConfigDependency,
+    IgnorePattern,
+    OverrideTester
+} = require("./config-array");
 const debug = require("debug")("eslint:config-array-factory");
 
 //------------------------------------------------------------------------------
@@ -51,6 +62,7 @@ const eslintRecommendedPath = path.resolve(__dirname, "../../conf/eslint-recomme
 const eslintAllPath = path.resolve(__dirname, "../../conf/eslint-all.js");
 const configFilenames = [
     ".eslintrc.js",
+    ".eslintrc.cjs",
     ".eslintrc.yaml",
     ".eslintrc.yml",
     ".eslintrc.json",
@@ -221,6 +233,26 @@ function loadPackageJSONConfigFile(filePath) {
     }
 }
 
+/**
+ * Loads a `.eslintignore` from a file.
+ * @param {string} filePath The filename to load.
+ * @returns {string[]} The ignore patterns from the file.
+ * @private
+ */
+function loadESLintIgnoreFile(filePath) {
+    debug(`Loading .eslintignore file: ${filePath}`);
+
+    try {
+        return readFile(filePath)
+            .split(/\r?\n/gu)
+            .filter(line => line.trim() !== "" && !line.startsWith("#"));
+    } catch (e) {
+        debug(`Error reading .eslintignore file: ${filePath}`);
+        e.message = `Cannot read .eslintignore file: ${filePath}\nError: ${e.message}`;
+        throw e;
+    }
+}
+
 /**
  * Creates an error to notify about a missing config to extend from.
  * @param {string} configName The name of the missing config.
@@ -248,6 +280,7 @@ function configMissingError(configName, importerName) {
 function loadConfigFile(filePath) {
     switch (path.extname(filePath)) {
         case ".js":
+        case ".cjs":
             return loadJSConfigFile(filePath);
 
         case ".json":
@@ -403,6 +436,54 @@ class ConfigArrayFactory {
         );
     }
 
+    /**
+     * Load `.eslintignore` file.
+     * @param {string} filePath The path to a `.eslintignore` file to load.
+     * @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
+     */
+    loadESLintIgnore(filePath) {
+        const { cwd } = internalSlotsMap.get(this);
+        const absolutePath = path.resolve(cwd, filePath);
+        const name = path.relative(cwd, absolutePath);
+        const ignorePatterns = loadESLintIgnoreFile(absolutePath);
+
+        return createConfigArray(
+            this._normalizeESLintIgnoreData(ignorePatterns, absolutePath, name)
+        );
+    }
+
+    /**
+     * Load `.eslintignore` file in the current working directory.
+     * @returns {ConfigArray} Loaded config. An empty `ConfigArray` if any config doesn't exist.
+     */
+    loadDefaultESLintIgnore() {
+        const { cwd } = internalSlotsMap.get(this);
+        const eslintIgnorePath = path.resolve(cwd, ".eslintignore");
+        const packageJsonPath = path.resolve(cwd, "package.json");
+
+        if (fs.existsSync(eslintIgnorePath)) {
+            return this.loadESLintIgnore(eslintIgnorePath);
+        }
+        if (fs.existsSync(packageJsonPath)) {
+            const data = loadJSONConfigFile(packageJsonPath);
+
+            if (Object.hasOwnProperty.call(data, "eslintIgnore")) {
+                if (!Array.isArray(data.eslintIgnore)) {
+                    throw new Error("Package.json eslintIgnore property requires an array of paths");
+                }
+                return createConfigArray(
+                    this._normalizeESLintIgnoreData(
+                        data.eslintIgnore,
+                        packageJsonPath,
+                        "eslintIgnore in package.json"
+                    )
+                );
+            }
+        }
+
+        return new ConfigArray();
+    }
+
     /**
      * Load a given config file.
      * @param {string} filePath The path to a config file.
@@ -451,6 +532,30 @@ class ConfigArrayFactory {
         return null;
     }
 
+    /**
+     * Normalize a given `.eslintignore` data to config array elements.
+     * @param {string[]} ignorePatterns The patterns to ignore files.
+     * @param {string|undefined} filePath The file path of this config.
+     * @param {string|undefined} name The name of this config.
+     * @returns {IterableIterator<ConfigArrayElement>} The normalized config.
+     * @private
+     */
+    *_normalizeESLintIgnoreData(ignorePatterns, filePath, name) {
+        const elements = this._normalizeObjectConfigData(
+            { ignorePatterns },
+            filePath,
+            name
+        );
+
+        // Set `ignorePattern.loose` flag for backward compatibility.
+        for (const element of elements) {
+            if (element.ignorePattern) {
+                element.ignorePattern.loose = true;
+            }
+            yield element;
+        }
+    }
+
     /**
      * Normalize a given config to an array.
      * @param {ConfigData} configData The config data to normalize.
@@ -494,6 +599,9 @@ class ConfigArrayFactory {
             if (element.criteria) {
                 element.criteria.basePath = basePath;
             }
+            if (element.ignorePattern) {
+                element.ignorePattern.basePath = basePath;
+            }
 
             /*
              * Merge the criteria; this is for only file extension processors in
@@ -526,6 +634,7 @@ class ConfigArrayFactory {
             env,
             extends: extend,
             globals,
+            ignorePatterns,
             noInlineConfig,
             parser: parserName,
             parserOptions,
@@ -541,6 +650,10 @@ class ConfigArrayFactory {
         name
     ) {
         const extendList = Array.isArray(extend) ? extend : [extend];
+        const ignorePattern = ignorePatterns && new IgnorePattern(
+            Array.isArray(ignorePatterns) ? ignorePatterns : [ignorePatterns],
+            filePath ? path.dirname(filePath) : internalSlotsMap.get(this).cwd
+        );
 
         // Flatten `extends`.
         for (const extendName of extendList.filter(Boolean)) {
@@ -569,6 +682,7 @@ class ConfigArrayFactory {
             criteria: null,
             env,
             globals,
+            ignorePattern,
             noInlineConfig,
             parser,
             parserOptions,

package/lib/cli-engine/file-enumerator.js

@@ -40,8 +40,8 @@ const getGlobParent = require("glob-parent");
 const isGlob = require("is-glob");
 const { escapeRegExp } = require("lodash");
 const { Minimatch } = require("minimatch");
+const { IgnorePattern } = require("./config-array");
 const { CascadingConfigArrayFactory } = require("./cascading-config-array-factory");
-const { IgnoredPaths } = require("./ignored-paths");
 const debug = require("debug")("eslint:file-enumerator");
 
 //------------------------------------------------------------------------------
@@ -64,7 +64,6 @@ const IGNORED = 2;
  * @property {string[]} [extensions] The extensions to match files for directory patterns.
  * @property {boolean} [globInputPaths] Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.
  * @property {boolean} [ignore] The flag to check ignored files.
- * @property {IgnoredPaths} [ignoredPaths] The ignored paths.
  * @property {string[]} [rulePaths] The value of `--rulesdir` option.
  */
 
@@ -92,8 +91,7 @@ const IGNORED = 2;
  * @property {RegExp} extensionRegExp The RegExp to test if a string ends with specific file extensions.
  * @property {boolean} globInputPaths Set to false to skip glob resolution of input file paths to lint (default: true). If false, each input file paths is assumed to be a non-glob path to an existing file.
  * @property {boolean} ignoreFlag The flag to check ignored files.
- * @property {IgnoredPaths} ignoredPathsWithDotfiles The ignored paths but don't include dot files.
- * @property {IgnoredPaths} ignoredPaths The ignored paths.
+ * @property {(filePath:string, dot:boolean) => boolean} defaultIgnores The default predicate function to ignore files.
  */
 
 /** @type {WeakMap<FileEnumerator, FileEnumeratorInternalSlots>} */
@@ -192,12 +190,13 @@ class FileEnumerator {
         configArrayFactory = new CascadingConfigArrayFactory({ cwd }),
         extensions = [".js"],
         globInputPaths = true,
-        ignore = true,
-        ignoredPaths = new IgnoredPaths({ cwd, ignore })
+        errorOnUnmatchedPattern = true,
+        ignore = true
     } = {}) {
         internalSlotsMap.set(this, {
             configArrayFactory,
             cwd,
+            defaultIgnores: IgnorePattern.createDefaultIgnore(cwd),
             extensionRegExp: new RegExp(
                 `.\\.(?:${extensions
                     .map(ext => escapeRegExp(
@@ -210,12 +209,8 @@ class FileEnumerator {
                 "u"
             ),
             globInputPaths,
-            ignoreFlag: ignore,
-            ignoredPaths,
-            ignoredPathsWithDotfiles: new IgnoredPaths({
-                ...ignoredPaths.options,
-                dotfiles: true
-            })
+            errorOnUnmatchedPattern,
+            ignoreFlag: ignore
         });
     }
 
@@ -233,7 +228,7 @@ class FileEnumerator {
      * @returns {IterableIterator<FileAndConfig>} The found files.
      */
     *iterateFiles(patternOrPatterns) {
-        const { globInputPaths } = internalSlotsMap.get(this);
+        const { globInputPaths, errorOnUnmatchedPattern } = internalSlotsMap.get(this);
         const patterns = Array.isArray(patternOrPatterns)
             ? patternOrPatterns
             : [patternOrPatterns];
@@ -272,14 +267,16 @@ class FileEnumerator {
             }
 
             // Raise an error if any files were not found.
-            if (!foundRegardlessOfIgnored) {
-                throw new NoFilesFoundError(
-                    pattern,
-                    !globInputPaths && isGlob(pattern)
-                );
-            }
-            if (!found) {
-                throw new AllFilesIgnoredError(pattern);
+            if (errorOnUnmatchedPattern) {
+                if (!foundRegardlessOfIgnored) {
+                    throw new NoFilesFoundError(
+                        pattern,
+                        !globInputPaths && isGlob(pattern)
+                    );
+                }
+                if (!found) {
+                    throw new AllFilesIgnoredError(pattern);
+                }
             }
         }
 
@@ -321,7 +318,7 @@ class FileEnumerator {
 
         const { configArrayFactory } = internalSlotsMap.get(this);
         const config = configArrayFactory.getConfigArrayForFile(filePath);
-        const ignored = this._isIgnoredFile(filePath, { direct: true });
+        const ignored = this._isIgnoredFile(filePath, { config, direct: true });
         const flag = ignored ? IGNORED : NONE;
 
         return [{ config, filePath, flag }];
@@ -353,7 +350,7 @@ class FileEnumerator {
     _iterateFilesWithGlob(pattern, dotfiles) {
         debug(`Glob: ${pattern}`);
 
-        const directoryPath = getGlobParent(pattern);
+        const directoryPath = path.resolve(getGlobParent(pattern));
         const globPart = pattern.slice(directoryPath.length + 1);
 
         /*
@@ -382,9 +379,6 @@ class FileEnumerator {
      * @private
      */
     *_iterateFilesRecursive(directoryPath, options) {
-        if (this._isIgnoredFile(directoryPath + path.sep, options)) {
-            return;
-        }
         debug(`Enter the directory: ${directoryPath}`);
         const { configArrayFactory, extensionRegExp } = internalSlotsMap.get(this);
 
@@ -399,9 +393,18 @@ class FileEnumerator {
             // Check if the file is matched.
             if (stat && stat.isFile()) {
                 if (!config) {
-                    config = configArrayFactory.getConfigArrayForFile(filePath);
+                    config = configArrayFactory.getConfigArrayForFile(
+                        filePath,
+
+                        /*
+                         * We must ignore `ConfigurationNotFoundError` at this
+                         * point because we don't know if target files exist in
+                         * this directory.
+                         */
+                        { ignoreNotFoundError: true }
+                    );
                 }
-                const ignored = this._isIgnoredFile(filePath, options);
+                const ignored = this._isIgnoredFile(filePath, { ...options, config });
                 const flag = ignored ? IGNORED_SILENTLY : NONE;
                 const matched = options.selector
 
@@ -413,14 +416,31 @@ class FileEnumerator {
 
                 if (matched) {
                     debug(`Yield: ${filename}${ignored ? " but ignored" : ""}`);
-                    yield { config, filePath, flag };
+                    yield {
+                        config: configArrayFactory.getConfigArrayForFile(filePath),
+                        filePath,
+                        flag
+                    };
                 } else {
                     debug(`Didn't match: ${filename}`);
                 }
 
             // Dive into the sub directory.
             } else if (options.recursive && stat && stat.isDirectory()) {
-                yield* this._iterateFilesRecursive(filePath, options);
+                if (!config) {
+                    config = configArrayFactory.getConfigArrayForFile(
+                        filePath,
+                        { ignoreNotFoundError: true }
+                    );
+                }
+                const ignored = this._isIgnoredFile(
+                    filePath + path.sep,
+                    { ...options, config }
+                );
+
+                if (!ignored) {
+                    yield* this._iterateFilesRecursive(filePath, options);
+                }
             }
         }
 
@@ -431,24 +451,37 @@ class FileEnumerator {
      * Check if a given file should be ignored.
      * @param {string} filePath The path to a file to check.
      * @param {Object} options Options
+     * @param {ConfigArray} [options.config] The config for this file.
      * @param {boolean} [options.dotfiles] If `true` then this is not ignore dot files by default.
      * @param {boolean} [options.direct] If `true` then this is a direct specified file.
      * @returns {boolean} `true` if the file should be ignored.
      * @private
      */
-    _isIgnoredFile(filePath, { dotfiles = false, direct = false }) {
+    _isIgnoredFile(filePath, {
+        config: providedConfig,
+        dotfiles = false,
+        direct = false
+    }) {
         const {
-            ignoreFlag,
-            ignoredPaths,
-            ignoredPathsWithDotfiles
+            configArrayFactory,
+            defaultIgnores,
+            ignoreFlag
         } = internalSlotsMap.get(this);
-        const adoptedIgnoredPaths = dotfiles
-            ? ignoredPathsWithDotfiles
-            : ignoredPaths;
 
-        return ignoreFlag
-            ? adoptedIgnoredPaths.contains(filePath)
-            : (!direct && adoptedIgnoredPaths.contains(filePath, "default"));
+        if (ignoreFlag) {
+            const config =
+                providedConfig ||
+                configArrayFactory.getConfigArrayForFile(
+                    filePath,
+                    { ignoreNotFoundError: true }
+                );
+            const ignores =
+                config.extractConfig(filePath).ignores || defaultIgnores;
+
+            return ignores(filePath, dotfiles);
+        }
+
+        return !direct && defaultIgnores(filePath, dotfiles);
     }
 }
 

package/lib/cli-engine/lint-result-cache.js

@@ -20,6 +20,7 @@ const hash = require("./hash");
 //-----------------------------------------------------------------------------
 
 const configHashCache = new WeakMap();
+const nodeVersion = process && process.version;
 
 /**
  * Calculates the hash of the config
@@ -28,7 +29,7 @@ const configHashCache = new WeakMap();
  */
 function hashOfConfigFor(config) {
     if (!configHashCache.has(config)) {
-        configHashCache.set(config, hash(`${pkg.version}_${stringify(config)}`));
+        configHashCache.set(config, hash(`${pkg.version}_${nodeVersion}_${stringify(config)}`));
     }
 
     return configHashCache.get(config);

package/lib/cli.js

@@ -68,7 +68,8 @@ function translateOptions(cliOptions) {
         fixTypes: cliOptions.fixType,
         allowInlineConfig: cliOptions.inlineConfig,
         reportUnusedDisableDirectives: cliOptions.reportUnusedDisableDirectives,
-        resolvePluginsRelativeTo: cliOptions.resolvePluginsRelativeTo
+        resolvePluginsRelativeTo: cliOptions.resolvePluginsRelativeTo,
+        errorOnUnmatchedPattern: cliOptions.errorOnUnmatchedPattern
     };
 }