]>
git.proxmox.com Git - pve-eslint.git/blob - eslint/tests/lib/rules/no-use-before-define.js
2 * @fileoverview Tests for no-use-before-define rule.
8 //------------------------------------------------------------------------------
10 //------------------------------------------------------------------------------
12 const rule
= require ( "../../../lib/rules/no-use-before-define" ),
13 { RuleTester
} = require ( "../../../lib/rule-tester" );
15 //------------------------------------------------------------------------------
17 //------------------------------------------------------------------------------
19 const ruleTester
= new RuleTester ();
21 ruleTester
. run ( "no-use-before-define" , rule
, {
25 "function foo () { arguments; }" ,
26 "var a=10; alert(a);" ,
27 "function b(a) { alert(a); }" ,
28 "Object.hasOwnProperty.call(a);" ,
29 "function a() { alert(arguments);}" ,
30 { code
: "a(); function a() { alert(arguments); }" , options
: [ "nofunc" ] },
31 { code
: "(() => { var a = 42; alert(a); })();" , parserOptions
: { ecmaVersion
: 6 } },
32 "a(); try { throw new Error() } catch (a) {}" ,
33 { code
: "class A {} new A();" , parserOptions
: { ecmaVersion
: 6 } },
35 { code
: "var {a = 0, b = a} = {};" , parserOptions
: { ecmaVersion
: 6 } },
36 { code
: "var [a = 0, b = a] = {};" , parserOptions
: { ecmaVersion
: 6 } },
37 "function foo() { foo(); }" ,
38 "var foo = function() { foo(); };" ,
39 "var a; for (a in a) {}" ,
40 { code
: "var a; for (a of a) {}" , parserOptions
: { ecmaVersion
: 6 } },
41 { code
: "let a; class C { static { a; } }" , parserOptions
: { ecmaVersion
: 2022 } },
42 { code
: "class C { static { let a; a; } }" , parserOptions
: { ecmaVersion
: 2022 } },
44 // Block-level bindings
45 { code
: " \" use strict \" ; a(); { function a() {} }" , parserOptions
: { ecmaVersion
: 6 } },
46 { code
: " \" use strict \" ; { a(); function a() {} }" , options
: [ "nofunc" ], parserOptions
: { ecmaVersion
: 6 } },
47 { code
: "switch (foo) { case 1: { a(); } default: { let a; }}" , parserOptions
: { ecmaVersion
: 6 } },
48 { code
: "a(); { let a = function () {}; }" , parserOptions
: { ecmaVersion
: 6 } },
50 // object style options
51 { code
: "a(); function a() { alert(arguments); }" , options
: [{ functions
: false }] },
52 { code
: " \" use strict \" ; { a(); function a() {} }" , options
: [{ functions
: false }], parserOptions
: { ecmaVersion
: 6 } },
53 { code
: "function foo() { new A(); } class A {};" , options
: [{ classes
: false }], parserOptions
: { ecmaVersion
: 6 } },
57 code
: "function foo() { bar; } var bar;" ,
58 options
: [{ variables
: false }]
61 code
: "var foo = () => bar; var bar;" ,
62 options
: [{ variables
: false }],
63 parserOptions
: { ecmaVersion
: 6 }
66 code
: "class C { static { () => foo; let foo; } }" ,
67 options
: [{ variables
: false }],
68 parserOptions
: { ecmaVersion
: 2022 }
71 // Tests related to class definition evaluation. These are not TDZ errors.
72 { code
: "class C extends (class { method() { C; } }) {}" , parserOptions
: { ecmaVersion
: 6 } },
73 { code
: "(class extends (class { method() { C; } }) {});" , parserOptions
: { ecmaVersion
: 6 } },
74 { code
: "const C = (class extends (class { method() { C; } }) {});" , parserOptions
: { ecmaVersion
: 6 } },
75 { code
: "class C extends (class { field = C; }) {}" , parserOptions
: { ecmaVersion
: 2022 } },
76 { code
: "(class extends (class { field = C; }) {});" , parserOptions
: { ecmaVersion
: 2022 } },
77 { code
: "const C = (class extends (class { field = C; }) {});" , parserOptions
: { ecmaVersion
: 2022 } },
78 { code
: "class C { [() => C](){} }" , parserOptions
: { ecmaVersion
: 6 } },
79 { code
: "(class C { [() => C](){} });" , parserOptions
: { ecmaVersion
: 6 } },
80 { code
: "const C = class { [() => C](){} };" , parserOptions
: { ecmaVersion
: 6 } },
81 { code
: "class C { static [() => C](){} }" , parserOptions
: { ecmaVersion
: 6 } },
82 { code
: "(class C { static [() => C](){} });" , parserOptions
: { ecmaVersion
: 6 } },
83 { code
: "const C = class { static [() => C](){} };" , parserOptions
: { ecmaVersion
: 6 } },
84 { code
: "class C { [() => C]; }" , parserOptions
: { ecmaVersion
: 2022 } },
85 { code
: "(class C { [() => C]; });" , parserOptions
: { ecmaVersion
: 2022 } },
86 { code
: "const C = class { [() => C]; };" , parserOptions
: { ecmaVersion
: 2022 } },
87 { code
: "class C { static [() => C]; }" , parserOptions
: { ecmaVersion
: 2022 } },
88 { code
: "(class C { static [() => C]; });" , parserOptions
: { ecmaVersion
: 2022 } },
89 { code
: "const C = class { static [() => C]; };" , parserOptions
: { ecmaVersion
: 2022 } },
90 { code
: "class C { method() { C; } }" , parserOptions
: { ecmaVersion
: 6 } },
91 { code
: "(class C { method() { C; } });" , parserOptions
: { ecmaVersion
: 6 } },
92 { code
: "const C = class { method() { C; } };" , parserOptions
: { ecmaVersion
: 6 } },
93 { code
: "class C { static method() { C; } }" , parserOptions
: { ecmaVersion
: 6 } },
94 { code
: "(class C { static method() { C; } });" , parserOptions
: { ecmaVersion
: 6 } },
95 { code
: "const C = class { static method() { C; } };" , parserOptions
: { ecmaVersion
: 6 } },
96 { code
: "class C { field = C; }" , parserOptions
: { ecmaVersion
: 2022 } },
97 { code
: "(class C { field = C; });" , parserOptions
: { ecmaVersion
: 2022 } },
98 { code
: "const C = class { field = C; };" , parserOptions
: { ecmaVersion
: 2022 } },
99 { code
: "class C { static field = C; }" , parserOptions
: { ecmaVersion
: 2022 } },
100 { code
: "(class C { static field = C; });" , parserOptions
: { ecmaVersion
: 2022 } }, // `const C = class { static field = C; };` is TDZ error
101 { code
: "class C { static field = class { static field = C; }; }" , parserOptions
: { ecmaVersion
: 2022 } },
102 { code
: "(class C { static field = class { static field = C; }; });" , parserOptions
: { ecmaVersion
: 2022 } },
103 { code
: "class C { field = () => C; }" , parserOptions
: { ecmaVersion
: 2022 } },
104 { code
: "(class C { field = () => C; });" , parserOptions
: { ecmaVersion
: 2022 } },
105 { code
: "const C = class { field = () => C; };" , parserOptions
: { ecmaVersion
: 2022 } },
106 { code
: "class C { static field = () => C; }" , parserOptions
: { ecmaVersion
: 2022 } },
107 { code
: "(class C { static field = () => C; });" , parserOptions
: { ecmaVersion
: 2022 } },
108 { code
: "const C = class { static field = () => C; };" , parserOptions
: { ecmaVersion
: 2022 } },
109 { code
: "class C { field = class extends C {}; }" , parserOptions
: { ecmaVersion
: 2022 } },
110 { code
: "(class C { field = class extends C {}; });" , parserOptions
: { ecmaVersion
: 2022 } },
111 { code
: "const C = class { field = class extends C {}; }" , parserOptions
: { ecmaVersion
: 2022 } },
112 { code
: "class C { static field = class extends C {}; }" , parserOptions
: { ecmaVersion
: 2022 } },
113 { code
: "(class C { static field = class extends C {}; });" , parserOptions
: { ecmaVersion
: 2022 } }, // `const C = class { static field = class extends C {}; };` is TDZ error
114 { code
: "class C { static field = class { [C]; }; }" , parserOptions
: { ecmaVersion
: 2022 } },
115 { code
: "(class C { static field = class { [C]; }; });" , parserOptions
: { ecmaVersion
: 2022 } }, // `const C = class { static field = class { [C]; } };` is TDZ error
116 { code
: "const C = class { static field = class { field = C; }; };" , parserOptions
: { ecmaVersion
: 2022 } },
118 code
: "class C { method() { a; } } let a;" ,
119 options
: [{ variables
: false }],
120 parserOptions
: { ecmaVersion
: 6 }
123 code
: "class C { static method() { a; } } let a;" ,
124 options
: [{ variables
: false }],
125 parserOptions
: { ecmaVersion
: 6 }
128 code
: "class C { field = a; } let a;" , // `class C { static field = a; } let a;` is TDZ error
129 options
: [{ variables
: false }],
130 parserOptions
: { ecmaVersion
: 2022 }
133 code
: "class C { field = D; } class D {}" , // `class C { static field = D; } class D {}` is TDZ error
134 options
: [{ classes
: false }],
135 parserOptions
: { ecmaVersion
: 2022 }
138 code
: "class C { field = class extends D {}; } class D {}" , // `class C { static field = class extends D {}; } class D {}` is TDZ error
139 options
: [{ classes
: false }],
140 parserOptions
: { ecmaVersion
: 2022 }
143 code
: "class C { field = () => a; } let a;" ,
144 options
: [{ variables
: false }],
145 parserOptions
: { ecmaVersion
: 2022 }
148 code
: "class C { static field = () => a; } let a;" ,
149 options
: [{ variables
: false }],
150 parserOptions
: { ecmaVersion
: 2022 }
153 code
: "class C { field = () => D; } class D {}" ,
154 options
: [{ classes
: false }],
155 parserOptions
: { ecmaVersion
: 2022 }
158 code
: "class C { static field = () => D; } class D {}" ,
159 options
: [{ classes
: false }],
160 parserOptions
: { ecmaVersion
: 2022 }
163 code
: "class C { static field = class { field = a; }; } let a;" ,
164 options
: [{ variables
: false }],
165 parserOptions
: { ecmaVersion
: 2022 }
168 code
: "class C { static { C; } }" , // `const C = class { static { C; } }` is TDZ error
169 parserOptions
: { ecmaVersion
: 2022 }
172 code
: "class C { static { C; } static {} static { C; } }" ,
173 parserOptions
: { ecmaVersion
: 2022 }
176 code
: "(class C { static { C; } })" ,
177 parserOptions
: { ecmaVersion
: 2022 }
180 code
: "class C { static { class D extends C {} } }" ,
181 parserOptions
: { ecmaVersion
: 2022 }
184 code
: "class C { static { (class { static { C } }) } }" ,
185 parserOptions
: { ecmaVersion
: 2022 }
188 code
: "class C { static { () => C; } }" ,
189 parserOptions
: { ecmaVersion
: 2022 }
192 code
: "(class C { static { () => C; } })" ,
193 parserOptions
: { ecmaVersion
: 2022 }
196 code
: "const C = class { static { () => C; } }" ,
197 parserOptions
: { ecmaVersion
: 2022 }
200 code
: "class C { static { () => D; } } class D {}" ,
201 options
: [{ classes
: false }],
202 parserOptions
: { ecmaVersion
: 2022 }
205 code
: "class C { static { () => a; } } let a;" ,
206 options
: [{ variables
: false }],
207 parserOptions
: { ecmaVersion
: 2022 }
210 code
: "const C = class C { static { C.x; } }" ,
211 parserOptions
: { ecmaVersion
: 2022 }
214 // "allowNamedExports" option
216 code
: "export { a }; const a = 1;" ,
217 options
: [{ allowNamedExports
: true }],
218 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" }
221 code
: "export { a as b }; const a = 1;" ,
222 options
: [{ allowNamedExports
: true }],
223 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" }
226 code
: "export { a, b }; let a, b;" ,
227 options
: [{ allowNamedExports
: true }],
228 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" }
231 code
: "export { a }; var a;" ,
232 options
: [{ allowNamedExports
: true }],
233 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" }
236 code
: "export { f }; function f() {}" ,
237 options
: [{ allowNamedExports
: true }],
238 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" }
241 code
: "export { C }; class C {}" ,
242 options
: [{ allowNamedExports
: true }],
243 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" }
248 code
: "a++; var a=19;" ,
249 parserOptions
: { ecmaVersion
: 6 , sourceType
: "module" },
251 messageId
: "usedBeforeDefined" ,
257 code
: "a++; var a=19;" ,
258 parserOptions
: { parserOptions
: { ecmaVersion
: 6 } },
260 messageId
: "usedBeforeDefined" ,
266 code
: "a++; var a=19;" ,
268 messageId
: "usedBeforeDefined" ,
274 code
: "a(); var a=function() {};" ,
276 messageId
: "usedBeforeDefined" ,
282 code
: "alert(a[1]); var a=[1,3];" ,
284 messageId
: "usedBeforeDefined" ,
290 code
: "a(); function a() { alert(b); var b=10; a(); }" ,
293 messageId
: "usedBeforeDefined" ,
298 messageId
: "usedBeforeDefined" ,
305 code
: "a(); var a=function() {};" ,
308 messageId
: "usedBeforeDefined" ,
314 code
: "(() => { alert(a); var a = 42; })();" ,
315 parserOptions
: { ecmaVersion
: 6 },
317 messageId
: "usedBeforeDefined" ,
323 code
: "(() => a())(); function a() { }" ,
324 parserOptions
: { ecmaVersion
: 6 },
326 messageId
: "usedBeforeDefined" ,
332 code
: " \" use strict \" ; a(); { function a() {} }" ,
334 messageId
: "usedBeforeDefined" ,
340 code
: "a(); try { throw new Error() } catch (foo) {var a;}" ,
342 messageId
: "usedBeforeDefined" ,
348 code
: "var f = () => a; var a;" ,
349 parserOptions
: { ecmaVersion
: 6 },
351 messageId
: "usedBeforeDefined" ,
357 code
: "new A(); class A {};" ,
358 parserOptions
: { ecmaVersion
: 6 },
360 messageId
: "usedBeforeDefined" ,
366 code
: "function foo() { new A(); } class A {};" ,
367 parserOptions
: { ecmaVersion
: 6 },
369 messageId
: "usedBeforeDefined" ,
375 code
: "new A(); var A = class {};" ,
376 parserOptions
: { ecmaVersion
: 6 },
378 messageId
: "usedBeforeDefined" ,
384 code
: "function foo() { new A(); } var A = class {};" ,
385 parserOptions
: { ecmaVersion
: 6 },
387 messageId
: "usedBeforeDefined" ,
393 // Block-level bindings
395 code
: "a++; { var a; }" ,
396 parserOptions
: { ecmaVersion
: 6 },
398 messageId
: "usedBeforeDefined" ,
404 code
: " \" use strict \" ; { a(); function a() {} }" ,
405 parserOptions
: { ecmaVersion
: 6 },
407 messageId
: "usedBeforeDefined" ,
413 code
: "{a; let a = 1}" ,
414 parserOptions
: { ecmaVersion
: 6 },
416 messageId
: "usedBeforeDefined" ,
422 code
: "switch (foo) { case 1: a(); \n default: \n let a;}" ,
423 parserOptions
: { ecmaVersion
: 6 },
425 messageId
: "usedBeforeDefined" ,
431 code
: "if (true) { function foo() { a; } let a;}" ,
432 parserOptions
: { ecmaVersion
: 6 },
434 messageId
: "usedBeforeDefined" ,
440 // object style options
442 code
: "a(); var a=function() {};" ,
443 options
: [{ functions
: false , classes
: false }],
445 messageId
: "usedBeforeDefined" ,
451 code
: "new A(); class A {};" ,
452 options
: [{ functions
: false , classes
: false }],
453 parserOptions
: { ecmaVersion
: 6 },
455 messageId
: "usedBeforeDefined" ,
461 code
: "new A(); var A = class {};" ,
462 options
: [{ classes
: false }],
463 parserOptions
: { ecmaVersion
: 6 },
465 messageId
: "usedBeforeDefined" ,
471 code
: "function foo() { new A(); } var A = class {};" ,
472 options
: [{ classes
: false }],
473 parserOptions
: { ecmaVersion
: 6 },
475 messageId
: "usedBeforeDefined" ,
481 // invalid initializers
485 messageId
: "usedBeforeDefined" ,
491 code
: "let a = a + b;" ,
492 parserOptions
: { ecmaVersion
: 6 },
494 messageId
: "usedBeforeDefined" ,
500 code
: "const a = foo(a);" ,
501 parserOptions
: { ecmaVersion
: 6 },
503 messageId
: "usedBeforeDefined" ,
509 code
: "function foo(a = a) {}" ,
510 parserOptions
: { ecmaVersion
: 6 },
512 messageId
: "usedBeforeDefined" ,
518 code
: "var {a = a} = [];" ,
519 parserOptions
: { ecmaVersion
: 6 },
521 messageId
: "usedBeforeDefined" ,
527 code
: "var [a = a] = [];" ,
528 parserOptions
: { ecmaVersion
: 6 },
530 messageId
: "usedBeforeDefined" ,
536 code
: "var {b = a, a} = {};" ,
537 parserOptions
: { ecmaVersion
: 6 },
539 messageId
: "usedBeforeDefined" ,
545 code
: "var [b = a, a] = {};" ,
546 parserOptions
: { ecmaVersion
: 6 },
548 messageId
: "usedBeforeDefined" ,
554 code
: "var {a = 0} = a;" ,
555 parserOptions
: { ecmaVersion
: 6 },
557 messageId
: "usedBeforeDefined" ,
563 code
: "var [a = 0] = a;" ,
564 parserOptions
: { ecmaVersion
: 6 },
566 messageId
: "usedBeforeDefined" ,
572 code
: "for (var a in a) {}" ,
574 messageId
: "usedBeforeDefined" ,
580 code
: "for (var a of a) {}" ,
581 parserOptions
: { ecmaVersion
: 6 },
583 messageId
: "usedBeforeDefined" ,
589 // "variables" option
591 code
: "function foo() { bar; var bar = 1; } var bar;" ,
592 options
: [{ variables
: false }],
594 messageId
: "usedBeforeDefined" ,
595 data
: { name
: "bar" },
600 code
: "foo; var foo;" ,
601 options
: [{ variables
: false }],
603 messageId
: "usedBeforeDefined" ,
604 data
: { name
: "foo" },
609 // https://github.com/eslint/eslint/issues/10227
611 code
: "for (let x = x;;); let x = 0" ,
612 parserOptions
: { ecmaVersion
: 2015 },
614 messageId
: "usedBeforeDefined" ,
619 code
: "for (let x in xs); let xs = []" ,
620 parserOptions
: { ecmaVersion
: 2015 },
622 messageId
: "usedBeforeDefined" ,
627 code
: "for (let x of xs); let xs = []" ,
628 parserOptions
: { ecmaVersion
: 2015 },
630 messageId
: "usedBeforeDefined" ,
635 code
: "try {} catch ({message = x}) {} let x = ''" ,
636 parserOptions
: { ecmaVersion
: 2015 },
638 messageId
: "usedBeforeDefined" ,
643 code
: "with (obj) x; let x = {}" ,
644 parserOptions
: { ecmaVersion
: 2015 },
646 messageId
: "usedBeforeDefined" ,
653 code
: "with (x); let x = {}" ,
654 parserOptions
: { ecmaVersion
: 2015 },
656 messageId
: "usedBeforeDefined" ,
661 code
: "with (obj) { x } let x = {}" ,
662 parserOptions
: { ecmaVersion
: 2015 },
664 messageId
: "usedBeforeDefined" ,
669 code
: "with (obj) { if (a) { x } } let x = {}" ,
670 parserOptions
: { ecmaVersion
: 2015 },
672 messageId
: "usedBeforeDefined" ,
677 code
: "with (obj) { (() => { if (a) { x } })() } let x = {}" ,
678 parserOptions
: { ecmaVersion
: 2015 },
680 messageId
: "usedBeforeDefined" ,
685 // Tests related to class definition evaluation. These are TDZ errors.
687 code
: "class C extends C {}" ,
688 options
: [{ classes
: false }],
689 parserOptions
: { ecmaVersion
: 6 },
691 messageId
: "usedBeforeDefined" ,
696 code
: "const C = class extends C {};" ,
697 options
: [{ variables
: false }],
698 parserOptions
: { ecmaVersion
: 6 },
700 messageId
: "usedBeforeDefined" ,
705 code
: "class C extends (class { [C](){} }) {}" ,
706 options
: [{ classes
: false }],
707 parserOptions
: { ecmaVersion
: 6 },
709 messageId
: "usedBeforeDefined" ,
714 code
: "const C = class extends (class { [C](){} }) {};" ,
715 options
: [{ variables
: false }],
716 parserOptions
: { ecmaVersion
: 6 },
718 messageId
: "usedBeforeDefined" ,
723 code
: "class C extends (class { static field = C; }) {}" ,
724 options
: [{ classes
: false }],
725 parserOptions
: { ecmaVersion
: 2022 },
727 messageId
: "usedBeforeDefined" ,
732 code
: "const C = class extends (class { static field = C; }) {};" ,
733 options
: [{ variables
: false }],
734 parserOptions
: { ecmaVersion
: 2022 },
736 messageId
: "usedBeforeDefined" ,
741 code
: "class C { [C](){} }" ,
742 options
: [{ classes
: false }],
743 parserOptions
: { ecmaVersion
: 6 },
745 messageId
: "usedBeforeDefined" ,
750 code
: "(class C { [C](){} });" ,
751 options
: [{ classes
: false }],
752 parserOptions
: { ecmaVersion
: 6 },
754 messageId
: "usedBeforeDefined" ,
759 code
: "const C = class { [C](){} };" ,
760 options
: [{ variables
: false }],
761 parserOptions
: { ecmaVersion
: 6 },
763 messageId
: "usedBeforeDefined" ,
768 code
: "class C { static [C](){} }" ,
769 options
: [{ classes
: false }],
770 parserOptions
: { ecmaVersion
: 6 },
772 messageId
: "usedBeforeDefined" ,
777 code
: "(class C { static [C](){} });" ,
778 options
: [{ classes
: false }],
779 parserOptions
: { ecmaVersion
: 6 },
781 messageId
: "usedBeforeDefined" ,
786 code
: "const C = class { static [C](){} };" ,
787 options
: [{ variables
: false }],
788 parserOptions
: { ecmaVersion
: 6 },
790 messageId
: "usedBeforeDefined" ,
795 code
: "class C { [C]; }" ,
796 options
: [{ classes
: false }],
797 parserOptions
: { ecmaVersion
: 2022 },
799 messageId
: "usedBeforeDefined" ,
804 code
: "(class C { [C]; });" ,
805 options
: [{ classes
: false }],
806 parserOptions
: { ecmaVersion
: 2022 },
808 messageId
: "usedBeforeDefined" ,
813 code
: "const C = class { [C]; };" ,
814 options
: [{ variables
: false }],
815 parserOptions
: { ecmaVersion
: 2022 },
817 messageId
: "usedBeforeDefined" ,
822 code
: "class C { [C] = foo; }" ,
823 options
: [{ classes
: false }],
824 parserOptions
: { ecmaVersion
: 2022 },
826 messageId
: "usedBeforeDefined" ,
831 code
: "(class C { [C] = foo; });" ,
832 options
: [{ classes
: false }],
833 parserOptions
: { ecmaVersion
: 2022 },
835 messageId
: "usedBeforeDefined" ,
840 code
: "const C = class { [C] = foo; };" ,
841 options
: [{ variables
: false }],
842 parserOptions
: { ecmaVersion
: 2022 },
844 messageId
: "usedBeforeDefined" ,
849 code
: "class C { static [C]; }" ,
850 options
: [{ classes
: false }],
851 parserOptions
: { ecmaVersion
: 2022 },
853 messageId
: "usedBeforeDefined" ,
858 code
: "(class C { static [C]; });" ,
859 options
: [{ classes
: false }],
860 parserOptions
: { ecmaVersion
: 2022 },
862 messageId
: "usedBeforeDefined" ,
867 code
: "const C = class { static [C]; };" ,
868 options
: [{ variables
: false }],
869 parserOptions
: { ecmaVersion
: 2022 },
871 messageId
: "usedBeforeDefined" ,
876 code
: "class C { static [C] = foo; }" ,
877 options
: [{ classes
: false }],
878 parserOptions
: { ecmaVersion
: 2022 },
880 messageId
: "usedBeforeDefined" ,
885 code
: "(class C { static [C] = foo; });" ,
886 options
: [{ classes
: false }],
887 parserOptions
: { ecmaVersion
: 2022 },
889 messageId
: "usedBeforeDefined" ,
894 code
: "const C = class { static [C] = foo; };" ,
895 options
: [{ variables
: false }],
896 parserOptions
: { ecmaVersion
: 2022 },
898 messageId
: "usedBeforeDefined" ,
903 code
: "const C = class { static field = C; };" ,
904 options
: [{ variables
: false }],
905 parserOptions
: { ecmaVersion
: 2022 },
907 messageId
: "usedBeforeDefined" ,
912 code
: "const C = class { static field = class extends C {}; };" ,
913 options
: [{ variables
: false }],
914 parserOptions
: { ecmaVersion
: 2022 },
916 messageId
: "usedBeforeDefined" ,
921 code
: "const C = class { static field = class { [C]; } };" ,
922 options
: [{ variables
: false }],
923 parserOptions
: { ecmaVersion
: 2022 },
925 messageId
: "usedBeforeDefined" ,
930 code
: "const C = class { static field = class { static field = C; }; };" ,
931 options
: [{ variables
: false }],
932 parserOptions
: { ecmaVersion
: 2022 },
934 messageId
: "usedBeforeDefined" ,
939 code
: "class C extends D {} class D {}" ,
940 options
: [{ classes
: false }],
941 parserOptions
: { ecmaVersion
: 6 },
943 messageId
: "usedBeforeDefined" ,
948 code
: "class C extends (class { [a](){} }) {} let a;" ,
949 options
: [{ variables
: false }],
950 parserOptions
: { ecmaVersion
: 6 },
952 messageId
: "usedBeforeDefined" ,
957 code
: "class C extends (class { static field = a; }) {} let a;" ,
958 options
: [{ variables
: false }],
959 parserOptions
: { ecmaVersion
: 2022 },
961 messageId
: "usedBeforeDefined" ,
966 code
: "class C { [a]() {} } let a;" ,
967 options
: [{ variables
: false }],
968 parserOptions
: { ecmaVersion
: 6 },
970 messageId
: "usedBeforeDefined" ,
975 code
: "class C { static [a]() {} } let a;" ,
976 options
: [{ variables
: false }],
977 parserOptions
: { ecmaVersion
: 6 },
979 messageId
: "usedBeforeDefined" ,
984 code
: "class C { [a]; } let a;" ,
985 options
: [{ variables
: false }],
986 parserOptions
: { ecmaVersion
: 2022 },
988 messageId
: "usedBeforeDefined" ,
993 code
: "class C { static [a]; } let a;" ,
994 options
: [{ variables
: false }],
995 parserOptions
: { ecmaVersion
: 2022 },
997 messageId
: "usedBeforeDefined" ,
1002 code
: "class C { [a] = foo; } let a;" ,
1003 options
: [{ variables
: false }],
1004 parserOptions
: { ecmaVersion
: 2022 },
1006 messageId
: "usedBeforeDefined" ,
1011 code
: "class C { static [a] = foo; } let a;" ,
1012 options
: [{ variables
: false }],
1013 parserOptions
: { ecmaVersion
: 2022 },
1015 messageId
: "usedBeforeDefined" ,
1020 code
: "class C { static field = a; } let a;" ,
1021 options
: [{ variables
: false }],
1022 parserOptions
: { ecmaVersion
: 2022 },
1024 messageId
: "usedBeforeDefined" ,
1029 code
: "class C { static field = D; } class D {}" ,
1030 options
: [{ classes
: false }],
1031 parserOptions
: { ecmaVersion
: 2022 },
1033 messageId
: "usedBeforeDefined" ,
1038 code
: "class C { static field = class extends D {}; } class D {}" ,
1039 options
: [{ classes
: false }],
1040 parserOptions
: { ecmaVersion
: 2022 },
1042 messageId
: "usedBeforeDefined" ,
1047 code
: "class C { static field = class { [a](){} } } let a;" ,
1048 options
: [{ variables
: false }],
1049 parserOptions
: { ecmaVersion
: 2022 },
1051 messageId
: "usedBeforeDefined" ,
1056 code
: "class C { static field = class { static field = a; }; } let a;" ,
1057 options
: [{ variables
: false }],
1058 parserOptions
: { ecmaVersion
: 2022 },
1060 messageId
: "usedBeforeDefined" ,
1065 code
: "const C = class { static { C; } };" ,
1066 options
: [{ variables
: false }],
1067 parserOptions
: { ecmaVersion
: 2022 },
1069 messageId
: "usedBeforeDefined" ,
1074 code
: "const C = class { static { (class extends C {}); } };" ,
1075 options
: [{ variables
: false }],
1076 parserOptions
: { ecmaVersion
: 2022 },
1078 messageId
: "usedBeforeDefined" ,
1083 code
: "class C { static { a; } } let a;" ,
1084 options
: [{ variables
: false }],
1085 parserOptions
: { ecmaVersion
: 2022 },
1087 messageId
: "usedBeforeDefined" ,
1092 code
: "class C { static { D; } } class D {}" ,
1093 options
: [{ classes
: false }],
1094 parserOptions
: { ecmaVersion
: 2022 },
1096 messageId
: "usedBeforeDefined" ,
1101 code
: "class C { static { (class extends D {}); } } class D {}" ,
1102 options
: [{ classes
: false }],
1103 parserOptions
: { ecmaVersion
: 2022 },
1105 messageId
: "usedBeforeDefined" ,
1110 code
: "class C { static { (class { [a](){} }); } } let a;" ,
1111 options
: [{ variables
: false }],
1112 parserOptions
: { ecmaVersion
: 2022 },
1114 messageId
: "usedBeforeDefined" ,
1119 code
: "class C { static { (class { static field = a; }); } } let a;" ,
1120 options
: [{ variables
: false }],
1121 parserOptions
: { ecmaVersion
: 2022 },
1123 messageId
: "usedBeforeDefined" ,
1129 * TODO(mdjermanovic): Add the following test cases once https://github.com/eslint/eslint-scope/issues/59 gets fixed:
1131 * code: "(class C extends C {});",
1132 * options: [{ classes: false }],
1133 * parserOptions: { ecmaVersion: 6 },
1135 * messageId: "usedBeforeDefined",
1136 * data: { name: "C" }
1140 * code: "(class C extends (class { [C](){} }) {});",
1141 * options: [{ classes: false }],
1142 * parserOptions: { ecmaVersion: 6 },
1144 * messageId: "usedBeforeDefined",
1145 * data: { name: "C" }
1149 * code: "(class C extends (class { static field = C; }) {});",
1150 * options: [{ classes: false }],
1151 * parserOptions: { ecmaVersion: 2022 },
1153 * messageId: "usedBeforeDefined",
1154 * data: { name: "C" }
1159 // "allowNamedExports" option
1161 code
: "export { a }; const a = 1;" ,
1162 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1164 messageId
: "usedBeforeDefined" ,
1169 code
: "export { a }; const a = 1;" ,
1171 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1173 messageId
: "usedBeforeDefined" ,
1178 code
: "export { a }; const a = 1;" ,
1179 options
: [{ allowNamedExports
: false }],
1180 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1182 messageId
: "usedBeforeDefined" ,
1187 code
: "export { a }; const a = 1;" ,
1188 options
: [ "nofunc" ],
1189 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1191 messageId
: "usedBeforeDefined" ,
1196 code
: "export { a as b }; const a = 1;" ,
1197 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1199 messageId
: "usedBeforeDefined" ,
1204 code
: "export { a, b }; let a, b;" ,
1205 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1208 messageId
: "usedBeforeDefined" ,
1212 messageId
: "usedBeforeDefined" ,
1218 code
: "export { a }; var a;" ,
1219 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1221 messageId
: "usedBeforeDefined" ,
1226 code
: "export { f }; function f() {}" ,
1227 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1229 messageId
: "usedBeforeDefined" ,
1234 code
: "export { C }; class C {}" ,
1235 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1237 messageId
: "usedBeforeDefined" ,
1242 code
: "export const foo = a; const a = 1;" ,
1243 options
: [{ allowNamedExports
: true }],
1244 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1246 messageId
: "usedBeforeDefined" ,
1251 code
: "export default a; const a = 1;" ,
1252 options
: [{ allowNamedExports
: true }],
1253 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1255 messageId
: "usedBeforeDefined" ,
1260 code
: "export function foo() { return a; }; const a = 1;" ,
1261 options
: [{ allowNamedExports
: true }],
1262 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1264 messageId
: "usedBeforeDefined" ,
1269 code
: "export class C { foo() { return a; } }; const a = 1;" ,
1270 options
: [{ allowNamedExports
: true }],
1271 parserOptions
: { ecmaVersion
: 2015 , sourceType
: "module" },
1273 messageId
: "usedBeforeDefined" ,