eslint 4.4.0 → 4.6.1

package/lib/linter.js

@@ -9,10 +9,10 @@
 // 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"),
@@ -23,7 +23,7 @@ const assert = require("assert"),
     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);
         }
     });
 
@@ -318,7 +323,8 @@ 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[]}} Modified config object, along with any problems encountered
+ * while parsing config comments
  */
 function modifyConfigsFromComments(filename, ast, config, linterContext) {
 
@@ -329,7 +335,7 @@ function modifyConfigsFromComments(filename, ast, config, linterContext) {
         env: {}
     };
     const commentRules = {};
-    const messages = linterContext.messages;
+    const problems = [];
     const reportingConfig = linterContext.reportingConfig;
 
     ast.comments.forEach(comment => {
@@ -364,14 +370,19 @@ function modifyConfigsFromComments(filename, ast, config, linterContext) {
                         break;
 
                     case "eslint": {
-                        const items = parseJsonConfig(value, comment.loc, messages);
+                        const parseResult = parseJsonConfig(value, comment.loc);
 
-                        Object.keys(items).forEach(name => {
-                            const ruleValue = items[name];
+                        if (parseResult.success) {
+                            Object.keys(parseResult.config).forEach(name => {
+                                const ruleValue = parseResult.config[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;
                     }
 
@@ -399,14 +410,17 @@ function modifyConfigsFromComments(filename, ast, config, linterContext) {
     });
     Object.assign(commentConfig.rules, commentRules);
 
-    return ConfigOps.merge(config, commentConfig);
+    return {
+        config: ConfigOps.merge(config, commentConfig),
+        problems
+    };
 }
 
 /**
  * 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
+ * @param  {Object} location 1-indexed location of message
  * @returns {boolean}          True if message should be ignored, false otherwise
  */
 function isDisabledByReportingConfig(reportingConfig, ruleId, location) {
@@ -416,8 +430,8 @@ function isDisabledByReportingConfig(reportingConfig, ruleId, location) {
         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)))) {
+            (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 - 1 <= ignore.end.column)))) {
             return true;
         }
     }
@@ -531,6 +545,8 @@ function createStubRule(message) {
     if (message) {
         return createRuleModule;
     }
+
+    /* istanbul ignore next */
     throw new Error("No message passed to stub rule");
 
 }
@@ -595,13 +611,7 @@ function stripUnicodeBOM(text) {
  * @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;
-
+    return Array.isArray(ruleConfig) ? ruleConfig[0] : ruleConfig;
 }
 
 /**
@@ -622,45 +632,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 +677,79 @@ 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 null;
+        return {
+            success: false,
+            error: {
+                ruleId: null,
+                fatal: true,
+                severity: 2,
+                source,
+                message,
+                line: ex.lineNumber,
+                column: ex.column
+            }
+        };
     }
 }
 
+// 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,13 +758,11 @@ function parse(text, config, filePath, messages) {
  * Object that is responsible for verifying JavaScript text
  * @name eslint
  */
-class Linter extends EventEmitter {
+class Linter {
 
     constructor() {
-        super();
         this.messages = [];
         this.currentConfig = null;
-        this.currentScopes = null;
         this.scopeManager = null;
         this.currentFilename = null;
         this.traverser = null;
@@ -720,9 +772,6 @@ class Linter extends EventEmitter {
 
         this.rules = new Rules();
         this.environments = new Environments();
-
-        // set unlimited listeners (see https://github.com/eslint/eslint/issues/524)
-        this.setMaxListeners(0);
     }
 
     /**
@@ -730,10 +779,8 @@ class Linter extends EventEmitter {
      * @returns {void}
      */
     reset() {
-        this.removeAllListeners();
         this.messages = [];
         this.currentConfig = null;
-        this.currentScopes = null;
         this.scopeManager = null;
         this.traverser = null;
         this.reportingConfig = [];
@@ -765,11 +812,18 @@ class Linter extends EventEmitter {
      * @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,
+        let text,
+            parserServices,
             allowInlineConfig;
 
+        if (typeof textOrSourceCode === "string") {
+            this.sourceCode = null;
+            text = textOrSourceCode;
+        } else {
+            this.sourceCode = textOrSourceCode;
+            text = this.sourceCode.text;
+        }
+
         // evaluate arguments
         if (typeof filenameOrOptions === "object") {
             this.currentFilename = filenameOrOptions.filename;
@@ -784,7 +838,7 @@ class Linter extends EventEmitter {
         }
 
         // search and apply "eslint-env *".
-        const envInFile = findEslintEnv(text || textOrSourceCode.text);
+        const envInFile = findEslintEnv(text);
 
         config = Object.assign({}, config);
 
@@ -799,136 +853,191 @@ 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,
+                this.currentFilename
             );
 
-            // if this result is from a parseForESLint() method, normalize
-            if (parseResult && parseResult.ast) {
-                ast = parseResult.ast;
-            } else {
-                ast = parseResult;
-                parseResult = null;
-            }
-
-            if (ast) {
-                this.sourceCode = new SourceCode(text, ast);
+            if (!parseResult.success) {
+                return [parseResult.error];
             }
 
-        } 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) {
+        // parse global comments and modify config
+        if (allowInlineConfig !== false) {
+            const modifyConfigResult = modifyConfigsFromComments(this.currentFilename, this.sourceCode.ast, config, this);
 
-            // parse global comments and modify config
-            if (allowInlineConfig !== false) {
-                config = modifyConfigsFromComments(this.currentFilename, ast, config, this);
-            }
-
-            // ensure that severities are normalized in the config
-            ConfigOps.normalize(config);
-
-            // enable appropriate rules
-            Object.keys(config.rules).filter(key => getRuleSeverity(config.rules[key]) > 0).forEach(key => {
-                let ruleCreator;
+            config = modifyConfigResult.config;
+            modifyConfigResult.problems.forEach(problem => this.messages.push(problem));
+        }
 
-                ruleCreator = this.rules.get(key);
+        // ensure that severities are normalized in the config
+        ConfigOps.normalize(config);
 
-                if (!ruleCreator) {
-                    const replacementMsg = getRuleReplacementMessage(key);
+        const emitter = new EventEmitter().setMaxListeners(Infinity);
 
-                    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: this.getAncestors.bind(this),
+                    getDeclaredVariables: this.getDeclaredVariables.bind(this),
+                    getFilename: this.getFilename.bind(this),
+                    getScope: this.getScope.bind(this),
+                    getSourceCode: () => this.sourceCode,
+                    markVariableAsUsed: this.markVariableAsUsed.bind(this),
+                    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 : {})
-                    );
+        // enable appropriate rules
+        Object.keys(config.rules).filter(ruleId => getRuleSeverity(config.rules[ruleId]) > 0).forEach(ruleId => {
+            let ruleCreator = this.rules.get(ruleId);
 
-                    const rule = ruleCreator.create ? ruleCreator.create(ruleContext)
-                        : ruleCreator(ruleContext);
+            if (!ruleCreator) {
+                const replacementMsg = getRuleReplacementMessage(ruleId);
 
-                    // 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;
+                if (replacementMsg) {
+                    ruleCreator = createStubRule(replacementMsg);
+                } else {
+                    ruleCreator = createStubRule(`Definition for rule '${ruleId}' was not found`);
                 }
-            });
+                this.rules.define(ruleId, ruleCreator);
+            }
 
-            // 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;
-
-            // 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
-            });
+            const severity = getRuleSeverity(config.rules[ruleId]);
+            const ruleContext = Object.freeze(
+                Object.assign(
+                    Object.create(sharedTraversalContext),
+                    {
+                        id: ruleId,
+                        options: getRuleOptions(config.rules[ruleId]),
+                        report: lodash.flow([
+                            createReportTranslator({ ruleId, severity, sourceCode: this.sourceCode }),
+                            problem => {
+                                if (problem.fix && ruleCreator.meta && !ruleCreator.meta.fixable) {
+                                    throw new Error("Fixable rules should export a `meta.fixable` property.");
+                                }
+                                if (!isDisabledByReportingConfig(this.reportingConfig, ruleId, problem)) {
+                                    this.messages.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
+                                    ruleId,
+                                    severity,
+                                    { loc: { start: { line: problem.line, column: problem.column - 1 } } },
+                                    problem.message
+                                );
+                            }
+                        ])
+                    }
+                )
+            );
 
-            this.currentScopes = this.scopeManager.scopes;
+            try {
+                const rule = ruleCreator.create
+                    ? ruleCreator.create(ruleContext)
+                    : ruleCreator(ruleContext);
 
-            // augment global scope with declared global variables
-            addDeclaredGlobals(ast, this.currentScopes[0], this.currentConfig, this.environments);
+                // add all the selectors from the rule as listeners
+                Object.keys(rule).forEach(selector => {
+                    emitter.on(
+                        selector, timing.enabled
+                            ? timing.time(ruleId, rule[selector])
+                            : rule[selector]
+                    );
+                });
+            } catch (ex) {
+                ex.message = `Error while loading rule '${ruleId}': ${ex.message}`;
+                throw ex;
+            }
+        });
 
-            let eventGenerator = new NodeEventGenerator(this);
+        // 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;
+
+        // gather scope data that may be needed by the rules
+        this.scopeManager = eslintScope.analyze(this.sourceCode.ast, {
+            ignoreEval: true,
+            nodejsScope: ecmaFeatures.globalReturn,
+            impliedStrict: ecmaFeatures.impliedStrict,
+            ecmaVersion,
+            sourceType: this.currentConfig.parserOptions.sourceType || "script",
+            fallback: Traverser.getKeys
+        });
 
-            eventGenerator = new CodePathAnalyzer(eventGenerator);
+        // augment global scope with declared global variables
+        addDeclaredGlobals(this.sourceCode.ast, this.scopeManager.scopes[0], this.currentConfig, 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));
+
+        /*
+         * 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(this.sourceCode.ast, {
+            enter(node, parent) {
+                node.parent = parent;
+                eventGenerator.enterNode(node);
+            },
+            leave(node) {
+                eventGenerator.leaveNode(node);
+            }
+        });
 
         // sort by line and column
         this.messages.sort((a, b) => {
@@ -944,88 +1053,6 @@ class Linter extends EventEmitter {
         return this.messages;
     }
 
-    /**
-     * 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}
-     */
-    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);
-    }
-
     /**
      * Gets the SourceCode object representing the parsed source.
      * @returns {SourceCode} The SourceCode object.
@@ -1083,7 +1110,7 @@ class Linter extends EventEmitter {
 
         }
 
-        return this.currentScopes[0];
+        return this.scopeManager.scopes[0];
     }
 
     /**
@@ -1210,7 +1237,7 @@ class Linter extends EventEmitter {
             fixed = false,
             passNumber = 0;
         const debugTextDescription = options && options.filename || `${text.slice(0, 10)}...`;
-        const shouldFix = options && options.fix || true;
+        const shouldFix = options && typeof options.fix !== "undefined" ? options.fix : true;
 
         /**
          * This loop continues until one of the following is true:
@@ -1228,7 +1255,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.
@@ -1263,33 +1290,8 @@ class Linter extends EventEmitter {
     }
 }
 
-// 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];
+Object.keys(DEPRECATED_SOURCECODE_PASSTHROUGHS).forEach(methodName => {
+    const exMethodName = DEPRECATED_SOURCECODE_PASSTHROUGHS[methodName];
 
     // Applies the SourceCode methods to the Linter prototype
     Object.defineProperty(Linter.prototype, methodName, {