eslint 5.7.0 → 5.11.0

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

@@ -79,6 +79,8 @@ function parseRegExp(regExpText) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "disallow unnecessary escape characters",
             category: "Best Practices",

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

@@ -11,13 +11,17 @@
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "disallow renaming import, export, and destructured assignments to the same name",
             category: "ECMAScript 6",
             recommended: false,
             url: "https://eslint.org/docs/rules/no-useless-rename"
         },
+
         fixable: "code",
+
         schema: [
             {
                 type: "object",

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

@@ -66,12 +66,15 @@ function isInFinally(node) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "disallow redundant return statements",
             category: "Best Practices",
             recommended: false,
             url: "https://eslint.org/docs/rules/no-useless-return"
         },
+
         fixable: "code",
         schema: []
     },

package/lib/rules/no-var.js

@@ -180,6 +180,8 @@ function hasReferenceInTDZ(node) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require `let` or `const` instead of `var`",
             category: "ECMAScript 6",

package/lib/rules/no-void.js

@@ -10,6 +10,8 @@
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "disallow `void` operators",
             category: "Best Practices",

package/lib/rules/no-warning-comments.js

@@ -13,6 +13,8 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "disallow specified warning terms in comments",
             category: "Best Practices",

package/lib/rules/no-whitespace-before-property.js

@@ -16,6 +16,8 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "disallow whitespace before properties",
             category: "Stylistic Issues",

package/lib/rules/no-with.js

@@ -11,6 +11,8 @@
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "disallow `with` statements",
             category: "Best Practices",

package/lib/rules/nonblock-statement-body-position.js

@@ -12,13 +12,17 @@ const POSITION_SCHEMA = { enum: ["beside", "below", "any"] };
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce the location of single-line statements",
             category: "Stylistic Issues",
             recommended: false,
             url: "https://eslint.org/docs/rules/nonblock-statement-body-position"
         },
+
         fixable: "whitespace",
+
         schema: [
             POSITION_SCHEMA,
             {

package/lib/rules/object-curly-newline.js

@@ -134,13 +134,17 @@ function areLineBreaksRequired(node, options, first, last) {
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce consistent line breaks inside braces",
             category: "Stylistic Issues",
             recommended: false,
             url: "https://eslint.org/docs/rules/object-curly-newline"
         },
+
         fixable: "whitespace",
+
         schema: [
             {
                 oneOf: [
@@ -168,7 +172,6 @@ module.exports = {
         /**
          * Reports a given node if it violated this rule.
          * @param {ASTNode} node - A node to check. This is an ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration node.
-         * @param {{multiline: boolean, minProperties: number, consistent: boolean}} options - An option object.
          * @returns {void}
          */
         function check(node) {

package/lib/rules/object-curly-spacing.js

@@ -12,6 +12,8 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce consistent spacing inside braces",
             category: "Stylistic Issues",

package/lib/rules/object-property-newline.js

@@ -11,6 +11,8 @@
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce placing object properties on separate lines",
             category: "Stylistic Issues",
@@ -38,8 +40,7 @@ module.exports = {
 
     create(context) {
         const allowSameLine = context.options[0] && (
-            Boolean(context.options[0].allowAllPropertiesOnSameLine) ||
-            Boolean(context.options[0].allowMultiplePropertiesPerLine) // Deprecated
+            (Boolean(context.options[0].allowAllPropertiesOnSameLine) || Boolean(context.options[0].allowMultiplePropertiesPerLine)) // Deprecated
         );
         const errorMessage = allowSameLine
             ? "Object properties must go on a new line if they aren't all on the same line."

package/lib/rules/object-shorthand.js

@@ -24,6 +24,8 @@ const astUtils = require("../util/ast-utils");
 //------------------------------------------------------------------------------
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require or disallow method and property shorthand syntax for object literals",
             category: "ECMAScript 6",

package/lib/rules/one-var-declaration-per-line.js

@@ -10,6 +10,8 @@
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require or disallow newlines around variable declarations",
             category: "Stylistic Issues",

package/lib/rules/one-var.js

@@ -11,6 +11,8 @@
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "enforce variables to be declared either together or separately in functions",
             category: "Stylistic Issues",
@@ -308,7 +310,6 @@ module.exports = {
         /**
          * Fixer to split a VariableDeclaration into individual declarations
          * @param   {VariableDeclaration}   declaration The `VariableDeclaration` to split
-         * @param   {?Function}             filter      Function to filter the declarations
          * @returns {Function}                          The fixer function
          */
         function splitDeclarations(declaration) {

package/lib/rules/operator-assignment.js

@@ -89,6 +89,8 @@ function canBeFixed(node) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require or disallow assignment operator shorthand where possible",
             category: "Stylistic Issues",

package/lib/rules/operator-linebreak.js

@@ -17,6 +17,8 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "enforce consistent linebreak style for operators",
             category: "Stylistic Issues",

package/lib/rules/padded-blocks.js

@@ -11,6 +11,8 @@
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "require or disallow padding within blocks",
             category: "Stylistic Issues",

package/lib/rules/padding-line-between-statements.js

@@ -36,6 +36,36 @@ function newKeywordTester(keyword) {
     };
 }
 
+/**
+ * Creates tester which check if a node starts with specific keyword and spans a single line.
+ *
+ * @param {string} keyword The keyword to test.
+ * @returns {Object} the created tester.
+ * @private
+ */
+function newSinglelineKeywordTester(keyword) {
+    return {
+        test: (node, sourceCode) =>
+            node.loc.start.line === node.loc.end.line &&
+            sourceCode.getFirstToken(node).value === keyword
+    };
+}
+
+/**
+ * Creates tester which check if a node starts with specific keyword and spans multiple lines.
+ *
+ * @param {string} keyword The keyword to test.
+ * @returns {Object} the created tester.
+ * @private
+ */
+function newMultilineKeywordTester(keyword) {
+    return {
+        test: (node, sourceCode) =>
+            node.loc.start.line !== node.loc.end.line &&
+            sourceCode.getFirstToken(node).value === keyword
+    };
+}
+
 /**
  * Creates tester which check if a node is specific type.
  *
@@ -368,6 +398,13 @@ const StatementTypes = {
             !isDirectivePrologue(node, sourceCode)
     },
 
+    "multiline-const": newMultilineKeywordTester("const"),
+    "multiline-let": newMultilineKeywordTester("let"),
+    "multiline-var": newMultilineKeywordTester("var"),
+    "singleline-const": newSinglelineKeywordTester("const"),
+    "singleline-let": newSinglelineKeywordTester("let"),
+    "singleline-var": newSinglelineKeywordTester("var"),
+
     block: newNodeTypeTester("BlockStatement"),
     empty: newNodeTypeTester("EmptyStatement"),
     function: newNodeTypeTester("FunctionDeclaration"),
@@ -400,13 +437,17 @@ const StatementTypes = {
 
 module.exports = {
     meta: {
+        type: "layout",
+
         docs: {
             description: "require or disallow padding lines between statements",
             category: "Stylistic Issues",
             recommended: false,
             url: "https://eslint.org/docs/rules/padding-line-between-statements"
         },
+
         fixable: "whitespace",
+
         schema: {
             definitions: {
                 paddingType: {

package/lib/rules/prefer-arrow-callback.js

@@ -132,6 +132,8 @@ function hasDuplicateParams(paramsList) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require using arrow functions for callbacks",
             category: "ECMAScript 6",

package/lib/rules/prefer-const.js

@@ -57,6 +57,7 @@ function canBecomeVariableDeclaration(identifier) {
  * @returns {boolean} Indicates if the variable is from outer scope or function parameters.
  */
 function isOuterVariableInDestructing(name, initScope) {
+
     if (initScope.through.find(ref => ref.resolved && ref.resolved.name === name)) {
         return true;
     }
@@ -96,6 +97,54 @@ function getDestructuringHost(reference) {
     return node;
 }
 
+/**
+ * Determines if a destructuring assignment node contains
+ * any MemberExpression nodes. This is used to determine if a
+ * variable that is only written once using destructuring can be
+ * safely converted into a const declaration.
+ * @param {ASTNode} node The ObjectPattern or ArrayPattern node to check.
+ * @returns {boolean} True if the destructuring pattern contains
+ *      a MemberExpression, false if not.
+ */
+function hasMemberExpressionAssignment(node) {
+    switch (node.type) {
+        case "ObjectPattern":
+            return node.properties.some(prop => {
+                if (prop) {
+
+                    /*
+                     * Spread elements have an argument property while
+                     * others have a value property. Because different
+                     * parsers use different node types for spread elements,
+                     * we just check if there is an argument property.
+                     */
+                    return hasMemberExpressionAssignment(prop.argument || prop.value);
+                }
+
+                return false;
+            });
+
+        case "ArrayPattern":
+            return node.elements.some(element => {
+                if (element) {
+                    return hasMemberExpressionAssignment(element);
+                }
+
+                return false;
+            });
+
+        case "AssignmentPattern":
+            return hasMemberExpressionAssignment(node.left);
+
+        case "MemberExpression":
+            return true;
+
+        // no default
+    }
+
+    return false;
+}
+
 /**
  * Gets an identifier node of a given variable.
  *
@@ -148,7 +197,8 @@ function getIdentifierIfShouldBeConst(variable, ignoreReadBeforeAssign) {
 
             if (destructuringHost !== null && destructuringHost.left !== void 0) {
                 const leftNode = destructuringHost.left;
-                let hasOuterVariables = false;
+                let hasOuterVariables = false,
+                    hasNonIdentifiers = false;
 
                 if (leftNode.type === "ObjectPattern") {
                     const properties = leftNode.properties;
@@ -157,16 +207,23 @@ function getIdentifierIfShouldBeConst(variable, ignoreReadBeforeAssign) {
                         .filter(prop => prop.value)
                         .map(prop => prop.value.name)
                         .some(name => isOuterVariableInDestructing(name, variable.scope));
+
+                    hasNonIdentifiers = hasMemberExpressionAssignment(leftNode);
+
                 } else if (leftNode.type === "ArrayPattern") {
                     const elements = leftNode.elements;
 
                     hasOuterVariables = elements
                         .map(element => element && element.name)
                         .some(name => isOuterVariableInDestructing(name, variable.scope));
+
+                    hasNonIdentifiers = hasMemberExpressionAssignment(leftNode);
                 }
-                if (hasOuterVariables) {
+
+                if (hasOuterVariables || hasNonIdentifiers) {
                     return null;
                 }
+
             }
 
             writer = reference;
@@ -192,9 +249,11 @@ function getIdentifierIfShouldBeConst(variable, ignoreReadBeforeAssign) {
     if (!shouldBeConst) {
         return null;
     }
+
     if (isReadBeforeInit) {
         return variable.defs[0].name;
     }
+
     return writer.identifier;
 }
 
@@ -271,6 +330,8 @@ function findUp(node, type, shouldStop) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require `const` declarations for variables that are never reassigned after declared",
             category: "ECMAScript 6",
@@ -295,9 +356,11 @@ module.exports = {
     create(context) {
         const options = context.options[0] || {};
         const sourceCode = context.getSourceCode();
-        const checkingMixedDestructuring = options.destructuring !== "all";
+        const shouldMatchAnyDestructuredVariable = options.destructuring !== "all";
         const ignoreReadBeforeAssign = options.ignoreReadBeforeAssign === true;
         const variables = [];
+        let reportCount = 0;
+        let name = "";
 
         /**
          * Reports given identifier nodes if all of the nodes should be declared
@@ -316,16 +379,43 @@ module.exports = {
         function checkGroup(nodes) {
             const nodesToReport = nodes.filter(Boolean);
 
-            if (nodes.length && (checkingMixedDestructuring || nodesToReport.length === nodes.length)) {
+            if (nodes.length && (shouldMatchAnyDestructuredVariable || nodesToReport.length === nodes.length)) {
                 const varDeclParent = findUp(nodes[0], "VariableDeclaration", parentNode => parentNode.type.endsWith("Statement"));
-                const shouldFix = varDeclParent &&
+                const isVarDecParentNull = varDeclParent === null;
+
+                if (!isVarDecParentNull && varDeclParent.declarations.length > 0) {
+                    const firstDeclaration = varDeclParent.declarations[0];
+
+                    if (firstDeclaration.init) {
+                        const firstDecParent = firstDeclaration.init.parent;
+
+                        /*
+                         * First we check the declaration type and then depending on
+                         * if the type is a "VariableDeclarator" or its an "ObjectPattern"
+                         * we compare the name from the first identifier, if the names are different
+                         * we assign the new name and reset the count of reportCount and nodeCount in
+                         * order to check each block for the number of reported errors and base our fix
+                         * based on comparing nodes.length and nodesToReport.length.
+                         */
+
+                        if (firstDecParent.type === "VariableDeclarator") {
+
+                            if (firstDecParent.id.name !== name) {
+                                name = firstDecParent.id.name;
+                                reportCount = 0;
+                            }
+
+                            if (firstDecParent.id.type === "ObjectPattern") {
+                                if (firstDecParent.init.name !== name) {
+                                    name = firstDecParent.init.name;
+                                    reportCount = 0;
+                                }
+                            }
+                        }
+                    }
+                }
 
-                    /*
-                     * If there are multiple variable declarations, like {let a = 1, b = 2}, then
-                     * do not attempt to fix if one of the declarations should be `const`. It's
-                     * too hard to know how the developer would want to automatically resolve the issue.
-                     */
-                    varDeclParent.declarations.length === 1 &&
+                let shouldFix = varDeclParent &&
 
                     // Don't do a fix unless the variable is initialized (or it's in a for-in or for-of loop)
                     (varDeclParent.parent.type === "ForInStatement" || varDeclParent.parent.type === "ForOfStatement" || varDeclParent.declarations[0].init) &&
@@ -337,6 +427,21 @@ module.exports = {
                      */
                     nodesToReport.length === nodes.length;
 
+                if (!isVarDecParentNull && varDeclParent.declarations && varDeclParent.declarations.length !== 1) {
+
+                    if (varDeclParent && varDeclParent.declarations && varDeclParent.declarations.length >= 1) {
+
+                        /*
+                         * Add nodesToReport.length to a count, then comparing the count to the length
+                         * of the declarations in the current block.
+                         */
+
+                        reportCount += nodesToReport.length;
+
+                        shouldFix = shouldFix && (reportCount === varDeclParent.declarations.length);
+                    }
+                }
+
                 nodesToReport.forEach(node => {
                     context.report({
                         node,

package/lib/rules/prefer-destructuring.js

@@ -10,12 +10,15 @@
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require destructuring from arrays and/or objects",
             category: "ECMAScript 6",
             recommended: false,
             url: "https://eslint.org/docs/rules/prefer-destructuring"
         },
+
         schema: [
             {
 

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

@@ -38,6 +38,8 @@ function isParseInt(calleeNode) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "disallow `parseInt()` and `Number.parseInt()` in favor of binary, octal, and hexadecimal literals",
             category: "ECMAScript 6",
@@ -46,7 +48,6 @@ module.exports = {
         },
 
         schema: [],
-
         fixable: "code"
     },
 

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

@@ -212,6 +212,8 @@ function defineFixer(node, sourceCode) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description:
                 "disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead.",
@@ -219,8 +221,10 @@ module.exports = {
             recommended: false,
             url: "https://eslint.org/docs/rules/prefer-object-spread"
         },
+
         schema: [],
         fixable: "code",
+
         messages: {
             useSpreadMessage: "Use an object spread instead of `Object.assign` eg: `{ ...foo }`",
             useLiteralMessage: "Use an object literal instead of `Object.assign`. eg: `{ foo: bar }`"

package/lib/rules/prefer-promise-reject-errors.js

@@ -12,13 +12,17 @@ const astUtils = require("../util/ast-utils");
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require using Error objects as Promise rejection reasons",
             category: "Best Practices",
             recommended: false,
             url: "https://eslint.org/docs/rules/prefer-promise-reject-errors"
         },
+
         fixable: null,
+
         schema: [
             {
                 type: "object",

package/lib/rules/prefer-reflect.js

@@ -11,16 +11,19 @@
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require `Reflect` methods where applicable",
             category: "ECMAScript 6",
             recommended: false,
-            replacedBy: [],
             url: "https://eslint.org/docs/rules/prefer-reflect"
         },
 
         deprecated: true,
 
+        replacedBy: [],
+
         schema: [
             {
                 type: "object",

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

@@ -62,6 +62,8 @@ function isNotNormalMemberAccess(reference) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require rest parameters instead of `arguments`",
             category: "ECMAScript 6",

package/lib/rules/prefer-spread.js

@@ -49,6 +49,8 @@ function isValidThisArg(expectedThis, thisArg, context) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require spread operators instead of `.apply()`",
             category: "ECMAScript 6",
@@ -57,7 +59,6 @@ module.exports = {
         },
 
         schema: [],
-
         fixable: "code"
     },
 

package/lib/rules/prefer-template.js

@@ -141,6 +141,8 @@ function endsWithTemplateCurly(node) {
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require template literals instead of string concatenation",
             category: "ECMAScript 6",
@@ -149,7 +151,6 @@ module.exports = {
         },
 
         schema: [],
-
         fixable: "code"
     },
 

package/lib/rules/quote-props.js

@@ -17,6 +17,8 @@ const espree = require("espree"),
 
 module.exports = {
     meta: {
+        type: "suggestion",
+
         docs: {
             description: "require quotes around object literal property names",
             category: "Stylistic Issues",