eslint 6.5.1 → 6.7.2

package/lib/rules/no-extra-bind.js

@@ -47,7 +47,6 @@ module.exports = {
          * Checks if a node is free of side effects.
          *
          * This check is stricter than it needs to be, in order to keep the implementation simple.
-         *
          * @param {ASTNode} node A node to check.
          * @returns {boolean} True if the node is known to be side-effect free, false otherwise.
          */
@@ -57,8 +56,7 @@ module.exports = {
 
         /**
          * Reports a given function node.
-         *
-         * @param {ASTNode} node - A node to report. This is a FunctionExpression or
+         * @param {ASTNode} node A node to report. This is a FunctionExpression or
          *      an ArrowFunctionExpression.
          * @returns {void}
          */
@@ -90,8 +88,7 @@ module.exports = {
          * method.
          *
          * e.g. `(function() {}.bind(foo))`
-         *
-         * @param {ASTNode} node - A node to report. This is a FunctionExpression or
+         * @param {ASTNode} node A node to report. This is a FunctionExpression or
          *      an ArrowFunctionExpression.
          * @returns {boolean} `true` if the node is the callee of `.bind()` method.
          */
@@ -113,8 +110,7 @@ module.exports = {
 
         /**
          * Adds a scope information object to the stack.
-         *
-         * @param {ASTNode} node - A node to add. This node is a FunctionExpression
+         * @param {ASTNode} node A node to add. This node is a FunctionExpression
          *      or a FunctionDeclaration node.
          * @returns {void}
          */
@@ -130,8 +126,7 @@ module.exports = {
          * Removes the scope information object from the top of the stack.
          * At the same time, this reports the function node if the function has
          * `.bind()` and the `this` keywords found.
-         *
-         * @param {ASTNode} node - A node to remove. This node is a
+         * @param {ASTNode} node A node to remove. This node is a
          *      FunctionExpression or a FunctionDeclaration node.
          * @returns {void}
          */
@@ -146,8 +141,7 @@ module.exports = {
         /**
          * Reports a given arrow function if the function is callee of `.bind()`
          * method.
-         *
-         * @param {ASTNode} node - A node to report. This node is an
+         * @param {ASTNode} node A node to report. This node is an
          *      ArrowFunctionExpression.
          * @returns {void}
          */
@@ -159,7 +153,6 @@ module.exports = {
 
         /**
          * Set the mark as the `this` keyword was found in this scope.
-         *
          * @returns {void}
          */
         function markAsThisFound() {

package/lib/rules/no-extra-boolean-cast.js

@@ -49,7 +49,6 @@ module.exports = {
 
         /**
          * Check if a node is in a context where its value would be coerced to a boolean at runtime.
-         *
          * @param {ASTNode} node The node
          * @param {ASTNode} parent Its parent
          * @returns {boolean} If it is in a boolean context
@@ -67,7 +66,6 @@ module.exports = {
 
         /**
          * Check if a node has comments inside.
-         *
          * @param {ASTNode} node The node to check.
          * @returns {boolean} `true` if it has comments inside.
          */

package/lib/rules/no-extra-label.js

@@ -40,8 +40,7 @@ module.exports = {
 
         /**
          * Creates a new scope with a breakable statement.
-         *
-         * @param {ASTNode} node - A node to create. This is a BreakableStatement.
+         * @param {ASTNode} node A node to create. This is a BreakableStatement.
          * @returns {void}
          */
         function enterBreakableStatement(node) {
@@ -54,7 +53,6 @@ module.exports = {
 
         /**
          * Removes the top scope of the stack.
-         *
          * @returns {void}
          */
         function exitBreakableStatement() {
@@ -66,8 +64,7 @@ module.exports = {
          *
          * This ignores it if the body is a breakable statement.
          * In this case it's handled in the `enterBreakableStatement` function.
-         *
-         * @param {ASTNode} node - A node to create. This is a LabeledStatement.
+         * @param {ASTNode} node A node to create. This is a LabeledStatement.
          * @returns {void}
          */
         function enterLabeledStatement(node) {
@@ -85,8 +82,7 @@ module.exports = {
          *
          * This ignores it if the body is a breakable statement.
          * In this case it's handled in the `exitBreakableStatement` function.
-         *
-         * @param {ASTNode} node - A node. This is a LabeledStatement.
+         * @param {ASTNode} node A node. This is a LabeledStatement.
          * @returns {void}
          */
         function exitLabeledStatement(node) {
@@ -97,8 +93,7 @@ module.exports = {
 
         /**
          * Reports a given control node if it's unnecessary.
-         *
-         * @param {ASTNode} node - A node. This is a BreakStatement or a
+         * @param {ASTNode} node A node. This is a BreakStatement or a
          *      ContinueStatement.
          * @returns {void}
          */

package/lib/rules/no-extra-parens.js

@@ -50,7 +50,8 @@ module.exports = {
                                 returnAssign: { type: "boolean" },
                                 ignoreJSX: { enum: ["none", "all", "single-line", "multi-line"] },
                                 enforceForArrowConditionals: { type: "boolean" },
-                                enforceForSequenceExpressions: { type: "boolean" }
+                                enforceForSequenceExpressions: { type: "boolean" },
+                                enforceForNewInMemberExpressions: { type: "boolean" }
                             },
                             additionalProperties: false
                         }
@@ -80,6 +81,8 @@ module.exports = {
             context.options[1].enforceForArrowConditionals === false;
         const IGNORE_SEQUENCE_EXPRESSIONS = ALL_NODES && context.options[1] &&
             context.options[1].enforceForSequenceExpressions === false;
+        const IGNORE_NEW_IN_MEMBER_EXPR = ALL_NODES && context.options[1] &&
+            context.options[1].enforceForNewInMemberExpressions === false;
 
         const PRECEDENCE_OF_ASSIGNMENT_EXPR = precedence({ type: "AssignmentExpression" });
         const PRECEDENCE_OF_UPDATE_EXPR = precedence({ type: "UpdateExpression" });
@@ -88,7 +91,7 @@ module.exports = {
 
         /**
          * Determines if this rule should be enforced for a node given the current configuration.
-         * @param {ASTNode} node - The node to be checked.
+         * @param {ASTNode} node The node to be checked.
          * @returns {boolean} True if the rule should be enforced for this node.
          * @private
          */
@@ -127,7 +130,7 @@ module.exports = {
 
         /**
          * Determines if a node is surrounded by parentheses.
-         * @param {ASTNode} node - The node to be checked.
+         * @param {ASTNode} node The node to be checked.
          * @returns {boolean} True if the node is parenthesised.
          * @private
          */
@@ -137,7 +140,7 @@ module.exports = {
 
         /**
          * Determines if a node is surrounded by parentheses twice.
-         * @param {ASTNode} node - The node to be checked.
+         * @param {ASTNode} node The node to be checked.
          * @returns {boolean} True if the node is doubly parenthesised.
          * @private
          */
@@ -147,7 +150,7 @@ module.exports = {
 
         /**
          * Determines if a node is surrounded by (potentially) invalid parentheses.
-         * @param {ASTNode} node - The node to be checked.
+         * @param {ASTNode} node The node to be checked.
          * @returns {boolean} True if the node is incorrectly parenthesised.
          * @private
          */
@@ -158,7 +161,7 @@ module.exports = {
         /**
          * Determines if a node that is expected to be parenthesised is surrounded by
          * (potentially) invalid extra parentheses.
-         * @param {ASTNode} node - The node to be checked.
+         * @param {ASTNode} node The node to be checked.
          * @returns {boolean} True if the node is has an unexpected extra pair of parentheses.
          * @private
          */
@@ -168,7 +171,7 @@ module.exports = {
 
         /**
          * Determines if a node test expression is allowed to have a parenthesised assignment
-         * @param {ASTNode} node - The node to be checked.
+         * @param {ASTNode} node The node to be checked.
          * @returns {boolean} True if the assignment can be parenthesised.
          * @private
          */
@@ -178,7 +181,7 @@ module.exports = {
 
         /**
          * Determines if a node is in a return statement
-         * @param {ASTNode} node - The node to be checked.
+         * @param {ASTNode} node The node to be checked.
          * @returns {boolean} True if the node is in a return statement.
          * @private
          */
@@ -197,7 +200,7 @@ module.exports = {
 
         /**
          * Determines if a constructor function is newed-up with parens
-         * @param {ASTNode} newExpression - The NewExpression node to be checked.
+         * @param {ASTNode} newExpression The NewExpression node to be checked.
          * @returns {boolean} True if the constructor is called with parens.
          * @private
          */
@@ -217,7 +220,7 @@ module.exports = {
 
         /**
          * Determines if a node is or contains an assignment expression
-         * @param {ASTNode} node - The node to be checked.
+         * @param {ASTNode} node The node to be checked.
          * @returns {boolean} True if the node is or contains an assignment expression.
          * @private
          */
@@ -239,7 +242,7 @@ module.exports = {
 
         /**
          * Determines if a node is contained by or is itself a return statement and is allowed to have a parenthesised assignment
-         * @param {ASTNode} node - The node to be checked.
+         * @param {ASTNode} node The node to be checked.
          * @returns {boolean} True if the assignment can be parenthesised.
          * @private
          */
@@ -261,8 +264,8 @@ module.exports = {
         /**
          * Determines if a node following a [no LineTerminator here] restriction is
          * surrounded by (potentially) invalid extra parentheses.
-         * @param {Token} token - The token preceding the [no LineTerminator here] restriction.
-         * @param {ASTNode} node - The node to be checked.
+         * @param {Token} token The token preceding the [no LineTerminator here] restriction.
+         * @param {ASTNode} node The node to be checked.
          * @returns {boolean} True if the node is incorrectly parenthesised.
          * @private
          */
@@ -567,7 +570,6 @@ module.exports = {
         /**
          * Checks whether the syntax of the given ancestor of an 'in' expression inside a for-loop initializer
          * is preventing the 'in' keyword from being interpreted as a part of an ill-formed for-in loop.
-         *
          * @param {ASTNode} node Ancestor of an 'in' expression.
          * @param {ASTNode} child Child of the node, ancestor of the same 'in' expression or the 'in' expression itself.
          * @returns {boolean} True if the keyword 'in' would be interpreted as the 'in' operator, without any parenthesis.
@@ -599,7 +601,6 @@ module.exports = {
         /**
          * Starts a new reports buffering. Warnings will be stored in a buffer instead of being reported immediately.
          * An additional logic that requires multiple nodes (e.g. a whole subtree) may dismiss some of the stored warnings.
-         *
          * @returns {void}
          */
         function startNewReportsBuffering() {
@@ -895,6 +896,7 @@ module.exports = {
                 }
 
                 if (nodeObjHasExcessParens &&
+                  !IGNORE_NEW_IN_MEMBER_EXPR &&
                   node.object.type === "NewExpression" &&
                   isNewExpressionWithParens(node.object)) {
                     report(node.object);

package/lib/rules/no-extra-semi.js

@@ -40,7 +40,7 @@ module.exports = {
 
         /**
          * Reports an unnecessary semicolon error.
-         * @param {Node|Token} nodeOrToken - A node or a token to be reported.
+         * @param {Node|Token} nodeOrToken A node or a token to be reported.
          * @returns {void}
          */
         function report(nodeOrToken) {
@@ -64,8 +64,7 @@ module.exports = {
         /**
          * Checks for a part of a class body.
          * This checks tokens from a specified token to a next MethodDefinition or the end of class body.
-         *
-         * @param {Token} firstToken - The first token to check.
+         * @param {Token} firstToken The first token to check.
          * @returns {void}
          */
         function checkForPartOfClassBody(firstToken) {
@@ -83,7 +82,7 @@ module.exports = {
 
             /**
              * Reports this empty statement, except if the parent node is a loop.
-             * @param {Node} node - A EmptyStatement node to be reported.
+             * @param {Node} node A EmptyStatement node to be reported.
              * @returns {void}
              */
             EmptyStatement(node) {
@@ -106,7 +105,7 @@ module.exports = {
 
             /**
              * Checks tokens from the head of this class body to the first MethodDefinition or the end of this class body.
-             * @param {Node} node - A ClassBody node to check.
+             * @param {Node} node A ClassBody node to check.
              * @returns {void}
              */
             ClassBody(node) {
@@ -115,7 +114,7 @@ module.exports = {
 
             /**
              * Checks tokens from this MethodDefinition to the next MethodDefinition or the end of this class body.
-             * @param {Node} node - A MethodDefinition node of the start point.
+             * @param {Node} node A MethodDefinition node of the start point.
              * @returns {void}
              */
             MethodDefinition(node) {

package/lib/rules/no-fallthrough.js

@@ -18,9 +18,9 @@ const DEFAULT_FALLTHROUGH_COMMENT = /falls?\s?through/iu;
 
 /**
  * Checks whether or not a given node has a fallthrough comment.
- * @param {ASTNode} node - A SwitchCase node to get comments.
- * @param {RuleContext} context - A rule context which stores comments.
- * @param {RegExp} fallthroughCommentPattern - A pattern to match comment to.
+ * @param {ASTNode} node A SwitchCase node to get comments.
+ * @param {RuleContext} context A rule context which stores comments.
+ * @param {RegExp} fallthroughCommentPattern A pattern to match comment to.
  * @returns {boolean} `true` if the node has a valid fallthrough comment.
  */
 function hasFallthroughComment(node, context, fallthroughCommentPattern) {
@@ -32,7 +32,7 @@ function hasFallthroughComment(node, context, fallthroughCommentPattern) {
 
 /**
  * Checks whether or not a given code path segment is reachable.
- * @param {CodePathSegment} segment - A CodePathSegment to check.
+ * @param {CodePathSegment} segment A CodePathSegment to check.
  * @returns {boolean} `true` if the segment is reachable.
  */
 function isReachable(segment) {
@@ -41,8 +41,8 @@ function isReachable(segment) {
 
 /**
  * Checks whether a node and a token are separated by blank lines
- * @param {ASTNode} node - The node to check
- * @param {Token} token - The token to compare against
+ * @param {ASTNode} node The node to check
+ * @param {Token} token The token to compare against
  * @returns {boolean} `true` if there are blank lines between node and token
  */
 function hasBlankLinesBetween(node, token) {

package/lib/rules/no-func-assign.js

@@ -29,7 +29,7 @@ module.exports = {
 
         /**
          * Reports a reference if is non initializer and writable.
-         * @param {References} references - Collection of reference to check.
+         * @param {References} references Collection of reference to check.
          * @returns {void}
          */
         function checkReference(references) {
@@ -40,7 +40,7 @@ module.exports = {
 
         /**
          * Finds and reports references that are non initializer and writable.
-         * @param {Variable} variable - A variable to check.
+         * @param {Variable} variable A variable to check.
          * @returns {void}
          */
         function checkVariable(variable) {
@@ -51,7 +51,7 @@ module.exports = {
 
         /**
          * Checks parameters of a given function node.
-         * @param {ASTNode} node - A function node to check.
+         * @param {ASTNode} node A function node to check.
          * @returns {void}
          */
         function checkForFunction(node) {

package/lib/rules/no-global-assign.js

@@ -41,9 +41,9 @@ module.exports = {
 
         /**
          * Reports write references.
-         * @param {Reference} reference - A reference to check.
-         * @param {int} index - The index of the reference in the references.
-         * @param {Reference[]} references - The array that the reference belongs to.
+         * @param {Reference} reference A reference to check.
+         * @param {int} index The index of the reference in the references.
+         * @param {Reference[]} references The array that the reference belongs to.
          * @returns {void}
          */
         function checkReference(reference, index, references) {
@@ -68,7 +68,7 @@ module.exports = {
 
         /**
          * Reports write references if a given variable is read-only builtin.
-         * @param {Variable} variable - A variable to check.
+         * @param {Variable} variable A variable to check.
          * @returns {void}
          */
         function checkVariable(variable) {

package/lib/rules/no-implicit-coercion.js

@@ -16,7 +16,7 @@ const ALLOWABLE_OPERATORS = ["~", "!!", "+", "*"];
 
 /**
  * Parses and normalizes an option object.
- * @param {Object} options - An option object to parse.
+ * @param {Object} options An option object to parse.
  * @returns {Object} The parsed and normalized option object.
  */
 function parseOptions(options) {
@@ -30,7 +30,7 @@ function parseOptions(options) {
 
 /**
  * Checks whether or not a node is a double logical nigating.
- * @param {ASTNode} node - An UnaryExpression node to check.
+ * @param {ASTNode} node An UnaryExpression node to check.
  * @returns {boolean} Whether or not the node is a double logical nigating.
  */
 function isDoubleLogicalNegating(node) {
@@ -43,7 +43,7 @@ function isDoubleLogicalNegating(node) {
 
 /**
  * Checks whether or not a node is a binary negating of `.indexOf()` method calling.
- * @param {ASTNode} node - An UnaryExpression node to check.
+ * @param {ASTNode} node An UnaryExpression node to check.
  * @returns {boolean} Whether or not the node is a binary negating of `.indexOf()` method calling.
  */
 function isBinaryNegatingOfIndexOf(node) {
@@ -58,7 +58,7 @@ function isBinaryNegatingOfIndexOf(node) {
 
 /**
  * Checks whether or not a node is a multiplying by one.
- * @param {BinaryExpression} node - A BinaryExpression node to check.
+ * @param {BinaryExpression} node A BinaryExpression node to check.
  * @returns {boolean} Whether or not the node is a multiplying by one.
  */
 function isMultiplyByOne(node) {
@@ -118,7 +118,7 @@ function isEmptyString(node) {
 
 /**
  * Checks whether or not a node is a concatenating with an empty string.
- * @param {ASTNode} node - A BinaryExpression node to check.
+ * @param {ASTNode} node A BinaryExpression node to check.
  * @returns {boolean} Whether or not the node is a concatenating with an empty string.
  */
 function isConcatWithEmptyString(node) {
@@ -130,7 +130,7 @@ function isConcatWithEmptyString(node) {
 
 /**
  * Checks whether or not a node is appended with an empty string.
- * @param {ASTNode} node - An AssignmentExpression node to check.
+ * @param {ASTNode} node An AssignmentExpression node to check.
  * @returns {boolean} Whether or not the node is appended with an empty string.
  */
 function isAppendEmptyString(node) {
@@ -139,7 +139,7 @@ function isAppendEmptyString(node) {
 
 /**
  * Returns the operand that is not an empty string from a flagged BinaryExpression.
- * @param {ASTNode} node - The flagged BinaryExpression node to check.
+ * @param {ASTNode} node The flagged BinaryExpression node to check.
  * @returns {ASTNode} The operand that is not an empty string from a flagged BinaryExpression.
  */
 function getNonEmptyOperand(node) {
@@ -196,9 +196,9 @@ module.exports = {
 
         /**
          * Reports an error and autofixes the node
-         * @param {ASTNode} node - An ast node to report the error on.
-         * @param {string} recommendation - The recommended code for the issue
-         * @param {bool} shouldFix - Whether this report should fix the node
+         * @param {ASTNode} node An ast node to report the error on.
+         * @param {string} recommendation The recommended code for the issue
+         * @param {bool} shouldFix Whether this report should fix the node
          * @returns {void}
          */
         function report(node, recommendation, shouldFix) {

package/lib/rules/no-implicit-globals.js

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Rule to check for implicit global variables and functions.
+ * @fileoverview Rule to check for implicit global variables, functions and classes.
  * @author Joshua Peek
  */
 
@@ -14,41 +14,123 @@ module.exports = {
         type: "suggestion",
 
         docs: {
-            description: "disallow variable and `function` declarations in the global scope",
+            description: "disallow declarations in the global scope",
             category: "Best Practices",
             recommended: false,
             url: "https://eslint.org/docs/rules/no-implicit-globals"
         },
 
-        schema: []
+        schema: [{
+            type: "object",
+            properties: {
+                lexicalBindings: {
+                    type: "boolean",
+                    default: false
+                }
+            },
+            additionalProperties: false
+        }],
+
+        messages: {
+            globalNonLexicalBinding: "Unexpected {{kind}} declaration in the global scope, wrap in an IIFE for a local variable, assign as global property for a global variable.",
+            globalLexicalBinding: "Unexpected {{kind}} declaration in the global scope, wrap in a block or in an IIFE.",
+            globalVariableLeak: "Global variable leak, declare the variable if it is intended to be local.",
+            assignmentToReadonlyGlobal: "Unexpected assignment to read-only global variable.",
+            redeclarationOfReadonlyGlobal: "Unexpected redeclaration of read-only global variable."
+        }
     },
 
     create(context) {
+
+        const checkLexicalBindings = context.options[0] && context.options[0].lexicalBindings === true;
+
+        /**
+         * Reports the node.
+         * @param {ASTNode} node Node to report.
+         * @param {string} messageId Id of the message to report.
+         * @param {string|undefined} kind Declaration kind, can be 'var', 'const', 'let', function or class.
+         * @returns {void}
+         */
+        function report(node, messageId, kind) {
+            context.report({
+                node,
+                messageId,
+                data: {
+                    kind
+                }
+            });
+        }
+
         return {
             Program() {
                 const scope = context.getScope();
 
                 scope.variables.forEach(variable => {
-                    if (variable.writeable) {
+
+                    // Only ESLint global variables have the `writable` key.
+                    const isReadonlyEslintGlobalVariable = variable.writeable === false;
+                    const isWritableEslintGlobalVariable = variable.writeable === true;
+
+                    if (isWritableEslintGlobalVariable) {
+
+                        // Everything is allowed with writable ESLint global variables.
                         return;
                     }
 
                     variable.defs.forEach(def => {
+                        const defNode = def.node;
+
                         if (def.type === "FunctionName" || (def.type === "Variable" && def.parent.kind === "var")) {
-                            context.report({ node: def.node, message: "Implicit global variable, assign as global property instead." });
+                            if (isReadonlyEslintGlobalVariable) {
+                                report(defNode, "redeclarationOfReadonlyGlobal");
+                            } else {
+                                report(
+                                    defNode,
+                                    "globalNonLexicalBinding",
+                                    def.type === "FunctionName" ? "function" : `'${def.parent.kind}'`
+                                );
+                            }
+                        }
+
+                        if (checkLexicalBindings) {
+                            if (def.type === "ClassName" ||
+                                    (def.type === "Variable" && (def.parent.kind === "let" || def.parent.kind === "const"))) {
+                                if (isReadonlyEslintGlobalVariable) {
+                                    report(defNode, "redeclarationOfReadonlyGlobal");
+                                } else {
+                                    report(
+                                        defNode,
+                                        "globalLexicalBinding",
+                                        def.type === "ClassName" ? "class" : `'${def.parent.kind}'`
+                                    );
+                                }
+                            }
                         }
                     });
                 });
 
+                // Undeclared assigned variables.
                 scope.implicit.variables.forEach(variable => {
                     const scopeVariable = scope.set.get(variable.name);
+                    let messageId;
 
-                    if (scopeVariable && scopeVariable.writeable) {
-                        return;
+                    if (scopeVariable) {
+
+                        // ESLint global variable
+                        if (scopeVariable.writeable) {
+                            return;
+                        }
+                        messageId = "assignmentToReadonlyGlobal";
+
+                    } else {
+
+                        // Reference to an unknown variable, possible global leak.
+                        messageId = "globalVariableLeak";
                     }
 
+                    // def.node is an AssignmentExpression, ForInStatement or ForOfStatement.
                     variable.defs.forEach(def => {
-                        context.report({ node: def.node, message: "Implicit global variable, assign as global property instead." });
+                        report(def.node, messageId);
                     });
                 });
             }

package/lib/rules/no-implied-eval.js

@@ -64,7 +64,6 @@ module.exports = {
          * Determines if a node represents a call to a potentially implied eval.
          *
          * This checks the callee name and that there's an argument, but not the type of the argument.
-         *
          * @param {ASTNode} node The CallExpression to check.
          * @returns {boolean} True if the node matches, false if not.
          * @private

package/lib/rules/no-inline-comments.js

@@ -35,22 +35,36 @@ module.exports = {
          */
         function testCodeAroundComment(node) {
 
-            // Get the whole line and cut it off at the start of the comment
-            const startLine = String(sourceCode.lines[node.loc.start.line - 1]);
-            const endLine = String(sourceCode.lines[node.loc.end.line - 1]);
+            const startLine = String(sourceCode.lines[node.loc.start.line - 1]),
+                endLine = String(sourceCode.lines[node.loc.end.line - 1]),
+                preamble = startLine.slice(0, node.loc.start.column).trim(),
+                postamble = endLine.slice(node.loc.end.column).trim(),
+                isPreambleEmpty = !preamble,
+                isPostambleEmpty = !postamble;
 
-            const preamble = startLine.slice(0, node.loc.start.column).trim();
+            // Nothing on both sides
+            if (isPreambleEmpty && isPostambleEmpty) {
+                return;
+            }
 
-            // Also check after the comment
-            const postamble = endLine.slice(node.loc.end.column).trim();
+            // JSX Exception
+            if (
+                (isPreambleEmpty || preamble === "{") &&
+                (isPostambleEmpty || postamble === "}")
+            ) {
+                const enclosingNode = sourceCode.getNodeByRangeIndex(node.range[0]);
 
-            // Check that this comment isn't an ESLint directive
-            const isDirective = astUtils.isDirectiveComment(node);
+                if (enclosingNode && enclosingNode.type === "JSXEmptyExpression") {
+                    return;
+                }
+            }
 
-            // Should be empty if there was only whitespace around the comment
-            if (!isDirective && (preamble || postamble)) {
-                context.report({ node, message: "Unexpected comment inline with code." });
+            // Don't report ESLint directive comments
+            if (astUtils.isDirectiveComment(node)) {
+                return;
             }
+
+            context.report({ node, message: "Unexpected comment inline with code." });
         }
 
         //--------------------------------------------------------------------------