eslint 3.9.0 → 3.10.2

package/lib/rules/comma-spacing.js

@@ -141,7 +141,7 @@ module.exports = {
         function addNullElementsToIgnoreList(node) {
             let previousToken = sourceCode.getFirstToken(node);
 
-            node.elements.forEach(function(element) {
+            node.elements.forEach(element => {
                 let token;
 
                 if (element === null) {
@@ -164,7 +164,7 @@ module.exports = {
 
         return {
             "Program:exit"() {
-                tokensAndComments.forEach(function(token, i) {
+                tokensAndComments.forEach((token, i) => {
 
                     if (!isComma(token)) {
                         return;

package/lib/rules/comma-style.js

@@ -41,10 +41,22 @@ module.exports = {
     create(context) {
         const style = context.options[0] || "last",
             sourceCode = context.getSourceCode();
-        let exceptions = {};
+        const exceptions = {
+            ArrayPattern: true,
+            ArrowFunctionExpression: true,
+            CallExpression: true,
+            FunctionDeclaration: true,
+            FunctionExpression: true,
+            ImportDeclaration: true,
+            ObjectPattern: true,
+        };
 
         if (context.options.length === 2 && context.options[1].hasOwnProperty("exceptions")) {
-            exceptions = context.options[1].exceptions;
+            const keys = Object.keys(context.options[1].exceptions);
+
+            for (let i = 0; i < keys.length; i++) {
+                exceptions[keys[i]] = context.options[1].exceptions[keys[i]];
+            }
         }
 
         //--------------------------------------------------------------------------
@@ -166,14 +178,14 @@ module.exports = {
          */
         function validateComma(node, property) {
             const items = node[property],
-                arrayLiteral = (node.type === "ArrayExpression");
+                arrayLiteral = (node.type === "ArrayExpression" || node.type === "ArrayPattern");
 
             if (items.length > 1 || arrayLiteral) {
 
                 // seed as opening [
                 let previousItemToken = sourceCode.getFirstToken(node);
 
-                items.forEach(function(item) {
+                items.forEach(item => {
                     const commaToken = item ? sourceCode.getTokenBefore(item) : previousItemToken,
                         currentItemToken = item ? sourceCode.getFirstToken(item) : sourceCode.getTokenAfter(commaToken),
                         reportItem = item || currentItemToken,
@@ -245,11 +257,46 @@ module.exports = {
                 validateComma(node, "properties");
             };
         }
+        if (!exceptions.ObjectPattern) {
+            nodes.ObjectPattern = function(node) {
+                validateComma(node, "properties");
+            };
+        }
         if (!exceptions.ArrayExpression) {
             nodes.ArrayExpression = function(node) {
                 validateComma(node, "elements");
             };
         }
+        if (!exceptions.ArrayPattern) {
+            nodes.ArrayPattern = function(node) {
+                validateComma(node, "elements");
+            };
+        }
+        if (!exceptions.FunctionDeclaration) {
+            nodes.FunctionDeclaration = function(node) {
+                validateComma(node, "params");
+            };
+        }
+        if (!exceptions.FunctionExpression) {
+            nodes.FunctionExpression = function(node) {
+                validateComma(node, "params");
+            };
+        }
+        if (!exceptions.ArrowFunctionExpression) {
+            nodes.ArrowFunctionExpression = function(node) {
+                validateComma(node, "params");
+            };
+        }
+        if (!exceptions.CallExpression) {
+            nodes.CallExpression = function(node) {
+                validateComma(node, "arguments");
+            };
+        }
+        if (!exceptions.ImportDeclaration) {
+            nodes.ImportDeclaration = function(node) {
+                validateComma(node, "specifiers");
+            };
+        }
 
         return nodes;
     }

package/lib/rules/consistent-this.js

@@ -84,16 +84,14 @@ module.exports = {
                 return;
             }
 
-            if (variable.defs.some(function(def) {
-                return def.node.type === "VariableDeclarator" &&
-                def.node.init !== null;
-            })) {
+            if (variable.defs.some(def => def.node.type === "VariableDeclarator" &&
+                def.node.init !== null)) {
                 return;
             }
 
             // The alias has been declared and not assigned: check it was
             // assigned later in the same scope.
-            if (!variable.references.some(function(reference) {
+            if (!variable.references.some(reference => {
                 const write = reference.writeExpr;
 
                 return (
@@ -102,9 +100,7 @@ module.exports = {
                     write.parent.operator === "="
                 );
             })) {
-                variable.defs.map(function(def) {
-                    return def.node;
-                }).forEach(function(node) {
+                variable.defs.map(def => def.node).forEach(node => {
                     reportBadAssignment(node, alias);
                 });
             }
@@ -117,7 +113,7 @@ module.exports = {
         function ensureWasAssigned() {
             const scope = context.getScope();
 
-            aliases.forEach(function(alias) {
+            aliases.forEach(alias => {
                 checkWasAssigned(alias, scope);
             });
         }

package/lib/rules/constructor-super.js

@@ -262,7 +262,7 @@ module.exports = {
 
                 funcInfo.codePath.traverseSegments(
                     {first: toSegment, last: fromSegment},
-                    function(segment) {
+                    segment => {
                         const info = segInfoMap[segment.id];
                         const prevSegments = segment.prevSegments;
 

package/lib/rules/curly.js

@@ -74,10 +74,11 @@ module.exports = {
          * @private
          */
         function isCollapsedOneLiner(node) {
-            const before = sourceCode.getTokenBefore(node),
-                last = sourceCode.getLastToken(node);
+            const before = sourceCode.getTokenBefore(node);
+            const last = sourceCode.getLastToken(node);
+            const lastExcludingSemicolon = last.type === "Punctuator" && last.value === ";" ? sourceCode.getTokenBefore(last) : last;
 
-            return before.loc.start.line === last.loc.end.line;
+            return before.loc.start.line === lastExcludingSemicolon.loc.end.line;
         }
 
         /**
@@ -289,7 +290,9 @@ module.exports = {
                 }
             } else if (multiOrNest) {
                 if (hasBlock && body.body.length === 1 && isOneLiner(body.body[0])) {
-                    expected = false;
+                    const leadingComments = sourceCode.getComments(body.body[0]).leading;
+
+                    expected = leadingComments.length > 0;
                 } else if (!isOneLiner(body)) {
                     expected = true;
                 }
@@ -337,14 +340,14 @@ module.exports = {
                  * all have braces.
                  * If all nodes shouldn't have braces, make sure they don't.
                  */
-                const expected = preparedChecks.some(function(preparedCheck) {
+                const expected = preparedChecks.some(preparedCheck => {
                     if (preparedCheck.expected !== null) {
                         return preparedCheck.expected;
                     }
                     return preparedCheck.actual;
                 });
 
-                preparedChecks.forEach(function(preparedCheck) {
+                preparedChecks.forEach(preparedCheck => {
                     preparedCheck.expected = expected;
                 });
             }
@@ -359,7 +362,7 @@ module.exports = {
         return {
             IfStatement(node) {
                 if (node.parent.type !== "IfStatement") {
-                    prepareIfChecks(node).forEach(function(preparedCheck) {
+                    prepareIfChecks(node).forEach(preparedCheck => {
                         preparedCheck.check();
                     });
                 }

package/lib/rules/default-case.js

@@ -67,9 +67,7 @@ module.exports = {
                     return;
                 }
 
-                const hasDefault = node.cases.some(function(v) {
-                    return v.test === null;
-                });
+                const hasDefault = node.cases.some(v => v.test === null);
 
                 if (!hasDefault) {
 

package/lib/rules/eqeqeq.js

@@ -47,7 +47,9 @@ module.exports = {
                     additionalItems: false
                 }
             ]
-        }
+        },
+
+        fixable: "code"
     },
 
     create(context) {
@@ -118,16 +120,26 @@ module.exports = {
         /**
          * Reports a message for this rule.
          * @param {ASTNode} node The binary expression node that was checked
-         * @param {string} message The message to report
+         * @param {string} expectedOperator The operator that was expected (either '==', '!=', '===', or '!==')
          * @returns {void}
          * @private
          */
-        function report(node, message) {
+        function report(node, expectedOperator) {
             context.report({
                 node,
                 loc: getOperatorLocation(node),
-                message,
-                data: { op: node.operator.charAt(0) }
+                message: "Expected '{{expectedOperator}}' and instead saw '{{actualOperator}}'.",
+                data: {expectedOperator, actualOperator: node.operator},
+                fix(fixer) {
+
+                    // If the comparison is a `typeof` comparison or both sides are literals with the same type, then it's safe to fix.
+                    if (isTypeOfBinary(node) || areLiteralsAndSameType(node)) {
+                        const operatorToken = sourceCode.getTokensBetween(node.left, node.right).find(token => token.value === node.operator);
+
+                        return fixer.replaceText(operatorToken, expectedOperator);
+                    }
+                    return null;
+                }
             });
         }
 
@@ -137,7 +149,7 @@ module.exports = {
 
                 if (node.operator !== "==" && node.operator !== "!=") {
                     if (enforceInverseRuleForNull && isNull) {
-                        report(node, "Expected '{{op}}=' and instead saw '{{op}}=='.");
+                        report(node, node.operator.slice(0, -1));
                     }
                     return;
                 }
@@ -151,7 +163,7 @@ module.exports = {
                     return;
                 }
 
-                report(node, "Expected '{{op}}==' and instead saw '{{op}}='.");
+                report(node, `${node.operator}=`);
             }
         };
 

package/lib/rules/func-names.js

@@ -28,21 +28,23 @@ module.exports = {
 
         schema: [
             {
-                enum: ["always", "never"]
+                enum: ["always", "as-needed", "never"]
             }
         ]
     },
 
     create(context) {
         const never = context.options[0] === "never";
+        const asNeeded = context.options[0] === "as-needed";
 
         /**
          * 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.
          * @returns {boolean} True if the node is a get, set, or shorthand method.
          */
-        function isObjectOrClassMethod() {
-            const parent = context.getAncestors().pop();
+        function isObjectOrClassMethod(node) {
+            const parent = node.parent;
 
             return (parent.type === "MethodDefinition" || (
                 parent.type === "Property" && (
@@ -53,6 +55,23 @@ 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.
+         * @returns {boolean} True if the node would have a name assigned automatically.
+         */
+        function hasInferredName(node) {
+            const parent = node.parent;
+
+            return isObjectOrClassMethod(node) ||
+                (parent.type === "VariableDeclarator" && parent.id.type === "Identifier" && parent.init === node) ||
+                (parent.type === "Property" && parent.value === node) ||
+                (parent.type === "AssignmentExpression" && parent.left.type === "Identifier" && parent.right === node) ||
+                (parent.type === "ExportDefaultDeclaration" && parent.declaration === node) ||
+                (parent.type === "AssignmentPattern" && parent.right === node);
+        }
+
         return {
             "FunctionExpression:exit"(node) {
 
@@ -70,7 +89,7 @@ module.exports = {
                         context.report(node, "Unexpected function expression name.");
                     }
                 } else {
-                    if (!name && !isObjectOrClassMethod()) {
+                    if (!name && (asNeeded ? !hasInferredName(node) : !isObjectOrClassMethod(node))) {
                         context.report(node, "Missing function expression name.");
                     }
                 }

package/lib/rules/global-require.js

@@ -23,10 +23,8 @@ const ACCEPTABLE_PARENTS = [
  * @returns {Reference|null} Returns the found reference or null if none were found.
  */
 function findReference(scope, node) {
-    const references = scope.references.filter(function(reference) {
-        return reference.identifier.range[0] === node.range[0] &&
-            reference.identifier.range[1] === node.range[1];
-    });
+    const references = scope.references.filter(reference => reference.identifier.range[0] === node.range[0] &&
+            reference.identifier.range[1] === node.range[1]);
 
     /* istanbul ignore else: correctly returns null */
     if (references.length === 1) {
@@ -65,9 +63,7 @@ module.exports = {
                 const currentScope = context.getScope();
 
                 if (node.callee.name === "require" && !isShadowed(currentScope, node.callee)) {
-                    const isGoodRequire = context.getAncestors().every(function(parent) {
-                        return ACCEPTABLE_PARENTS.indexOf(parent.type) > -1;
-                    });
+                    const isGoodRequire = context.getAncestors().every(parent => ACCEPTABLE_PARENTS.indexOf(parent.type) > -1);
 
                     if (!isGoodRequire) {
                         context.report(node, "Unexpected require().");

package/lib/rules/handle-callback-err.js

@@ -59,9 +59,7 @@ module.exports = {
          * @returns {array} All parameters of the given scope.
          */
         function getParameters(scope) {
-            return scope.variables.filter(function(variable) {
-                return variable.defs[0] && variable.defs[0].type === "Parameter";
-            });
+            return scope.variables.filter(variable => variable.defs[0] && variable.defs[0].type === "Parameter");
         }
 
         /**

package/lib/rules/id-length.js

@@ -50,7 +50,7 @@ module.exports = {
         const maxLength = typeof options.max !== "undefined" ? options.max : Infinity;
         const properties = options.properties !== "never";
         const exceptions = (options.exceptions ? options.exceptions : [])
-            .reduce(function(obj, item) {
+            .reduce((obj, item) => {
                 obj[item] = true;
 
                 return obj;

package/lib/rules/indent.js

@@ -255,20 +255,18 @@ module.exports = {
          * @param {int} lastNodeCheckEndOffset Number of charecters to skip from the end
          * @returns {void}
          */
-        function report(node, needed, gottenSpaces, gottenTabs, loc, isLastNodeCheck, lastNodeCheckEndOffset) {
+        function report(node, needed, gottenSpaces, gottenTabs, loc, isLastNodeCheck) {
             if (gottenSpaces && gottenTabs) {
 
                 // To avoid conflicts with `no-mixed-spaces-and-tabs`, don't report lines that have both spaces and tabs.
                 return;
             }
 
-            lastNodeCheckEndOffset = lastNodeCheckEndOffset || 0;
-
-            const desiredIndent = (indentType === "space" ? " " : "\t").repeat(needed - lastNodeCheckEndOffset);
+            const desiredIndent = (indentType === "space" ? " " : "\t").repeat(needed);
 
             const textRange = isLastNodeCheck
-                ? [node.range[1] - gottenSpaces - gottenTabs - 1, node.range[1] - 1 - lastNodeCheckEndOffset]
-                : [node.range[0] - gottenSpaces - gottenTabs, node.range[0]];
+                ? [node.range[1] - node.loc.end.column, node.range[1] - node.loc.end.column + gottenSpaces + gottenTabs]
+                : [node.range[0] - node.loc.start.column, node.range[0] - node.loc.start.column + gottenSpaces + gottenTabs];
 
             context.report({
                 node,
@@ -406,13 +404,11 @@ module.exports = {
          */
         function checkLastReturnStatementLineIndent(node, firstLineIndent) {
             const nodeLastToken = sourceCode.getLastToken(node);
-            let lastNodeCheckEndOffset = 0;
             let lastToken = nodeLastToken;
 
             // in case if return statement ends with ');' we have traverse back to ')'
             // otherwise we'll measure indent for ';' and replace ')'
             while (lastToken.value !== ")") {
-                lastNodeCheckEndOffset++;
                 lastToken = sourceCode.getTokenBefore(lastToken);
             }
 
@@ -433,8 +429,7 @@ module.exports = {
                     endIndent.space,
                     endIndent.tab,
                     { line: lastToken.loc.start.line, column: lastToken.loc.start.column },
-                    true,
-                    lastNodeCheckEndOffset
+                    true
                 );
             }
         }
@@ -684,9 +679,7 @@ module.exports = {
             let elements = (node.type === "ArrayExpression") ? node.elements : node.properties;
 
             // filter out empty elements example would be [ , 2] so remove first element as espree considers it as null
-            elements = elements.filter(function(elem) {
-                return elem !== null;
-            });
+            elements = elements.filter(elem => elem !== null);
 
             let nodeIndent;
             let elementsIndent;
@@ -695,19 +688,11 @@ module.exports = {
             // TODO - come up with a better strategy in future
             if (isNodeFirstInLine(node)) {
                 const parent = node.parent;
-                let effectiveParent = parent;
 
-                if (parent.type === "MemberExpression") {
-                    if (isNodeFirstInLine(parent)) {
-                        effectiveParent = parent.parent.parent;
-                    } else {
-                        effectiveParent = parent.parent;
-                    }
-                }
-                nodeIndent = getNodeIndent(effectiveParent).goodChar;
+                nodeIndent = getNodeIndent(parent).goodChar;
                 if (parentVarNode && parentVarNode.loc.start.line !== node.loc.start.line) {
                     if (parent.type !== "VariableDeclarator" || parentVarNode === parentVarNode.parent.declarations[0]) {
-                        if (parent.type === "VariableDeclarator" && parentVarNode.loc.start.line === effectiveParent.loc.start.line) {
+                        if (parent.type === "VariableDeclarator" && parentVarNode.loc.start.line === parent.loc.start.line) {
                             nodeIndent = nodeIndent + (indentSize * options.VariableDeclarator[parentVarNode.parent.kind]);
                         } else if (
                             parent.type === "ObjectExpression" ||
@@ -720,7 +705,7 @@ module.exports = {
                             nodeIndent = nodeIndent + indentSize;
                         }
                     }
-                } else if (!parentVarNode && !isFirstArrayElementOnSameLine(parent) && effectiveParent.type !== "MemberExpression" && effectiveParent.type !== "ExpressionStatement" && effectiveParent.type !== "AssignmentExpression" && effectiveParent.type !== "Property") {
+                } else if (!parentVarNode && !isFirstArrayElementOnSameLine(parent) && parent.type !== "MemberExpression" && parent.type !== "ExpressionStatement" && parent.type !== "AssignmentExpression" && parent.type !== "Property") {
                     nodeIndent = nodeIndent + indentSize;
                 }
 
@@ -827,7 +812,7 @@ module.exports = {
          * @returns {ASTNode[]} Filtered elements
          */
         function filterOutSameLineVars(node) {
-            return node.declarations.reduce(function(finalCollection, elem) {
+            return node.declarations.reduce((finalCollection, elem) => {
                 const lastElem = finalCollection[finalCollection.length - 1];
 
                 if ((elem.loc.start.line !== node.loc.start.line && !lastElem) ||

package/lib/rules/key-spacing.js

@@ -417,8 +417,8 @@ module.exports = {
         function report(property, side, whitespace, expected, mode) {
             const diff = whitespace.length - expected,
                 nextColon = getNextColon(property.key),
-                tokenBeforeColon = sourceCode.getTokenBefore(nextColon),
-                tokenAfterColon = sourceCode.getTokenAfter(nextColon),
+                tokenBeforeColon = sourceCode.getTokenOrCommentBefore(nextColon),
+                tokenAfterColon = sourceCode.getTokenOrCommentAfter(nextColon),
                 isKeySide = side === "key",
                 locStart = isKeySide ? tokenBeforeColon.loc.start : tokenAfterColon.loc.start,
                 isExtra = diff > 0,
@@ -514,7 +514,7 @@ module.exports = {
                 return [node.properties];
             }
 
-            return node.properties.reduce(function(groups, property) {
+            return node.properties.reduce((groups, property) => {
                 const currentGroup = last(groups),
                     prev = last(currentGroup);
 
@@ -579,7 +579,7 @@ module.exports = {
          * @returns {void}
          */
         function verifyAlignment(node) {
-            createGroups(node).forEach(function(group) {
+            createGroups(node).forEach(group => {
                 verifyGroupAlignment(group.filter(isKeyValueProperty));
             });
         }

package/lib/rules/keyword-spacing.js

@@ -81,7 +81,7 @@ module.exports = {
                     after: {type: "boolean"},
                     overrides: {
                         type: "object",
-                        properties: KEYS.reduce(function(retv, key) {
+                        properties: KEYS.reduce((retv, key) => {
                             retv[key] = {
                                 type: "object",
                                 properties: {

package/lib/rules/lines-around-comment.js

@@ -21,16 +21,10 @@ const lodash = require("lodash"),
  * @returns {Array} An array of line numbers.
  */
 function getEmptyLineNums(lines) {
-    const emptyLines = lines.map(function(line, i) {
-        return {
-            code: line.trim(),
-            num: i + 1
-        };
-    }).filter(function(line) {
-        return !line.code;
-    }).map(function(line) {
-        return line.num;
-    });
+    const emptyLines = lines.map((line, i) => ({
+        code: line.trim(),
+        num: i + 1
+    })).filter(line => !line.code).map(line => line.num);
 
     return emptyLines;
 }
@@ -43,7 +37,7 @@ function getEmptyLineNums(lines) {
 function getCommentLineNums(comments) {
     const lines = [];
 
-    comments.forEach(function(token) {
+    comments.forEach(token => {
         const start = token.loc.start.line;
         const end = token.loc.end.line;
 

package/lib/rules/lines-around-directive.js

@@ -63,15 +63,32 @@ module.exports = {
             return node.loc.start.line - tokenLineBefore >= 2;
         }
 
+        /**
+        * Gets the last token of a node that is on the same line as the rest of the node.
+        * This will usually be the last token of the node, but it will be the second-to-last token if the node has a trailing
+        * semicolon on a different line.
+        * @param {ASTNode} node A directive node
+        * @returns {Token} The last token of the node on the line
+        */
+        function getLastTokenOnLine(node) {
+            const lastToken = sourceCode.getLastToken(node);
+            const secondToLastToken = sourceCode.getTokenBefore(lastToken);
+
+            return lastToken.type === "Punctuator" && lastToken.value === ";" && lastToken.loc.start.line > secondToLastToken.loc.end.line
+                ? secondToLastToken
+                : lastToken;
+        }
+
         /**
          * Check if node is followed by a blank newline.
          * @param {ASTNode} node Node to check.
          * @returns {boolean} Whether or not the passed in node is followed by a blank newline.
          */
         function hasNewlineAfter(node) {
-            const tokenAfter = sourceCode.getTokenOrCommentAfter(node);
+            const lastToken = getLastTokenOnLine(node);
+            const tokenAfter = sourceCode.getTokenOrCommentAfter(lastToken);
 
-            return tokenAfter.loc.start.line - node.loc.end.line >= 2;
+            return tokenAfter.loc.start.line - lastToken.loc.end.line >= 2;
         }
 
         /**
@@ -91,10 +108,12 @@ module.exports = {
                     location
                 },
                 fix(fixer) {
+                    const lastToken = getLastTokenOnLine(node);
+
                     if (expected) {
-                        return location === "before" ? fixer.insertTextBefore(node, "\n") : fixer.insertTextAfter(node, "\n");
+                        return location === "before" ? fixer.insertTextBefore(node, "\n") : fixer.insertTextAfter(lastToken, "\n");
                     }
-                    return fixer.removeRange(location === "before" ? [node.range[0] - 1, node.range[0]] : [node.range[1], node.range[1] + 1]);
+                    return fixer.removeRange(location === "before" ? [node.range[0] - 1, node.range[0]] : [lastToken.range[1], lastToken.range[1] + 1]);
                 }
             });
         }

package/lib/rules/max-len.js

@@ -103,7 +103,7 @@ module.exports = {
         function computeLineLength(line, tabWidth) {
             let extraCharacterCount = 0;
 
-            line.replace(/\t/g, function(match, offset) {
+            line.replace(/\t/g, (match, offset) => {
                 const totalOffset = offset + extraCharacterCount,
                     previousTabStopOffset = tabWidth ? totalOffset % tabWidth : 0,
                     spaceCount = tabWidth - previousTabStopOffset;
@@ -213,9 +213,7 @@ module.exports = {
          * @returns {ASTNode[]} An array of string nodes.
          */
         function getAllStrings() {
-            return sourceCode.ast.tokens.filter(function(token) {
-                return token.type === "String";
-            });
+            return sourceCode.ast.tokens.filter(token => token.type === "String");
         }
 
         /**
@@ -224,9 +222,7 @@ module.exports = {
          * @returns {ASTNode[]} An array of template literal nodes.
          */
         function getAllTemplateLiterals() {
-            return sourceCode.ast.tokens.filter(function(token) {
-                return token.type === "Template";
-            });
+            return sourceCode.ast.tokens.filter(token => token.type === "Template");
         }
 
 
@@ -236,9 +232,7 @@ module.exports = {
          * @returns {ASTNode[]} An array of RegExp literal nodes.
          */
         function getAllRegExpLiterals() {
-            return sourceCode.ast.tokens.filter(function(token) {
-                return token.type === "RegularExpression";
-            });
+            return sourceCode.ast.tokens.filter(token => token.type === "RegularExpression");
         }
 
 
@@ -283,7 +277,7 @@ module.exports = {
             const regExpLiterals = getAllRegExpLiterals(sourceCode);
             const regExpLiteralsByLine = regExpLiterals.reduce(groupByLineNumber, {});
 
-            lines.forEach(function(line, i) {
+            lines.forEach((line, i) => {
 
                 // i is zero-indexed, line numbers are one-indexed
                 const lineNumber = i + 1;