eslint 6.5.0 → 6.7.1

package/lib/rules/max-statements-per-line.js

@@ -61,7 +61,6 @@ module.exports = {
 
         /**
          * Reports with the first extra statement, and clears it.
-         *
          * @returns {void}
          */
         function reportFirstExtraStatementAndClear() {
@@ -81,8 +80,7 @@ module.exports = {
 
         /**
          * Gets the actual last token of a given node.
-         *
-         * @param {ASTNode} node - A node to get. This is a node except EmptyStatement.
+         * @param {ASTNode} node A node to get. This is a node except EmptyStatement.
          * @returns {Token} The actual last token.
          */
         function getActualLastToken(node) {
@@ -92,8 +90,7 @@ module.exports = {
         /**
          * Addresses a given node.
          * It updates the state of this rule, then reports the node if the node violated this rule.
-         *
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {void}
          */
         function enterStatement(node) {
@@ -127,8 +124,7 @@ module.exports = {
 
         /**
          * Updates the state of this rule with the end line of leaving node to check with the next statement.
-         *
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {void}
          */
         function leaveStatement(node) {

package/lib/rules/multiline-comment-style.js

@@ -43,17 +43,150 @@ module.exports = {
         //----------------------------------------------------------------------
 
         /**
-         * Gets a list of comment lines in a group
-         * @param {Token[]} commentGroup A group of comments, containing either multiple line comments or a single block comment
-         * @returns {string[]} A list of comment lines
+         * Checks if a comment line is starred.
+         * @param {string} line A string representing a comment line.
+         * @returns {boolean} Whether or not the comment line is starred.
+         */
+        function isStarredCommentLine(line) {
+            return /^\s*\*/u.test(line);
+        }
+
+        /**
+         * Checks if a comment group is in starred-block form.
+         * @param {Token[]} commentGroup A group of comments, containing either multiple line comments or a single block comment.
+         * @returns {boolean} Whether or not the comment group is in starred block form.
+         */
+        function isStarredBlockComment([firstComment]) {
+            if (firstComment.type !== "Block") {
+                return false;
+            }
+
+            const lines = firstComment.value.split(astUtils.LINEBREAK_MATCHER);
+
+            // The first and last lines can only contain whitespace.
+            return lines.length > 0 && lines.every((line, i) => (i === 0 || i === lines.length - 1 ? /^\s*$/u : /^\s*\*/u).test(line));
+        }
+
+        /**
+         * Checks if a comment group is in JSDoc form.
+         * @param {Token[]} commentGroup A group of comments, containing either multiple line comments or a single block comment.
+         * @returns {boolean} Whether or not the comment group is in JSDoc form.
+         */
+        function isJSDocComment([firstComment]) {
+            if (firstComment.type !== "Block") {
+                return false;
+            }
+
+            const lines = firstComment.value.split(astUtils.LINEBREAK_MATCHER);
+
+            return /^\*\s*$/u.test(lines[0]) &&
+                lines.slice(1, -1).every(line => /^\s* /u.test(line)) &&
+                /^\s*$/u.test(lines[lines.length - 1]);
+        }
+
+        /**
+         * Processes a comment group that is currently in separate-line form, calculating the offset for each line.
+         * @param {Token[]} commentGroup A group of comments containing multiple line comments.
+         * @returns {string[]} An array of the processed lines.
+         */
+        function processSeparateLineComments(commentGroup) {
+            const allLinesHaveLeadingSpace = commentGroup
+                .map(({ value }) => value)
+                .filter(line => line.trim().length)
+                .every(line => line.startsWith(" "));
+
+            return commentGroup.map(({ value }) => (allLinesHaveLeadingSpace ? value.replace(/^ /u, "") : value));
+        }
+
+        /**
+         * Processes a comment group that is currently in starred-block form, calculating the offset for each line.
+         * @param {Token} comment A single block comment token in starred-block form.
+         * @returns {string[]} An array of the processed lines.
+         */
+        function processStarredBlockComment(comment) {
+            const lines = comment.value.split(astUtils.LINEBREAK_MATCHER)
+                .filter((line, i, linesArr) => !(i === 0 || i === linesArr.length - 1))
+                .map(line => line.replace(/^\s*$/u, ""));
+            const allLinesHaveLeadingSpace = lines
+                .map(line => line.replace(/\s*\*/u, ""))
+                .filter(line => line.trim().length)
+                .every(line => line.startsWith(" "));
+
+            return lines.map(line => line.replace(allLinesHaveLeadingSpace ? /\s*\* ?/u : /\s*\*/u, ""));
+        }
+
+        /**
+         * Processes a comment group that is currently in bare-block form, calculating the offset for each line.
+         * @param {Token} comment A single block comment token in bare-block form.
+         * @returns {string[]} An array of the processed lines.
+         */
+        function processBareBlockComment(comment) {
+            const lines = comment.value.split(astUtils.LINEBREAK_MATCHER).map(line => line.replace(/^\s*$/u, ""));
+            const leadingWhitespace = `${sourceCode.text.slice(comment.range[0] - comment.loc.start.column, comment.range[0])}   `;
+            let offset = "";
+
+            /*
+             * Calculate the offset of the least indented line and use that as the basis for offsetting all the lines.
+             * The first line should not be checked because it is inline with the opening block comment delimiter.
+             */
+            for (const [i, line] of lines.entries()) {
+                if (!line.trim().length || i === 0) {
+                    continue;
+                }
+
+                const [, lineOffset] = line.match(/^(\s*\*?\s*)/u);
+
+                if (lineOffset.length < leadingWhitespace.length) {
+                    const newOffset = leadingWhitespace.slice(lineOffset.length - leadingWhitespace.length);
+
+                    if (newOffset.length > offset.length) {
+                        offset = newOffset;
+                    }
+                }
+            }
+
+            return lines.map(line => {
+                const match = line.match(/^(\s*\*?\s*)(.*)/u);
+                const [, lineOffset, lineContents] = match;
+
+                if (lineOffset.length > leadingWhitespace.length) {
+                    return `${lineOffset.slice(leadingWhitespace.length - (offset.length + lineOffset.length))}${lineContents}`;
+                }
+
+                if (lineOffset.length < leadingWhitespace.length) {
+                    return `${lineOffset.slice(leadingWhitespace.length)}${lineContents}`;
+                }
+
+                return lineContents;
+            });
+        }
+
+        /**
+         * Gets a list of comment lines in a group, formatting leading whitespace as necessary.
+         * @param {Token[]} commentGroup A group of comments containing either multiple line comments or a single block comment.
+         * @returns {string[]} A list of comment lines.
          */
         function getCommentLines(commentGroup) {
-            if (commentGroup[0].type === "Line") {
-                return commentGroup.map(comment => comment.value);
+            const [firstComment] = commentGroup;
+
+            if (firstComment.type === "Line") {
+                return processSeparateLineComments(commentGroup);
             }
-            return commentGroup[0].value
-                .split(astUtils.LINEBREAK_MATCHER)
-                .map(line => line.replace(/^\s*\*?/u, ""));
+
+            if (isStarredBlockComment(commentGroup)) {
+                return processStarredBlockComment(firstComment);
+            }
+
+            return processBareBlockComment(firstComment);
+        }
+
+        /**
+         * Gets the initial offset (whitespace) from the beginning of a line to a given comment token.
+         * @param {Token} comment The token to check.
+         * @returns {string} The offset from the beginning of a line to the token.
+         */
+        function getInitialOffset(comment) {
+            return sourceCode.text.slice(comment.range[0] - comment.loc.start.column, comment.range[0]);
         }
 
         /**
@@ -63,10 +196,9 @@ module.exports = {
          * @returns {string} A representation of the comment value in starred-block form, excluding start and end markers
          */
         function convertToStarredBlock(firstComment, commentLinesList) {
-            const initialOffset = sourceCode.text.slice(firstComment.range[0] - firstComment.loc.start.column, firstComment.range[0]);
-            const starredLines = commentLinesList.map(line => `${initialOffset} *${line}`);
+            const initialOffset = getInitialOffset(firstComment);
 
-            return `\n${starredLines.join("\n")}\n${initialOffset} `;
+            return `/*\n${commentLinesList.map(line => `${initialOffset} * ${line}`).join("\n")}\n${initialOffset} */`;
         }
 
         /**
@@ -76,10 +208,7 @@ module.exports = {
          * @returns {string} A representation of the comment value in separate-line form
          */
         function convertToSeparateLines(firstComment, commentLinesList) {
-            const initialOffset = sourceCode.text.slice(firstComment.range[0] - firstComment.loc.start.column, firstComment.range[0]);
-            const separateLines = commentLinesList.map(line => `// ${line.trim()}`);
-
-            return separateLines.join(`\n${initialOffset}`);
+            return commentLinesList.map(line => `// ${line}`).join(`\n${getInitialOffset(firstComment)}`);
         }
 
         /**
@@ -89,24 +218,7 @@ module.exports = {
          * @returns {string} A representation of the comment value in bare-block form
          */
         function convertToBlock(firstComment, commentLinesList) {
-            const initialOffset = sourceCode.text.slice(firstComment.range[0] - firstComment.loc.start.column, firstComment.range[0]);
-            const blockLines = commentLinesList.map(line => line.trim());
-
-            return `/* ${blockLines.join(`\n${initialOffset}   `)} */`;
-        }
-
-        /**
-         * Check a comment is JSDoc form
-         * @param {Token[]} commentGroup A group of comments, containing either multiple line comments or a single block comment
-         * @returns {boolean} if commentGroup is JSDoc form, return true
-         */
-        function isJSDoc(commentGroup) {
-            const lines = commentGroup[0].value.split(astUtils.LINEBREAK_MATCHER);
-
-            return commentGroup[0].type === "Block" &&
-                /^\*\s*$/u.test(lines[0]) &&
-                lines.slice(1, -1).every(line => /^\s* /u.test(line)) &&
-                /^\s*$/u.test(lines[lines.length - 1]);
+            return `/* ${commentLinesList.join(`\n${getInitialOffset(firstComment)}   `)} */`;
         }
 
         /**
@@ -117,6 +229,7 @@ module.exports = {
          */
         const commentGroupCheckers = {
             "starred-block"(commentGroup) {
+                const [firstComment] = commentGroup;
                 const commentLines = getCommentLines(commentGroup);
 
                 if (commentLines.some(value => value.includes("*/"))) {
@@ -126,31 +239,30 @@ module.exports = {
                 if (commentGroup.length > 1) {
                     context.report({
                         loc: {
-                            start: commentGroup[0].loc.start,
+                            start: firstComment.loc.start,
                             end: commentGroup[commentGroup.length - 1].loc.end
                         },
                         messageId: "expectedBlock",
                         fix(fixer) {
-                            const range = [commentGroup[0].range[0], commentGroup[commentGroup.length - 1].range[1]];
-                            const starredBlock = `/*${convertToStarredBlock(commentGroup[0], commentLines)}*/`;
+                            const range = [firstComment.range[0], commentGroup[commentGroup.length - 1].range[1]];
 
                             return commentLines.some(value => value.startsWith("/"))
                                 ? null
-                                : fixer.replaceTextRange(range, starredBlock);
+                                : fixer.replaceTextRange(range, convertToStarredBlock(firstComment, commentLines));
                         }
                     });
                 } else {
-                    const block = commentGroup[0];
-                    const lines = block.value.split(astUtils.LINEBREAK_MATCHER);
-                    const expectedLinePrefix = `${sourceCode.text.slice(block.range[0] - block.loc.start.column, block.range[0])} *`;
+                    const lines = firstComment.value.split(astUtils.LINEBREAK_MATCHER);
+                    const expectedLeadingWhitespace = getInitialOffset(firstComment);
+                    const expectedLinePrefix = `${expectedLeadingWhitespace} *`;
 
                     if (!/^\*?\s*$/u.test(lines[0])) {
-                        const start = block.value.startsWith("*") ? block.range[0] + 1 : block.range[0];
+                        const start = firstComment.value.startsWith("*") ? firstComment.range[0] + 1 : firstComment.range[0];
 
                         context.report({
                             loc: {
-                                start: block.loc.start,
-                                end: { line: block.loc.start.line, column: block.loc.start.column + 2 }
+                                start: firstComment.loc.start,
+                                end: { line: firstComment.loc.start.line, column: firstComment.loc.start.column + 2 }
                             },
                             messageId: "startNewline",
                             fix: fixer => fixer.insertTextAfterRange([start, start + 2], `\n${expectedLinePrefix}`)
@@ -160,36 +272,54 @@ module.exports = {
                     if (!/^\s*$/u.test(lines[lines.length - 1])) {
                         context.report({
                             loc: {
-                                start: { line: block.loc.end.line, column: block.loc.end.column - 2 },
-                                end: block.loc.end
+                                start: { line: firstComment.loc.end.line, column: firstComment.loc.end.column - 2 },
+                                end: firstComment.loc.end
                             },
                             messageId: "endNewline",
-                            fix: fixer => fixer.replaceTextRange([block.range[1] - 2, block.range[1]], `\n${expectedLinePrefix}/`)
+                            fix: fixer => fixer.replaceTextRange([firstComment.range[1] - 2, firstComment.range[1]], `\n${expectedLinePrefix}/`)
                         });
                     }
 
-                    for (let lineNumber = block.loc.start.line + 1; lineNumber <= block.loc.end.line; lineNumber++) {
+                    for (let lineNumber = firstComment.loc.start.line + 1; lineNumber <= firstComment.loc.end.line; lineNumber++) {
                         const lineText = sourceCode.lines[lineNumber - 1];
+                        const errorType = isStarredCommentLine(lineText)
+                            ? "alignment"
+                            : "missingStar";
 
                         if (!lineText.startsWith(expectedLinePrefix)) {
                             context.report({
                                 loc: {
                                     start: { line: lineNumber, column: 0 },
-                                    end: { line: lineNumber, column: sourceCode.lines[lineNumber - 1].length }
+                                    end: { line: lineNumber, column: lineText.length }
                                 },
-                                messageId: /^\s*\*/u.test(lineText)
-                                    ? "alignment"
-                                    : "missingStar",
+                                messageId: errorType,
                                 fix(fixer) {
                                     const lineStartIndex = sourceCode.getIndexFromLoc({ line: lineNumber, column: 0 });
-                                    const linePrefixLength = lineText.match(/^\s*\*? ?/u)[0].length;
-                                    const commentStartIndex = lineStartIndex + linePrefixLength;
 
-                                    const replacementText = lineNumber === block.loc.end.line || lineText.length === linePrefixLength
-                                        ? expectedLinePrefix
-                                        : `${expectedLinePrefix} `;
+                                    if (errorType === "alignment") {
+                                        const [, commentTextPrefix = ""] = lineText.match(/^(\s*\*)/u) || [];
+                                        const commentTextStartIndex = lineStartIndex + commentTextPrefix.length;
+
+                                        return fixer.replaceTextRange([lineStartIndex, commentTextStartIndex], expectedLinePrefix);
+                                    }
+
+                                    const [, commentTextPrefix = ""] = lineText.match(/^(\s*)/u) || [];
+                                    const commentTextStartIndex = lineStartIndex + commentTextPrefix.length;
+                                    let offset;
+
+                                    for (const [idx, line] of lines.entries()) {
+                                        if (!/\S+/u.test(line)) {
+                                            continue;
+                                        }
+
+                                        const lineTextToAlignWith = sourceCode.lines[firstComment.loc.start.line - 1 + idx];
+                                        const [, prefix = "", initialOffset = ""] = lineTextToAlignWith.match(/^(\s*(?:\/?\*)?(\s*))/u) || [];
 
-                                    return fixer.replaceTextRange([lineStartIndex, commentStartIndex], replacementText);
+                                        offset = `${commentTextPrefix.slice(prefix.length)}${initialOffset}`;
+                                        break;
+                                    }
+
+                                    return fixer.replaceTextRange([lineStartIndex, commentTextStartIndex], `${expectedLinePrefix}${offset}`);
                                 }
                             });
                         }
@@ -197,67 +327,68 @@ module.exports = {
                 }
             },
             "separate-lines"(commentGroup) {
-                if (!isJSDoc(commentGroup) && commentGroup[0].type === "Block") {
-                    const commentLines = getCommentLines(commentGroup);
-                    const block = commentGroup[0];
-                    const tokenAfter = sourceCode.getTokenAfter(block, { includeComments: true });
+                const [firstComment] = commentGroup;
+
+                if (firstComment.type !== "Block" || isJSDocComment(commentGroup)) {
+                    return;
+                }
 
-                    if (tokenAfter && block.loc.end.line === tokenAfter.loc.start.line) {
-                        return;
+                const commentLines = getCommentLines(commentGroup);
+                const tokenAfter = sourceCode.getTokenAfter(firstComment, { includeComments: true });
+
+                if (tokenAfter && firstComment.loc.end.line === tokenAfter.loc.start.line) {
+                    return;
+                }
+
+                context.report({
+                    loc: {
+                        start: firstComment.loc.start,
+                        end: { line: firstComment.loc.start.line, column: firstComment.loc.start.column + 2 }
+                    },
+                    messageId: "expectedLines",
+                    fix(fixer) {
+                        return fixer.replaceText(firstComment, convertToSeparateLines(firstComment, commentLines));
                     }
+                });
+            },
+            "bare-block"(commentGroup) {
+                if (isJSDocComment(commentGroup)) {
+                    return;
+                }
 
+                const [firstComment] = commentGroup;
+                const commentLines = getCommentLines(commentGroup);
+
+                // Disallows consecutive line comments in favor of using a block comment.
+                if (firstComment.type === "Line" && commentLines.length > 1 &&
+                    !commentLines.some(value => value.includes("*/"))) {
                     context.report({
                         loc: {
-                            start: block.loc.start,
-                            end: { line: block.loc.start.line, column: block.loc.start.column + 2 }
+                            start: firstComment.loc.start,
+                            end: commentGroup[commentGroup.length - 1].loc.end
                         },
-                        messageId: "expectedLines",
+                        messageId: "expectedBlock",
                         fix(fixer) {
-                            return fixer.replaceText(block, convertToSeparateLines(block, commentLines.filter(line => line)));
+                            return fixer.replaceTextRange(
+                                [firstComment.range[0], commentGroup[commentGroup.length - 1].range[1]],
+                                convertToBlock(firstComment, commentLines)
+                            );
                         }
                     });
                 }
-            },
-            "bare-block"(commentGroup) {
-                if (!isJSDoc(commentGroup)) {
-                    const commentLines = getCommentLines(commentGroup);
-
-                    // disallows consecutive line comments in favor of using a block comment.
-                    if (commentGroup[0].type === "Line" && commentLines.length > 1 &&
-                        !commentLines.some(value => value.includes("*/"))) {
-                        context.report({
-                            loc: {
-                                start: commentGroup[0].loc.start,
-                                end: commentGroup[commentGroup.length - 1].loc.end
-                            },
-                            messageId: "expectedBlock",
-                            fix(fixer) {
-                                const range = [commentGroup[0].range[0], commentGroup[commentGroup.length - 1].range[1]];
-                                const block = convertToBlock(commentGroup[0], commentLines.filter(line => line));
-
-                                return fixer.replaceTextRange(range, block);
-                            }
-                        });
-                    }
 
-                    // prohibits block comments from having a * at the beginning of each line.
-                    if (commentGroup[0].type === "Block") {
-                        const block = commentGroup[0];
-                        const lines = block.value.split(astUtils.LINEBREAK_MATCHER).filter(line => line.trim());
-
-                        if (lines.length > 0 && lines.every(line => /^\s*\*/u.test(line))) {
-                            context.report({
-                                loc: {
-                                    start: block.loc.start,
-                                    end: { line: block.loc.start.line, column: block.loc.start.column + 2 }
-                                },
-                                messageId: "expectedBareBlock",
-                                fix(fixer) {
-                                    return fixer.replaceText(block, convertToBlock(block, commentLines.filter(line => line)));
-                                }
-                            });
+                // Prohibits block comments from having a * at the beginning of each line.
+                if (isStarredBlockComment(commentGroup)) {
+                    context.report({
+                        loc: {
+                            start: firstComment.loc.start,
+                            end: { line: firstComment.loc.start.line, column: firstComment.loc.start.column + 2 }
+                        },
+                        messageId: "expectedBareBlock",
+                        fix(fixer) {
+                            return fixer.replaceText(firstComment, convertToBlock(firstComment, commentLines));
                         }
-                    }
+                    });
                 }
             }
         };

package/lib/rules/multiline-ternary.js

@@ -46,9 +46,9 @@ module.exports = {
 
         /**
          * Tests whether node is preceded by supplied tokens
-         * @param {ASTNode} node - node to check
-         * @param {ASTNode} parentNode - parent of node to report
-         * @param {boolean} expected - whether newline was expected or not
+         * @param {ASTNode} node node to check
+         * @param {ASTNode} parentNode parent of node to report
+         * @param {boolean} expected whether newline was expected or not
          * @returns {void}
          * @private
          */

package/lib/rules/newline-after-var.js

@@ -72,8 +72,7 @@ module.exports = {
          *     var foo = 1
          *
          *     ;(a || b).doSomething()
-         *
-         * @param {ASTNode} node - The node to get.
+         * @param {ASTNode} node The node to get.
          * @returns {Token} The token to compare line to the next statement.
          */
         function getLastToken(node) {
@@ -93,7 +92,7 @@ module.exports = {
         /**
          * Determine if provided keyword is a variable declaration
          * @private
-         * @param {string} keyword - keyword to test
+         * @param {string} keyword keyword to test
          * @returns {boolean} True if `keyword` is a type of var
          */
         function isVar(keyword) {
@@ -103,7 +102,7 @@ module.exports = {
         /**
          * Determine if provided keyword is a variant of for specifiers
          * @private
-         * @param {string} keyword - keyword to test
+         * @param {string} keyword keyword to test
          * @returns {boolean} True if `keyword` is a variant of for specifier
          */
         function isForTypeSpecifier(keyword) {
@@ -113,7 +112,7 @@ module.exports = {
         /**
          * Determine if provided keyword is an export specifiers
          * @private
-         * @param {string} nodeType - nodeType to test
+         * @param {string} nodeType nodeType to test
          * @returns {boolean} True if `nodeType` is an export specifier
          */
         function isExportSpecifier(nodeType) {
@@ -124,7 +123,7 @@ module.exports = {
         /**
          * Determine if provided node is the last of their parent block.
          * @private
-         * @param {ASTNode} node - node to test
+         * @param {ASTNode} node node to test
          * @returns {boolean} True if `node` is last of their parent block.
          */
         function isLastNode(node) {
@@ -159,7 +158,7 @@ module.exports = {
          * set to "always", or checks that there is no blank line when mode is set
          * to "never"
          * @private
-         * @param {ASTNode} node - `VariableDeclaration` node to test
+         * @param {ASTNode} node `VariableDeclaration` node to test
          * @returns {void}
          */
         function checkForBlankLine(node) {

package/lib/rules/newline-before-return.js

@@ -39,8 +39,8 @@ module.exports = {
 
         /**
          * Tests whether node is preceded by supplied tokens
-         * @param {ASTNode} node - node to check
-         * @param {Array} testTokens - array of tokens to test against
+         * @param {ASTNode} node node to check
+         * @param {Array} testTokens array of tokens to test against
          * @returns {boolean} Whether or not the node is preceded by one of the supplied tokens
          * @private
          */
@@ -52,7 +52,7 @@ module.exports = {
 
         /**
          * Checks whether node is the first node after statement or in block
-         * @param {ASTNode} node - node to check
+         * @param {ASTNode} node node to check
          * @returns {boolean} Whether or not the node is the first node after statement or in block
          * @private
          */
@@ -80,8 +80,8 @@ module.exports = {
 
         /**
          * Returns the number of lines of comments that precede the node
-         * @param {ASTNode} node - node to check for overlapping comments
-         * @param {number} lineNumTokenBefore - line number of previous token, to check for overlapping comments
+         * @param {ASTNode} node node to check for overlapping comments
+         * @param {number} lineNumTokenBefore line number of previous token, to check for overlapping comments
          * @returns {number} Number of lines of comments that precede the node
          * @private
          */
@@ -115,7 +115,7 @@ module.exports = {
 
         /**
          * Returns the line number of the token before the node that is passed in as an argument
-         * @param {ASTNode} node - The node to use as the start of the calculation
+         * @param {ASTNode} node The node to use as the start of the calculation
          * @returns {number} Line number of the token before `node`
          * @private
          */
@@ -142,7 +142,7 @@ module.exports = {
 
         /**
          * Checks whether node is preceded by a newline
-         * @param {ASTNode} node - node to check
+         * @param {ASTNode} node node to check
          * @returns {boolean} Whether or not the node is preceded by a newline
          * @private
          */
@@ -160,8 +160,7 @@ module.exports = {
          * The fix is not considered safe if the given return statement has leading comments,
          * as we cannot safely determine if the newline should be added before or after the comments.
          * For more information, see: https://github.com/eslint/eslint/issues/5958#issuecomment-222767211
-         *
-         * @param {ASTNode} node - The return statement node to check.
+         * @param {ASTNode} node The return statement node to check.
          * @returns {boolean} `true` if it can fix the node.
          * @private
          */

package/lib/rules/newline-per-chained-call.js

@@ -53,8 +53,7 @@ module.exports = {
          * Get the prefix of a given MemberExpression node.
          * If the MemberExpression node is a computed value it returns a
          * left bracket. If not it returns a period.
-         *
-         * @param  {ASTNode} node - A MemberExpression node to get
+         * @param  {ASTNode} node A MemberExpression node to get
          * @returns {string} The prefix of the node.
          */
         function getPrefix(node) {
@@ -64,8 +63,7 @@ module.exports = {
         /**
          * Gets the property text of a given MemberExpression node.
          * If the text is multiline, this returns only the first line.
-         *
-         * @param {ASTNode} node - A MemberExpression node to get.
+         * @param {ASTNode} node A MemberExpression node to get.
          * @returns {string} The property text of the node.
          */
         function getPropertyText(node) {

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

@@ -33,7 +33,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) {
@@ -45,7 +45,7 @@ module.exports = {
 
         /**
          * Finds and reports references that are non initializer and writable.
-         * @param {ASTNode} node - A ClassDeclaration/ClassExpression node to check.
+         * @param {ASTNode} node A ClassDeclaration/ClassExpression node to check.
          * @returns {void}
          */
         function checkForClass(node) {

package/lib/rules/no-compare-neg-zero.js

@@ -35,8 +35,7 @@ module.exports = {
 
         /**
          * Checks a given node is -0
-         *
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {boolean} `true` if the node is -0.
          */
         function isNegZero(node) {