eslint 6.5.0 → 6.7.1

package/lib/rules/no-unreachable.js

@@ -10,7 +10,7 @@
 
 /**
  * Checks whether or not a given variable declarator has the initializer.
- * @param {ASTNode} node - A VariableDeclarator node to check.
+ * @param {ASTNode} node A VariableDeclarator node to check.
  * @returns {boolean} `true` if the node has the initializer.
  */
 function isInitialized(node) {
@@ -19,7 +19,7 @@ function isInitialized(node) {
 
 /**
  * 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) {
@@ -57,7 +57,7 @@ class ConsecutiveRange {
 
     /**
      * Checks whether the given node is inside of this range.
-     * @param {ASTNode|Token} node - The node to check.
+     * @param {ASTNode|Token} node The node to check.
      * @returns {boolean} `true` if the node is inside of this range.
      */
     contains(node) {
@@ -69,7 +69,7 @@ class ConsecutiveRange {
 
     /**
      * Checks whether the given node is consecutive to this range.
-     * @param {ASTNode} node - The node to check.
+     * @param {ASTNode} node The node to check.
      * @returns {boolean} `true` if the node is consecutive to this range.
      */
     isConsecutive(node) {
@@ -78,7 +78,7 @@ class ConsecutiveRange {
 
     /**
      * Merges the given node to this range.
-     * @param {ASTNode} node - The node to merge.
+     * @param {ASTNode} node The node to merge.
      * @returns {void}
      */
     merge(node) {
@@ -87,7 +87,7 @@ class ConsecutiveRange {
 
     /**
      * Resets this range by the given node or null.
-     * @param {ASTNode|null} node - The node to reset, or null.
+     * @param {ASTNode|null} node The node to reset, or null.
      * @returns {void}
      */
     reset(node) {
@@ -120,7 +120,7 @@ module.exports = {
 
         /**
          * Reports a given node if it's unreachable.
-         * @param {ASTNode} node - A statement node to report.
+         * @param {ASTNode} node A statement node to report.
          * @returns {void}
          */
         function reportIfUnreachable(node) {

package/lib/rules/no-unsafe-finally.js

@@ -35,8 +35,7 @@ module.exports = {
 
         /**
          * Checks if the node is the finalizer of a TryStatement
-         *
-         * @param {ASTNode} node - node to check.
+         * @param {ASTNode} node node to check.
          * @returns {boolean} - true if the node is the finalizer of a TryStatement
          */
         function isFinallyBlock(node) {
@@ -45,9 +44,8 @@ module.exports = {
 
         /**
          * Climbs up the tree if the node is not a sentinel node
-         *
-         * @param {ASTNode} node - node to check.
-         * @param {string} label - label of the break or continue statement
+         * @param {ASTNode} node node to check.
+         * @param {string} label label of the break or continue statement
          * @returns {boolean} - return whether the node is a finally block or a sentinel node
          */
         function isInFinallyBlock(node, label) {
@@ -82,8 +80,7 @@ module.exports = {
 
         /**
          * Checks whether the possibly-unsafe statement is inside a finally block.
-         *
-         * @param {ASTNode} node - node to check.
+         * @param {ASTNode} node node to check.
          * @returns {void}
          */
         function check(node) {

package/lib/rules/no-unsafe-negation.js

@@ -16,19 +16,26 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 /**
- * Checks whether the given operator is a relational operator or not.
- *
- * @param {string} op - The operator type to check.
- * @returns {boolean} `true` if the operator is a relational operator.
+ * Checks whether the given operator is `in` or `instanceof`
+ * @param {string} op The operator type to check.
+ * @returns {boolean} `true` if the operator is `in` or `instanceof`
  */
-function isRelationalOperator(op) {
+function isInOrInstanceOfOperator(op) {
     return op === "in" || op === "instanceof";
 }
 
+/**
+ * Checks whether the given operator is an ordering relational operator or not.
+ * @param {string} op The operator type to check.
+ * @returns {boolean} `true` if the operator is an ordering relational operator.
+ */
+function isOrderingRelationalOperator(op) {
+    return op === "<" || op === ">" || op === ">=" || op === "<=";
+}
+
 /**
  * Checks whether the given node is a logical negation expression or not.
- *
- * @param {ASTNode} node - The node to check.
+ * @param {ASTNode} node The node to check.
  * @returns {boolean} `true` if the node is a logical negation expression.
  */
 function isNegation(node) {
@@ -50,7 +57,18 @@ module.exports = {
             url: "https://eslint.org/docs/rules/no-unsafe-negation"
         },
 
-        schema: [],
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    enforceForOrderingRelations: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
         fixable: null,
         messages: {
             unexpected: "Unexpected negating the left operand of '{{operator}}' operator."
@@ -59,10 +77,15 @@ module.exports = {
 
     create(context) {
         const sourceCode = context.getSourceCode();
+        const options = context.options[0] || {};
+        const enforceForOrderingRelations = options.enforceForOrderingRelations === true;
 
         return {
             BinaryExpression(node) {
-                if (isRelationalOperator(node.operator) &&
+                const orderingRelationRuleApplies = enforceForOrderingRelations && isOrderingRelationalOperator(node.operator);
+
+                if (
+                    (isInOrInstanceOfOperator(node.operator) || orderingRelationRuleApplies) &&
                     isNegation(node.left) &&
                     !astUtils.isParenthesised(sourceCode, node.left)
                 ) {

package/lib/rules/no-unused-expressions.js

@@ -47,8 +47,9 @@ module.exports = {
             allowTernary = config.allowTernary || false,
             allowTaggedTemplates = config.allowTaggedTemplates || false;
 
+        // eslint-disable-next-line jsdoc/require-description
         /**
-         * @param {ASTNode} node - any node
+         * @param {ASTNode} node any node
          * @returns {boolean} whether the given node structurally represents a directive
          */
         function looksLikeDirective(node) {
@@ -56,9 +57,10 @@ module.exports = {
                 node.expression.type === "Literal" && typeof node.expression.value === "string";
         }
 
+        // eslint-disable-next-line jsdoc/require-description
         /**
-         * @param {Function} predicate - ([a] -> Boolean) the function used to make the determination
-         * @param {a[]} list - the input list
+         * @param {Function} predicate ([a] -> Boolean) the function used to make the determination
+         * @param {a[]} list the input list
          * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
          */
         function takeWhile(predicate, list) {
@@ -70,17 +72,19 @@ module.exports = {
             return list.slice();
         }
 
+        // eslint-disable-next-line jsdoc/require-description
         /**
-         * @param {ASTNode} node - a Program or BlockStatement node
+         * @param {ASTNode} node a Program or BlockStatement node
          * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
          */
         function directives(node) {
             return takeWhile(looksLikeDirective, node.body);
         }
 
+        // eslint-disable-next-line jsdoc/require-description
         /**
-         * @param {ASTNode} node - any node
-         * @param {ASTNode[]} ancestors - the given node's ancestors
+         * @param {ASTNode} node any node
+         * @param {ASTNode[]} ancestors the given node's ancestors
          * @returns {boolean} whether the given node is considered a directive in its current position
          */
         function isDirective(node, ancestors) {
@@ -94,7 +98,7 @@ module.exports = {
 
         /**
          * Determines whether or not a given node is a valid expression. Recurses on short circuit eval and ternary nodes if enabled by flags.
-         * @param {ASTNode} node - any node
+         * @param {ASTNode} node any node
          * @returns {boolean} whether the given node is a valid expression
          */
         function isValidExpression(node) {

package/lib/rules/no-unused-labels.js

@@ -35,8 +35,7 @@ module.exports = {
 
         /**
          * Adds a scope info to the stack.
-         *
-         * @param {ASTNode} node - A node to add. This is a LabeledStatement.
+         * @param {ASTNode} node A node to add. This is a LabeledStatement.
          * @returns {void}
          */
         function enterLabeledScope(node) {
@@ -50,8 +49,7 @@ module.exports = {
         /**
          * Removes the top of the stack.
          * At the same time, this reports the label if it's never used.
-         *
-         * @param {ASTNode} node - A node to report. This is a LabeledStatement.
+         * @param {ASTNode} node A node to report. This is a LabeledStatement.
          * @returns {void}
          */
         function exitLabeledScope(node) {
@@ -81,8 +79,7 @@ module.exports = {
 
         /**
          * Marks the label of a given node as used.
-         *
-         * @param {ASTNode} node - A node to mark. This is a BreakStatement or
+         * @param {ASTNode} node A node to mark. This is a BreakStatement or
          *      ContinueStatement.
          * @returns {void}
          */

package/lib/rules/no-unused-vars.js

@@ -103,7 +103,7 @@ module.exports = {
         /**
          * Generate the warning message about the variable being
          * defined and unused, including the ignore pattern if configured.
-         * @param {Variable} unusedVar - eslint-scope variable object.
+         * @param {Variable} unusedVar eslint-scope variable object.
          * @returns {string} The warning message to be used with this unused variable.
          */
         function getDefinedMessage(unusedVar) {
@@ -146,7 +146,7 @@ module.exports = {
 
         /**
          * Determines if a given variable is being exported from a module.
-         * @param {Variable} variable - eslint-scope variable object.
+         * @param {Variable} variable eslint-scope variable object.
          * @returns {boolean} True if the variable is exported, false if not.
          * @private
          */
@@ -172,7 +172,7 @@ module.exports = {
 
         /**
          * Determines if a variable has a sibling rest property
-         * @param {Variable} variable - eslint-scope variable object.
+         * @param {Variable} variable eslint-scope variable object.
          * @returns {boolean} True if the variable is exported, false if not.
          * @private
          */
@@ -195,7 +195,7 @@ module.exports = {
 
         /**
          * Determines if a reference is a read operation.
-         * @param {Reference} ref - An eslint-scope Reference
+         * @param {Reference} ref An eslint-scope Reference
          * @returns {boolean} whether the given reference represents a read operation
          * @private
          */
@@ -205,8 +205,8 @@ module.exports = {
 
         /**
          * Determine if an identifier is referencing an enclosing function name.
-         * @param {Reference} ref - The reference to check.
-         * @param {ASTNode[]} nodes - The candidate function nodes.
+         * @param {Reference} ref The reference to check.
+         * @param {ASTNode[]} nodes The candidate function nodes.
          * @returns {boolean} True if it's a self-reference, false if not.
          * @private
          */
@@ -226,7 +226,7 @@ module.exports = {
 
         /**
          * Gets a list of function definitions for a specified variable.
-         * @param {Variable} variable - eslint-scope variable object.
+         * @param {Variable} variable eslint-scope variable object.
          * @returns {ASTNode[]} Function nodes.
          * @private
          */
@@ -252,9 +252,8 @@ module.exports = {
 
         /**
          * Checks the position of given nodes.
-         *
-         * @param {ASTNode} inner - A node which is expected as inside.
-         * @param {ASTNode} outer - A node which is expected as outside.
+         * @param {ASTNode} inner A node which is expected as inside.
+         * @param {ASTNode} outer A node which is expected as outside.
          * @returns {boolean} `true` if the `inner` node exists in the `outer` node.
          * @private
          */
@@ -275,9 +274,8 @@ module.exports = {
          * - The reference is inside of a loop.
          * - The reference is inside of a function scope which is different from
          *   the declaration.
-         *
-         * @param {eslint-scope.Reference} ref - A reference to check.
-         * @param {ASTNode} prevRhsNode - The previous RHS node.
+         * @param {eslint-scope.Reference} ref A reference to check.
+         * @param {ASTNode} prevRhsNode The previous RHS node.
          * @returns {ASTNode|null} The RHS node or null.
          * @private
          */
@@ -310,9 +308,8 @@ module.exports = {
         /**
          * Checks whether a given function node is stored to somewhere or not.
          * If the function node is stored, the function can be used later.
-         *
-         * @param {ASTNode} funcNode - A function node to check.
-         * @param {ASTNode} rhsNode - The RHS node of the previous assignment.
+         * @param {ASTNode} funcNode A function node to check.
+         * @param {ASTNode} rhsNode The RHS node of the previous assignment.
          * @returns {boolean} `true` if under the following conditions:
          *      - the funcNode is assigned to a variable.
          *      - the funcNode is bound as an argument of a function call.
@@ -367,9 +364,8 @@ module.exports = {
          * - the function is bound as an argument of a function call.
          *
          * If a reference exists in a function which can be used later, the reference is read when the function is called.
-         *
-         * @param {ASTNode} id - An Identifier node to check.
-         * @param {ASTNode} rhsNode - The RHS node of the previous assignment.
+         * @param {ASTNode} id An Identifier node to check.
+         * @param {ASTNode} rhsNode The RHS node of the previous assignment.
          * @returns {boolean} `true` if the `id` node exists inside of a function node which can be used later.
          * @private
          */
@@ -385,9 +381,8 @@ module.exports = {
 
         /**
          * Checks whether a given reference is a read to update itself or not.
-         *
-         * @param {eslint-scope.Reference} ref - A reference to check.
-         * @param {ASTNode} rhsNode - The RHS node of the previous assignment.
+         * @param {eslint-scope.Reference} ref A reference to check.
+         * @param {ASTNode} rhsNode The RHS node of the previous assignment.
          * @returns {boolean} The reference is a read to update itself.
          * @private
          */
@@ -416,8 +411,7 @@ module.exports = {
 
         /**
          * Determine if an identifier is used either in for-in loops.
-         *
-         * @param {Reference} ref - The reference to check.
+         * @param {Reference} ref The reference to check.
          * @returns {boolean} whether reference is used in the for-in loops
          * @private
          */
@@ -453,7 +447,7 @@ module.exports = {
 
         /**
          * Determines if the variable is used.
-         * @param {Variable} variable - The variable to check.
+         * @param {Variable} variable The variable to check.
          * @returns {boolean} True if the variable is used
          * @private
          */
@@ -481,8 +475,7 @@ module.exports = {
 
         /**
          * Checks whether the given variable is after the last used parameter.
-         *
-         * @param {eslint-scope.Variable} variable - The variable to check.
+         * @param {eslint-scope.Variable} variable The variable to check.
          * @returns {boolean} `true` if the variable is defined after the last
          * used parameter.
          */
@@ -497,8 +490,8 @@ module.exports = {
 
         /**
          * Gets an array of variables without read references.
-         * @param {Scope} scope - an eslint-scope Scope object.
-         * @param {Variable[]} unusedVars - an array that saving result.
+         * @param {Scope} scope an eslint-scope Scope object.
+         * @param {Variable[]} unusedVars an array that saving result.
          * @returns {Variable[]} unused variables of the scope and descendant scopes.
          * @private
          */

package/lib/rules/no-use-before-define.js

@@ -14,8 +14,7 @@ const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u;
 
 /**
  * Parses a given value as options.
- *
- * @param {any} options - A value to parse.
+ * @param {any} options A value to parse.
  * @returns {Object} The parsed options.
  */
 function parseOptions(options) {
@@ -36,8 +35,7 @@ function parseOptions(options) {
 
 /**
  * Checks whether or not a given variable is a function declaration.
- *
- * @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 declaration.
  */
 function isFunction(variable) {
@@ -46,9 +44,8 @@ function isFunction(variable) {
 
 /**
  * Checks whether or not a given variable is a class declaration in an upper function scope.
- *
- * @param {eslint-scope.Variable} variable - A variable to check.
- * @param {eslint-scope.Reference} reference - A reference to check.
+ * @param {eslint-scope.Variable} variable A variable to check.
+ * @param {eslint-scope.Reference} reference A reference to check.
  * @returns {boolean} `true` if the variable is a class declaration.
  */
 function isOuterClass(variable, reference) {
@@ -60,8 +57,8 @@ function isOuterClass(variable, reference) {
 
 /**
  * Checks whether or not a given variable is a variable declaration in an upper function scope.
- * @param {eslint-scope.Variable} variable - A variable to check.
- * @param {eslint-scope.Reference} reference - A reference to check.
+ * @param {eslint-scope.Variable} variable A variable to check.
+ * @param {eslint-scope.Reference} reference A reference to check.
  * @returns {boolean} `true` if the variable is a variable declaration.
  */
 function isOuterVariable(variable, reference) {
@@ -73,9 +70,8 @@ function isOuterVariable(variable, reference) {
 
 /**
  * Checks whether or not a given location is inside of the range of a given node.
- *
- * @param {ASTNode} node - An node to check.
- * @param {number} location - A location to check.
+ * @param {ASTNode} node An node to check.
+ * @param {number} location A location to check.
  * @returns {boolean} `true` if the location is inside of the range of the node.
  */
 function isInRange(node, location) {
@@ -92,9 +88,8 @@ function isInRange(node, location) {
  *     var {a = a} = obj
  *     for (var a in a) {}
  *     for (var a of a) {}
- *
- * @param {Variable} variable - A variable to check.
- * @param {Reference} reference - A reference to check.
+ * @param {Variable} variable A variable to check.
+ * @param {Reference} reference A reference to check.
  * @returns {boolean} `true` if the reference is inside of the initializers.
  */
 function isInInitializer(variable, reference) {

package/lib/rules/no-useless-call.js

@@ -13,7 +13,7 @@ const astUtils = require("./utils/ast-utils");
 
 /**
  * Checks whether or not a node is a `.call()`/`.apply()`.
- * @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 `.call()`/`.apply()`.
  */
 function isCallOrNonVariadicApply(node) {
@@ -31,9 +31,9 @@ function isCallOrNonVariadicApply(node) {
 
 /**
  * Checks whether or not `thisArg` is not changed by `.call()`/`.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 `.call()`/`.apply()`.
- * @param {SourceCode} sourceCode - The ESLint source code 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 `.call()`/`.apply()`.
+ * @param {SourceCode} sourceCode The ESLint source code object.
  * @returns {boolean} Whether or not `thisArg` is not changed by `.call()`/`.apply()`.
  */
 function isValidThisArg(expectedThis, thisArg, sourceCode) {

package/lib/rules/no-useless-computed-key.js

@@ -8,6 +8,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
+const lodash = require("lodash");
 const astUtils = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
@@ -21,57 +22,83 @@ module.exports = {
         type: "suggestion",
 
         docs: {
-            description: "disallow unnecessary computed property keys in object literals",
+            description: "disallow unnecessary computed property keys in objects and classes",
             category: "ECMAScript 6",
             recommended: false,
             url: "https://eslint.org/docs/rules/no-useless-computed-key"
         },
 
-        schema: [],
+        schema: [{
+            type: "object",
+            properties: {
+                enforceForClassMembers: {
+                    type: "boolean",
+                    default: false
+                }
+            },
+            additionalProperties: false
+        }],
         fixable: "code"
     },
     create(context) {
         const sourceCode = context.getSourceCode();
+        const enforceForClassMembers = context.options[0] && context.options[0].enforceForClassMembers;
+
+        /**
+         * Reports a given node if it violated this rule.
+         * @param {ASTNode} node The node to check.
+         * @returns {void}
+         */
+        function check(node) {
+            if (!node.computed) {
+                return;
+            }
 
-        return {
-            Property(node) {
-                if (!node.computed) {
-                    return;
-                }
-
-                const key = node.key,
-                    nodeType = typeof key.value;
+            const key = node.key,
+                nodeType = typeof key.value;
 
-                if (key.type === "Literal" && (nodeType === "string" || nodeType === "number") && key.value !== "__proto__") {
-                    context.report({
-                        node,
-                        message: MESSAGE_UNNECESSARY_COMPUTED,
-                        data: { property: sourceCode.getText(key) },
-                        fix(fixer) {
-                            const leftSquareBracket = sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken);
-                            const rightSquareBracket = sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken);
-                            const tokensBetween = sourceCode.getTokensBetween(leftSquareBracket, rightSquareBracket, 1);
+            let allowedKey;
 
-                            if (tokensBetween.slice(0, -1).some((token, index) =>
-                                sourceCode.getText().slice(token.range[1], tokensBetween[index + 1].range[0]).trim())) {
+            if (node.type === "MethodDefinition") {
+                allowedKey = node.static ? "prototype" : "constructor";
+            } else {
+                allowedKey = "__proto__";
+            }
 
-                                // If there are comments between the brackets and the property name, don't do a fix.
-                                return null;
-                            }
+            if (key.type === "Literal" && (nodeType === "string" || nodeType === "number") && key.value !== allowedKey) {
+                context.report({
+                    node,
+                    message: MESSAGE_UNNECESSARY_COMPUTED,
+                    data: { property: sourceCode.getText(key) },
+                    fix(fixer) {
+                        const leftSquareBracket = sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken);
+                        const rightSquareBracket = sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken);
+                        const tokensBetween = sourceCode.getTokensBetween(leftSquareBracket, rightSquareBracket, 1);
+
+                        if (tokensBetween.slice(0, -1).some((token, index) =>
+                            sourceCode.getText().slice(token.range[1], tokensBetween[index + 1].range[0]).trim())) {
+
+                            // If there are comments between the brackets and the property name, don't do a fix.
+                            return null;
+                        }
 
-                            const tokenBeforeLeftBracket = sourceCode.getTokenBefore(leftSquareBracket);
+                        const tokenBeforeLeftBracket = sourceCode.getTokenBefore(leftSquareBracket);
 
-                            // Insert a space before the key to avoid changing identifiers, e.g. ({ get[2]() {} }) to ({ get2() {} })
-                            const needsSpaceBeforeKey = tokenBeforeLeftBracket.range[1] === leftSquareBracket.range[0] &&
-                                !astUtils.canTokensBeAdjacent(tokenBeforeLeftBracket, sourceCode.getFirstToken(key));
+                        // Insert a space before the key to avoid changing identifiers, e.g. ({ get[2]() {} }) to ({ get2() {} })
+                        const needsSpaceBeforeKey = tokenBeforeLeftBracket.range[1] === leftSquareBracket.range[0] &&
+                            !astUtils.canTokensBeAdjacent(tokenBeforeLeftBracket, sourceCode.getFirstToken(key));
 
-                            const replacementKey = (needsSpaceBeforeKey ? " " : "") + key.raw;
+                        const replacementKey = (needsSpaceBeforeKey ? " " : "") + key.raw;
 
-                            return fixer.replaceTextRange([leftSquareBracket.range[0], rightSquareBracket.range[1]], replacementKey);
-                        }
-                    });
-                }
+                        return fixer.replaceTextRange([leftSquareBracket.range[0], rightSquareBracket.range[1]], replacementKey);
+                    }
+                });
             }
+        }
+
+        return {
+            Property: check,
+            MethodDefinition: enforceForClassMembers ? check : lodash.noop
         };
     }
 };

package/lib/rules/no-useless-concat.js

@@ -16,7 +16,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) {
@@ -25,7 +25,7 @@ function isConcatenation(node) {
 
 /**
  * Checks if the given token is a `+` 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 `+` token.
  */
 function isConcatOperatorToken(token) {
@@ -34,7 +34,7 @@ function isConcatOperatorToken(token) {
 
 /**
  * Get's the right most node on the left side of a BinaryExpression with + operator.
- * @param {ASTNode} node - A BinaryExpression node to check.
+ * @param {ASTNode} node A BinaryExpression node to check.
  * @returns {ASTNode} node
  */
 function getLeft(node) {
@@ -48,7 +48,7 @@ function getLeft(node) {
 
 /**
  * Get's the left most node on the right side of a BinaryExpression with + operator.
- * @param {ASTNode} node - A BinaryExpression node to check.
+ * @param {ASTNode} node A BinaryExpression node to check.
  * @returns {ASTNode} node
  */
 function getRight(node) {