eslint 4.7.1 → 4.10.0

package/lib/rules/no-var.js

@@ -15,6 +15,15 @@ const astUtils = require("../ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
+/**
+ * Check whether a given variable is a global variable or not.
+ * @param {eslint-scope.Variable} variable The variable to check.
+ * @returns {boolean} `true` if the variable is a global variable.
+ */
+function isGlobal(variable) {
+    return Boolean(variable.scope) && variable.scope.type === "global";
+}
+
 /**
  * Finds the nearest function scope or global scope walking up the scope
  * hierarchy.
@@ -203,6 +212,7 @@ module.exports = {
          * Checks whether it can fix a given variable declaration or not.
          * It cannot fix if the following cases:
          *
+         * - A variable is a global variable.
          * - A variable is declared on a SwitchCase node.
          * - A variable is redeclared.
          * - A variable is used from outside the scope.
@@ -256,6 +266,7 @@ module.exports = {
 
             if (node.parent.type === "SwitchCase" ||
                 node.declarations.some(hasSelfReferenceInTDZ) ||
+                variables.some(isGlobal) ||
                 variables.some(isRedeclared) ||
                 variables.some(isUsedFromOutsideOf(scopeNode))
             ) {

package/lib/rules/object-shorthand.js

@@ -215,8 +215,12 @@ module.exports = {
         * @returns {Object} A fix for this node
         */
         function makeFunctionShorthand(fixer, node) {
-            const firstKeyToken = node.computed ? sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken) : sourceCode.getFirstToken(node.key);
-            const lastKeyToken = node.computed ? sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken) : sourceCode.getLastToken(node.key);
+            const firstKeyToken = node.computed
+                ? sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken)
+                : sourceCode.getFirstToken(node.key);
+            const lastKeyToken = node.computed
+                ? sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken)
+                : sourceCode.getLastToken(node.key);
             const keyText = sourceCode.text.slice(firstKeyToken.range[0], lastKeyToken.range[1]);
             let keyPrefix = "";
 

package/lib/rules/operator-linebreak.js

@@ -87,7 +87,9 @@ module.exports = {
                 if (hasLinebreakBefore !== hasLinebreakAfter && desiredStyle !== "none") {
 
                     // If there is a comment before and after the operator, don't do a fix.
-                    if (sourceCode.getTokenBefore(operatorToken, { includeComments: true }) !== tokenBefore && sourceCode.getTokenAfter(operatorToken, { includeComments: true }) !== tokenAfter) {
+                    if (sourceCode.getTokenBefore(operatorToken, { includeComments: true }) !== tokenBefore &&
+                        sourceCode.getTokenAfter(operatorToken, { includeComments: true }) !== tokenAfter) {
+
                         return null;
                     }
 

package/lib/rules/padding-line-between-statements.js

@@ -205,14 +205,14 @@ function verifyForAny() {
  * blank lines automatically.
  *
  * @param {RuleContext} context The rule context to report.
- * @param {ASTNode} prevNode The previous node to check.
+ * @param {ASTNode} _ Unused. The previous node to check.
  * @param {ASTNode} nextNode The next node to check.
  * @param {Array<Token[]>} paddingLines The array of token pairs that blank
  * lines exist between the pair.
  * @returns {void}
  * @private
  */
-function verifyForNever(context, prevNode, nextNode, paddingLines) {
+function verifyForNever(context, _, nextNode, paddingLines) {
     if (paddingLines.length === 0) {
         return;
     }

package/lib/rules/require-jsdoc.js

@@ -30,6 +30,9 @@ module.exports = {
                             },
                             ArrowFunctionExpression: {
                                 type: "boolean"
+                            },
+                            FunctionExpression: {
+                                type: "boolean"
                             }
                         },
                         additionalProperties: false
@@ -45,7 +48,9 @@ module.exports = {
         const DEFAULT_OPTIONS = {
             FunctionDeclaration: true,
             MethodDefinition: false,
-            ClassDeclaration: false
+            ClassDeclaration: false,
+            ArrowFunctionExpression: false,
+            FunctionExpression: false
         };
         const options = Object.assign(DEFAULT_OPTIONS, context.options[0] && context.options[0].require || {});
 
@@ -58,21 +63,6 @@ module.exports = {
             context.report({ node, message: "Missing JSDoc comment." });
         }
 
-        /**
-         * Check if the jsdoc comment is present for class methods
-         * @param {ASTNode} node node to examine
-         * @returns {void}
-         */
-        function checkClassMethodJsDoc(node) {
-            if (node.parent.type === "MethodDefinition") {
-                const jsdocComment = source.getJSDocComment(node);
-
-                if (!jsdocComment) {
-                    report(node);
-                }
-            }
-        }
-
         /**
          * Check if the jsdoc comment is present or not.
          * @param {ASTNode} node node to examine
@@ -93,8 +83,11 @@ module.exports = {
                 }
             },
             FunctionExpression(node) {
-                if (options.MethodDefinition) {
-                    checkClassMethodJsDoc(node);
+                if (
+                    (options.MethodDefinition && node.parent.type === "MethodDefinition") ||
+                    (options.FunctionExpression && (node.parent.type === "VariableDeclarator" || (node.parent.type === "Property" && node === node.parent.value)))
+                ) {
+                    checkJsDoc(node);
                 }
             },
             ClassDeclaration(node) {

package/lib/rules/sort-imports.js

@@ -67,9 +67,11 @@ module.exports = {
         function usedMemberSyntax(node) {
             if (node.specifiers.length === 0) {
                 return "none";
-            } else if (node.specifiers[0].type === "ImportNamespaceSpecifier") {
+            }
+            if (node.specifiers[0].type === "ImportNamespaceSpecifier") {
                 return "all";
-            } else if (node.specifiers.length === 1) {
+            }
+            if (node.specifiers.length === 1) {
                 return "single";
             }
             return "multiple";
@@ -149,7 +151,8 @@ module.exports = {
                             message: "Member '{{memberName}}' of the import declaration should be sorted alphabetically.",
                             data: { memberName: importSpecifiers[firstUnsortedIndex].local.name },
                             fix(fixer) {
-                                if (importSpecifiers.some(specifier => sourceCode.getCommentsBefore(specifier).length || sourceCode.getCommentsAfter(specifier).length)) {
+                                if (importSpecifiers.some(specifier =>
+                                    sourceCode.getCommentsBefore(specifier).length || sourceCode.getCommentsAfter(specifier).length)) {
 
                                     // If there are comments in the ImportSpecifier list, don't rearrange the specifiers.
                                     return null;

package/lib/rules/space-unary-ops.js

@@ -76,21 +76,19 @@ module.exports = {
 
         /**
         * Checks if an override exists for a given operator.
-        * @param {ASTnode} node AST node
         * @param {string} operator Operator
         * @returns {boolean} Whether or not an override has been provided for the operator
         */
-        function overrideExistsForOperator(node, operator) {
+        function overrideExistsForOperator(operator) {
             return options.overrides && options.overrides.hasOwnProperty(operator);
         }
 
         /**
         * Gets the value that the override was set to for this operator
-        * @param {ASTnode} node AST node
         * @param {string} operator Operator
         * @returns {boolean} Whether or not an override enforces a space with this operator
         */
-        function overrideEnforcesSpaces(node, operator) {
+        function overrideEnforcesSpaces(operator) {
             return options.overrides[operator];
         }
 
@@ -153,8 +151,8 @@ module.exports = {
         function checkUnaryWordOperatorForSpaces(node, firstToken, secondToken, word) {
             word = word || firstToken.value;
 
-            if (overrideExistsForOperator(node, word)) {
-                if (overrideEnforcesSpaces(node, word)) {
+            if (overrideExistsForOperator(word)) {
+                if (overrideEnforcesSpaces(word)) {
                     verifyWordHasSpaces(node, firstToken, secondToken, word);
                 } else {
                     verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word);
@@ -292,8 +290,8 @@ module.exports = {
 
             const operator = node.prefix ? tokens[0].value : tokens[1].value;
 
-            if (overrideExistsForOperator(node, operator)) {
-                if (overrideEnforcesSpaces(node, operator)) {
+            if (overrideExistsForOperator(operator)) {
+                if (overrideEnforcesSpaces(operator)) {
                     verifyNonWordsHaveSpaces(node, firstToken, secondToken);
                 } else {
                     verifyNonWordsDontHaveSpaces(node, firstToken, secondToken);

package/lib/rules/valid-jsdoc.js

@@ -226,8 +226,10 @@ module.exports = {
         function checkJSDoc(node) {
             const jsdocNode = sourceCode.getJSDocComment(node),
                 functionData = fns.pop(),
-                params = Object.create(null);
+                params = Object.create(null),
+                paramsTags = [];
             let hasReturns = false,
+                returnsTag,
                 hasConstructor = false,
                 isInterface = false,
                 isOverride = false,
@@ -261,43 +263,13 @@ module.exports = {
                         case "param":
                         case "arg":
                         case "argument":
-                            if (!tag.type) {
-                                context.report({ node: jsdocNode, message: "Missing JSDoc parameter type for '{{name}}'.", data: { name: tag.name } });
-                            }
-
-                            if (!tag.description && requireParamDescription) {
-                                context.report({ node: jsdocNode, message: "Missing JSDoc parameter description for '{{name}}'.", data: { name: tag.name } });
-                            }
-
-                            if (params[tag.name]) {
-                                context.report({ node: jsdocNode, message: "Duplicate JSDoc parameter '{{name}}'.", data: { name: tag.name } });
-                            } else if (tag.name.indexOf(".") === -1) {
-                                params[tag.name] = 1;
-                            }
+                            paramsTags.push(tag);
                             break;
 
                         case "return":
                         case "returns":
                             hasReturns = true;
-
-                            if (!requireReturn && !functionData.returnPresent && (tag.type === null || !isValidReturnType(tag)) && !isAbstract) {
-                                context.report({
-                                    node: jsdocNode,
-                                    message: "Unexpected @{{title}} tag; function has no return statement.",
-                                    data: {
-                                        title: tag.title
-                                    }
-                                });
-                            } else {
-                                if (requireReturnType && !tag.type) {
-                                    context.report({ node: jsdocNode, message: "Missing JSDoc return type." });
-                                }
-
-                                if (!isValidReturnType(tag) && !tag.description && requireReturnDescription) {
-                                    context.report({ node: jsdocNode, message: "Missing JSDoc return description." });
-                                }
-                            }
-
+                            returnsTag = tag;
                             break;
 
                         case "constructor":
@@ -333,6 +305,40 @@ module.exports = {
                     }
                 });
 
+                paramsTags.forEach(param => {
+                    if (!param.type) {
+                        context.report({ node: jsdocNode, message: "Missing JSDoc parameter type for '{{name}}'.", data: { name: param.name } });
+                    }
+                    if (!param.description && requireParamDescription) {
+                        context.report({ node: jsdocNode, message: "Missing JSDoc parameter description for '{{name}}'.", data: { name: param.name } });
+                    }
+                    if (params[param.name]) {
+                        context.report({ node: jsdocNode, message: "Duplicate JSDoc parameter '{{name}}'.", data: { name: param.name } });
+                    } else if (param.name.indexOf(".") === -1) {
+                        params[param.name] = 1;
+                    }
+                });
+
+                if (hasReturns) {
+                    if (!requireReturn && !functionData.returnPresent && (returnsTag.type === null || !isValidReturnType(returnsTag)) && !isAbstract) {
+                        context.report({
+                            node: jsdocNode,
+                            message: "Unexpected @{{title}} tag; function has no return statement.",
+                            data: {
+                                title: returnsTag.title
+                            }
+                        });
+                    } else {
+                        if (requireReturnType && !returnsTag.type) {
+                            context.report({ node: jsdocNode, message: "Missing JSDoc return type." });
+                        }
+
+                        if (!isValidReturnType(returnsTag) && !returnsTag.description && requireReturnDescription) {
+                            context.report({ node: jsdocNode, message: "Missing JSDoc return description." });
+                        }
+                    }
+                }
+
                 // check for functions missing @returns
                 if (!isOverride && !hasReturns && !hasConstructor && !isInterface &&
                     node.parent.kind !== "get" && node.parent.kind !== "constructor" &&

package/lib/testers/rule-tester.js

@@ -178,7 +178,7 @@ class RuleTester {
      */
     static setDefaultConfig(config) {
         if (typeof config !== "object") {
-            throw new Error("RuleTester.setDefaultConfig: config must be an object");
+            throw new TypeError("RuleTester.setDefaultConfig: config must be an object");
         }
         defaultConfig = config;
 
@@ -254,7 +254,7 @@ class RuleTester {
             linter = this.linter;
 
         if (lodash.isNil(test) || typeof test !== "object") {
-            throw new Error(`Test Scenarios for rule ${ruleName} : Could not find test scenario object`);
+            throw new TypeError(`Test Scenarios for rule ${ruleName} : Could not find test scenario object`);
         }
 
         requiredScenarios.forEach(scenarioType => {
@@ -369,6 +369,7 @@ class RuleTester {
             if (!lodash.isEqual(beforeAST, afterAST)) {
 
                 // Not using directly to avoid performance problem in node 6.1.0. See #6111
+                // eslint-disable-next-line no-restricted-properties
                 assert.deepEqual(beforeAST, afterAST, "Rule should not modify AST.");
             }
         }
@@ -384,7 +385,7 @@ class RuleTester {
             const result = runRuleForItem(item);
             const messages = result.messages;
 
-            assert.equal(messages.length, 0, util.format("Should have no errors but had %d: %s",
+            assert.strictEqual(messages.length, 0, util.format("Should have no errors but had %d: %s",
                 messages.length, util.inspect(messages)));
 
             assertASTDidntChange(result.beforeAST, result.afterAST);
@@ -408,7 +409,7 @@ class RuleTester {
                     `Expected '${actual}' to match ${expected}`
                 );
             } else {
-                assert.equal(actual, expected);
+                assert.strictEqual(actual, expected);
             }
         }
 
@@ -428,10 +429,10 @@ class RuleTester {
 
 
             if (typeof item.errors === "number") {
-                assert.equal(messages.length, item.errors, util.format("Should have %d error%s but had %d: %s",
+                assert.strictEqual(messages.length, item.errors, util.format("Should have %d error%s but had %d: %s",
                     item.errors, item.errors === 1 ? "" : "s", messages.length, util.inspect(messages)));
             } else {
-                assert.equal(
+                assert.strictEqual(
                     messages.length, item.errors.length,
                     util.format(
                         "Should have %d error%s but had %d: %s",
@@ -460,23 +461,35 @@ class RuleTester {
                             assertMessageMatches(messages[i].message, item.errors[i].message);
                         }
 
+                        // The following checks use loose equality assertions for backwards compatibility.
+
                         if (item.errors[i].type) {
+
+                            // eslint-disable-next-line no-restricted-properties
                             assert.equal(messages[i].nodeType, item.errors[i].type, `Error type should be ${item.errors[i].type}, found ${messages[i].nodeType}`);
                         }
 
                         if (item.errors[i].hasOwnProperty("line")) {
+
+                            // eslint-disable-next-line no-restricted-properties
                             assert.equal(messages[i].line, item.errors[i].line, `Error line should be ${item.errors[i].line}`);
                         }
 
                         if (item.errors[i].hasOwnProperty("column")) {
+
+                            // eslint-disable-next-line no-restricted-properties
                             assert.equal(messages[i].column, item.errors[i].column, `Error column should be ${item.errors[i].column}`);
                         }
 
                         if (item.errors[i].hasOwnProperty("endLine")) {
+
+                            // eslint-disable-next-line no-restricted-properties
                             assert.equal(messages[i].endLine, item.errors[i].endLine, `Error endLine should be ${item.errors[i].endLine}`);
                         }
 
                         if (item.errors[i].hasOwnProperty("endColumn")) {
+
+                            // eslint-disable-next-line no-restricted-properties
                             assert.equal(messages[i].endColumn, item.errors[i].endColumn, `Error endColumn should be ${item.errors[i].endColumn}`);
                         }
                     } else {
@@ -497,6 +510,7 @@ class RuleTester {
                 } else {
                     const fixResult = SourceCodeFixer.applyFixes(item.code, messages);
 
+                    // eslint-disable-next-line no-restricted-properties
                     assert.equal(fixResult.output, item.output, "Output is incorrect.");
                 }
             }

package/lib/util/apply-disable-directives.js

@@ -19,20 +19,24 @@ function compareLocations(itemA, itemB) {
 }
 
 /**
- * This is the same as the exported function, except that it doesn't handle disable-line and disable-next-line directives.
- * @param {Object} options options (see the exported function)
- * @returns {Problem[]} Filtered problems (see the exported function)
+ * This is the same as the exported function, except that it
+ * doesn't handle disable-line and disable-next-line directives, and it always reports unused
+ * disable directives.
+ * @param {Object} options options for applying directives. This is the same as the options
+ * for the exported function, except that `reportUnusedDisableDirectives` is not supported
+ * (this function always reports unused disable directives).
+ * @returns {{problems: Problem[], unusedDisableDirectives: Problem[]}} An object with a list
+ * of filtered problems and unused eslint-disable directives
  */
 function applyDirectives(options) {
     const problems = [];
     let nextDirectiveIndex = 0;
-    let globalDisableActive = false;
+    let currentGlobalDisableDirective = null;
+    const disabledRuleMap = new Map();
 
-    // disabledRules is only used when there is no active global /* eslint-disable */ comment.
-    const disabledRules = new Set();
-
-    // enabledRules is only used when there is an active global /* eslint-disable */ comment.
+    // enabledRules is only used when there is a current global disable directive.
     const enabledRules = new Set();
+    const usedDisableDirectives = new Set();
 
     for (const problem of options.problems) {
         while (
@@ -44,23 +48,26 @@ function applyDirectives(options) {
             switch (directive.type) {
                 case "disable":
                     if (directive.ruleId === null) {
-                        globalDisableActive = true;
+                        currentGlobalDisableDirective = directive;
+                        disabledRuleMap.clear();
                         enabledRules.clear();
-                    } else if (globalDisableActive) {
+                    } else if (currentGlobalDisableDirective) {
                         enabledRules.delete(directive.ruleId);
+                        disabledRuleMap.set(directive.ruleId, directive);
                     } else {
-                        disabledRules.add(directive.ruleId);
+                        disabledRuleMap.set(directive.ruleId, directive);
                     }
                     break;
 
                 case "enable":
                     if (directive.ruleId === null) {
-                        globalDisableActive = false;
-                        disabledRules.clear();
-                    } else if (globalDisableActive) {
+                        currentGlobalDisableDirective = null;
+                        disabledRuleMap.clear();
+                    } else if (currentGlobalDisableDirective) {
                         enabledRules.add(directive.ruleId);
+                        disabledRuleMap.delete(directive.ruleId);
                     } else {
-                        disabledRules.delete(directive.ruleId);
+                        disabledRuleMap.delete(directive.ruleId);
                     }
                     break;
 
@@ -68,15 +75,30 @@ function applyDirectives(options) {
             }
         }
 
-        if (
-            globalDisableActive && enabledRules.has(problem.ruleId) ||
-            !globalDisableActive && !disabledRules.has(problem.ruleId)
-        ) {
+        if (disabledRuleMap.has(problem.ruleId)) {
+            usedDisableDirectives.add(disabledRuleMap.get(problem.ruleId));
+        } else if (currentGlobalDisableDirective && !enabledRules.has(problem.ruleId)) {
+            usedDisableDirectives.add(currentGlobalDisableDirective);
+        } else {
             problems.push(problem);
         }
     }
 
-    return problems;
+    const unusedDisableDirectives = options.directives
+        .filter(directive => directive.type === "disable" && !usedDisableDirectives.has(directive))
+        .map(directive => ({
+            ruleId: null,
+            message: directive.ruleId
+                ? `Unused eslint-disable directive (no problems were reported from '${directive.ruleId}').`
+                : "Unused eslint-disable directive (no problems were reported).",
+            line: directive.unprocessedDirective.line,
+            column: directive.unprocessedDirective.column,
+            severity: 2,
+            source: null,
+            nodeType: null
+        }));
+
+    return { problems, unusedDisableDirectives };
 }
 
 /**
@@ -93,12 +115,14 @@ function applyDirectives(options) {
  * comment for two different rules is represented as two directives).
  * @param {{ruleId: (string|null), line: number, column: number}[]} options.problems
  * A list of problems reported by rules, sorted by increasing location in the file, with one-based columns.
+ * @param {boolean} options.reportUnusedDisableDirectives If `true`, adds additional problems for unused directives
  * @returns {{ruleId: (string|null), line: number, column: number}[]}
  * A list of reported problems that were not disabled by the directive comments.
  */
 module.exports = options => {
     const blockDirectives = options.directives
         .filter(directive => directive.type === "disable" || directive.type === "enable")
+        .map(directive => Object.assign({}, directive, { unprocessedDirective: directive }))
         .sort(compareLocations);
 
     const lineDirectives = lodash.flatMap(options.directives, directive => {
@@ -109,14 +133,14 @@ module.exports = options => {
 
             case "disable-line":
                 return [
-                    { type: "disable", line: directive.line, column: 1, ruleId: directive.ruleId },
-                    { type: "enable", line: directive.line + 1, column: 0, ruleId: directive.ruleId }
+                    { type: "disable", line: directive.line, column: 1, ruleId: directive.ruleId, unprocessedDirective: directive },
+                    { type: "enable", line: directive.line + 1, column: 0, ruleId: directive.ruleId, unprocessedDirective: directive }
                 ];
 
             case "disable-next-line":
                 return [
-                    { type: "disable", line: directive.line + 1, column: 1, ruleId: directive.ruleId },
-                    { type: "enable", line: directive.line + 2, column: 0, ruleId: directive.ruleId }
+                    { type: "disable", line: directive.line + 1, column: 1, ruleId: directive.ruleId, unprocessedDirective: directive },
+                    { type: "enable", line: directive.line + 2, column: 0, ruleId: directive.ruleId, unprocessedDirective: directive }
                 ];
 
             default:
@@ -124,8 +148,13 @@ module.exports = options => {
         }
     }).sort(compareLocations);
 
-    const problemsAfterBlockDirectives = applyDirectives({ problems: options.problems, directives: blockDirectives });
-    const problemsAfterLineDirectives = applyDirectives({ problems: problemsAfterBlockDirectives, directives: lineDirectives });
+    const blockDirectivesResult = applyDirectives({ problems: options.problems, directives: blockDirectives });
+    const lineDirectivesResult = applyDirectives({ problems: blockDirectivesResult.problems, directives: lineDirectives });
 
-    return problemsAfterLineDirectives.sort(compareLocations);
+    return options.reportUnusedDisableDirectives
+        ? lineDirectivesResult.problems
+            .concat(blockDirectivesResult.unusedDisableDirectives)
+            .concat(lineDirectivesResult.unusedDisableDirectives)
+            .sort(compareLocations)
+        : lineDirectivesResult.problems;
 };

package/lib/util/node-event-generator.js

@@ -160,7 +160,7 @@ function tryParseSelector(rawSelector) {
         return esquery.parse(rawSelector.replace(/:exit$/, ""));
     } catch (err) {
         if (typeof err.offset === "number") {
-            throw new Error(`Syntax error in selector "${rawSelector}" at position ${err.offset}: ${err.message}`);
+            throw new SyntaxError(`Syntax error in selector "${rawSelector}" at position ${err.offset}: ${err.message}`);
         }
         throw err;
     }
@@ -194,7 +194,7 @@ const parseSelector = lodash.memoize(rawSelector => {
  *
  * ```ts
  * interface EventGenerator {
- *     emitter: EventEmitter;
+ *     emitter: SafeEmitter;
  *     enterNode(node: ASTNode): void;
  *     leaveNode(node: ASTNode): void;
  * }
@@ -203,8 +203,10 @@ const parseSelector = lodash.memoize(rawSelector => {
 class NodeEventGenerator {
 
     /**
-    * @param {EventEmitter} emitter - An event emitter which is the destination of events. This emitter must already
+    * @param {SafeEmitter} emitter
+    * An SafeEmitter which is the destination of events. This emitter must already
     * have registered listeners for all of the events that it needs to listen for.
+    * (See lib/util/safe-emitter.js for more details on `SafeEmitter`.)
     * @returns {NodeEventGenerator} new instance
     */
     constructor(emitter) {
@@ -215,23 +217,7 @@ class NodeEventGenerator {
         this.anyTypeEnterSelectors = [];
         this.anyTypeExitSelectors = [];
 
-        const eventNames = typeof emitter.eventNames === "function"
-
-            // Use the built-in eventNames() function if available (Node 6+)
-            ? emitter.eventNames()
-
-            /*
-             * Otherwise, use the private _events property.
-             * Using a private property isn't ideal here, but this seems to
-             * be the best way to get a list of event names without overriding
-             * addEventListener, which would hurt performance. This property
-             * is widely used and unlikely to be removed in a future version
-             * (see https://github.com/nodejs/node/issues/1817). Also, future
-             * node versions will have eventNames() anyway.
-             */
-            : Object.keys(emitter._events); // eslint-disable-line no-underscore-dangle
-
-        eventNames.forEach(rawSelector => {
+        emitter.eventNames().forEach(rawSelector => {
             const selector = parseSelector(rawSelector);
 
             if (selector.listenerTypes) {