eslint 6.5.1 → 6.7.2

package/lib/rules/prefer-numeric-literals.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -94,13 +100,13 @@ module.exports = {
                             functionName: sourceCode.getText(node.callee)
                         },
                         fix(fixer) {
-                            const newPrefix = prefixMap[node.arguments[1].value];
-
                             if (sourceCode.getCommentsInside(node).length) {
                                 return null;
                             }
 
-                            if (+(newPrefix + node.arguments[0].value) !== parseInt(node.arguments[0].value, node.arguments[1].value)) {
+                            const replacement = `${prefixMap[node.arguments[1].value]}${node.arguments[0].value}`;
+
+                            if (+replacement !== parseInt(node.arguments[0].value, node.arguments[1].value)) {
 
                                 /*
                                  * If the newly-produced literal would be invalid, (e.g. 0b1234),
@@ -108,7 +114,29 @@ module.exports = {
                                  */
                                 return null;
                             }
-                            return fixer.replaceText(node, prefixMap[node.arguments[1].value] + node.arguments[0].value);
+
+                            const tokenBefore = sourceCode.getTokenBefore(node),
+                                tokenAfter = sourceCode.getTokenAfter(node);
+                            let prefix = "",
+                                suffix = "";
+
+                            if (
+                                tokenBefore &&
+                                tokenBefore.range[1] === node.range[0] &&
+                                !astUtils.canTokensBeAdjacent(tokenBefore, replacement)
+                            ) {
+                                prefix = " ";
+                            }
+
+                            if (
+                                tokenAfter &&
+                                node.range[1] === tokenAfter.range[0] &&
+                                !astUtils.canTokensBeAdjacent(replacement, tokenAfter)
+                            ) {
+                                suffix = " ";
+                            }
+
+                            return fixer.replaceText(node, `${prefix}${replacement}${suffix}`);
                         }
                     });
                 }

package/lib/rules/prefer-object-spread.js

@@ -18,7 +18,7 @@ const ANY_SPACE = /\s/u;
 
 /**
  * Helper that checks if the Object.assign call has array spread
- * @param {ASTNode} node - The node that the rule warns on
+ * @param {ASTNode} node The node that the rule warns on
  * @returns {boolean} - Returns true if the Object.assign call has array spread
  */
 function hasArraySpread(node) {
@@ -28,8 +28,8 @@ function hasArraySpread(node) {
 /**
  * Helper that checks if the node needs parentheses to be valid JS.
  * The default is to wrap the node in parentheses to avoid parsing errors.
- * @param {ASTNode} node - The node that the rule warns on
- * @param {Object} sourceCode - in context sourcecode object
+ * @param {ASTNode} node The node that the rule warns on
+ * @param {Object} sourceCode in context sourcecode object
  * @returns {boolean} - Returns true if the node needs parentheses
  */
 function needsParens(node, sourceCode) {
@@ -51,8 +51,8 @@ function needsParens(node, sourceCode) {
 
 /**
  * Determines if an argument needs parentheses. The default is to not add parens.
- * @param {ASTNode} node - The node to be checked.
- * @param {Object} sourceCode - in context sourcecode object
+ * @param {ASTNode} node The node to be checked.
+ * @param {Object} sourceCode in context sourcecode object
  * @returns {boolean} True if the node needs parentheses
  */
 function argNeedsParens(node, sourceCode) {
@@ -142,8 +142,8 @@ function getEndWithSpaces(token, sourceCode) {
 
 /**
  * Autofixes the Object.assign call to use an object spread instead.
- * @param {ASTNode|null} node - The node that the rule warns on, i.e. the Object.assign call
- * @param {string} sourceCode - sourceCode of the Object.assign call
+ * @param {ASTNode|null} node The node that the rule warns on, i.e. the Object.assign call
+ * @param {string} sourceCode sourceCode of the Object.assign call
  * @returns {Function} autofixer - replaces the Object.assign with a spread object.
  */
 function defineFixer(node, sourceCode) {

package/lib/rules/prefer-rest-params.js

@@ -11,7 +11,7 @@
 
 /**
  * Gets the variable object of `arguments` which is defined implicitly.
- * @param {eslint-scope.Scope} scope - A scope to get.
+ * @param {eslint-scope.Scope} scope A scope to get.
  * @returns {eslint-scope.Variable} The found variable object.
  */
 function getVariableOfArguments(scope) {
@@ -41,8 +41,7 @@ function getVariableOfArguments(scope) {
  * - arguments[i]      .... true    // computed member access
  * - arguments[0]      .... true    // computed member access
  * - arguments.length  .... false   // normal member access
- *
- * @param {eslint-scope.Reference} reference - The reference to check.
+ * @param {eslint-scope.Reference} reference The reference to check.
  * @returns {boolean} `true` if the reference is not normal member access.
  */
 function isNotNormalMemberAccess(reference) {
@@ -78,8 +77,7 @@ module.exports = {
 
         /**
          * Reports a given reference.
-         *
-         * @param {eslint-scope.Reference} reference - A reference to report.
+         * @param {eslint-scope.Reference} reference A reference to report.
          * @returns {void}
          */
         function report(reference) {
@@ -92,7 +90,6 @@ module.exports = {
 
         /**
          * Reports references of the implicit `arguments` variable if exist.
-         *
          * @returns {void}
          */
         function checkForArguments() {

package/lib/rules/prefer-spread.js

@@ -13,7 +13,7 @@ const astUtils = require("./utils/ast-utils");
 
 /**
  * Checks whether or not a node is a `.apply()` for variadic.
- * @param {ASTNode} node - A CallExpression node to check.
+ * @param {ASTNode} node A CallExpression node to check.
  * @returns {boolean} Whether or not the node is a `.apply()` for variadic.
  */
 function isVariadicApplyCalling(node) {
@@ -31,9 +31,9 @@ function isVariadicApplyCalling(node) {
 
 /**
  * Checks whether or not `thisArg` is not changed by `.apply()`.
- * @param {ASTNode|null} expectedThis - The node that is the owner of the applied function.
- * @param {ASTNode} thisArg - The node that is given to the first argument of the `.apply()`.
- * @param {RuleContext} context - The ESLint rule context object.
+ * @param {ASTNode|null} expectedThis The node that is the owner of the applied function.
+ * @param {ASTNode} thisArg The node that is given to the first argument of the `.apply()`.
+ * @param {RuleContext} context The ESLint rule context object.
  * @returns {boolean} Whether or not `thisArg` is not changed by `.apply()`.
  */
 function isValidThisArg(expectedThis, thisArg, context) {

package/lib/rules/prefer-template.js

@@ -17,7 +17,7 @@ const astUtils = require("./utils/ast-utils");
 
 /**
  * Checks whether or not a given node is a concatenation.
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node is a concatenation.
  */
 function isConcatenation(node) {
@@ -26,7 +26,7 @@ function isConcatenation(node) {
 
 /**
  * Gets the top binary expression node for concatenation in parents of a given node.
- * @param {ASTNode} node - A node to get.
+ * @param {ASTNode} node A node to get.
  * @returns {ASTNode} the top binary expression node in parents of a given node.
  */
 function getTopConcatBinaryExpression(node) {
@@ -70,7 +70,7 @@ function hasOctalEscapeSequence(node) {
 
 /**
  * Checks whether or not a given binary expression has string literals.
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node has string literals.
  */
 function hasStringLiteral(node) {
@@ -84,7 +84,7 @@ function hasStringLiteral(node) {
 
 /**
  * Checks whether or not a given binary expression has non string literals.
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node has non string literals.
  */
 function hasNonStringLiteral(node) {
@@ -242,8 +242,7 @@ module.exports = {
 
         /**
          * Reports if a given node is string concatenation with non string literals.
-         *
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {void}
          */
         function checkForStringConcat(node) {

package/lib/rules/quote-props.js

@@ -85,7 +85,7 @@ module.exports = {
 
         /**
          * Checks whether a certain string constitutes an ES3 token
-         * @param   {string} tokenStr - The string to be checked.
+         * @param   {string} tokenStr The string to be checked.
          * @returns {boolean} `true` if it is an ES3 token.
          */
         function isKeyword(tokenStr) {

package/lib/rules/quotes.js

@@ -41,7 +41,7 @@ const UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\])(\\\\)*[${Arr
  * escaping and unescaping as necessary.
  * Only escaping of the minimal set of characters is changed.
  * Note: escaping of newlines when switching from backtick to other quotes is not handled.
- * @param {string} str - A string to convert.
+ * @param {string} str A string to convert.
  * @returns {string} The string with changed quotes.
  * @private
  */
@@ -143,7 +143,6 @@ module.exports = {
          *
          * In both cases, inside of the braces is handled as normal JavaScript.
          * The braces are `JSXExpressionContainer` nodes.
-         *
          * @param {ASTNode} node The Literal node to check.
          * @returns {boolean} True if the node is a part of JSX, false if not.
          * @private
@@ -155,7 +154,7 @@ module.exports = {
         /**
          * Checks whether or not a given node is a directive.
          * The directive is a `ExpressionStatement` which has only a string literal.
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {boolean} Whether or not the node is a directive.
          * @private
          */
@@ -170,7 +169,7 @@ module.exports = {
         /**
          * Checks whether or not a given node is a part of directive prologues.
          * See also: http://www.ecma-international.org/ecma-262/6.0/#sec-directive-prologues-and-the-use-strict-directive
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {boolean} Whether or not the node is a part of directive prologues.
          * @private
          */
@@ -198,7 +197,7 @@ module.exports = {
 
         /**
          * Checks whether or not a given node is allowed as non backtick.
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {boolean} Whether or not the node is allowed as non backtick.
          * @private
          */
@@ -230,7 +229,7 @@ module.exports = {
 
         /**
          * Checks whether or not a given TemplateLiteral node is actually using any of the special features provided by template literal strings.
-         * @param {ASTNode} node - A TemplateLiteral node to check.
+         * @param {ASTNode} node A TemplateLiteral node to check.
          * @returns {boolean} Whether or not the TemplateLiteral node is using any of the special features provided by template literal strings.
          * @private
          */

package/lib/rules/radix.js

@@ -20,8 +20,7 @@ const MODE_ALWAYS = "always",
 
 /**
  * Checks whether a given variable is shadowed or not.
- *
- * @param {eslint-scope.Variable} variable - A variable to check.
+ * @param {eslint-scope.Variable} variable A variable to check.
  * @returns {boolean} `true` if the variable is shadowed.
  */
 function isShadowed(variable) {
@@ -30,8 +29,7 @@ function isShadowed(variable) {
 
 /**
  * Checks whether a given node is a MemberExpression of `parseInt` method or not.
- *
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node is a MemberExpression of `parseInt`
  *      method.
  */
@@ -51,8 +49,7 @@ function isParseIntMethod(node) {
  *
  * - A literal except numbers.
  * - undefined.
- *
- * @param {ASTNode} radix - A node of radix to check.
+ * @param {ASTNode} radix A node of radix to check.
  * @returns {boolean} `true` if the node is valid.
  */
 function isValidRadix(radix) {
@@ -64,8 +61,7 @@ function isValidRadix(radix) {
 
 /**
  * Checks whether a given node is a default value of radix or not.
- *
- * @param {ASTNode} radix - A node of radix to check.
+ * @param {ASTNode} radix A node of radix to check.
  * @returns {boolean} `true` if the node is the literal node of `10`.
  */
 function isDefaultRadix(radix) {
@@ -100,8 +96,7 @@ module.exports = {
         /**
          * Checks the arguments of a given CallExpression node and reports it if it
          * offends this rule.
-         *
-         * @param {ASTNode} node - A CallExpression node to check.
+         * @param {ASTNode} node A CallExpression node to check.
          * @returns {void}
          */
         function checkArguments(node) {

package/lib/rules/require-await.js

@@ -17,8 +17,7 @@ const astUtils = require("./utils/ast-utils");
 
 /**
  * Capitalize the 1st letter of the given text.
- *
- * @param {string} text - The text to capitalize.
+ * @param {string} text The text to capitalize.
  * @returns {string} The text that the 1st letter was capitalized.
  */
 function capitalizeFirstLetter(text) {
@@ -49,7 +48,6 @@ module.exports = {
 
         /**
          * Push the scope info object to the stack.
-         *
          * @returns {void}
          */
         function enterFunction() {
@@ -62,8 +60,7 @@ module.exports = {
         /**
          * Pop the top scope info object from the stack.
          * Also, it reports the function if needed.
-         *
-         * @param {ASTNode} node - The node to report.
+         * @param {ASTNode} node The node to report.
          * @returns {void}
          */
         function exitFunction(node) {
@@ -92,9 +89,17 @@ module.exports = {
             "ArrowFunctionExpression:exit": exitFunction,
 
             AwaitExpression() {
+                if (!scopeInfo) {
+                    return;
+                }
+
                 scopeInfo.hasAwait = true;
             },
             ForOfStatement(node) {
+                if (!scopeInfo) {
+                    return;
+                }
+
                 if (node.await) {
                     scopeInfo.hasAwait = true;
                 }

package/lib/rules/require-yield.js

@@ -28,7 +28,7 @@ module.exports = {
 
         /**
          * If the node is a generator function, start counting `yield` keywords.
-         * @param {Node} node - A function node to check.
+         * @param {Node} node A function node to check.
          * @returns {void}
          */
         function beginChecking(node) {
@@ -40,7 +40,7 @@ module.exports = {
         /**
          * If the node is a generator function, end counting `yield` keywords, then
          * reports result.
-         * @param {Node} node - A function node to check.
+         * @param {Node} node A function node to check.
          * @returns {void}
          */
         function endChecking(node) {

package/lib/rules/rest-spread-spacing.js

@@ -39,7 +39,7 @@ module.exports = {
 
         /**
          * Checks whitespace between rest/spread operators and their expressions
-         * @param {ASTNode} node - The node to check
+         * @param {ASTNode} node The node to check
          * @returns {void}
          */
         function checkWhiteSpace(node) {

package/lib/rules/semi.js

@@ -93,17 +93,20 @@ module.exports = {
             const lastToken = sourceCode.getLastToken(node);
             let message,
                 fix,
-                loc = lastToken.loc;
+                loc;
 
             if (!missing) {
                 message = "Missing semicolon.";
-                loc = loc.end;
+                loc = {
+                    start: lastToken.loc.end,
+                    end: astUtils.getNextLocation(sourceCode, lastToken.loc.end)
+                };
                 fix = function(fixer) {
                     return fixer.insertTextAfter(lastToken, ";");
                 };
             } else {
                 message = "Extra semicolon.";
-                loc = loc.start;
+                loc = lastToken.loc;
                 fix = function(fixer) {
 
                     /*

package/lib/rules/sort-imports.js

@@ -70,8 +70,7 @@ module.exports = {
          * import * as myModule from "my-module.js" --> all
          * import {myMember} from "my-module.js" --> single
          * import {foo, bar} from  "my-module.js" --> multiple
-         *
-         * @param {ASTNode} node - the ImportDeclaration node.
+         * @param {ASTNode} node the ImportDeclaration node.
          * @returns {string} used member parameter style, ["all", "multiple", "single"]
          */
         function usedMemberSyntax(node) {
@@ -90,7 +89,7 @@ module.exports = {
 
         /**
          * Gets the group by member parameter index for given declaration.
-         * @param {ASTNode} node - the ImportDeclaration node.
+         * @param {ASTNode} node the ImportDeclaration node.
          * @returns {number} the declaration group by member index.
          */
         function getMemberParameterGroupIndex(node) {
@@ -99,7 +98,7 @@ module.exports = {
 
         /**
          * Gets the local name of the first imported module.
-         * @param {ASTNode} node - the ImportDeclaration node.
+         * @param {ASTNode} node the ImportDeclaration node.
          * @returns {?string} the local name of the first imported module.
          */
         function getFirstLocalMemberName(node) {

package/lib/rules/sort-keys.js

@@ -23,8 +23,7 @@ const astUtils = require("./utils/ast-utils"),
  *   whether it's a computed property or not.
  * - If the property has a static name, this returns the static name.
  * - Otherwise, this returns null.
- *
- * @param {ASTNode} node - The `Property` node to get.
+ * @param {ASTNode} node The `Property` node to get.
  * @returns {string|null} The property name or null.
  * @private
  */
@@ -43,7 +42,6 @@ function getPropertyName(node) {
  *
  * Postfix `I` is meant insensitive.
  * Postfix `N` is meant natual.
- *
  * @private
  */
 const isValidOrders = {

package/lib/rules/space-before-blocks.js

@@ -79,8 +79,7 @@ module.exports = {
         /**
          * Checks whether or not a given token is an arrow operator (=>) or a keyword
          * in order to avoid to conflict with `arrow-spacing` and `keyword-spacing`.
-         *
-         * @param {Token} token - A token to check.
+         * @param {Token} token A token to check.
          * @returns {boolean} `true` if the token is an arrow operator.
          */
         function isConflicted(token) {

package/lib/rules/space-in-parens.js

@@ -232,7 +232,7 @@ module.exports = {
                     if (token.value === "(" && openerMissingSpace(token, nextToken)) {
                         context.report({
                             node,
-                            loc: token.loc.start,
+                            loc: token.loc,
                             messageId: "missingOpeningSpace",
                             fix(fixer) {
                                 return fixer.insertTextAfter(token, " ");
@@ -244,7 +244,7 @@ module.exports = {
                     if (token.value === "(" && openerRejectsSpace(token, nextToken)) {
                         context.report({
                             node,
-                            loc: token.loc.start,
+                            loc: { start: token.loc.end, end: nextToken.loc.start },
                             messageId: "rejectedOpeningSpace",
                             fix(fixer) {
                                 return fixer.removeRange([token.range[1], nextToken.range[0]]);
@@ -256,7 +256,7 @@ module.exports = {
                     if (token.value === ")" && closerMissingSpace(prevToken, token)) {
                         context.report({
                             node,
-                            loc: token.loc.start,
+                            loc: token.loc,
                             messageId: "missingClosingSpace",
                             fix(fixer) {
                                 return fixer.insertTextBefore(token, " ");
@@ -268,7 +268,7 @@ module.exports = {
                     if (token.value === ")" && closerRejectsSpace(prevToken, token)) {
                         context.report({
                             node,
-                            loc: token.loc.start,
+                            loc: { start: prevToken.loc.end, end: token.loc.start },
                             messageId: "rejectedClosingSpace",
                             fix(fixer) {
                                 return fixer.removeRange([prevToken.range[1], token.range[0]]);

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

@@ -41,9 +41,9 @@ module.exports = {
 
         /**
          * Returns the first token which violates the rule
-         * @param {ASTNode} left - The left node of the main node
-         * @param {ASTNode} right - The right node of the main node
-         * @param {string} op - The operator of the main node
+         * @param {ASTNode} left The left node of the main node
+         * @param {ASTNode} right The right node of the main node
+         * @param {string} op The operator of the main node
          * @returns {Object} The violator token or null
          * @private
          */
@@ -61,15 +61,15 @@ module.exports = {
 
         /**
          * Reports an AST node as a rule violation
-         * @param {ASTNode} mainNode - The node to report
-         * @param {Object} culpritToken - The token which has a problem
+         * @param {ASTNode} mainNode The node to report
+         * @param {Object} culpritToken The token which has a problem
          * @returns {void}
          * @private
          */
         function report(mainNode, culpritToken) {
             context.report({
                 node: mainNode,
-                loc: culpritToken.loc.start,
+                loc: culpritToken.loc,
                 message: "Operator '{{operator}}' must be spaced.",
                 data: {
                     operator: culpritToken.value

package/lib/rules/spaced-comment.js

@@ -13,7 +13,7 @@ const astUtils = require("./utils/ast-utils");
 
 /**
  * Escapes the control characters of a given string.
- * @param {string} s - A string to escape.
+ * @param {string} s A string to escape.
  * @returns {string} An escaped string.
  */
 function escape(s) {
@@ -23,7 +23,7 @@ function escape(s) {
 /**
  * Escapes the control characters of a given string.
  * And adds a repeat flag.
- * @param {string} s - A string to escape.
+ * @param {string} s A string to escape.
  * @returns {string} An escaped string.
  */
 function escapeAndRepeat(s) {
@@ -33,7 +33,7 @@ function escapeAndRepeat(s) {
 /**
  * Parses `markers` option.
  * If markers don't include `"*"`, this adds `"*"` to allow JSDoc comments.
- * @param {string[]} [markers] - A marker list.
+ * @param {string[]} [markers] A marker list.
  * @returns {string[]} A marker list.
  */
 function parseMarkersOption(markers) {
@@ -51,8 +51,7 @@ function parseMarkersOption(markers) {
  * Generated pattern:
  *
  * 1. A space or an exception pattern sequence.
- *
- * @param {string[]} exceptions - An exception pattern list.
+ * @param {string[]} exceptions An exception pattern list.
  * @returns {string} A regular expression string for exceptions.
  */
 function createExceptionsPattern(exceptions) {
@@ -97,9 +96,8 @@ function createExceptionsPattern(exceptions) {
  *
  * 1. First, a marker or nothing.
  * 2. Next, a space or an exception pattern sequence.
- *
- * @param {string[]} markers - A marker list.
- * @param {string[]} exceptions - An exception pattern list.
+ * @param {string[]} markers A marker list.
+ * @param {string[]} exceptions An exception pattern list.
  * @returns {RegExp} A RegExp object for the beginning of a comment in `always` mode.
  */
 function createAlwaysStylePattern(markers, exceptions) {
@@ -135,8 +133,7 @@ function createAlwaysStylePattern(markers, exceptions) {
  *
  * 1. First, a marker or nothing (captured).
  * 2. Next, a space or a tab.
- *
- * @param {string[]} markers - A marker list.
+ * @param {string[]} markers A marker list.
  * @returns {RegExp} A RegExp object for `never` mode.
  */
 function createNeverStylePattern(markers) {
@@ -252,7 +249,8 @@ module.exports = {
                 beginRegex: requireSpace ? createAlwaysStylePattern(markers, exceptions) : createNeverStylePattern(markers),
                 endRegex: balanced && requireSpace ? new RegExp(`${createExceptionsPattern(exceptions)}$`, "u") : new RegExp(endNeverPattern, "u"),
                 hasExceptions: exceptions.length > 0,
-                markers: new RegExp(`^(${markers.map(escape).join("|")})`, "u")
+                captureMarker: new RegExp(`^(${markers.map(escape).join("|")})`, "u"),
+                markers: new Set(markers)
             };
 
             return rule;
@@ -260,10 +258,10 @@ module.exports = {
 
         /**
          * Reports a beginning spacing error with an appropriate message.
-         * @param {ASTNode} node - A comment node to check.
-         * @param {string} message - An error message to report.
-         * @param {Array} match - An array of match results for markers.
-         * @param {string} refChar - Character used for reference in the error message.
+         * @param {ASTNode} node A comment node to check.
+         * @param {string} message An error message to report.
+         * @param {Array} match An array of match results for markers.
+         * @param {string} refChar Character used for reference in the error message.
          * @returns {void}
          */
         function reportBegin(node, message, match, refChar) {
@@ -293,9 +291,9 @@ module.exports = {
 
         /**
          * Reports an ending spacing error with an appropriate message.
-         * @param {ASTNode} node - A comment node to check.
-         * @param {string} message - An error message to report.
-         * @param {string} match - An array of the matched whitespace characters.
+         * @param {ASTNode} node A comment node to check.
+         * @param {string} message An error message to report.
+         * @param {string} match An array of the matched whitespace characters.
          * @returns {void}
          */
         function reportEnd(node, message, match) {
@@ -317,7 +315,7 @@ module.exports = {
 
         /**
          * Reports a given comment if it's invalid.
-         * @param {ASTNode} node - a comment node to check.
+         * @param {ASTNode} node a comment node to check.
          * @returns {void}
          */
         function checkCommentForSpace(node) {
@@ -325,8 +323,8 @@ module.exports = {
                 rule = styleRules[type],
                 commentIdentifier = type === "block" ? "/*" : "//";
 
-            // Ignores empty comments.
-            if (node.value.length === 0) {
+            // Ignores empty comments and comments that consist only of a marker.
+            if (node.value.length === 0 || rule.markers.has(node.value)) {
                 return;
             }
 
@@ -336,7 +334,7 @@ module.exports = {
             // Checks.
             if (requireSpace) {
                 if (!beginMatch) {
-                    const hasMarker = rule.markers.exec(node.value);
+                    const hasMarker = rule.captureMarker.exec(node.value);
                     const marker = hasMarker ? commentIdentifier + hasMarker[0] : commentIdentifier;
 
                     if (rule.hasExceptions) {