eslint 6.5.0 → 6.7.1

package/lib/rules/comma-dangle.js

@@ -27,8 +27,7 @@ const DEFAULT_OPTIONS = Object.freeze({
 /**
  * Checks whether or not a trailing comma is allowed in a given node.
  * If the `lastItem` is `RestElement` or `RestProperty`, it disallows trailing commas.
- *
- * @param {ASTNode} lastItem - The node of the last element in the given node.
+ * @param {ASTNode} lastItem The node of the last element in the given node.
  * @returns {boolean} `true` if a trailing comma is allowed.
  */
 function isTrailingCommaAllowed(lastItem) {
@@ -41,20 +40,18 @@ function isTrailingCommaAllowed(lastItem) {
 
 /**
  * Normalize option value.
- *
- * @param {string|Object|undefined} optionValue - The 1st option value to normalize.
+ * @param {string|Object|undefined} optionValue The 1st option value to normalize.
+ * @param {number} ecmaVersion The normalized ECMAScript version.
  * @returns {Object} The normalized option value.
  */
-function normalizeOptions(optionValue) {
+function normalizeOptions(optionValue, ecmaVersion) {
     if (typeof optionValue === "string") {
         return {
             arrays: optionValue,
             objects: optionValue,
             imports: optionValue,
             exports: optionValue,
-
-            // For backward compatibility, always ignore functions.
-            functions: "ignore"
+            functions: (!ecmaVersion || ecmaVersion < 8) ? "ignore" : optionValue
         };
     }
     if (typeof optionValue === "object" && optionValue !== null) {
@@ -137,12 +134,13 @@ module.exports = {
     },
 
     create(context) {
-        const options = normalizeOptions(context.options[0]);
+        const options = normalizeOptions(context.options[0], context.parserOptions.ecmaVersion);
+
         const sourceCode = context.getSourceCode();
 
         /**
          * Gets the last item of the given node.
-         * @param {ASTNode} node - The node to get.
+         * @param {ASTNode} node The node to get.
          * @returns {ASTNode|null} The last node or null.
          */
         function getLastItem(node) {
@@ -172,9 +170,8 @@ module.exports = {
          * Gets the trailing comma token of the given node.
          * If the trailing comma does not exist, this returns the token which is
          * the insertion point of the trailing comma token.
-         *
-         * @param {ASTNode} node - The node to get.
-         * @param {ASTNode} lastItem - The last item of the node.
+         * @param {ASTNode} node The node to get.
+         * @param {ASTNode} lastItem The last item of the node.
          * @returns {Token} The trailing comma token or the insertion point.
          */
         function getTrailingToken(node, lastItem) {
@@ -199,8 +196,7 @@ module.exports = {
          * Checks whether or not a given node is multiline.
          * This rule handles a given node as multiline when the closing parenthesis
          * and the last element are not on the same line.
-         *
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {boolean} `true` if the node is multiline.
          */
         function isMultiline(node) {
@@ -218,8 +214,7 @@ module.exports = {
 
         /**
          * Reports a trailing comma if it exists.
-         *
-         * @param {ASTNode} node - A node to check. Its type is one of
+         * @param {ASTNode} node A node to check. Its type is one of
          *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
          *   ImportDeclaration, and ExportNamedDeclaration.
          * @returns {void}
@@ -236,7 +231,7 @@ module.exports = {
             if (astUtils.isCommaToken(trailingToken)) {
                 context.report({
                     node: lastItem,
-                    loc: trailingToken.loc.start,
+                    loc: trailingToken.loc,
                     messageId: "unexpected",
                     fix(fixer) {
                         return fixer.remove(trailingToken);
@@ -251,8 +246,7 @@ module.exports = {
          *
          * If a given node is `ArrayPattern` which has `RestElement`, the trailing
          * comma is disallowed, so report if it exists.
-         *
-         * @param {ASTNode} node - A node to check. Its type is one of
+         * @param {ASTNode} node A node to check. Its type is one of
          *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
          *   ImportDeclaration, and ExportNamedDeclaration.
          * @returns {void}
@@ -273,7 +267,10 @@ module.exports = {
             if (trailingToken.value !== ",") {
                 context.report({
                     node: lastItem,
-                    loc: trailingToken.loc.end,
+                    loc: {
+                        start: trailingToken.loc.end,
+                        end: astUtils.getNextLocation(sourceCode, trailingToken.loc.end)
+                    },
                     messageId: "missing",
                     fix(fixer) {
                         return fixer.insertTextAfter(trailingToken, ",");
@@ -286,8 +283,7 @@ module.exports = {
          * If a given node is multiline, reports the last element of a given node
          * when it does not have a trailing comma.
          * Otherwise, reports a trailing comma if it exists.
-         *
-         * @param {ASTNode} node - A node to check. Its type is one of
+         * @param {ASTNode} node A node to check. Its type is one of
          *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
          *   ImportDeclaration, and ExportNamedDeclaration.
          * @returns {void}
@@ -304,8 +300,7 @@ module.exports = {
          * Only if a given node is not multiline, reports the last element of a given node
          * when it does not have a trailing comma.
          * Otherwise, reports a trailing comma if it exists.
-         *
-         * @param {ASTNode} node - A node to check. Its type is one of
+         * @param {ASTNode} node A node to check. Its type is one of
          *   ObjectExpression, ObjectPattern, ArrayExpression, ArrayPattern,
          *   ImportDeclaration, and ExportNamedDeclaration.
          * @returns {void}

package/lib/rules/comma-spacing.js

@@ -105,7 +105,7 @@ module.exports = {
 
         /**
          * Validates the spacing around a comma token.
-         * @param {Object} tokens - The tokens to be validated.
+         * @param {Object} tokens The tokens to be validated.
          * @param {Token} tokens.comma The token representing the comma.
          * @param {Token} [tokens.left] The last token before the comma.
          * @param {Token} [tokens.right] The first token after the comma.

package/lib/rules/computed-property-spacing.js

@@ -59,9 +59,9 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a space after the first token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
-         * @param {Token} tokenAfter - The token after `token`.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
+         * @param {Token} tokenAfter The token after `token`.
          * @returns {void}
          */
         function reportNoBeginningSpace(node, token, tokenAfter) {
@@ -80,9 +80,9 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a space before the last token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
-         * @param {Token} tokenBefore - The token before `token`.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
+         * @param {Token} tokenBefore The token before `token`.
          * @returns {void}
          */
         function reportNoEndingSpace(node, token, tokenBefore) {
@@ -101,8 +101,8 @@ module.exports = {
 
         /**
          * Reports that there should be a space after the first token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredBeginningSpace(node, token) {
@@ -121,8 +121,8 @@ module.exports = {
 
         /**
          * Reports that there should be a space before the last token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredEndingSpace(node, token) {
@@ -153,10 +153,10 @@ module.exports = {
 
                 const property = node[propertyName];
 
-                const before = sourceCode.getTokenBefore(property),
-                    first = sourceCode.getFirstToken(property),
-                    last = sourceCode.getLastToken(property),
-                    after = sourceCode.getTokenAfter(property);
+                const before = sourceCode.getTokenBefore(property, astUtils.isOpeningBracketToken),
+                    first = sourceCode.getTokenAfter(before, { includeComments: true }),
+                    after = sourceCode.getTokenAfter(property, astUtils.isClosingBracketToken),
+                    last = sourceCode.getTokenBefore(after, { includeComments: true });
 
                 if (astUtils.isTokenOnSameLine(before, first)) {
                     if (propertyNameMustBeSpaced) {

package/lib/rules/consistent-return.js

@@ -18,8 +18,8 @@ const astUtils = require("./utils/ast-utils");
 
 /**
  * Checks whether or not a given node is an `Identifier` node which was named a given name.
- * @param {ASTNode} node - A node to check.
- * @param {string} name - An expected name of the node.
+ * @param {ASTNode} node A node to check.
+ * @param {string} name An expected name of the node.
  * @returns {boolean} `true` if the node is an `Identifier` node which was named as expected.
  */
 function isIdentifier(node, name) {
@@ -28,7 +28,7 @@ function isIdentifier(node, name) {
 
 /**
  * Checks whether or not a given code path segment is unreachable.
- * @param {CodePathSegment} segment - A CodePathSegment to check.
+ * @param {CodePathSegment} segment A CodePathSegment to check.
  * @returns {boolean} `true` if the segment is unreachable.
  */
 function isUnreachable(segment) {
@@ -88,8 +88,7 @@ module.exports = {
         /**
          * Checks whether of not the implicit returning is consistent if the last
          * code path segment is reachable.
-         *
-         * @param {ASTNode} node - A program/function node to check.
+         * @param {ASTNode} node A program/function node to check.
          * @returns {void}
          */
         function checkLastSegment(node) {

package/lib/rules/consistent-this.js

@@ -46,8 +46,8 @@ module.exports = {
         /**
          * Reports that a variable declarator or assignment expression is assigning
          * a non-'this' value to the specified alias.
-         * @param {ASTNode} node - The assigning node.
-         * @param {string}  name - the name of the alias that was incorrectly used.
+         * @param {ASTNode} node The assigning node.
+         * @param {string}  name the name of the alias that was incorrectly used.
          * @returns {void}
          */
         function reportBadAssignment(node, name) {
@@ -57,9 +57,9 @@ module.exports = {
         /**
          * Checks that an assignment to an identifier only assigns 'this' to the
          * appropriate alias, and the alias is only assigned to 'this'.
-         * @param {ASTNode} node - The assigning node.
-         * @param {Identifier} name - The name of the variable assigned to.
-         * @param {Expression} value - The value of the assignment.
+         * @param {ASTNode} node The assigning node.
+         * @param {Identifier} name The name of the variable assigned to.
+         * @param {Expression} value The value of the assignment.
          * @returns {void}
          */
         function checkAssignment(node, name, value) {

package/lib/rules/constructor-super.js

@@ -11,8 +11,7 @@
 
 /**
  * Checks whether a given code path segment is reachable or not.
- *
- * @param {CodePathSegment} segment - A code path segment to check.
+ * @param {CodePathSegment} segment A code path segment to check.
  * @returns {boolean} `true` if the segment is reachable.
  */
 function isReachable(segment) {
@@ -21,7 +20,7 @@ function isReachable(segment) {
 
 /**
  * Checks whether or not a given node is a constructor.
- * @param {ASTNode} node - A node to check. This node type is one of
+ * @param {ASTNode} node A node to check. This node type is one of
  *   `Program`, `FunctionDeclaration`, `FunctionExpression`, and
  *   `ArrowFunctionExpression`.
  * @returns {boolean} `true` if the node is a constructor.
@@ -36,8 +35,7 @@ function isConstructorFunction(node) {
 
 /**
  * Checks whether a given node can be a constructor or not.
- *
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node can be a constructor.
  */
 function isPossibleConstructor(node) {
@@ -137,7 +135,7 @@ module.exports = {
 
         /**
          * Gets the flag which shows `super()` is called in some paths.
-         * @param {CodePathSegment} segment - A code path segment to get.
+         * @param {CodePathSegment} segment A code path segment to get.
          * @returns {boolean} The flag which shows `super()` is called in some paths
          */
         function isCalledInSomePath(segment) {
@@ -146,7 +144,7 @@ module.exports = {
 
         /**
          * Gets the flag which shows `super()` is called in all paths.
-         * @param {CodePathSegment} segment - A code path segment to get.
+         * @param {CodePathSegment} segment A code path segment to get.
          * @returns {boolean} The flag which shows `super()` is called in all paths.
          */
         function isCalledInEveryPath(segment) {
@@ -168,8 +166,8 @@ module.exports = {
 
             /**
              * Stacks a constructor information.
-             * @param {CodePath} codePath - A code path which was started.
-             * @param {ASTNode} node - The current node.
+             * @param {CodePath} codePath A code path which was started.
+             * @param {ASTNode} node The current node.
              * @returns {void}
              */
             onCodePathStart(codePath, node) {
@@ -200,8 +198,8 @@ module.exports = {
             /**
              * Pops a constructor information.
              * And reports if `super()` lacked.
-             * @param {CodePath} codePath - A code path which was ended.
-             * @param {ASTNode} node - The current node.
+             * @param {CodePath} codePath A code path which was ended.
+             * @param {ASTNode} node The current node.
              * @returns {void}
              */
             onCodePathEnd(codePath, node) {
@@ -231,7 +229,7 @@ module.exports = {
 
             /**
              * Initialize information of a given code path segment.
-             * @param {CodePathSegment} segment - A code path segment to initialize.
+             * @param {CodePathSegment} segment A code path segment to initialize.
              * @returns {void}
              */
             onCodePathSegmentStart(segment) {
@@ -258,9 +256,9 @@ module.exports = {
             /**
              * Update information of the code path segment when a code path was
              * looped.
-             * @param {CodePathSegment} fromSegment - The code path segment of the
+             * @param {CodePathSegment} fromSegment The code path segment of the
              *      end of a loop.
-             * @param {CodePathSegment} toSegment - A code path segment of the head
+             * @param {CodePathSegment} toSegment A code path segment of the head
              *      of a loop.
              * @returns {void}
              */
@@ -303,7 +301,7 @@ module.exports = {
 
             /**
              * Checks for a call of `super()`.
-             * @param {ASTNode} node - A CallExpression node to check.
+             * @param {ASTNode} node A CallExpression node to check.
              * @returns {void}
              */
             "CallExpression:exit"(node) {
@@ -358,7 +356,7 @@ module.exports = {
 
             /**
              * Set the mark to the returned path as `super()` was called.
-             * @param {ASTNode} node - A ReturnStatement node to check.
+             * @param {ASTNode} node A ReturnStatement node to check.
              * @returns {void}
              */
             ReturnStatement(node) {

package/lib/rules/curly.js

@@ -97,10 +97,15 @@ module.exports = {
          * @private
          */
         function isOneLiner(node) {
-            const first = sourceCode.getFirstToken(node),
-                last = sourceCode.getLastToken(node);
+            if (node.type === "EmptyStatement") {
+                return true;
+            }
 
-            return first.loc.start.line === last.loc.end.line;
+            const first = sourceCode.getFirstToken(node);
+            const last = sourceCode.getLastToken(node);
+            const lastExcludingSemicolon = astUtils.isSemicolonToken(last) ? sourceCode.getTokenBefore(last) : last;
+
+            return first.loc.start.line === lastExcludingSemicolon.loc.end.line;
         }
 
         /**
@@ -119,8 +124,7 @@ module.exports = {
 
         /**
          * Checks if the given token is an `else` token or not.
-         *
-         * @param {Token} token - The token to check.
+         * @param {Token} token The token to check.
          * @returns {boolean} `true` if the token is an `else` token.
          */
         function isElseKeywordToken(token) {
@@ -129,7 +133,7 @@ module.exports = {
 
         /**
          * Gets the `else` keyword token of a given `IfStatement` node.
-         * @param {ASTNode} node - A `IfStatement` node to get.
+         * @param {ASTNode} node A `IfStatement` node to get.
          * @returns {Token} The `else` keyword token.
          */
         function getElseKeyword(node) {
@@ -143,8 +147,7 @@ module.exports = {
          * 1. The given node has the `alternate` node.
          * 2. There is a `IfStatement` which doesn't have `alternate` node in the
          *    trailing statement chain of the `consequent` node.
-         *
-         * @param {ASTNode} node - A IfStatement node to check.
+         * @param {ASTNode} node A IfStatement node to check.
          * @returns {boolean} `true` if the node requires braces of the consequent chunk.
          */
         function requiresBraceOfConsequent(node) {
@@ -242,7 +245,7 @@ module.exports = {
             if (node.type === "IfStatement" && node.consequent === body && requiresBraceOfConsequent(node)) {
                 expected = true;
             } else if (multiOnly) {
-                if (hasBlock && body.body.length === 1) {
+                if (hasBlock && body.body.length === 1 && !isLexicalDeclaration(body.body[0])) {
                     expected = false;
                 }
             } else if (multiLine) {

package/lib/rules/default-param-last.js

@@ -25,6 +25,7 @@ module.exports = {
 
     create(context) {
 
+        // eslint-disable-next-line jsdoc/require-description
         /**
          * @param {ASTNode} node function node
          * @returns {void}

package/lib/rules/dot-location.js

@@ -47,19 +47,18 @@ module.exports = {
 
         /**
          * Reports if the dot between object and property is on the correct loccation.
-         * @param {ASTNode} obj The object owning the property.
-         * @param {ASTNode} prop The property of the object.
-         * @param {ASTNode} node The corresponding node of the token.
+         * @param {ASTNode} node The `MemberExpression` node.
          * @returns {void}
          */
-        function checkDotLocation(obj, prop, node) {
-            const dot = sourceCode.getTokenBefore(prop);
+        function checkDotLocation(node) {
+            const property = node.property;
+            const dot = sourceCode.getTokenBefore(property);
 
             // `obj` expression can be parenthesized, but those paren tokens are not a part of the `obj` node.
             const tokenBeforeDot = sourceCode.getTokenBefore(dot);
 
             const textBeforeDot = sourceCode.getText().slice(tokenBeforeDot.range[1], dot.range[0]);
-            const textAfterDot = sourceCode.getText().slice(dot.range[1], prop.range[0]);
+            const textAfterDot = sourceCode.getText().slice(dot.range[1], property.range[0]);
 
             if (onObject) {
                 if (!astUtils.isTokenOnSameLine(tokenBeforeDot, dot)) {
@@ -67,17 +66,17 @@ module.exports = {
 
                     context.report({
                         node,
-                        loc: dot.loc.start,
+                        loc: dot.loc,
                         messageId: "expectedDotAfterObject",
-                        fix: fixer => fixer.replaceTextRange([tokenBeforeDot.range[1], prop.range[0]], `${neededTextAfterToken}.${textBeforeDot}${textAfterDot}`)
+                        fix: fixer => fixer.replaceTextRange([tokenBeforeDot.range[1], property.range[0]], `${neededTextAfterToken}.${textBeforeDot}${textAfterDot}`)
                     });
                 }
-            } else if (!astUtils.isTokenOnSameLine(dot, prop)) {
+            } else if (!astUtils.isTokenOnSameLine(dot, property)) {
                 context.report({
                     node,
-                    loc: dot.loc.start,
+                    loc: dot.loc,
                     messageId: "expectedDotBeforeProperty",
-                    fix: fixer => fixer.replaceTextRange([tokenBeforeDot.range[1], prop.range[0]], `${textBeforeDot}${textAfterDot}.`)
+                    fix: fixer => fixer.replaceTextRange([tokenBeforeDot.range[1], property.range[0]], `${textBeforeDot}${textAfterDot}.`)
                 });
             }
         }
@@ -89,7 +88,7 @@ module.exports = {
          */
         function checkNode(node) {
             if (!node.computed) {
-                checkDotLocation(node.object, node.property, node);
+                checkDotLocation(node);
             }
         }
 

package/lib/rules/func-names.js

@@ -13,7 +13,7 @@ const astUtils = require("./utils/ast-utils");
 
 /**
  * Checks whether or not a given variable is a function name.
- * @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 a function name.
  */
 function isFunctionName(variable) {
@@ -73,7 +73,7 @@ module.exports = {
 
         /**
          * Returns the config option for the given node.
-         * @param {ASTNode} node - A node to get the config for.
+         * @param {ASTNode} node A node to get the config for.
          * @returns {string} The config option.
          */
         function getConfigForNode(node) {
@@ -91,7 +91,7 @@ module.exports = {
         /**
          * Determines whether the current FunctionExpression node is a get, set, or
          * shorthand method in an object literal or a class.
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {boolean} True if the node is a get, set, or shorthand method.
          */
         function isObjectOrClassMethod(node) {
@@ -109,7 +109,7 @@ module.exports = {
         /**
          * Determines whether the current FunctionExpression node has a name that would be
          * inferred from context in a conforming ES6 environment.
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {boolean} True if the node would have a name assigned automatically.
          */
         function hasInferredName(node) {
@@ -125,7 +125,7 @@ module.exports = {
 
         /**
          * Reports that an unnamed function should be named
-         * @param {ASTNode} node - The node to report in the event of an error.
+         * @param {ASTNode} node The node to report in the event of an error.
          * @returns {void}
          */
         function reportUnexpectedUnnamedFunction(node) {
@@ -139,7 +139,7 @@ module.exports = {
 
         /**
          * Reports that a named function should be unnamed
-         * @param {ASTNode} node - The node to report in the event of an error.
+         * @param {ASTNode} node The node to report in the event of an error.
          * @returns {void}
          */
         function reportUnexpectedNamedFunction(node) {

package/lib/rules/function-call-argument-newline.js

@@ -40,13 +40,13 @@ module.exports = {
         const checkers = {
             unexpected: {
                 messageId: "unexpectedLineBreak",
-                check: (prevToken, currentToken) => prevToken.loc.start.line !== currentToken.loc.start.line,
+                check: (prevToken, currentToken) => prevToken.loc.end.line !== currentToken.loc.start.line,
                 createFix: (token, tokenBefore) => fixer =>
                     fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], " ")
             },
             missing: {
                 messageId: "missingLineBreak",
-                check: (prevToken, currentToken) => prevToken.loc.start.line === currentToken.loc.start.line,
+                check: (prevToken, currentToken) => prevToken.loc.end.line === currentToken.loc.start.line,
                 createFix: (token, tokenBefore) => fixer =>
                     fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], "\n")
             }
@@ -61,7 +61,7 @@ module.exports = {
          */
         function checkArguments(node, checker) {
             for (let i = 1; i < node.arguments.length; i++) {
-                const prevArgToken = sourceCode.getFirstToken(node.arguments[i - 1]);
+                const prevArgToken = sourceCode.getLastToken(node.arguments[i - 1]);
                 const currentArgToken = sourceCode.getFirstToken(node.arguments[i]);
 
                 if (checker.check(prevArgToken, currentArgToken)) {
@@ -70,6 +70,8 @@ module.exports = {
                         { includeComments: true }
                     );
 
+                    const hasLineCommentBefore = tokenBefore.type === "Line";
+
                     context.report({
                         node,
                         loc: {
@@ -77,7 +79,7 @@ module.exports = {
                             end: currentArgToken.loc.start
                         },
                         messageId: checker.messageId,
-                        fix: checker.createFix(currentArgToken, tokenBefore)
+                        fix: hasLineCommentBefore ? null : checker.createFix(currentArgToken, tokenBefore)
                     });
                 }
             }
@@ -101,10 +103,10 @@ module.exports = {
             } else if (option === "always") {
                 checkArguments(node, checkers.missing);
             } else if (option === "consistent") {
-                const firstArgToken = sourceCode.getFirstToken(node.arguments[0]);
+                const firstArgToken = sourceCode.getLastToken(node.arguments[0]);
                 const secondArgToken = sourceCode.getFirstToken(node.arguments[1]);
 
-                if (firstArgToken.loc.start.line === secondArgToken.loc.start.line) {
+                if (firstArgToken.loc.end.line === secondArgToken.loc.start.line) {
                     checkArguments(node, checkers.unexpected);
                 } else {
                     checkArguments(node, checkers.missing);

package/lib/rules/generator-star-spacing.js

@@ -78,9 +78,8 @@ module.exports = {
 
         /**
          * Returns resolved option definitions based on an option and defaults
-         *
-         * @param {any} option - The option object or string value
-         * @param {Object} defaults - The defaults to use if options are not present
+         * @param {any} option The option object or string value
+         * @param {Object} defaults The defaults to use if options are not present
          * @returns {Object} the resolved object definition
          */
         function optionToDefinition(option, defaults) {
@@ -107,8 +106,7 @@ module.exports = {
 
         /**
          * Checks if the given token is a star token or not.
-         *
-         * @param {Token} token - The token to check.
+         * @param {Token} token The token to check.
          * @returns {boolean} `true` if the token is a star token.
          */
         function isStarToken(token) {
@@ -117,8 +115,7 @@ module.exports = {
 
         /**
          * Gets the generator star token of the given function node.
-         *
-         * @param {ASTNode} node - The function node to get.
+         * @param {ASTNode} node The function node to get.
          * @returns {Token} Found star token.
          */
         function getStarToken(node) {
@@ -139,7 +136,6 @@ module.exports = {
 
         /**
          * Checks the spacing between two tokens before or after the star token.
-         *
          * @param {string} kind Either "named", "anonymous", or "method"
          * @param {string} side Either "before" or "after".
          * @param {Token} leftToken `function` keyword token if side is "before", or
@@ -173,7 +169,6 @@ module.exports = {
 
         /**
          * Enforces the spacing around the star if node is a generator function.
-         *
          * @param {ASTNode} node A function expression or declaration node.
          * @returns {void}
          */