eslint 4.5.0 → 4.7.1

package/lib/linter.js

@@ -9,21 +9,21 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const assert = require("assert"),
-    EventEmitter = require("events").EventEmitter,
+const EventEmitter = require("events").EventEmitter,
     eslintScope = require("eslint-scope"),
     levn = require("levn"),
+    lodash = require("lodash"),
     blankScriptAST = require("../conf/blank-script.json"),
     defaultConfig = require("../conf/default-config-options.js"),
-    replacements = require("../conf/replacements.json"),
     CodePathAnalyzer = require("./code-path-analysis/code-path-analyzer"),
     ConfigOps = require("./config/config-ops"),
     validator = require("./config/config-validator"),
     Environments = require("./config/environments"),
+    applyDisableDirectives = require("./util/apply-disable-directives"),
     NodeEventGenerator = require("./util/node-event-generator"),
     SourceCode = require("./util/source-code"),
     Traverser = require("./util/traverser"),
-    RuleContext = require("./rule-context"),
+    createReportTranslator = require("./report-translator"),
     Rules = require("./rules"),
     timing = require("./timing"),
     astUtils = require("./ast-utils"),
@@ -87,10 +87,9 @@ function parseBooleanConfig(string, comment) {
  * Parses a JSON-like config.
  * @param {string} string The string to parse.
  * @param {Object} location Start line and column of comments for potential error message.
- * @param {Object[]} messages The messages queue for potential error message.
- * @returns {Object} Result map object
+ * @returns {({success: true, config: Object}|{success: false, error: Problem})} Result map object
  */
-function parseJsonConfig(string, location, messages) {
+function parseJsonConfig(string, location) {
     let items = {};
 
     // Parses a JSON-like comment by the same way as parsing CLI option.
@@ -102,7 +101,10 @@ function parseJsonConfig(string, location, messages) {
         //     "no-alert: 2 no-console: 2" --> {"no-alert": "2 no-console: 2"}
         // Should ignore that case as well.
         if (ConfigOps.isEverySeverityValid(items)) {
-            return items;
+            return {
+                success: true,
+                config: items
+            };
         }
     } catch (ex) {
 
@@ -116,20 +118,25 @@ function parseJsonConfig(string, location, messages) {
     try {
         items = JSON.parse(`{${string}}`);
     } catch (ex) {
-
-        messages.push({
-            ruleId: null,
-            fatal: true,
-            severity: 2,
-            source: null,
-            message: `Failed to parse JSON from '${string}': ${ex.message}`,
-            line: location.start.line,
-            column: location.start.column + 1
-        });
+        return {
+            success: false,
+            error: {
+                ruleId: null,
+                fatal: true,
+                severity: 2,
+                source: null,
+                message: `Failed to parse JSON from '${string}': ${ex.message}`,
+                line: location.start.line,
+                column: location.start.column + 1
+            }
+        };
 
     }
 
-    return items;
+    return {
+        success: true,
+        config: items
+    };
 }
 
 /**
@@ -171,14 +178,12 @@ function addDeclaredGlobals(program, globalScope, config, envContext) {
 
     Object.assign(declaredGlobals, builtin);
 
-    Object.keys(config.env).forEach(name => {
-        if (config.env[name]) {
-            const env = envContext.get(name),
-                environmentGlobals = env && env.globals;
+    Object.keys(config.env).filter(name => config.env[name]).forEach(name => {
+        const env = envContext.get(name),
+            environmentGlobals = env && env.globals;
 
-            if (environmentGlobals) {
-                Object.assign(declaredGlobals, environmentGlobals);
-            }
+        if (environmentGlobals) {
+            Object.assign(declaredGlobals, environmentGlobals);
         }
     });
 
@@ -246,68 +251,23 @@ function addDeclaredGlobals(program, globalScope, config, envContext) {
 }
 
 /**
- * Add data to reporting configuration to disable reporting for list of rules
- * starting from start location
- * @param  {Object[]} reportingConfig Current reporting configuration
- * @param  {Object} start Position to start
- * @param  {string[]} rulesToDisable List of rules
- * @returns {void}
- */
-function disableReporting(reportingConfig, start, rulesToDisable) {
-
-    if (rulesToDisable.length) {
-        rulesToDisable.forEach(rule => {
-            reportingConfig.push({
-                start,
-                end: null,
-                rule
-            });
-        });
-    } else {
-        reportingConfig.push({
-            start,
-            end: null,
-            rule: null
-        });
-    }
-}
-
-/**
- * Add data to reporting configuration to enable reporting for list of rules
- * starting from start location
- * @param  {Object[]} reportingConfig Current reporting configuration
- * @param  {Object} start Position to start
- * @param  {string[]} rulesToEnable List of rules
- * @returns {void}
+ * 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
+ * comment specified no specific rules, so it applies to all rules (e.g. `eslint-disable`)
+ * @returns {{
+ *     type: ("disable"|"enable"|"disable-line"|"disable-next-line"),
+ *     line: number,
+ *     column: number,
+ *     ruleId: (string|null)
+ * }[]} Directives from the comment
  */
-function enableReporting(reportingConfig, start, rulesToEnable) {
-    let i;
-
-    if (rulesToEnable.length) {
-        rulesToEnable.forEach(rule => {
-            for (i = reportingConfig.length - 1; i >= 0; i--) {
-                if (!reportingConfig[i].end && reportingConfig[i].rule === rule) {
-                    reportingConfig[i].end = start;
-                    break;
-                }
-            }
-        });
-    } else {
-
-        // find all previous disabled locations if they was started as list of rules
-        let prevStart;
-
-        for (i = reportingConfig.length - 1; i >= 0; i--) {
-            if (prevStart && prevStart !== reportingConfig[i].start) {
-                break;
-            }
+function createDisableDirectives(type, loc, value) {
+    const ruleIds = Object.keys(parseListConfig(value));
+    const directiveRules = ruleIds.length ? ruleIds : [null];
 
-            if (!reportingConfig[i].end) {
-                reportingConfig[i].end = start;
-                prevStart = reportingConfig[i].start;
-            }
-        }
-    }
+    return directiveRules.map(ruleId => ({ type, line: loc.line, column: loc.column + 1, ruleId }));
 }
 
 /**
@@ -318,7 +278,17 @@ function enableReporting(reportingConfig, start, rulesToEnable) {
  * @param {ASTNode} ast The top node of the AST.
  * @param {Object} config The existing configuration data.
  * @param {Linter} linterContext Linter context object
- * @returns {Object} Modified config object
+ * @returns {{
+ *      config: Object,
+ *      problems: Problem[],
+ *      disableDirectives: {
+ *          type: ("disable"|"enable"|"disable-line"|"disable-next-line"),
+ *          line: number,
+ *          column: number,
+ *          ruleId: (string|null)
+ *      }[]
+ * }} Modified config object, along with any problems encountered
+ * while parsing config comments
  */
 function modifyConfigsFromComments(filename, ast, config, linterContext) {
 
@@ -329,10 +299,10 @@ function modifyConfigsFromComments(filename, ast, config, linterContext) {
         env: {}
     };
     const commentRules = {};
-    const messages = linterContext.messages;
-    const reportingConfig = linterContext.reportingConfig;
+    const problems = [];
+    const disableDirectives = [];
 
-    ast.comments.forEach(comment => {
+    ast.comments.filter(token => token.type !== "Shebang").forEach(comment => {
 
         let value = comment.value.trim();
         const match = /^(eslint(-\w+){0,3}|exported|globals?)(\s|$)/.exec(value);
@@ -356,22 +326,27 @@ function modifyConfigsFromComments(filename, ast, config, linterContext) {
                         break;
 
                     case "eslint-disable":
-                        disableReporting(reportingConfig, comment.loc.start, Object.keys(parseListConfig(value)));
+                        [].push.apply(disableDirectives, createDisableDirectives("disable", comment.loc.start, value));
                         break;
 
                     case "eslint-enable":
-                        enableReporting(reportingConfig, comment.loc.start, Object.keys(parseListConfig(value)));
+                        [].push.apply(disableDirectives, createDisableDirectives("enable", comment.loc.start, value));
                         break;
 
                     case "eslint": {
-                        const items = parseJsonConfig(value, comment.loc, messages);
+                        const parseResult = parseJsonConfig(value, comment.loc);
+
+                        if (parseResult.success) {
+                            Object.keys(parseResult.config).forEach(name => {
+                                const ruleValue = parseResult.config[name];
 
-                        Object.keys(items).forEach(name => {
-                            const ruleValue = items[name];
+                                validator.validateRuleOptions(name, ruleValue, `${filename} line ${comment.loc.start.line}`, linterContext.rules);
+                                commentRules[name] = ruleValue;
+                            });
+                        } else {
+                            problems.push(parseResult.error);
+                        }
 
-                            validator.validateRuleOptions(name, ruleValue, `${filename} line ${comment.loc.start.line}`, linterContext.rules);
-                            commentRules[name] = ruleValue;
-                        });
                         break;
                     }
 
@@ -379,11 +354,9 @@ function modifyConfigsFromComments(filename, ast, config, linterContext) {
                 }
             } else { // comment.type === "Line"
                 if (match[1] === "eslint-disable-line") {
-                    disableReporting(reportingConfig, { line: comment.loc.start.line, column: 0 }, Object.keys(parseListConfig(value)));
-                    enableReporting(reportingConfig, comment.loc.end, Object.keys(parseListConfig(value)));
+                    [].push.apply(disableDirectives, createDisableDirectives("disable-line", comment.loc.start, value));
                 } else if (match[1] === "eslint-disable-next-line") {
-                    disableReporting(reportingConfig, comment.loc.start, Object.keys(parseListConfig(value)));
-                    enableReporting(reportingConfig, { line: comment.loc.start.line + 2 }, Object.keys(parseListConfig(value)));
+                    [].push.apply(disableDirectives, createDisableDirectives("disable-next-line", comment.loc.start, value));
                 }
             }
         }
@@ -399,30 +372,11 @@ function modifyConfigsFromComments(filename, ast, config, linterContext) {
     });
     Object.assign(commentConfig.rules, commentRules);
 
-    return ConfigOps.merge(config, commentConfig);
-}
-
-/**
- * Check if message of rule with ruleId should be ignored in location
- * @param  {Object[]} reportingConfig  Collection of ignore records
- * @param  {string} ruleId   Id of rule
- * @param  {Object} location Location of message
- * @returns {boolean}          True if message should be ignored, false otherwise
- */
-function isDisabledByReportingConfig(reportingConfig, ruleId, location) {
-
-    for (let i = 0, c = reportingConfig.length; i < c; i++) {
-
-        const ignore = reportingConfig[i];
-
-        if ((!ignore.rule || ignore.rule === ruleId) &&
-            (location.line > ignore.start.line || (location.line === ignore.start.line && location.column >= ignore.start.column)) &&
-            (!ignore.end || (location.line < ignore.end.line || (location.line === ignore.end.line && location.column <= ignore.end.column)))) {
-            return true;
-        }
-    }
-
-    return false;
+    return {
+        config: ConfigOps.merge(config, commentConfig),
+        problems,
+        disableDirectives
+    };
 }
 
 /**
@@ -505,51 +459,6 @@ function prepareConfig(config, envContext) {
     return preparedConfig;
 }
 
-/**
- * Provide a stub rule with a given message
- * @param  {string} message The message to be displayed for the rule
- * @returns {Function}      Stub rule function
- */
-function createStubRule(message) {
-
-    /**
-     * Creates a fake rule object
-     * @param {Object} context context object for each rule
-     * @returns {Object} collection of node to listen on
-     */
-    function createRuleModule(context) {
-        return {
-            Program() {
-                context.report({
-                    loc: { line: 1, column: 0 },
-                    message
-                });
-            }
-        };
-    }
-
-    if (message) {
-        return createRuleModule;
-    }
-    throw new Error("No message passed to stub rule");
-
-}
-
-/**
- * Provide a rule replacement message
- * @param  {string} ruleId Name of the rule
- * @returns {string}       Message detailing rule replacement
- */
-function getRuleReplacementMessage(ruleId) {
-    if (ruleId in replacements.rules) {
-        const newRules = replacements.rules[ruleId];
-
-        return `Rule '${ruleId}' was removed and replaced by: ${newRules.join(", ")}`;
-    }
-
-    return null;
-}
-
 const eslintEnvPattern = /\/\*\s*eslint-env\s(.+?)\*\//g;
 
 /**
@@ -588,22 +497,6 @@ function stripUnicodeBOM(text) {
     return text;
 }
 
-/**
- * Get the severity level of a rule (0 - none, 1 - warning, 2 - error)
- * Returns 0 if the rule config is not valid (an Array or a number)
- * @param {Array|number} ruleConfig rule configuration
- * @returns {number} 0, 1, or 2, indicating rule severity
- */
-function getRuleSeverity(ruleConfig) {
-    if (typeof ruleConfig === "number") {
-        return ruleConfig;
-    } else if (Array.isArray(ruleConfig)) {
-        return ruleConfig[0];
-    }
-    return 0;
-
-}
-
 /**
  * Get the options for a rule (not including severity), if any
  * @param {Array|number} ruleConfig rule configuration
@@ -622,45 +515,41 @@ function getRuleOptions(ruleConfig) {
  * optimization of functions, so it's best to keep the try-catch as isolated
  * as possible
  * @param {string} text The text to parse.
- * @param {Object} config The ESLint configuration object.
+ * @param {Object} providedParserOptions Options to pass to the parser
+ * @param {string} parserName The name of the parser
  * @param {string} filePath The path to the file being parsed.
- * @returns {ASTNode|CustomParseResult} The AST or parse result if successful,
- *      or null if not.
- * @param {Array<Object>} messages Messages array for the linter object
- * @returns {*} parsed text if successful otherwise null
+ * @returns {{success: false, error: Problem}|{success: true,ast: ASTNode, services: Object}}
+ * An object containing the AST and parser services if parsing was successful, or the error if parsing failed
  * @private
  */
-function parse(text, config, filePath, messages) {
-
-    let parser,
-        parserOptions = {
-            loc: true,
-            range: true,
-            raw: true,
-            tokens: true,
-            comment: true,
-            filePath
-        };
+function parse(text, providedParserOptions, parserName, filePath) {
+
+    const parserOptions = Object.assign({}, providedParserOptions, {
+        loc: true,
+        range: true,
+        raw: true,
+        tokens: true,
+        comment: true,
+        filePath
+    });
+
+    let parser;
 
     try {
-        parser = require(config.parser);
+        parser = require(parserName);
     } catch (ex) {
-        messages.push({
-            ruleId: null,
-            fatal: true,
-            severity: 2,
-            source: null,
-            message: ex.message,
-            line: 0,
-            column: 0
-        });
-
-        return null;
-    }
-
-    // merge in any additional parser options
-    if (config.parserOptions) {
-        parserOptions = Object.assign({}, config.parserOptions, parserOptions);
+        return {
+            success: false,
+            error: {
+                ruleId: null,
+                fatal: true,
+                severity: 2,
+                source: null,
+                message: ex.message,
+                line: 0,
+                column: 0
+            }
+        };
     }
 
     /*
@@ -671,31 +560,160 @@ function parse(text, config, filePath, messages) {
      */
     try {
         if (typeof parser.parseForESLint === "function") {
-            return parser.parseForESLint(text, parserOptions);
+            const parseResult = parser.parseForESLint(text, parserOptions);
+
+            return {
+                success: true,
+                ast: parseResult.ast,
+                services: parseResult.services || {}
+            };
         }
-        return parser.parse(text, parserOptions);
 
+        return {
+            success: true,
+            ast: parser.parse(text, parserOptions),
+            services: {}
+        };
     } catch (ex) {
 
         // If the message includes a leading line number, strip it:
-        const message = ex.message.replace(/^line \d+:/i, "").trim();
-        const source = (ex.lineNumber) ? SourceCode.splitLines(text)[ex.lineNumber - 1] : null;
-
-        messages.push({
-            ruleId: null,
-            fatal: true,
-            severity: 2,
-            source,
-            message: `Parsing error: ${message}`,
-
-            line: ex.lineNumber,
-            column: ex.column
-        });
+        const message = `Parsing error: ${ex.message.replace(/^line \d+:/i, "").trim()}`;
+        const source = ex.lineNumber ? SourceCode.splitLines(text)[ex.lineNumber - 1] : null;
+
+        return {
+            success: false,
+            error: {
+                ruleId: null,
+                fatal: true,
+                severity: 2,
+                source,
+                message,
+                line: ex.lineNumber,
+                column: ex.column
+            }
+        };
+    }
+}
+
+/**
+ * Gets the scope for the current node
+ * @param {ScopeManager} scopeManager The scope manager for this AST
+ * @param {ASTNode} currentNode The node to get the scope of
+ * @param {number} ecmaVersion The `ecmaVersion` setting that this code was parsed with
+ * @returns {eslint-scope.Scope} The scope information for this node
+ */
+function getScope(scopeManager, currentNode, ecmaVersion) {
+    let initialNode;
+
+    // if current node introduces a scope, add it to the list
+    if (
+        ["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].indexOf(currentNode.type) >= 0 ||
+        ecmaVersion >= 6 && ["BlockStatement", "SwitchStatement", "CatchClause"].indexOf(currentNode.type) >= 0
+    ) {
+        initialNode = currentNode;
+    } else {
+        initialNode = currentNode.parent;
+    }
+
+    // Ascend the current node's parents
+    for (let node = initialNode; node; node = node.parent) {
+
+        // Get the innermost scope
+        const scope = scopeManager.acquire(node, true);
+
+        if (scope) {
+            if (scope.type === "function-expression-name") {
+                return scope.childScopes[0];
+            }
+            return scope;
+        }
+    }
+
+    return scopeManager.scopes[0];
+}
+
+/**
+ * Marks a variable as used in the current scope
+ * @param {ScopeManager} scopeManager The scope manager for this AST. The scope may be mutated by this function.
+ * @param {ASTNode} currentNode The node currently being traversed
+ * @param {Object} parserOptions The options used to parse this text
+ * @param {string} name The name of the variable that should be marked as used.
+ * @returns {boolean} True if the variable was found and marked as used, false if not.
+ */
+function markVariableAsUsed(scopeManager, currentNode, parserOptions, name) {
+    const hasGlobalReturn = parserOptions.ecmaFeatures && parserOptions.ecmaFeatures.globalReturn;
+    const specialScope = hasGlobalReturn || parserOptions.sourceType === "module";
+    const currentScope = getScope(scopeManager, currentNode, parserOptions.ecmaVersion);
+
+    // Special Node.js scope means we need to start one level deeper
+    const initialScope = currentScope.type === "global" && specialScope ? currentScope.childScopes[0] : currentScope;
+
+    for (let scope = initialScope; scope; scope = scope.upper) {
+        const variable = scope.variables.find(scopeVar => scopeVar.name === name);
+
+        if (variable) {
+            variable.eslintUsed = true;
+            return true;
+        }
+    }
+
+    return false;
+}
 
-        return null;
+/**
+ * Gets all the ancestors of a given node
+ * @param {ASTNode} node The node
+ * @returns {ASTNode[]} All the ancestor nodes in the AST, not including the provided node, starting
+ * from the root node and going inwards to the parent node.
+ */
+function getAncestors(node) {
+    if (node.parent) {
+        const parentAncestors = getAncestors(node.parent);
+
+        parentAncestors.push(node.parent);
+        return parentAncestors;
     }
+    return [];
 }
 
+// methods that exist on SourceCode object
+const DEPRECATED_SOURCECODE_PASSTHROUGHS = {
+    getSource: "getText",
+    getSourceLines: "getLines",
+    getAllComments: "getAllComments",
+    getNodeByRangeIndex: "getNodeByRangeIndex",
+    getComments: "getComments",
+    getCommentsBefore: "getCommentsBefore",
+    getCommentsAfter: "getCommentsAfter",
+    getCommentsInside: "getCommentsInside",
+    getJSDocComment: "getJSDocComment",
+    getFirstToken: "getFirstToken",
+    getFirstTokens: "getFirstTokens",
+    getLastToken: "getLastToken",
+    getLastTokens: "getLastTokens",
+    getTokenAfter: "getTokenAfter",
+    getTokenBefore: "getTokenBefore",
+    getTokenByRangeStart: "getTokenByRangeStart",
+    getTokens: "getTokens",
+    getTokensAfter: "getTokensAfter",
+    getTokensBefore: "getTokensBefore",
+    getTokensBetween: "getTokensBetween"
+};
+
+const BASE_TRAVERSAL_CONTEXT = Object.freeze(
+    Object.keys(DEPRECATED_SOURCECODE_PASSTHROUGHS).reduce(
+        (contextInfo, methodName) =>
+            Object.assign(contextInfo, {
+                [methodName]() {
+                    const sourceCode = this.getSourceCode();
+
+                    return sourceCode[DEPRECATED_SOURCECODE_PASSTHROUGHS[methodName]].apply(sourceCode, arguments);
+                }
+            }),
+        {}
+    )
+);
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -704,40 +722,14 @@ function parse(text, config, filePath, messages) {
  * Object that is responsible for verifying JavaScript text
  * @name eslint
  */
-class Linter extends EventEmitter {
+module.exports = class Linter {
 
     constructor() {
-        super();
-        this.messages = [];
-        this.currentConfig = null;
-        this.currentScopes = null;
-        this.scopeManager = null;
-        this.currentFilename = null;
-        this.traverser = null;
-        this.reportingConfig = [];
         this.sourceCode = null;
         this.version = pkg.version;
 
         this.rules = new Rules();
         this.environments = new Environments();
-
-        // set unlimited listeners (see https://github.com/eslint/eslint/issues/524)
-        this.setMaxListeners(0);
-    }
-
-    /**
-     * Resets the internal state of the object.
-     * @returns {void}
-     */
-    reset() {
-        this.removeAllListeners();
-        this.messages = [];
-        this.currentConfig = null;
-        this.currentScopes = null;
-        this.scopeManager = null;
-        this.traverser = null;
-        this.reportingConfig = [];
-        this.sourceCode = null;
     }
 
     /**
@@ -752,39 +744,42 @@ class Linter extends EventEmitter {
      */
 
     /**
-     * Verifies the text against the rules specified by the second argument.
+     * Same as linter.verify, except without support for processors.
      * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.
      * @param {ESLintConfig} config 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} [saveState] Indicates if the state from the last run should be saved.
-     *      Mostly useful for testing purposes.
      * @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.
      * @returns {Object[]} The results as an array of messages or null if no messages.
      */
-    verify(textOrSourceCode, config, filenameOrOptions, saveState) {
-        const text = (typeof textOrSourceCode === "string") ? textOrSourceCode : null;
-        let ast,
-            parseResult,
-            allowInlineConfig;
+    _verifyWithoutProcessors(textOrSourceCode, config, filenameOrOptions) {
+        let text,
+            parserServices,
+            allowInlineConfig,
+            providedFilename;
 
         // evaluate arguments
         if (typeof filenameOrOptions === "object") {
-            this.currentFilename = filenameOrOptions.filename;
+            providedFilename = filenameOrOptions.filename;
             allowInlineConfig = filenameOrOptions.allowInlineConfig;
-            saveState = filenameOrOptions.saveState;
         } else {
-            this.currentFilename = filenameOrOptions;
+            providedFilename = filenameOrOptions;
         }
 
-        if (!saveState) {
-            this.reset();
+        const filename = typeof providedFilename === "string" ? providedFilename : "<input>";
+
+        if (typeof textOrSourceCode === "string") {
+            this.sourceCode = null;
+            text = textOrSourceCode;
+        } else {
+            this.sourceCode = textOrSourceCode;
+            text = this.sourceCode.text;
         }
 
         // search and apply "eslint-env *".
-        const envInFile = findEslintEnv(text || textOrSourceCode.text);
+        const envInFile = findEslintEnv(text);
 
         config = Object.assign({}, config);
 
@@ -799,231 +794,233 @@ class Linter extends EventEmitter {
         // process initial config to make it safe to extend
         config = prepareConfig(config, this.environments);
 
-        // only do this for text
-        if (text !== null) {
+        if (this.sourceCode) {
+            parserServices = {};
+        } else {
 
             // there's no input, just exit here
             if (text.trim().length === 0) {
                 this.sourceCode = new SourceCode(text, blankScriptAST);
-                return this.messages;
+                return [];
             }
 
-            parseResult = parse(
+            const parseResult = parse(
                 stripUnicodeBOM(text).replace(astUtils.SHEBANG_MATCHER, (match, captured) => `//${captured}`),
-                config,
-                this.currentFilename,
-                this.messages
+                config.parserOptions,
+                config.parser,
+                filename
             );
 
-            // if this result is from a parseForESLint() method, normalize
-            if (parseResult && parseResult.ast) {
-                ast = parseResult.ast;
-            } else {
-                ast = parseResult;
-                parseResult = null;
+            if (!parseResult.success) {
+                return [parseResult.error];
             }
 
-            if (ast) {
-                this.sourceCode = new SourceCode(text, ast);
-            }
-
-        } else {
-            this.sourceCode = textOrSourceCode;
-            ast = this.sourceCode.ast;
+            parserServices = parseResult.services;
+            this.sourceCode = new SourceCode(text, parseResult.ast);
         }
 
-        // if espree failed to parse the file, there's no sense in setting up rules
-        if (ast) {
+        const problems = [];
+        const sourceCode = this.sourceCode;
+        let disableDirectives;
 
-            // parse global comments and modify config
-            if (allowInlineConfig !== false) {
-                config = modifyConfigsFromComments(this.currentFilename, ast, config, this);
-            }
+        // parse global comments and modify config
+        if (allowInlineConfig !== false) {
+            const modifyConfigResult = modifyConfigsFromComments(filename, sourceCode.ast, config, this);
 
-            // ensure that severities are normalized in the config
-            ConfigOps.normalize(config);
+            config = modifyConfigResult.config;
+            modifyConfigResult.problems.forEach(problem => problems.push(problem));
+            disableDirectives = modifyConfigResult.disableDirectives;
+        } else {
+            disableDirectives = [];
+        }
 
-            // enable appropriate rules
-            Object.keys(config.rules).filter(key => getRuleSeverity(config.rules[key]) > 0).forEach(key => {
-                let ruleCreator;
+        const emitter = new EventEmitter().setMaxListeners(Infinity);
+        const ecmaFeatures = config.parserOptions.ecmaFeatures || {};
+        const ecmaVersion = config.parserOptions.ecmaVersion || 5;
+        const scopeManager = eslintScope.analyze(sourceCode.ast, {
+            ignoreEval: true,
+            nodejsScope: ecmaFeatures.globalReturn,
+            impliedStrict: ecmaFeatures.impliedStrict,
+            ecmaVersion,
+            sourceType: config.parserOptions.sourceType || "script",
+            fallback: Traverser.getKeys
+        });
 
-                ruleCreator = this.rules.get(key);
+        let currentNode = sourceCode.ast;
+        const nodeQueue = [];
 
-                if (!ruleCreator) {
-                    const replacementMsg = getRuleReplacementMessage(key);
+        new Traverser().traverse(sourceCode.ast, {
+            enter(node, parent) {
+                node.parent = parent;
+                nodeQueue.push({ isEntering: true, node });
+            },
+            leave(node) {
+                nodeQueue.push({ isEntering: false, node });
+            }
+        });
 
-                    if (replacementMsg) {
-                        ruleCreator = createStubRule(replacementMsg);
-                    } else {
-                        ruleCreator = createStubRule(`Definition for rule '${key}' was not found`);
+        /*
+         * Create a frozen object with the ruleContext properties and methods that are shared by all rules.
+         * All rule contexts will inherit from this object. This avoids the performance penalty of copying all the
+         * properties once for each rule.
+         */
+        const sharedTraversalContext = Object.freeze(
+            Object.assign(
+                Object.create(BASE_TRAVERSAL_CONTEXT),
+                {
+                    getAncestors: () => getAncestors(currentNode),
+                    getDeclaredVariables: scopeManager.getDeclaredVariables.bind(scopeManager),
+                    getFilename: () => filename,
+                    getScope: () => getScope(scopeManager, currentNode, config.parserOptions.ecmaVersion),
+                    getSourceCode: () => sourceCode,
+                    markVariableAsUsed: name => markVariableAsUsed(scopeManager, currentNode, config.parserOptions, name),
+                    parserOptions: config.parserOptions,
+                    parserPath: config.parser,
+                    parserServices,
+                    settings: config.settings,
+
+                    /**
+                     * This is used to avoid breaking rules that used to monkeypatch the `Linter#report` method
+                     * by using the `_linter` property on rule contexts.
+                     *
+                     * This should be removed in a major release after we create a better way to
+                     * lint for unused disable comments.
+                     * https://github.com/eslint/eslint/issues/9193
+                     */
+                    _linter: {
+                        report() {},
+                        on: emitter.on.bind(emitter)
                     }
-                    this.rules.define(key, ruleCreator);
                 }
+            )
+        );
 
-                const severity = getRuleSeverity(config.rules[key]);
-                const options = getRuleOptions(config.rules[key]);
-
-                try {
-                    const ruleContext = new RuleContext(
-                        key, this, severity, options,
-                        config.settings, config.parserOptions, config.parser,
-                        ruleCreator.meta,
-                        (parseResult && parseResult.services ? parseResult.services : {})
-                    );
-
-                    const rule = ruleCreator.create ? ruleCreator.create(ruleContext)
-                        : ruleCreator(ruleContext);
-
-                    // add all the selectors from the rule as listeners
-                    Object.keys(rule).forEach(selector => {
-                        this.on(selector, timing.enabled
-                            ? timing.time(key, rule[selector])
-                            : rule[selector]
-                        );
-                    });
-                } catch (ex) {
-                    ex.message = `Error while loading rule '${key}': ${ex.message}`;
-                    throw ex;
-                }
-            });
-
-            // save config so rules can access as necessary
-            this.currentConfig = config;
-            this.traverser = new Traverser();
-
-            const ecmaFeatures = this.currentConfig.parserOptions.ecmaFeatures || {};
-            const ecmaVersion = this.currentConfig.parserOptions.ecmaVersion || 5;
+        // enable appropriate rules
+        Object.keys(config.rules).forEach(ruleId => {
+            const severity = ConfigOps.getRuleSeverity(config.rules[ruleId]);
 
-            // gather scope data that may be needed by the rules
-            this.scopeManager = eslintScope.analyze(ast, {
-                ignoreEval: true,
-                nodejsScope: ecmaFeatures.globalReturn,
-                impliedStrict: ecmaFeatures.impliedStrict,
-                ecmaVersion,
-                sourceType: this.currentConfig.parserOptions.sourceType || "script",
-                fallback: Traverser.getKeys
-            });
+            if (severity === 0) {
+                return;
+            }
 
-            this.currentScopes = this.scopeManager.scopes;
+            const rule = this.rules.get(ruleId);
+            let reportTranslator = null;
+            const ruleContext = Object.freeze(
+                Object.assign(
+                    Object.create(sharedTraversalContext),
+                    {
+                        id: ruleId,
+                        options: getRuleOptions(config.rules[ruleId]),
+                        report() {
+
+                            /*
+                             * Create a report translator lazily.
+                             * In a vast majority of cases, any given rule reports zero errors on a given
+                             * piece of code. Creating a translator lazily avoids the performance cost of
+                             * creating a new translator function for each rule that usually doesn't get
+                             * called.
+                             *
+                             * Using lazy report translators improves end-to-end performance by about 3%
+                             * with Node 8.4.0.
+                             */
+                            if (reportTranslator === null) {
+                                reportTranslator = createReportTranslator({ ruleId, severity, sourceCode });
+                            }
+                            const problem = reportTranslator.apply(null, arguments);
+
+                            if (problem.fix && rule.meta && !rule.meta.fixable) {
+                                throw new Error("Fixable rules should export a `meta.fixable` property.");
+                            }
+                            problems.push(problem);
+
+                            /*
+                             * This is used to avoid breaking rules that used monkeypatch Linter, and relied on
+                             * `linter.report` getting called with report info every time a rule reports a problem.
+                             * To continue to support this, make sure that `context._linter.report` is called every
+                             * time a problem is reported by a rule, even though `context._linter` is no longer a
+                             * `Linter` instance.
+                             *
+                             * This should be removed in a major release after we create a better way to
+                             * lint for unused disable comments.
+                             * https://github.com/eslint/eslint/issues/9193
+                             */
+                            sharedTraversalContext._linter.report( // eslint-disable-line no-underscore-dangle
+                                problem.ruleId,
+                                problem.severity,
+                                { loc: { start: { line: problem.line, column: problem.column - 1 } } },
+                                problem.message
+                            );
+                        }
+                    }
+                )
+            );
 
-            // augment global scope with declared global variables
-            addDeclaredGlobals(ast, this.currentScopes[0], this.currentConfig, this.environments);
+            try {
+                const ruleListeners = rule.create(ruleContext);
 
-            let eventGenerator = new NodeEventGenerator(this);
+                // add all the selectors from the rule as listeners
+                Object.keys(ruleListeners).forEach(selector => {
+                    emitter.on(
+                        selector,
+                        timing.enabled
+                            ? timing.time(ruleId, ruleListeners[selector])
+                            : ruleListeners[selector]
+                    );
+                });
+            } catch (ex) {
+                ex.message = `Error while loading rule '${ruleId}': ${ex.message}`;
+                throw ex;
+            }
+        });
 
-            eventGenerator = new CodePathAnalyzer(eventGenerator);
+        // augment global scope with declared global variables
+        addDeclaredGlobals(sourceCode.ast, scopeManager.scopes[0], config, this.environments);
 
-            /*
-             * Each node has a type property. Whenever a particular type of
-             * node is found, an event is fired. This allows any listeners to
-             * automatically be informed that this type of node has been found
-             * and react accordingly.
-             */
-            this.traverser.traverse(ast, {
-                enter(node, parent) {
-                    node.parent = parent;
-                    eventGenerator.enterNode(node);
-                },
-                leave(node) {
-                    eventGenerator.leaveNode(node);
-                }
-            });
-        }
+        const eventGenerator = new CodePathAnalyzer(new NodeEventGenerator(emitter));
 
-        // sort by line and column
-        this.messages.sort((a, b) => {
-            const lineDiff = a.line - b.line;
+        nodeQueue.forEach(traversalInfo => {
+            currentNode = traversalInfo.node;
 
-            if (lineDiff === 0) {
-                return a.column - b.column;
+            if (traversalInfo.isEntering) {
+                eventGenerator.enterNode(currentNode);
+            } else {
+                eventGenerator.leaveNode(currentNode);
             }
-            return lineDiff;
-
         });
 
-        return this.messages;
+        return applyDisableDirectives({
+            directives: disableDirectives,
+            problems: problems.sort((problemA, problemB) => problemA.line - problemB.line || problemA.column - problemB.column)
+        });
     }
 
     /**
-     * Reports a message from one of the rules.
-     * @param {string} ruleId The ID of the rule causing the message.
-     * @param {number} severity The severity level of the rule as configured.
-     * @param {ASTNode} node The AST node that the message relates to.
-     * @param {Object=} location An object containing the error line and column
-     *      numbers. If location is not provided the node's start location will
-     *      be used.
-     * @param {string} message The actual message.
-     * @param {Object} opts Optional template data which produces a formatted message
-     *     with symbols being replaced by this object's values.
-     * @param {Object} fix A fix command description.
-     * @param {Object} meta Metadata of the rule
-     * @returns {void}
+     * Verifies the text against the rules specified by the second argument.
+     * @param {string|SourceCode} textOrSourceCode The text to parse or a SourceCode object.
+     * @param {ESLintConfig} config 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} [saveState] Indicates if the state from the last run should be saved.
+     *      Mostly useful for testing purposes.
+     * @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<Object[]>): Object[]} [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
+     * @returns {Object[]} The results as an array of messages or null if no messages.
      */
-    report(ruleId, severity, node, location, message, opts, fix, meta) {
-        if (node) {
-            assert.strictEqual(typeof node, "object", "Node must be an object");
-        }
-
-        let endLocation;
-
-        if (typeof location === "string") {
-            assert.ok(node, "Node must be provided when reporting error if location is not provided");
-
-            meta = fix;
-            fix = opts;
-            opts = message;
-            message = location;
-            location = node.loc.start;
-            endLocation = node.loc.end;
-        } else {
-            endLocation = location.end;
-        }
-
-        location = location.start || location;
-
-        if (isDisabledByReportingConfig(this.reportingConfig, ruleId, location)) {
-            return;
-        }
-
-        if (opts) {
-            message = message.replace(/\{\{\s*([^{}]+?)\s*\}\}/g, (fullMatch, term) => {
-                if (term in opts) {
-                    return opts[term];
-                }
-
-                // Preserve old behavior: If parameter name not provided, don't replace it.
-                return fullMatch;
-            });
-        }
-
-        const problem = {
-            ruleId,
-            severity,
-            message,
-            line: location.line,
-            column: location.column + 1, // switch to 1-base instead of 0-base
-            nodeType: node && node.type,
-            source: this.sourceCode.lines[location.line - 1] || ""
-        };
-
-        // Define endLine and endColumn if exists.
-        if (endLocation) {
-            problem.endLine = endLocation.line;
-            problem.endColumn = endLocation.column + 1; // switch to 1-base instead of 0-base
-        }
-
-        // ensure there's range and text properties, otherwise it's not a valid fix
-        if (fix && Array.isArray(fix.range) && (typeof fix.text === "string")) {
-
-            // If rule uses fix, has metadata, but has no metadata.fixable, we should throw
-            if (meta && !meta.fixable) {
-                throw new Error("Fixable rules should export a `meta.fixable` property.");
-            }
-
-            problem.fix = fix;
-        }
-
-        this.messages.push(problem);
+    verify(textOrSourceCode, config, filenameOrOptions) {
+        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)
+            )
+        );
     }
 
     /**
@@ -1034,103 +1031,6 @@ class Linter extends EventEmitter {
         return this.sourceCode;
     }
 
-    /**
-     * Gets nodes that are ancestors of current node.
-     * @returns {ASTNode[]} Array of objects representing ancestors.
-     */
-    getAncestors() {
-        return this.traverser.parents();
-    }
-
-    /**
-     * Gets the scope for the current node.
-     * @returns {Object} An object representing the current node's scope.
-     */
-    getScope() {
-        const parents = this.traverser.parents();
-
-        // Don't do this for Program nodes - they have no parents
-        if (parents.length) {
-
-            // if current node introduces a scope, add it to the list
-            const current = this.traverser.current();
-
-            if (this.currentConfig.parserOptions.ecmaVersion >= 6) {
-                if (["BlockStatement", "SwitchStatement", "CatchClause", "FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].indexOf(current.type) >= 0) {
-                    parents.push(current);
-                }
-            } else {
-                if (["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"].indexOf(current.type) >= 0) {
-                    parents.push(current);
-                }
-            }
-
-            // Ascend the current node's parents
-            for (let i = parents.length - 1; i >= 0; --i) {
-
-                // Get the innermost scope
-                const scope = this.scopeManager.acquire(parents[i], true);
-
-                if (scope) {
-                    if (scope.type === "function-expression-name") {
-                        return scope.childScopes[0];
-                    }
-                    return scope;
-
-                }
-
-            }
-
-        }
-
-        return this.currentScopes[0];
-    }
-
-    /**
-     * Record that a particular variable has been used in code
-     * @param {string} name The name of the variable to mark as used
-     * @returns {boolean} True if the variable was found and marked as used,
-     *      false if not.
-     */
-    markVariableAsUsed(name) {
-        const hasGlobalReturn = this.currentConfig.parserOptions.ecmaFeatures && this.currentConfig.parserOptions.ecmaFeatures.globalReturn,
-            specialScope = hasGlobalReturn || this.currentConfig.parserOptions.sourceType === "module";
-        let scope = this.getScope(),
-            i,
-            len;
-
-        // Special Node.js scope means we need to start one level deeper
-        if (scope.type === "global" && specialScope) {
-            scope = scope.childScopes[0];
-        }
-
-        do {
-            const variables = scope.variables;
-
-            for (i = 0, len = variables.length; i < len; i++) {
-                if (variables[i].name === name) {
-                    variables[i].eslintUsed = true;
-                    return true;
-                }
-            }
-        } while ((scope = scope.upper));
-
-        return false;
-    }
-
-    /**
-     * Gets the filename for the currently parsed source.
-     * @returns {string} The filename associated with the source being parsed.
-     *     Defaults to "<input>" if no filename info is present.
-     */
-    getFilename() {
-        if (typeof this.currentFilename === "string") {
-            return this.currentFilename;
-        }
-        return "<input>";
-
-    }
-
     /**
      * Defines a new linting rule.
      * @param {string} ruleId A unique rule identifier
@@ -1152,14 +1052,6 @@ class Linter extends EventEmitter {
         });
     }
 
-    /**
-     * Gets the default eslint configuration.
-     * @returns {Object} Object mapping rule IDs to their default configurations
-     */
-    defaults() { // eslint-disable-line class-methods-use-this
-        return defaultConfig;
-    }
-
     /**
      * Gets an object with all loaded rules.
      * @returns {Map} All loaded rules
@@ -1168,29 +1060,6 @@ class Linter extends EventEmitter {
         return this.rules.getAllLoadedRules();
     }
 
-    /**
-     * Gets variables that are declared by a specified node.
-     *
-     * The variables are its `defs[].node` or `defs[].parent` is same as the specified node.
-     * Specifically, below:
-     *
-     * - `VariableDeclaration` - variables of its all declarators.
-     * - `VariableDeclarator` - variables.
-     * - `FunctionDeclaration`/`FunctionExpression` - its function name and parameters.
-     * - `ArrowFunctionExpression` - its parameters.
-     * - `ClassDeclaration`/`ClassExpression` - its class name.
-     * - `CatchClause` - variables of its exception.
-     * - `ImportDeclaration` - variables of  its all specifiers.
-     * - `ImportSpecifier`/`ImportDefaultSpecifier`/`ImportNamespaceSpecifier` - a variable.
-     * - others - always an empty array.
-     *
-     * @param {ASTNode} node A node to get.
-     * @returns {eslint-scope.Variable[]} Variables that are declared by the node.
-     */
-    getDeclaredVariables(node) {
-        return (this.scopeManager && this.scopeManager.getDeclaredVariables(node)) || [];
-    }
-
     /**
      * Performs multiple autofix passes over the text until as many fixes as possible
      * have been applied.
@@ -1201,6 +1070,11 @@ class Linter extends EventEmitter {
      * @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
      * @returns {Object} The result of the fix operation as returned from the
      *      SourceCodeFixer.
      */
@@ -1228,7 +1102,7 @@ class Linter extends EventEmitter {
             messages = this.verify(text, config, options);
 
             debug(`Generating fixed text for ${debugTextDescription} (pass ${passNumber})`);
-            fixedResult = SourceCodeFixer.applyFixes(this.getSourceCode(), messages, shouldFix);
+            fixedResult = SourceCodeFixer.applyFixes(text, messages, shouldFix);
 
             // stop if there are any syntax errors.
             // 'fixedResult.output' is a empty string.
@@ -1261,48 +1135,4 @@ class Linter extends EventEmitter {
 
         return fixedResult;
     }
-}
-
-// methods that exist on SourceCode object
-const externalMethods = {
-    getSource: "getText",
-    getSourceLines: "getLines",
-    getAllComments: "getAllComments",
-    getNodeByRangeIndex: "getNodeByRangeIndex",
-    getComments: "getComments",
-    getCommentsBefore: "getCommentsBefore",
-    getCommentsAfter: "getCommentsAfter",
-    getCommentsInside: "getCommentsInside",
-    getJSDocComment: "getJSDocComment",
-    getFirstToken: "getFirstToken",
-    getFirstTokens: "getFirstTokens",
-    getLastToken: "getLastToken",
-    getLastTokens: "getLastTokens",
-    getTokenAfter: "getTokenAfter",
-    getTokenBefore: "getTokenBefore",
-    getTokenByRangeStart: "getTokenByRangeStart",
-    getTokens: "getTokens",
-    getTokensAfter: "getTokensAfter",
-    getTokensBefore: "getTokensBefore",
-    getTokensBetween: "getTokensBetween"
 };
-
-// copy over methods
-Object.keys(externalMethods).forEach(methodName => {
-    const exMethodName = externalMethods[methodName];
-
-    // Applies the SourceCode methods to the Linter prototype
-    Object.defineProperty(Linter.prototype, methodName, {
-        value() {
-            if (this.sourceCode) {
-                return this.sourceCode[exMethodName].apply(this.sourceCode, arguments);
-            }
-            return null;
-        },
-        configurable: true,
-        writable: true,
-        enumerable: false
-    });
-});
-
-module.exports = Linter;