eslint 3.13.1 → 3.16.0

package/lib/rules/brace-style.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -52,215 +54,86 @@ module.exports = {
         //--------------------------------------------------------------------------
 
         /**
-         * Determines if a given node is a block statement.
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} True if the node is a block statement, false if not.
-         * @private
-         */
-        function isBlock(node) {
-            return node && node.type === "BlockStatement";
-        }
-
-        /**
-         * Check if the token is an punctuator with a value of curly brace
-         * @param {Object} token - Token to check
-         * @returns {boolean} true if its a curly punctuator
-         * @private
-         */
-        function isCurlyPunctuator(token) {
-            return token.value === "{" || token.value === "}";
-        }
-
-        /**
-        * Reports a place where a newline unexpectedly appears
-        * @param {ASTNode} node The node to report
-        * @param {string} message The message to report
+        * Fixes a place where a newline unexpectedly appears
         * @param {Token} firstToken The token before the unexpected newline
-        * @returns {void}
+        * @param {Token} secondToken The token after the unexpected newline
+        * @returns {Function} A fixer function to remove the newlines between the tokens
         */
-        function reportExtraNewline(node, message, firstToken) {
-            context.report({
-                node,
-                message,
-                fix(fixer) {
-                    const secondToken = sourceCode.getTokenAfter(firstToken);
-                    const textBetween = sourceCode.getText().slice(firstToken.range[1], secondToken.range[0]);
-                    const NEWLINE_REGEX = /\r\n|\r|\n|\u2028|\u2029/g;
+        function removeNewlineBetween(firstToken, secondToken) {
+            const textRange = [firstToken.range[1], secondToken.range[0]];
+            const textBetween = sourceCode.text.slice(textRange[0], textRange[1]);
+            const NEWLINE_REGEX = astUtils.createGlobalLinebreakMatcher();
 
-                    // Don't do a fix if there is a comment between the tokens.
-                    return textBetween.trim() ? null : fixer.replaceTextRange([firstToken.range[1], secondToken.range[0]], textBetween.replace(NEWLINE_REGEX, ""));
-                }
-            });
+            // Don't do a fix if there is a comment between the tokens
+            return fixer => fixer.replaceTextRange(textRange, textBetween.trim() ? null : textBetween.replace(NEWLINE_REGEX, ""));
         }
 
         /**
-         * Binds a list of properties to a function that verifies that the opening
-         * curly brace is on the same line as its controlling statement of a given
-         * node.
-         * @param {...string} The properties to check on the node.
-         * @returns {Function} A function that will perform the check on a node
-         * @private
-         */
-        function checkBlock() {
-            const blockProperties = arguments;
-
-            return function(node) {
-                Array.prototype.forEach.call(blockProperties, blockProp => {
-                    const block = node[blockProp];
-
-                    if (!isBlock(block)) {
-                        return;
-                    }
-
-                    const previousToken = sourceCode.getTokenBefore(block);
-                    const curlyToken = sourceCode.getFirstToken(block);
-                    const curlyTokenEnd = sourceCode.getLastToken(block);
-                    const allOnSameLine = previousToken.loc.start.line === curlyTokenEnd.loc.start.line;
-
-                    if (allOnSameLine && params.allowSingleLine) {
-                        return;
-                    }
-
-                    if (style !== "allman" && previousToken.loc.start.line !== curlyToken.loc.start.line) {
-                        reportExtraNewline(node, OPEN_MESSAGE, previousToken);
-                    } else if (style === "allman" && previousToken.loc.start.line === curlyToken.loc.start.line) {
-                        context.report({
-                            node,
-                            message: OPEN_MESSAGE_ALLMAN,
-                            fix: fixer => fixer.insertTextBefore(curlyToken, "\n")
-                        });
-                    }
-
-                    if (!block.body.length) {
-                        return;
-                    }
-
-                    if (curlyToken.loc.start.line === block.body[0].loc.start.line) {
-                        context.report({
-                            node: block.body[0],
-                            message: BODY_MESSAGE,
-                            fix: fixer => fixer.insertTextAfter(curlyToken, "\n")
-                        });
-                    }
+        * Validates a pair of curly brackets based on the user's config
+        * @param {Token} openingCurly The opening curly bracket
+        * @param {Token} closingCurly The closing curly bracket
+        * @returns {void}
+        */
+        function validateCurlyPair(openingCurly, closingCurly) {
+            const tokenBeforeOpeningCurly = sourceCode.getTokenBefore(openingCurly);
+            const tokenAfterOpeningCurly = sourceCode.getTokenAfter(openingCurly);
+            const tokenBeforeClosingCurly = sourceCode.getTokenBefore(closingCurly);
+            const singleLineException = params.allowSingleLine && astUtils.isTokenOnSameLine(openingCurly, closingCurly);
 
-                    if (curlyTokenEnd.loc.start.line === block.body[block.body.length - 1].loc.end.line) {
-                        context.report({
-                            node: block.body[block.body.length - 1],
-                            message: CLOSE_MESSAGE_SINGLE,
-                            fix: fixer => fixer.insertTextBefore(curlyTokenEnd, "\n")
-                        });
-                    }
+            if (style !== "allman" && !astUtils.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly)) {
+                context.report({
+                    node: openingCurly,
+                    message: OPEN_MESSAGE,
+                    fix: removeNewlineBetween(tokenBeforeOpeningCurly, openingCurly)
                 });
-            };
-        }
-
-        /**
-         * Enforces the configured brace style on IfStatements
-         * @param {ASTNode} node An IfStatement node.
-         * @returns {void}
-         * @private
-         */
-        function checkIfStatement(node) {
-            checkBlock("consequent", "alternate")(node);
-
-            if (node.alternate) {
-
-                const tokens = sourceCode.getTokensBefore(node.alternate, 2);
-
-                if (style === "1tbs") {
-                    if (tokens[0].loc.start.line !== tokens[1].loc.start.line &&
-                        node.consequent.type === "BlockStatement" &&
-                        isCurlyPunctuator(tokens[0])) {
-                        reportExtraNewline(node.alternate, CLOSE_MESSAGE, tokens[0]);
-                    }
-                } else if (tokens[0].loc.start.line === tokens[1].loc.start.line) {
-                    context.report({
-                        node: node.alternate,
-                        message: CLOSE_MESSAGE_STROUSTRUP_ALLMAN,
-                        fix: fixer => fixer.insertTextAfter(tokens[0], "\n")
-                    });
-                }
-
             }
-        }
-
-        /**
-         * Enforces the configured brace style on TryStatements
-         * @param {ASTNode} node A TryStatement node.
-         * @returns {void}
-         * @private
-         */
-        function checkTryStatement(node) {
-            checkBlock("block", "finalizer")(node);
 
-            if (isBlock(node.finalizer)) {
-                const tokens = sourceCode.getTokensBefore(node.finalizer, 2);
-
-                if (style === "1tbs") {
-                    if (tokens[0].loc.start.line !== tokens[1].loc.start.line) {
-                        reportExtraNewline(node.finalizer, CLOSE_MESSAGE, tokens[0]);
-                    }
-                } else if (tokens[0].loc.start.line === tokens[1].loc.start.line) {
-                    context.report({
-                        node: node.finalizer,
-                        message: CLOSE_MESSAGE_STROUSTRUP_ALLMAN,
-                        fix: fixer => fixer.insertTextAfter(tokens[0], "\n")
-                    });
-                }
+            if (style === "allman" && astUtils.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly) && !singleLineException) {
+                context.report({
+                    node: openingCurly,
+                    message: OPEN_MESSAGE_ALLMAN,
+                    fix: fixer => fixer.insertTextBefore(openingCurly, "\n")
+                });
             }
-        }
-
-        /**
-         * Enforces the configured brace style on CatchClauses
-         * @param {ASTNode} node A CatchClause node.
-         * @returns {void}
-         * @private
-         */
-        function checkCatchClause(node) {
-            const previousToken = sourceCode.getTokenBefore(node),
-                firstToken = sourceCode.getFirstToken(node);
 
-            checkBlock("body")(node);
+            if (astUtils.isTokenOnSameLine(openingCurly, tokenAfterOpeningCurly) && tokenAfterOpeningCurly !== closingCurly && !singleLineException) {
+                context.report({
+                    node: openingCurly,
+                    message: BODY_MESSAGE,
+                    fix: fixer => fixer.insertTextAfter(openingCurly, "\n")
+                });
+            }
 
-            if (isBlock(node.body)) {
-                if (style === "1tbs") {
-                    if (previousToken.loc.start.line !== firstToken.loc.start.line) {
-                        reportExtraNewline(node, CLOSE_MESSAGE, previousToken);
-                    }
-                } else {
-                    if (previousToken.loc.start.line === firstToken.loc.start.line) {
-                        context.report({
-                            node,
-                            message: CLOSE_MESSAGE_STROUSTRUP_ALLMAN,
-                            fix: fixer => fixer.insertTextAfter(previousToken, "\n")
-                        });
-                    }
-                }
+            if (tokenBeforeClosingCurly !== openingCurly && !singleLineException && astUtils.isTokenOnSameLine(tokenBeforeClosingCurly, closingCurly)) {
+                context.report({
+                    node: closingCurly,
+                    message: CLOSE_MESSAGE_SINGLE,
+                    fix: fixer => fixer.insertTextBefore(closingCurly, "\n")
+                });
             }
         }
 
         /**
-         * Enforces the configured brace style on SwitchStatements
-         * @param {ASTNode} node A SwitchStatement node.
-         * @returns {void}
-         * @private
-         */
-        function checkSwitchStatement(node) {
-            let tokens;
+        * Validates the location of a token that appears before a keyword (e.g. a newline before `else`)
+        * @param {Token} curlyToken The closing curly token. This is assumed to precede a keyword token (such as `else` or `finally`).
+        * @returns {void}
+        */
+        function validateCurlyBeforeKeyword(curlyToken) {
+            const keywordToken = sourceCode.getTokenAfter(curlyToken);
 
-            if (node.cases && node.cases.length) {
-                tokens = sourceCode.getTokensBefore(node.cases[0], 2);
-            } else {
-                tokens = sourceCode.getLastTokens(node, 3);
+            if (style === "1tbs" && !astUtils.isTokenOnSameLine(curlyToken, keywordToken)) {
+                context.report({
+                    node: curlyToken,
+                    message: CLOSE_MESSAGE,
+                    fix: removeNewlineBetween(curlyToken, keywordToken)
+                });
             }
 
-            if (style !== "allman" && tokens[0].loc.start.line !== tokens[1].loc.start.line) {
-                reportExtraNewline(node, OPEN_MESSAGE, tokens[0]);
-            } else if (style === "allman" && tokens[0].loc.start.line === tokens[1].loc.start.line) {
+            if (style !== "1tbs" && astUtils.isTokenOnSameLine(curlyToken, keywordToken)) {
                 context.report({
-                    node,
-                    message: OPEN_MESSAGE_ALLMAN,
-                    fix: fixer => fixer.insertTextBefore(tokens[1], "\n")
+                    node: curlyToken,
+                    message: CLOSE_MESSAGE_STROUSTRUP_ALLMAN,
+                    fix: fixer => fixer.insertTextAfter(curlyToken, "\n")
                 });
             }
         }
@@ -270,20 +143,38 @@ module.exports = {
         //--------------------------------------------------------------------------
 
         return {
-            FunctionDeclaration: checkBlock("body"),
-            FunctionExpression: checkBlock("body"),
-            ArrowFunctionExpression: checkBlock("body"),
-            IfStatement: checkIfStatement,
-            TryStatement: checkTryStatement,
-            CatchClause: checkCatchClause,
-            DoWhileStatement: checkBlock("body"),
-            WhileStatement: checkBlock("body"),
-            WithStatement: checkBlock("body"),
-            ForStatement: checkBlock("body"),
-            ForInStatement: checkBlock("body"),
-            ForOfStatement: checkBlock("body"),
-            SwitchStatement: checkSwitchStatement
-        };
+            BlockStatement(node) {
+                if (!astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)) {
+                    validateCurlyPair(sourceCode.getFirstToken(node), sourceCode.getLastToken(node));
+                }
+            },
+            ClassBody(node) {
+                validateCurlyPair(sourceCode.getFirstToken(node), sourceCode.getLastToken(node));
+            },
+            SwitchStatement(node) {
+                const closingCurly = sourceCode.getLastToken(node);
+                const openingCurly = sourceCode.getTokenBefore(node.cases.length ? node.cases[0] : closingCurly);
+
+                validateCurlyPair(openingCurly, closingCurly);
+            },
+            IfStatement(node) {
+                if (node.consequent.type === "BlockStatement" && node.alternate) {
+
+                    // Handle the keyword after the `if` block (before `else`)
+                    validateCurlyBeforeKeyword(sourceCode.getLastToken(node.consequent));
+                }
+            },
+            TryStatement(node) {
+
+                // Handle the keyword after the `try` block (before `catch` or `finally`)
+                validateCurlyBeforeKeyword(sourceCode.getLastToken(node.block));
 
+                if (node.handler && node.finalizer) {
+
+                    // Handle the keyword after the `catch` block (before `finally`)
+                    validateCurlyBeforeKeyword(sourceCode.getLastToken(node.handler.body));
+                }
+            }
+        };
     }
 };

package/lib/rules/capitalized-comments.js

@@ -163,8 +163,8 @@ module.exports = {
          * otherwise.
          */
         function isInlineComment(comment) {
-            const previousToken = sourceCode.getTokenOrCommentBefore(comment),
-                nextToken = sourceCode.getTokenOrCommentAfter(comment);
+            const previousToken = sourceCode.getTokenBefore(comment, { includeComments: true }),
+                nextToken = sourceCode.getTokenAfter(comment, { includeComments: true });
 
             return Boolean(
                 previousToken &&
@@ -181,7 +181,7 @@ module.exports = {
          * @returns {boolean} True if the comment follows a valid comment.
          */
         function isConsecutiveComment(comment) {
-            const previousTokenOrComment = sourceCode.getTokenOrCommentBefore(comment);
+            const previousTokenOrComment = sourceCode.getTokenBefore(comment, { includeComments: true });
 
             return Boolean(
                 previousTokenOrComment &&
@@ -264,9 +264,9 @@ module.exports = {
                 commentValid = isCommentValid(comment, options);
 
             if (!commentValid) {
-                const message = capitalize === "always" ?
-                    ALWAYS_MESSAGE :
-                    NEVER_MESSAGE;
+                const message = capitalize === "always"
+                    ? ALWAYS_MESSAGE
+                    : NEVER_MESSAGE;
 
                 context.report({
                     node: null,         // Intentionally using loc instead

package/lib/rules/comma-dangle.js

@@ -20,7 +20,7 @@ const DEFAULT_OPTIONS = Object.freeze({
     objects: "never",
     imports: "never",
     exports: "never",
-    functions: "ignore",
+    functions: "ignore"
 });
 
 /**
@@ -53,7 +53,7 @@ function normalizeOptions(optionValue) {
             exports: optionValue,
 
             // For backward compatibility, always ignore functions.
-            functions: "ignore",
+            functions: "ignore"
         };
     }
     if (typeof optionValue === "object" && optionValue !== null) {
@@ -62,7 +62,7 @@ function normalizeOptions(optionValue) {
             objects: optionValue.objects || DEFAULT_OPTIONS.objects,
             imports: optionValue.imports || DEFAULT_OPTIONS.imports,
             exports: optionValue.exports || DEFAULT_OPTIONS.exports,
-            functions: optionValue.functions || DEFAULT_OPTIONS.functions,
+            functions: optionValue.functions || DEFAULT_OPTIONS.functions
         };
     }
 
@@ -121,7 +121,7 @@ module.exports = {
                         additionalProperties: false
                     }
                 ]
-            },
+            }
         ]
     },
 
@@ -312,7 +312,7 @@ module.exports = {
             "always-multiline": forceTrailingCommaIfMultiline,
             "only-multiline": allowTrailingCommaIfMultiline,
             never: forbidTrailingComma,
-            ignore: lodash.noop,
+            ignore: lodash.noop
         };
 
         return {
@@ -330,7 +330,7 @@ module.exports = {
             FunctionExpression: predicate[options.functions],
             ArrowFunctionExpression: predicate[options.functions],
             CallExpression: predicate[options.functions],
-            NewExpression: predicate[options.functions],
+            NewExpression: predicate[options.functions]
         };
     }
 };

package/lib/rules/comma-spacing.js

@@ -78,27 +78,27 @@ module.exports = {
                     if (options[dir]) {
                         if (dir === "before") {
                             return fixer.insertTextBefore(node, " ");
-                        } else {
-                            return fixer.insertTextAfter(node, " ");
                         }
-                    } else {
-                        let start, end;
-                        const newText = "";
+                        return fixer.insertTextAfter(node, " ");
 
-                        if (dir === "before") {
-                            start = otherNode.range[1];
-                            end = node.range[0];
-                        } else {
-                            start = node.range[1];
-                            end = otherNode.range[0];
-                        }
+                    }
+                    let start, end;
+                    const newText = "";
 
-                        return fixer.replaceTextRange([start, end], newText);
+                    if (dir === "before") {
+                        start = otherNode.range[1];
+                        end = node.range[0];
+                    } else {
+                        start = node.range[1];
+                        end = otherNode.range[0];
                     }
+
+                    return fixer.replaceTextRange([start, end], newText);
+
                 },
-                message: options[dir] ?
-                  "A space is required {{dir}} ','." :
-                  "There should be no space {{dir}} ','.",
+                message: options[dir]
+                  ? "A space is required {{dir}} ','."
+                  : "There should be no space {{dir}} ','.",
                 data: {
                     dir
                 }

package/lib/rules/comma-style.js

@@ -48,7 +48,7 @@ module.exports = {
             FunctionDeclaration: true,
             FunctionExpression: true,
             ImportDeclaration: true,
-            ObjectPattern: true,
+            ObjectPattern: true
         };
 
         if (context.options.length === 2 && context.options[1].hasOwnProperty("exceptions")) {

package/lib/rules/consistent-return.js

@@ -104,7 +104,7 @@ module.exports = {
             } else if (node.type === "ArrowFunctionExpression") {
 
                 // `=>` token
-                loc = context.getSourceCode().getTokenBefore(node.body).loc.start;
+                loc = context.getSourceCode().getTokenBefore(node.body, astUtils.isArrowToken).loc.start;
                 type = "function";
             } else if (
                 node.parent.type === "MethodDefinition" ||

package/lib/rules/constructor-super.js

@@ -209,9 +209,9 @@ module.exports = {
 
                 if (!calledInEveryPaths) {
                     context.report({
-                        message: calledInSomePaths ?
-                            "Lacked a call of 'super()' in some code paths." :
-                            "Expected to call 'super()'.",
+                        message: calledInSomePaths
+                            ? "Lacked a call of 'super()' in some code paths."
+                            : "Expected to call 'super()'.",
                         node: node.parent
                     });
                 }

package/lib/rules/curly.js

@@ -94,19 +94,23 @@ module.exports = {
             return first.loc.start.line === last.loc.end.line;
         }
 
+        /**
+         * Checks if the given token is an `else` token or not.
+         *
+         * @param {Token} token - The token to check.
+         * @returns {boolean} `true` if the token is an `else` token.
+         */
+        function isElseKeywordToken(token) {
+            return token.value === "else" && token.type === "Keyword";
+        }
+
         /**
          * Gets the `else` keyword token of a given `IfStatement` node.
          * @param {ASTNode} node - A `IfStatement` node to get.
          * @returns {Token} The `else` keyword token.
          */
         function getElseKeyword(node) {
-            let token = sourceCode.getTokenAfter(node.consequent);
-
-            while (token.type !== "Keyword" || token.value !== "else") {
-                token = sourceCode.getTokenAfter(token);
-            }
-
-            return token;
+            return node.alternate && sourceCode.getFirstTokenBetween(node.consequent, node.alternate, isElseKeywordToken);
         }
 
         /**

package/lib/rules/default-case.js

@@ -31,9 +31,9 @@ module.exports = {
 
     create(context) {
         const options = context.options[0] || {};
-        const commentPattern = options.commentPattern ?
-            new RegExp(options.commentPattern) :
-            DEFAULT_COMMENT_PATTERN;
+        const commentPattern = options.commentPattern
+            ? new RegExp(options.commentPattern)
+            : DEFAULT_COMMENT_PATTERN;
 
         const sourceCode = context.getSourceCode();
 

package/lib/rules/eqeqeq.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -57,9 +63,9 @@ module.exports = {
         const options = context.options[1] || {};
         const sourceCode = context.getSourceCode();
 
-        const nullOption = (config === "always") ?
-            options.null || "always" :
-            "ignore";
+        const nullOption = (config === "always")
+            ? options.null || "always"
+            : "ignore";
         const enforceRuleForNull = (nullOption === "always");
         const enforceInverseRuleForNull = (nullOption === "never");
 
@@ -100,8 +106,7 @@ module.exports = {
          * @private
          */
         function isNullCheck(node) {
-            return (node.right.type === "Literal" && node.right.value === null) ||
-                    (node.left.type === "Literal" && node.left.value === null);
+            return astUtils.isNullLiteral(node.right) || astUtils.isNullLiteral(node.left);
         }
 
         /**
@@ -134,7 +139,11 @@ module.exports = {
 
                     // If the comparison is a `typeof` comparison or both sides are literals with the same type, then it's safe to fix.
                     if (isTypeOfBinary(node) || areLiteralsAndSameType(node)) {
-                        const operatorToken = sourceCode.getTokensBetween(node.left, node.right).find(token => token.value === node.operator);
+                        const operatorToken = sourceCode.getFirstTokenBetween(
+                            node.left,
+                            node.right,
+                            token => token.value === node.operator
+                        );
 
                         return fixer.replaceText(operatorToken, expectedOperator);
                     }

package/lib/rules/func-call-spacing.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -67,28 +73,19 @@ module.exports = {
          * @private
          */
         function checkSpacing(node) {
+            const lastToken = sourceCode.getLastToken(node);
             const lastCalleeToken = sourceCode.getLastToken(node.callee);
-            let prevToken = lastCalleeToken;
-            let parenToken = sourceCode.getTokenAfter(lastCalleeToken);
-
-            // advances to an open parenthesis.
-            while (
-                parenToken &&
-                parenToken.range[1] < node.range[1] &&
-                parenToken.value !== "("
-            ) {
-                prevToken = parenToken;
-                parenToken = sourceCode.getTokenAfter(parenToken);
-            }
+            const parenToken = sourceCode.getFirstTokenBetween(lastCalleeToken, lastToken, astUtils.isOpeningParenToken);
+            const prevToken = parenToken && sourceCode.getTokenBefore(parenToken);
 
             // Parens in NewExpression are optional
             if (!(parenToken && parenToken.range[1] < node.range[1])) {
                 return;
             }
 
-            const hasWhitespace = sourceCode.isSpaceBetweenTokens(prevToken, parenToken);
-            const hasNewline = hasWhitespace &&
-                /\n/.test(text.slice(prevToken.range[1], parenToken.range[0]).replace(/\/\*.*?\*\//g, ""));
+            const textBetweenTokens = text.slice(prevToken.range[1], parenToken.range[0]).replace(/\/\*.*?\*\//g, "");
+            const hasWhitespace = /\s/.test(textBetweenTokens);
+            const hasNewline = hasWhitespace && astUtils.LINEBREAK_MATCHER.test(textBetweenTokens);
 
             /*
              * never allowNewlines hasWhitespace hasNewline message

package/lib/rules/func-name-matching.js

@@ -155,7 +155,7 @@ module.exports = {
                     return;
                 }
 
-                const isProp = node.left.type === "MemberExpression" ? true : false;
+                const isProp = node.left.type === "MemberExpression";
                 const name = isProp ? astUtils.getStaticPropertyName(node.left) : node.left.name;
 
                 if (node.right.id && isIdentifier(name) && shouldWarn(name, node.right.id.name)) {