eslint 4.7.2 → 4.11.0

package/lib/config/config-validator.js

@@ -14,9 +14,7 @@ const ajv = require("../util/ajv"),
     configSchema = require("../../conf/config-schema.js"),
     util = require("util");
 
-const validators = {
-    rules: Object.create(null)
-};
+const ruleValidators = new WeakMap();
 
 //------------------------------------------------------------------------------
 // Private
@@ -25,13 +23,11 @@ let validateSchema;
 
 /**
  * Gets a complete options schema for a rule.
- * @param {string} id The rule's unique name.
- * @param {Rules} rulesContext Rule context
+ * @param {{create: Function, schema: (Array|null)}} rule A new-style rule object
  * @returns {Object} JSON Schema for the rule's options.
  */
-function getRuleOptionsSchema(id, rulesContext) {
-    const rule = rulesContext.get(id),
-        schema = rule && rule.schema || rule && rule.meta && rule.meta.schema;
+function getRuleOptionsSchema(rule) {
+    const schema = rule.schema || rule.meta && rule.meta.schema;
 
     // Given a tuple of schemas, insert warning level at the beginning
     if (Array.isArray(schema)) {
@@ -56,10 +52,10 @@ function getRuleOptionsSchema(id, rulesContext) {
 }
 
 /**
-* Validates a rule's severity and returns the severity value. Throws an error if the severity is invalid.
-* @param {options} options The given options for the rule.
-* @returns {number|string} The rule's severity value
-*/
+ * Validates a rule's severity and returns the severity value. Throws an error if the severity is invalid.
+ * @param {options} options The given options for the rule.
+ * @returns {number|string} The rule's severity value
+ */
 function validateRuleSeverity(options) {
     const severity = Array.isArray(options) ? options[0] : options;
 
@@ -71,46 +67,52 @@ function validateRuleSeverity(options) {
 }
 
 /**
-* Validates the non-severity options passed to a rule, based on its schema.
-* @param {string} id The rule's unique name
-* @param {array} localOptions The options for the rule, excluding severity
-* @param {Rules} rulesContext Rule context
-* @returns {void}
-*/
-function validateRuleSchema(id, localOptions, rulesContext) {
-    const schema = getRuleOptionsSchema(id, rulesContext);
-
-    if (!validators.rules[id] && schema) {
-        validators.rules[id] = ajv.compile(schema);
+ * Validates the non-severity options passed to a rule, based on its schema.
+ * @param {{create: Function}} rule The rule to validate
+ * @param {array} localOptions The options for the rule, excluding severity
+ * @returns {void}
+ */
+function validateRuleSchema(rule, localOptions) {
+    if (!ruleValidators.has(rule)) {
+        const schema = getRuleOptionsSchema(rule);
+
+        if (schema) {
+            ruleValidators.set(rule, ajv.compile(schema));
+        }
     }
 
-    const validateRule = validators.rules[id];
+    const validateRule = ruleValidators.get(rule);
 
     if (validateRule) {
         validateRule(localOptions);
         if (validateRule.errors) {
-            throw new Error(validateRule.errors.map(error => `\tValue "${error.data}" ${error.message}.\n`).join(""));
+            throw new Error(validateRule.errors.map(
+                error => `\tValue ${JSON.stringify(error.data)} ${error.message}.\n`
+            ).join(""));
         }
     }
 }
 
 /**
  * Validates a rule's options against its schema.
- * @param {string} id The rule's unique name.
+ * @param {{create: Function}|null} rule The rule that the config is being validated for
+ * @param {string} ruleId The rule's unique name.
  * @param {array|number} options The given options for the rule.
  * @param {string} source The name of the configuration source to report in any errors.
- * @param {Rules} rulesContext Rule context
  * @returns {void}
  */
-function validateRuleOptions(id, options, source, rulesContext) {
+function validateRuleOptions(rule, ruleId, options, source) {
+    if (!rule) {
+        return;
+    }
     try {
         const severity = validateRuleSeverity(options);
 
         if (severity !== 0 && !(typeof severity === "string" && severity.toLowerCase() === "off")) {
-            validateRuleSchema(id, Array.isArray(options) ? options.slice(1) : [], rulesContext);
+            validateRuleSchema(rule, Array.isArray(options) ? options.slice(1) : []);
         }
     } catch (err) {
-        throw new Error(`${source}:\n\tConfiguration for rule "${id}" is invalid:\n${err.message}`);
+        throw new Error(`${source}:\n\tConfiguration for rule "${ruleId}" is invalid:\n${err.message}`);
     }
 }
 
@@ -141,16 +143,16 @@ function validateEnvironment(environment, source, envContext) {
  * Validates a rules config object
  * @param {Object} rulesConfig The rules config object to validate.
  * @param {string} source The name of the configuration source to report in any errors.
- * @param {Rules} rulesContext Rule context
+ * @param {function(string): {create: Function}} ruleMapper A mapper function from strings to loaded rules
  * @returns {void}
  */
-function validateRules(rulesConfig, source, rulesContext) {
+function validateRules(rulesConfig, source, ruleMapper) {
     if (!rulesConfig) {
         return;
     }
 
     Object.keys(rulesConfig).forEach(id => {
-        validateRuleOptions(id, rulesConfig[id], source, rulesContext);
+        validateRuleOptions(ruleMapper(id), id, rulesConfig[id], source);
     });
 }
 
@@ -221,13 +223,13 @@ function validateConfigSchema(config, source) {
  * Validates an entire config object.
  * @param {Object} config The config object to validate.
  * @param {string} source The name of the configuration source to report in any errors.
- * @param {Rules} rulesContext The rules context
+ * @param {function(string): {create: Function}} ruleMapper A mapper function from rule IDs to defined rules
  * @param {Environments} envContext The env context
  * @returns {void}
  */
-function validate(config, source, rulesContext, envContext) {
+function validate(config, source, ruleMapper, envContext) {
     validateConfigSchema(config, source);
-    validateRules(config.rules, source, rulesContext);
+    validateRules(config.rules, source, ruleMapper);
     validateEnvironment(config.env, source, envContext);
 }
 

package/lib/config/plugins.js

@@ -9,13 +9,13 @@
 //------------------------------------------------------------------------------
 
 const debug = require("debug")("eslint:plugins");
+const naming = require("../util/naming");
 
 //------------------------------------------------------------------------------
 // Private
 //------------------------------------------------------------------------------
 
-const PLUGIN_NAME_PREFIX = "eslint-plugin-",
-    NAMESPACE_REGEX = /^@.*\//i;
+const PLUGIN_NAME_PREFIX = "eslint-plugin-";
 
 //------------------------------------------------------------------------------
 // Public Interface
@@ -37,33 +37,6 @@ class Plugins {
         this._rules = rulesContext;
     }
 
-    /**
-     * Removes the prefix `eslint-plugin-` from a plugin name.
-     * @param {string} pluginName The name of the plugin which may have the prefix.
-     * @returns {string} The name of the plugin without prefix.
-     */
-    static removePrefix(pluginName) {
-        return pluginName.startsWith(PLUGIN_NAME_PREFIX) ? pluginName.slice(PLUGIN_NAME_PREFIX.length) : pluginName;
-    }
-
-    /**
-     * Gets the scope (namespace) of a plugin.
-     * @param {string} pluginName The name of the plugin which may have the prefix.
-     * @returns {string} The name of the plugins namepace if it has one.
-     */
-    static getNamespace(pluginName) {
-        return pluginName.match(NAMESPACE_REGEX) ? pluginName.match(NAMESPACE_REGEX)[0] : "";
-    }
-
-    /**
-     * Removes the namespace from a plugin name.
-     * @param {string} pluginName The name of the plugin which may have the prefix.
-     * @returns {string} The name of the plugin without the namespace.
-     */
-    static removeNamespace(pluginName) {
-        return pluginName.replace(NAMESPACE_REGEX, "");
-    }
-
     /**
      * Defines a plugin with a given name rather than loading from disk.
      * @param {string} pluginName The name of the plugin to load.
@@ -71,9 +44,9 @@ class Plugins {
      * @returns {void}
      */
     define(pluginName, plugin) {
-        const pluginNamespace = Plugins.getNamespace(pluginName),
-            pluginNameWithoutNamespace = Plugins.removeNamespace(pluginName),
-            pluginNameWithoutPrefix = Plugins.removePrefix(pluginNameWithoutNamespace),
+        const pluginNamespace = naming.getNamespaceFromTerm(pluginName),
+            pluginNameWithoutNamespace = naming.removeNamespaceFromTerm(pluginName),
+            pluginNameWithoutPrefix = naming.removePrefixFromTerm(PLUGIN_NAME_PREFIX, pluginNameWithoutNamespace),
             shortName = pluginNamespace + pluginNameWithoutPrefix;
 
         // load up environments and rules
@@ -106,9 +79,9 @@ class Plugins {
      * @throws {Error} If the plugin cannot be loaded.
      */
     load(pluginName) {
-        const pluginNamespace = Plugins.getNamespace(pluginName),
-            pluginNameWithoutNamespace = Plugins.removeNamespace(pluginName),
-            pluginNameWithoutPrefix = Plugins.removePrefix(pluginNameWithoutNamespace),
+        const pluginNamespace = naming.getNamespaceFromTerm(pluginName),
+            pluginNameWithoutNamespace = naming.removeNamespaceFromTerm(pluginName),
+            pluginNameWithoutPrefix = naming.removePrefixFromTerm(PLUGIN_NAME_PREFIX, pluginNameWithoutNamespace),
             shortName = pluginNamespace + pluginNameWithoutPrefix,
             longName = pluginNamespace + PLUGIN_NAME_PREFIX + pluginNameWithoutPrefix;
         let plugin = null;

package/lib/config.js

@@ -120,10 +120,10 @@ class Config {
     }
 
     /**
-    * Loads the config options from a config specified on the command line.
-    * @param {string} [config] A shareable named config or path to a config file.
-    * @returns {void}
-    */
+     * Loads the config options from a config specified on the command line.
+     * @param {string} [config] A shareable named config or path to a config file.
+     * @returns {void}
+     */
     loadSpecificConfig(config) {
         if (config) {
             debug(`Using command line config ${config}`);
@@ -216,8 +216,10 @@ class Config {
                 return localConfigHierarchy;
             }
 
-            // Don't consider the personal config file in the home directory,
-            // except if the home directory is the same as the current working directory
+            /*
+             * Don't consider the personal config file in the home directory,
+             * except if the home directory is the same as the current working directory
+             */
             if (localConfigDirectory === PERSONAL_CONFIG_DIR && localConfigFile !== projectConfigPath) {
                 continue;
             }
@@ -343,8 +345,10 @@ class Config {
             this.plugins.loadAll(this.cliConfig.plugins);
         }
 
-        // Step 3: Override parser only if it is passed explicitly through the command line
-        // or if it's not defined yet (because the final object will at least have the parser key)
+        /*
+         * Step 3: Override parser only if it is passed explicitly through the command line
+         * or if it's not defined yet (because the final object will at least have the parser key)
+         */
         if (this.parser || !config.parser) {
             config = ConfigOps.merge(config, { parser: this.parser });
         }

package/lib/formatters/html-template-message.html

@@ -3,6 +3,6 @@
     <td class="clr-<%= severityNumber %>"><%= severityName %></td>
     <td><%- message %></td>
     <td>
-        <a href="http://eslint.org/docs/rules/<%= ruleId %>" target="_blank"><%= ruleId %></a>
+        <a href="https://eslint.org/docs/rules/<%= ruleId %>" target="_blank"><%= ruleId %></a>
     </td>
 </tr>

package/lib/formatters/html-template-page.html

@@ -1,5 +1,7 @@
 <!DOCTYPE html>
+<html>
     <head>
+        <meta charset="UTF-8">
         <title>ESLint Report</title>
         <style>
             body {
@@ -29,7 +31,7 @@
             }
             th {
                 font-weight:400;
-                font-size:normal;
+                font-size:medium;
                 text-align:left;
                 cursor:pointer
             }

package/lib/formatters/html.js

@@ -51,7 +51,8 @@ function renderSummary(totalErrors, totalWarnings) {
 function renderColor(totalErrors, totalWarnings) {
     if (totalErrors !== 0) {
         return 2;
-    } else if (totalWarnings !== 0) {
+    }
+    if (totalWarnings !== 0) {
         return 1;
     }
     return 0;

package/lib/formatters/junit.js

@@ -39,22 +39,28 @@ module.exports = function(results) {
 
         const messages = result.messages;
 
-        output += `<testsuite package="org.eslint" time="0" tests="${messages.length}" errors="${messages.length}" name="${result.filePath}">\n`;
-        messages.forEach(message => {
-            const type = message.fatal ? "error" : "failure";
+        if (messages.length > 0) {
+            output += `<testsuite package="org.eslint" time="0" tests="${messages.length}" errors="${messages.length}" name="${result.filePath}">\n`;
+            messages.forEach(message => {
+                const type = message.fatal ? "error" : "failure";
 
-            output += `<testcase time="0" name="org.eslint.${message.ruleId || "unknown"}">`;
-            output += `<${type} message="${xmlEscape(message.message || "")}">`;
-            output += "<![CDATA[";
-            output += `line ${message.line || 0}, col `;
-            output += `${message.column || 0}, ${getMessageType(message)}`;
-            output += ` - ${xmlEscape(message.message || "")}`;
-            output += (message.ruleId ? ` (${message.ruleId})` : "");
-            output += "]]>";
-            output += `</${type}>`;
-            output += "</testcase>\n";
-        });
-        output += "</testsuite>\n";
+                output += `<testcase time="0" name="org.eslint.${message.ruleId || "unknown"}">`;
+                output += `<${type} message="${xmlEscape(message.message || "")}">`;
+                output += "<![CDATA[";
+                output += `line ${message.line || 0}, col `;
+                output += `${message.column || 0}, ${getMessageType(message)}`;
+                output += ` - ${xmlEscape(message.message || "")}`;
+                output += (message.ruleId ? ` (${message.ruleId})` : "");
+                output += "]]>";
+                output += `</${type}>`;
+                output += "</testcase>\n";
+            });
+            output += "</testsuite>\n";
+        } else {
+            output += `<testsuite package="org.eslint" time="0" tests="1" errors="0" name="${result.filePath}">\n`;
+            output += `<testcase time="0" name="${result.filePath}" />\n`;
+            output += "</testsuite>\n";
+        }
 
     });
 

package/lib/formatters/tap.js

@@ -63,9 +63,11 @@ module.exports = function(results) {
                     }
                 };
 
-                // If we have multiple messages place them under a messages key
-                // The first error will be logged as message key
-                // This is to adhere to TAP 13 loosely defined specification of having a message key
+                /*
+                 * If we have multiple messages place them under a messages key
+                 * The first error will be logged as message key
+                 * This is to adhere to TAP 13 loosely defined specification of having a message key
+                 */
                 if ("message" in diagnostics) {
                     if (typeof diagnostics.messages === "undefined") {
                         diagnostics.messages = [];

package/lib/ignored-paths.js

@@ -114,8 +114,10 @@ class IgnoredPaths {
             default: ignore()
         };
 
-        // Add a way to keep track of ignored files.  This was present in node-ignore
-        // 2.x, but dropped for now as of 3.0.10.
+        /*
+         * Add a way to keep track of ignored files.  This was present in node-ignore
+         * 2.x, but dropped for now as of 3.0.10.
+         */
         this.ig.custom.ignoreFiles = [];
         this.ig.default.ignoreFiles = [];
 
@@ -184,7 +186,7 @@ class IgnoredPaths {
                                     addPattern(this.ig.default, pattern);
                                 });
                             } else {
-                                throw new Error("Package.json eslintIgnore property requires an array of paths");
+                                throw new TypeError("Package.json eslintIgnore property requires an array of paths");
                             }
                         }
                     }

package/lib/linter.js

@@ -9,8 +9,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const EventEmitter = require("events").EventEmitter,
-    eslintScope = require("eslint-scope"),
+const eslintScope = require("eslint-scope"),
     levn = require("levn"),
     lodash = require("lodash"),
     blankScriptAST = require("../conf/blank-script.json"),
@@ -20,6 +19,7 @@ const EventEmitter = require("events").EventEmitter,
     validator = require("./config/config-validator"),
     Environments = require("./config/environments"),
     applyDisableDirectives = require("./util/apply-disable-directives"),
+    createEmitter = require("./util/safe-emitter"),
     NodeEventGenerator = require("./util/node-event-generator"),
     SourceCode = require("./util/source-code"),
     Traverser = require("./util/traverser"),
@@ -111,8 +111,10 @@ function parseJsonConfig(string, location) {
         // ignore to parse the string by a fallback.
     }
 
-    // Optionator cannot parse commaless notations.
-    // But we are supporting that. So this is a fallback for that.
+    /*
+     * Optionator cannot parse commaless notations.
+     * But we are supporting that. So this is a fallback for that.
+     */
     items = {};
     string = string.replace(/([a-zA-Z0-9\-/]+):/g, "\"$1\":").replace(/(]|[0-9])\s+(?=")/, "$1,");
     try {
@@ -164,13 +166,12 @@ function parseListConfig(string) {
  * Ensures that variables representing built-in properties of the Global Object,
  * and any globals declared by special block comments, are present in the global
  * scope.
- * @param {ASTNode} program The top node of the AST.
  * @param {Scope} globalScope The global scope.
  * @param {Object} config The existing configuration data.
  * @param {Environments} envContext Env context
  * @returns {void}
  */
-function addDeclaredGlobals(program, globalScope, config, envContext) {
+function addDeclaredGlobals(globalScope, config, envContext) {
     const declaredGlobals = {},
         exportedGlobals = {},
         explicitGlobals = {},
@@ -277,7 +278,7 @@ function createDisableDirectives(type, loc, value) {
  * @param {string} filename The file being checked.
  * @param {ASTNode} ast The top node of the AST.
  * @param {Object} config The existing configuration data.
- * @param {Linter} linterContext Linter context object
+ * @param {function(string): {create: Function}} ruleMapper A map from rule IDs to defined rules
  * @returns {{
  *      config: Object,
  *      problems: Problem[],
@@ -290,9 +291,9 @@ function createDisableDirectives(type, loc, value) {
  * }} Modified config object, along with any problems encountered
  * while parsing config comments
  */
-function modifyConfigsFromComments(filename, ast, config, linterContext) {
+function modifyConfigsFromComments(filename, ast, config, ruleMapper) {
 
-    let commentConfig = {
+    const commentConfig = {
         exported: {},
         astGlobals: {},
         rules: {},
@@ -321,10 +322,6 @@ function modifyConfigsFromComments(filename, ast, config, linterContext) {
                         Object.assign(commentConfig.astGlobals, parseBooleanConfig(value, comment));
                         break;
 
-                    case "eslint-env":
-                        Object.assign(commentConfig.env, parseListConfig(value));
-                        break;
-
                     case "eslint-disable":
                         [].push.apply(disableDirectives, createDisableDirectives("disable", comment.loc.start, value));
                         break;
@@ -340,7 +337,7 @@ function modifyConfigsFromComments(filename, ast, config, linterContext) {
                             Object.keys(parseResult.config).forEach(name => {
                                 const ruleValue = parseResult.config[name];
 
-                                validator.validateRuleOptions(name, ruleValue, `${filename} line ${comment.loc.start.line}`, linterContext.rules);
+                                validator.validateRuleOptions(ruleMapper(name), name, ruleValue, `${filename} line ${comment.loc.start.line}`);
                                 commentRules[name] = ruleValue;
                             });
                         } else {
@@ -362,14 +359,6 @@ function modifyConfigsFromComments(filename, ast, config, linterContext) {
         }
     });
 
-    // apply environment configs
-    Object.keys(commentConfig.env).forEach(name => {
-        const env = linterContext.environments.get(name);
-
-        if (env) {
-            commentConfig = ConfigOps.merge(commentConfig, env);
-        }
-    });
     Object.assign(commentConfig.rules, commentRules);
 
     return {
@@ -392,8 +381,10 @@ function normalizeEcmaVersion(ecmaVersion, isModule) {
         ecmaVersion = 6;
     }
 
-    // Calculate ECMAScript edition number from official year version starting with
-    // ES2015, which corresponds with ES6 (or a difference of 2009).
+    /*
+     * Calculate ECMAScript edition number from official year version starting with
+     * ES2015, which corresponds with ES6 (or a difference of 2009).
+     */
     if (ecmaVersion >= 2015) {
         ecmaVersion -= 2009;
     }
@@ -698,6 +689,8 @@ const BASE_TRAVERSAL_CONTEXT = Object.freeze(
     )
 );
 
+const lastSourceCodes = new WeakMap();
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -709,7 +702,7 @@ const BASE_TRAVERSAL_CONTEXT = Object.freeze(
 module.exports = class Linter {
 
     constructor() {
-        this.sourceCode = null;
+        lastSourceCodes.set(this, null);
         this.version = pkg.version;
 
         this.rules = new Rules();
@@ -734,20 +727,24 @@ module.exports = class Linter {
      * @param {(string|Object)} [filenameOrOptions] The optional filename of the file being checked.
      *      If this is not set, the filename will default to '<input>' in the rule context. If
      *      an object, then it has "filename", "saveState", and "allowInlineConfig" properties.
-     * @param {boolean} [filenameOrOptions.allowInlineConfig] Allow/disallow inline comments' ability to change config once it is set. Defaults to true if not supplied.
+     * @param {boolean} [filenameOrOptions.allowInlineConfig=true] Allow/disallow inline comments' ability to change config once it is set. Defaults to true if not supplied.
      *      Useful if you want to validate JS without comments overriding rules.
+     * @param {boolean} [filenameOrOptions.reportUnusedDisableDirectives=false] Adds reported errors for unused
+     *      eslint-disable directives
      * @returns {Object[]} The results as an array of messages or null if no messages.
      */
     _verifyWithoutProcessors(textOrSourceCode, config, filenameOrOptions) {
         let text,
             parserServices,
             allowInlineConfig,
-            providedFilename;
+            providedFilename,
+            reportUnusedDisableDirectives;
 
         // evaluate arguments
         if (typeof filenameOrOptions === "object") {
             providedFilename = filenameOrOptions.filename;
             allowInlineConfig = filenameOrOptions.allowInlineConfig;
+            reportUnusedDisableDirectives = filenameOrOptions.reportUnusedDisableDirectives;
         } else {
             providedFilename = filenameOrOptions;
         }
@@ -755,11 +752,11 @@ module.exports = class Linter {
         const filename = typeof providedFilename === "string" ? providedFilename : "<input>";
 
         if (typeof textOrSourceCode === "string") {
-            this.sourceCode = null;
+            lastSourceCodes.set(this, null);
             text = textOrSourceCode;
         } else {
-            this.sourceCode = textOrSourceCode;
-            text = this.sourceCode.text;
+            lastSourceCodes.set(this, textOrSourceCode);
+            text = textOrSourceCode.text;
         }
 
         // search and apply "eslint-env *".
@@ -778,13 +775,13 @@ module.exports = class Linter {
         // process initial config to make it safe to extend
         config = prepareConfig(config, this.environments);
 
-        if (this.sourceCode) {
+        if (lastSourceCodes.get(this)) {
             parserServices = {};
         } else {
 
             // there's no input, just exit here
             if (text.trim().length === 0) {
-                this.sourceCode = new SourceCode(text, blankScriptAST);
+                lastSourceCodes.set(this, new SourceCode(text, blankScriptAST));
                 return [];
             }
 
@@ -800,16 +797,16 @@ module.exports = class Linter {
             }
 
             parserServices = parseResult.services;
-            this.sourceCode = new SourceCode(text, parseResult.ast);
+            lastSourceCodes.set(this, new SourceCode(text, parseResult.ast));
         }
 
         const problems = [];
-        const sourceCode = this.sourceCode;
+        const sourceCode = lastSourceCodes.get(this);
         let disableDirectives;
 
         // parse global comments and modify config
         if (allowInlineConfig !== false) {
-            const modifyConfigResult = modifyConfigsFromComments(filename, sourceCode.ast, config, this);
+            const modifyConfigResult = modifyConfigsFromComments(filename, sourceCode.ast, config, ruleId => this.rules.get(ruleId));
 
             config = modifyConfigResult.config;
             modifyConfigResult.problems.forEach(problem => problems.push(problem));
@@ -818,7 +815,7 @@ module.exports = class Linter {
             disableDirectives = [];
         }
 
-        const emitter = new EventEmitter().setMaxListeners(Infinity);
+        const emitter = createEmitter();
         const traverser = new Traverser();
         const ecmaFeatures = config.parserOptions.ecmaFeatures || {};
         const ecmaVersion = config.parserOptions.ecmaVersion || 5;
@@ -861,7 +858,7 @@ module.exports = class Linter {
                      */
                     _linter: {
                         report() {},
-                        on: emitter.on.bind(emitter)
+                        on: emitter.on
                     }
                 }
             )
@@ -946,7 +943,7 @@ module.exports = class Linter {
         });
 
         // augment global scope with declared global variables
-        addDeclaredGlobals(sourceCode.ast, scopeManager.scopes[0], config, this.environments);
+        addDeclaredGlobals(scopeManager.scopes[0], config, this.environments);
 
         const eventGenerator = new CodePathAnalyzer(new NodeEventGenerator(emitter));
 
@@ -968,7 +965,8 @@ module.exports = class Linter {
 
         return applyDisableDirectives({
             directives: disableDirectives,
-            problems: problems.sort((problemA, problemB) => problemA.line - problemB.line || problemA.column - problemB.column)
+            problems: problems.sort((problemA, problemB) => problemA.line - problemB.line || problemA.column - problemB.column),
+            reportUnusedDisableDirectives
         });
     }
 
@@ -1006,7 +1004,7 @@ module.exports = class Linter {
      * @returns {SourceCode} The SourceCode object.
      */
     getSourceCode() {
-        return this.sourceCode;
+        return lastSourceCodes.get(this);
     }
 
     /**
@@ -1082,8 +1080,10 @@ module.exports = class Linter {
             debug(`Generating fixed text for ${debugTextDescription} (pass ${passNumber})`);
             fixedResult = SourceCodeFixer.applyFixes(text, messages, shouldFix);
 
-            // stop if there are any syntax errors.
-            // 'fixedResult.output' is a empty string.
+            /*
+             * stop if there are any syntax errors.
+             * 'fixedResult.output' is a empty string.
+             */
             if (messages.length === 1 && messages[0].fatal) {
                 break;
             }