mirror of
https://github.com/hanzoai/eslint.git
synced 2026-10-30 19:38:10 +00:00
965 lines
21 KiB
JavaScript
965 lines
21 KiB
JavaScript
/**
|
|
* @fileoverview Tests for no-loop-func rule.
|
|
* @author Ilya Volodin
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
|
|
const rule = require("../../../lib/rules/no-loop-func"),
|
|
RuleTester = require("../../../lib/rule-tester/rule-tester");
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Tests
|
|
//------------------------------------------------------------------------------
|
|
|
|
const ruleTester = new RuleTester();
|
|
|
|
ruleTester.run("no-loop-func", rule, {
|
|
valid: [
|
|
"string = 'function a() {}';",
|
|
"for (var i=0; i<l; i++) { } var a = function() { i; };",
|
|
"for (var i=0, a=function() { i; }; i<l; i++) { }",
|
|
"for (var x in xs.filter(function(x) { return x != upper; })) { }",
|
|
{
|
|
code: "for (var x of xs.filter(function(x) { return x != upper; })) { }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// no refers to variables that declared on upper scope.
|
|
"for (var i=0; i<l; i++) { (function() {}) }",
|
|
"for (var i in {}) { (function() {}) }",
|
|
{
|
|
code: "for (var i of {}) { (function() {}) }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// functions which are using unmodified variables are OK.
|
|
{
|
|
code: "for (let i=0; i<l; i++) { (function() { i; }) }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "for (let i in {}) { i = 7; (function() { i; }) }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "for (const i of {}) { (function() { i; }) }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "for (using i of foo) { (function() { i; }) }",
|
|
languageOptions: { ecmaVersion: 2026 },
|
|
},
|
|
{
|
|
code: "for (await using i of foo) { (function() { i; }) }",
|
|
languageOptions: { ecmaVersion: 2026 },
|
|
},
|
|
{
|
|
code: "for (var i = 0; i < 10; ++i) { using foo = bar(i); (function() { foo; }) }",
|
|
languageOptions: { ecmaVersion: 2026 },
|
|
},
|
|
{
|
|
code: "for (var i = 0; i < 10; ++i) { await using foo = bar(i); (function() { foo; }) }",
|
|
languageOptions: { ecmaVersion: 2026 },
|
|
},
|
|
{
|
|
code: "for (let i = 0; i < 10; ++i) { for (let x in xs.filter(x => x != i)) { } }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "let a = 0; for (let i=0; i<l; i++) { (function() { a; }); }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "let a = 0; for (let i in {}) { (function() { a; }); }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "let a = 0; for (let i of {}) { (function() { a; }); }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "let a = 0; for (let i=0; i<l; i++) { (function() { (function() { a; }); }); }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "let a = 0; for (let i in {}) { function foo() { (function() { a; }); } }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "let a = 0; for (let i of {}) { (() => { (function() { a; }); }); }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var a = 0; for (let i=0; i<l; i++) { (function() { a; }); }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var a = 0; for (let i in {}) { (function() { a; }); }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "var a = 0; for (let i of {}) { (function() { a; }); }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: [
|
|
"let result = {};",
|
|
"for (const score in scores) {",
|
|
" const letters = scores[score];",
|
|
" letters.split('').forEach(letter => {",
|
|
" result[letter] = score;",
|
|
" });",
|
|
"}",
|
|
"result.__default = 6;",
|
|
].join("\n"),
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: [
|
|
"while (true) {",
|
|
" (function() { a; });",
|
|
"}",
|
|
"let a;",
|
|
].join("\n"),
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
/*
|
|
* These loops _look_ like they might be unsafe, but because i is undeclared, they're fine
|
|
* at least as far as this rule is concerned - the loop doesn't declare/generate the variable.
|
|
*/
|
|
"while(i) { (function() { i; }) }",
|
|
"do { (function() { i; }) } while (i)",
|
|
|
|
/**
|
|
* These loops _look_ like they might be unsafe, but because i is declared outside the loop
|
|
* and is not updated in or after the loop, they're fine as far as this rule is concerned.
|
|
* The variable that's captured is just the one variable shared by all the loops, but that's
|
|
* explicitly expected in these cases.
|
|
*/
|
|
"var i; while(i) { (function() { i; }) }",
|
|
"var i; do { (function() { i; }) } while (i)",
|
|
|
|
/**
|
|
* These loops use an undeclared variable, and so shouldn't be flagged by this rule,
|
|
* they'll be picked up by no-undef.
|
|
*/
|
|
{
|
|
code: "for (var i=0; i<l; i++) { (function() { undeclared; }) }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "for (let i=0; i<l; i++) { (function() { undeclared; }) }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "for (var i in {}) { i = 7; (function() { undeclared; }) }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "for (let i in {}) { i = 7; (function() { undeclared; }) }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "for (const i of {}) { (function() { undeclared; }) }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "for (let i = 0; i < 10; ++i) { for (let x in xs.filter(x => x != undeclared)) { } }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
|
|
// IIFE
|
|
{
|
|
code: `
|
|
let current = getStart();
|
|
while (current) {
|
|
(() => {
|
|
current;
|
|
current.a;
|
|
current.b;
|
|
current.c;
|
|
current.d;
|
|
})();
|
|
|
|
current = current.upper;
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
"for (var i=0; (function() { i; })(), i<l; i++) { }",
|
|
"for (var i=0; i<l; (function() { i; })(), i++) { }",
|
|
{
|
|
code: "for (var i = 0; i < 10; ++i) { (()=>{ i;})() }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: "for (var i = 0; i < 10; ++i) { (function a(){i;})() }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: `
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
arr.push((f => f)((() => i)()));
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: `
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
arr.push((() => {
|
|
return (() => i)();
|
|
})());
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: `
|
|
const foo = bar;
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
arr.push(() => foo);
|
|
}
|
|
|
|
foo = baz; // This is a runtime error, but not concern of this rule. For this rule, variable 'foo' is constant.
|
|
`,
|
|
languageOptions: { ecmaVersion: 6 },
|
|
},
|
|
{
|
|
code: `
|
|
using foo = bar;
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
arr.push(() => foo);
|
|
}
|
|
|
|
foo = baz; // This is a runtime error, but not concern of this rule. For this rule, variable 'foo' is constant.
|
|
`,
|
|
languageOptions: { ecmaVersion: 2026 },
|
|
},
|
|
{
|
|
code: `
|
|
await using foo = bar;
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
arr.push(() => foo);
|
|
}
|
|
|
|
foo = baz; // This is a runtime error, but not concern of this rule. For this rule, variable 'foo' is constant.
|
|
`,
|
|
languageOptions: { ecmaVersion: 2026 },
|
|
},
|
|
],
|
|
invalid: [
|
|
{
|
|
code: "for (var i=0; i<l; i++) { (function() { i; }) }",
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "for (var i=0; i<l; i++) { for (var j=0; j<m; j++) { (function() { i+j; }) } }",
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i', 'j'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "for (var i in {}) { (function() { i; }) }",
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "for (var i of {}) { (function() { i; }) }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "for (var i=0; i < l; i++) { (() => { i; }) }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "for (var i=0; i < l; i++) { var a = function() { i; } }",
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "for (var i=0; i < l; i++) { function a() { i; }; a(); }",
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
|
|
// Warns functions which are using modified variables.
|
|
{
|
|
code: "let a; for (let i=0; i<l; i++) { a = 1; (function() { a; });}",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'a'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "let a; for (let i in {}) { (function() { a; }); a = 1; }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'a'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "let a; for (let i of {}) { (function() { a; }); } a = 1; ",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'a'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "let a; for (let i=0; i<l; i++) { (function() { (function() { a; }); }); a = 1; }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'a'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "let a; for (let i in {}) { a = 1; function foo() { (function() { a; }); } }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'a'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "let a; for (let i of {}) { (() => { (function() { a; }); }); } a = 1;",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'a'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "for (var i = 0; i < 10; ++i) { for (let x in xs.filter(x => x != i)) { } }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "for (let x of xs) { let a; for (let y of ys) { a = 1; (function() { a; }); } }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'a'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "for (var x of xs) { for (let y of ys) { (function() { x; }); } }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'x'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "for (var x of xs) { (function() { x; }); }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'x'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var a; for (let x of xs) { a = 1; (function() { a; }); }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'a'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "var a; for (let x of xs) { (function() { a; }); a = 1; }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'a'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "let a; function foo() { a = 10; } for (let x of xs) { (function() { a; }); } foo();",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'a'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "let a; function foo() { a = 10; for (let x of xs) { (function() { a; }); } } foo();",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'a'" },
|
|
},
|
|
],
|
|
},
|
|
|
|
// IIFE
|
|
{
|
|
code: "let a; for (var i=0; i<l; i++) { (function* (){i;})() }",
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "let a; for (var i=0; i<l; i++) { (async function (){i;})() }",
|
|
languageOptions: { ecmaVersion: 2022 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
let current = getStart();
|
|
const arr = [];
|
|
while (current) {
|
|
(function f() {
|
|
current;
|
|
arr.push(f);
|
|
})();
|
|
|
|
current = current.upper;
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'current'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
(function fun () {
|
|
if (arr.includes(fun)) return i;
|
|
else arr.push(fun);
|
|
})();
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
let current = getStart();
|
|
const arr = [];
|
|
while (current) {
|
|
const p = (async () => {
|
|
await someDelay();
|
|
current;
|
|
})();
|
|
|
|
arr.push(p);
|
|
current = current.upper;
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 2022 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'current'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
arr.push((f => f)(
|
|
() => i
|
|
));
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
line: 6,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
arr.push((() => {
|
|
return () => i;
|
|
})());
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
line: 6,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
arr.push((() => {
|
|
return () => { return i };
|
|
})());
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
line: 6,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
arr.push((() => {
|
|
return () => {
|
|
return () => i
|
|
};
|
|
})());
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
line: 6,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < 5; i++) {
|
|
arr.push((() => {
|
|
return () =>
|
|
(() => i)();
|
|
})());
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 6 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
line: 6,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < 5; i ++) {
|
|
(() => {
|
|
arr.push((async () => {
|
|
await 1;
|
|
return i;
|
|
})());
|
|
})();
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 2022 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
line: 6,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < 5; i ++) {
|
|
(() => {
|
|
(function f() {
|
|
if (!arr.includes(f)) {
|
|
arr.push(f);
|
|
}
|
|
return i;
|
|
})();
|
|
})();
|
|
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 2022 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
var arr1 = [], arr2 = [];
|
|
|
|
for (var [i, j] of ["a", "b", "c"].entries()) {
|
|
(() => {
|
|
arr1.push((() => i)());
|
|
arr2.push(() => j);
|
|
})();
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 2022 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'j'" },
|
|
line: 7,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
var arr = [];
|
|
|
|
for (var i = 0; i < 5; i ++) {
|
|
((f) => {
|
|
arr.push(f);
|
|
})(() => {
|
|
return (() => i)();
|
|
});
|
|
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 2022 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
line: 7,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
for (var i = 0; i < 5; i++) {
|
|
(async () => {
|
|
() => i;
|
|
})();
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 2022 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
line: 3,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
for (var i = 0; i < 10; i++) {
|
|
items.push({
|
|
id: i,
|
|
name: "Item " + i
|
|
});
|
|
|
|
const process = function (callback){
|
|
callback({ id: i, name: "Item " + i });
|
|
};
|
|
}
|
|
`,
|
|
languageOptions: { ecmaVersion: 2022 },
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
line: 8,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
});
|
|
|
|
const ruleTesterTypeScript = new RuleTester({
|
|
languageOptions: {
|
|
parser: require("@typescript-eslint/parser"),
|
|
},
|
|
});
|
|
|
|
ruleTesterTypeScript.run("no-loop-func", rule, {
|
|
valid: [
|
|
`
|
|
for (let i = 0; i < 10; i++) {
|
|
function foo() {
|
|
console.log('A');
|
|
}
|
|
}
|
|
`,
|
|
`
|
|
let someArray: MyType[] = [];
|
|
for (let i = 0; i < 10; i += 1) {
|
|
someArray = someArray.filter((item: MyType) => !!item);
|
|
}
|
|
`,
|
|
{
|
|
code: `
|
|
let someArray: MyType[] = [];
|
|
for (let i = 0; i < 10; i += 1) {
|
|
someArray = someArray.filter((item: MyType) => !!item);
|
|
}
|
|
`,
|
|
languageOptions: {
|
|
globals: {
|
|
MyType: "readonly",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
code: `
|
|
let someArray: MyType[] = [];
|
|
for (let i = 0; i < 10; i += 1) {
|
|
someArray = someArray.filter((item: MyType) => !!item);
|
|
}
|
|
`,
|
|
languageOptions: {
|
|
globals: {
|
|
MyType: "writable",
|
|
},
|
|
},
|
|
},
|
|
`
|
|
type MyType = 1;
|
|
let someArray: MyType[] = [];
|
|
for (let i = 0; i < 10; i += 1) {
|
|
someArray = someArray.filter((item: MyType) => !!item);
|
|
}
|
|
`,
|
|
// Test case for a global type that hasn't been configured
|
|
`
|
|
// UnconfiguredGlobalType is not defined anywhere or configured in globals
|
|
for (var i = 0; i < 10; i++) {
|
|
const process = (item: UnconfiguredGlobalType) => {
|
|
// This is valid because the type reference is considered safe
|
|
// even though UnconfiguredGlobalType is not configured
|
|
return item.id;
|
|
};
|
|
}
|
|
`,
|
|
|
|
// Test both configured and unconfigured global types
|
|
{
|
|
code: `
|
|
for (var i = 0; i < 10; i++) {
|
|
// ConfiguredType is in globals, UnconfiguredType is not
|
|
// Both should be considered safe as they are type references
|
|
const process = (configItem: ConfiguredType, unconfigItem: UnconfiguredType) => {
|
|
return {
|
|
config: configItem.value,
|
|
unconfig: unconfigItem.value
|
|
};
|
|
};
|
|
}
|
|
`,
|
|
languageOptions: {
|
|
globals: {
|
|
ConfiguredType: "readonly",
|
|
},
|
|
},
|
|
},
|
|
],
|
|
invalid: [
|
|
{
|
|
code: `
|
|
for (var i = 0; i < 10; i++) {
|
|
function foo() {
|
|
console.log(i);
|
|
}
|
|
}
|
|
`,
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
for (var i = 0; i < 10; i++) {
|
|
const handler = (event: Event) => {
|
|
console.log(i);
|
|
};
|
|
}
|
|
`,
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
interface Item {
|
|
id: number;
|
|
name: string;
|
|
}
|
|
|
|
const items: Item[] = [];
|
|
for (var i = 0; i < 10; i++) {
|
|
items.push({
|
|
id: i,
|
|
name: "Item " + i
|
|
});
|
|
|
|
const process = function(callback: (item: Item) => void): void {
|
|
callback({ id: i, name: "Item " + i });
|
|
};
|
|
}
|
|
`,
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: `
|
|
type Processor<T> = (item: T) => void;
|
|
|
|
for (var i = 0; i < 10; i++) {
|
|
const processor: Processor<number> = (item) => {
|
|
return item + i;
|
|
};
|
|
}
|
|
`,
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
// Function uses unconfigured global type but still references loop variable
|
|
{
|
|
code: `
|
|
for (var i = 0; i < 10; i++) {
|
|
// UnconfiguredGlobalType is not defined anywhere
|
|
// But the function still references i which makes it unsafe
|
|
const process = (item: UnconfiguredGlobalType) => {
|
|
console.log(i, item.value);
|
|
};
|
|
}
|
|
`,
|
|
errors: [
|
|
{
|
|
messageId: "unsafeRefs",
|
|
data: { varNames: "'i'" },
|
|
},
|
|
],
|
|
},
|
|
],
|
|
});
|