import eslint 7.28.0

[pve-eslint.git] / eslint / tests / lib / rules / no-unused-vars.js

diff --git a/eslint/tests/lib/rules/no-unused-vars.js b/eslint/tests/lib/rules/no-unused-vars.js
index ec23acae19dbf3ce49b0dc2e80103f2434311039..48ccdb1d42ff9ad8517435062a1dfd7e41b7633d 100644 (file)
--- a/eslint/tests/lib/rules/no-unused-vars.js
+++ b/eslint/tests/lib/rules/no-unused-vars.js
@@ -177,6 +177,10 @@ ruleTester.run("no-unused-vars", rule, {
         { code: "(function(obj) { for ( const name in obj ) { return true } })({})", parserOptions: { ecmaVersion: 6 } },
         { code: "(function(obj) { for ( const name in obj ) return true })({})", parserOptions: { ecmaVersion: 6 } },
 
+        // Sequence Expressions (See https://github.com/eslint/eslint/issues/14325)
+        { code: "let x = 0; foo = (0, x++);", parserOptions: { ecmaVersion: 6 } },
+        { code: "let x = 0; foo = (0, x += 1);", parserOptions: { ecmaVersion: 6 } },
+
         // caughtErrors
         {
             code: "try{}catch(err){console.error(err);}",
@@ -291,6 +295,13 @@ ruleTester.run("no-unused-vars", rule, {
             parserOptions: { ecmaVersion: 2018 }
         },
 
+        // https://github.com/eslint/eslint/issues/14163
+        {
+            code: "let foo, rest;\n({ foo, ...rest } = something);\nconsole.log(rest);",
+            options: [{ ignoreRestSiblings: true }],
+            parserOptions: { ecmaVersion: 2020 }
+        },
+
         // https://github.com/eslint/eslint/issues/10952
         "/*eslint use-every-a:1*/ !function(b, a) { return 1 }",
 
@@ -304,6 +315,18 @@ ruleTester.run("no-unused-vars", rule, {
         {
             code: "const a = () => () => { a(); }; a();",
             parserOptions: { ecmaVersion: 2015 }
+        },
+
+        // export * as ns from "source"
+        {
+            code: 'export * as ns from "source"',
+            parserOptions: { ecmaVersion: 2020, sourceType: "module" }
+        },
+
+        // import.meta
+        {
+            code: "import.meta",
+            parserOptions: { ecmaVersion: 2020, sourceType: "module" }
         }
     ],
     invalid: [
@@ -444,7 +467,7 @@ ruleTester.run("no-unused-vars", rule, {
             code: "(function(obj) { var name; for ( name in obj ) { i(); return; } })({});",
             errors: [{
                 line: 1,
-                column: 22,
+                column: 34,
                 messageId: "unusedVar",
                 data: {
                     varName: "name",
@@ -457,7 +480,7 @@ ruleTester.run("no-unused-vars", rule, {
             code: "(function(obj) { var name; for ( name in obj ) { } })({});",
             errors: [{
                 line: 1,
-                column: 22,
+                column: 34,
                 messageId: "unusedVar",
                 data: {
                     varName: "name",
@@ -576,6 +599,23 @@ ruleTester.run("no-unused-vars", rule, {
                 }
             ]
         },
+        {
+            code: "let type, coords;\n({ type, ...coords } = data);\n console.log(type)",
+            options: [{ ignoreRestSiblings: true }],
+            parserOptions: { ecmaVersion: 2018 },
+            errors: [
+                {
+                    line: 2,
+                    column: 13,
+                    messageId: "unusedVar",
+                    data: {
+                        varName: "coords",
+                        action: "assigned a value",
+                        additional: ""
+                    }
+                }
+            ]
+        },
 
         // Unused rest property without ignoreRestSiblings
         {
@@ -959,6 +999,71 @@ ruleTester.run("no-unused-vars", rule, {
                 definedError("c")
             ]
         },
+
+        // https://github.com/eslint/eslint/issues/14325
+        {
+            code: `let x = 0;
+            x++, x = 0;`,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 2, column: 18 }]
+        },
+        {
+            code: `let x = 0;
+            x++, x = 0;
+            x=3;`,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 3, column: 13 }]
+        },
+        {
+            code: "let x = 0; x++, 0;",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 1, column: 12 }]
+        },
+        {
+            code: "let x = 0; 0, x++;",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 1, column: 15 }]
+        },
+        {
+            code: "let x = 0; 0, (1, x++);",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 1, column: 19 }]
+        },
+        {
+            code: "let x = 0; foo = (x++, 0);",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 1, column: 19 }]
+        },
+        {
+            code: "let x = 0; foo = ((0, x++), 0);",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 1, column: 23 }]
+        },
+        {
+            code: "let x = 0; x += 1, 0;",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 1, column: 12 }]
+        },
+        {
+            code: "let x = 0; 0, x += 1;",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 1, column: 15 }]
+        },
+        {
+            code: "let x = 0; 0, (1, x += 1);",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 1, column: 19 }]
+        },
+        {
+            code: "let x = 0; foo = (x += 1, 0);",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 1, column: 19 }]
+        },
+        {
+            code: "let x = 0; foo = ((0, x += 1), 0);",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 1, column: 23 }]
+        },
         {
             code: "(function ({ a, b }, { c } ) { return b; })();",
             parserOptions: { ecmaVersion: 2015 },
@@ -1021,6 +1126,87 @@ ruleTester.run("no-unused-vars", rule, {
             code: "const a = () => () => { a(); };",
             parserOptions: { ecmaVersion: 2015 },
             errors: [assignedError("a")]
+        },
+        {
+            code: `let myArray = [1,2,3,4].filter((x) => x == 0);
+    myArray = myArray.filter((x) => x == 1);`,
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("myArray"), line: 2, column: 5 }]
+        },
+        {
+            code: "const a = 1; a += 1;",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("a"), line: 1, column: 14 }]
+        },
+        {
+            code: "var a = function() { a(); };",
+            errors: [{ ...assignedError("a"), line: 1, column: 5 }]
+        },
+        {
+            code: "var a = function(){ return function() { a(); } };",
+            errors: [{ ...assignedError("a"), line: 1, column: 5 }]
+        },
+        {
+            code: "const a = () => { a(); };",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("a"), line: 1, column: 7 }]
+        },
+        {
+            code: "const a = () => () => { a(); };",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("a"), line: 1, column: 7 }]
+        },
+
+        // https://github.com/eslint/eslint/issues/14324
+        {
+            code: "let x = [];\nx = x.concat(x);",
+            parserOptions: { ecmaVersion: 2015 },
+            errors: [{ ...assignedError("x"), line: 2, column: 1 }]
+        },
+        {
+
+            code: `let a = 'a';
+            a = 10;
+            function foo(){
+                a = 11;
+                a = () => {
+                    a = 13
+                }
+            }`,
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [{ ...assignedError("a"), line: 2, column: 13 }, { ...definedError("foo"), line: 3, column: 22 }]
+        },
+        {
+            code: `let foo;
+            init();
+            foo = foo + 2;
+            function init() {
+                foo = 1;
+            }`,
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [{ ...assignedError("foo"), line: 3, column: 13 }]
+        },
+        {
+            code: `function foo(n) {
+                if (n < 2) return 1;
+                return n * foo(n - 1);
+            }`,
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [{ ...definedError("foo"), line: 1, column: 10 }]
+        },
+        {
+            code: `let c = 'c'
+c = 10
+function foo1() {
+  c = 11
+  c = () => {
+    c = 13
+  }
+}
+
+c = foo1`,
+            parserOptions: { ecmaVersion: 2020 },
+            errors: [{ ...assignedError("c"), line: 10, column: 1 }]
         }
     ]
 });