@flint.fyi/ts 0.14.2 → 0.14.3

package/src/rules/functionAssignments.test.ts

@@ -0,0 +1,210 @@
+import rule from "./functionAssignments.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+function myFunction() {}
+myFunction = function() {};
+`,
+			snapshot: `
+function myFunction() {}
+myFunction = function() {};
+~~~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+		},
+		{
+			code: `
+function myFunction() {}
+myFunction = 123;
+`,
+			snapshot: `
+function myFunction() {}
+myFunction = 123;
+~~~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+		},
+		{
+			code: `
+function myFunction() {}
+myFunction += 1;
+`,
+			snapshot: `
+function myFunction() {}
+myFunction += 1;
+~~~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+		},
+		{
+			code: `
+function myFunction() {}
+myFunction++;
+`,
+			snapshot: `
+function myFunction() {}
+myFunction++;
+~~~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+		},
+		{
+			code: `
+function myFunction() {}
+++myFunction;
+`,
+			snapshot: `
+function myFunction() {}
+++myFunction;
+  ~~~~~~~~~~
+  Variables declared with function declarations should not be reassigned.
+`,
+		},
+		{
+			code: `
+function myFunction() {
+    return 42;
+}
+myFunction = () => 100;
+`,
+			snapshot: `
+function myFunction() {
+    return 42;
+}
+myFunction = () => 100;
+~~~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+		},
+		{
+			code: `
+function outer() {
+    function inner() {}
+    inner = function() {};
+}
+`,
+			snapshot: `
+function outer() {
+    function inner() {}
+    inner = function() {};
+    ~~~~~
+    Variables declared with function declarations should not be reassigned.
+}
+`,
+		},
+		{
+			code: `
+function myFunction() {}
+if (condition) {
+    myFunction = null;
+}
+`,
+			snapshot: `
+function myFunction() {}
+if (condition) {
+    myFunction = null;
+    ~~~~~~~~~~
+    Variables declared with function declarations should not be reassigned.
+}
+`,
+		},
+		{
+			code: `
+function getValue() {
+    return 1;
+}
+getValue ??= function() { return 0; };
+`,
+			snapshot: `
+function getValue() {
+    return 1;
+}
+getValue ??= function() { return 0; };
+~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+		},
+		{
+			code: `
+function getValue() {
+    return true;
+}
+getValue &&= false;
+`,
+			snapshot: `
+function getValue() {
+    return true;
+}
+getValue &&= false;
+~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+		},
+		{
+			code: `
+function getValue() {
+    return false;
+}
+getValue ||= () => true;
+`,
+			snapshot: `
+function getValue() {
+    return false;
+}
+getValue ||= () => true;
+~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+		},
+		{
+			code: `
+function calculate(value: number): number {
+    return value * 2;
+}
+calculate = (value: number) => value * 3;
+`,
+			snapshot: `
+function calculate(value: number): number {
+    return value * 2;
+}
+calculate = (value: number) => value * 3;
+~~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+		},
+	],
+	valid: [
+		`function myFunction() { return 42; }`,
+		`function myFunction() {} const result = myFunction();`,
+		`const myFunction = function() {}; myFunction = () => {};`,
+		`const myFunction = () => {}; myFunction = function() {};`,
+		`let myFunction = function() {}; myFunction = () => {};`,
+		`function outer() { const inner = function() {}; inner = () => {}; }`,
+		`
+function outer() {
+    const myFunction = "shadowed variable";
+    myFunction = "reassigning shadowed variable is ok";
+}
+`,
+		`
+let myFunction = "outer variable";
+function scope() {
+    function myFunction() {}
+    console.log(myFunction);
+}
+myFunction = "reassigning outer is ok";
+`,
+		`function myFunction() {} const copy = myFunction;`,
+		`function myFunction() {} if (condition) { callWith(myFunction); }`,
+		`
+function myFunction() {
+    return function nested() {
+        return 42;
+    };
+}
+`,
+	],
+});

package/src/rules/functionAssignments.ts

@@ -0,0 +1,51 @@
+import { typescriptLanguage } from "../language.js";
+import { getModifyingReferences } from "../utils/getModifyingReferences.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports reassigning variables declared with function declarations.",
+		id: "functionAssignments",
+		preset: "untyped",
+	},
+	messages: {
+		noFunctionAssignment: {
+			primary:
+				"Variables declared with function declarations should not be reassigned.",
+			secondary: [
+				"Reassigning a function declaration can make code harder to understand and maintain.",
+				"Function declarations are hoisted to the top of their scope, and reassigning them can lead to unexpected behavior.",
+			],
+			suggestions: [
+				"Use a function expression or const variable instead if you need to reassign the function.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				FunctionDeclaration: (node) => {
+					if (!node.name) {
+						return;
+					}
+
+					const modifyingReferences = getModifyingReferences(
+						node.name,
+						context.sourceFile,
+						context.typeChecker,
+					);
+
+					for (const reference of modifyingReferences) {
+						context.report({
+							message: "noFunctionAssignment",
+							range: {
+								begin: reference.getStart(context.sourceFile),
+								end: reference.getEnd(),
+							},
+						});
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/generatorFunctionYields.test.ts

@@ -0,0 +1,152 @@
+import rule from "./generatorFunctionYields.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+function* emptyGenerator() {
+    console.log("No yield here");
+}
+`,
+			snapshot: `
+function* emptyGenerator() {
+        ~
+        Generator functions must contain at least one yield expression to produce values.
+    console.log("No yield here");
+}
+`,
+		},
+		{
+			code: `
+const generator = function* () {
+    return 42;
+};
+`,
+			snapshot: `
+const generator = function* () {
+                          ~
+                          Generator functions must contain at least one yield expression to produce values.
+    return 42;
+};
+`,
+		},
+		{
+			code: `
+class MyClass {
+    *generatorMethod() {
+        this.doSomething();
+    }
+}
+`,
+			snapshot: `
+class MyClass {
+    *generatorMethod() {
+    ~
+    Generator functions must contain at least one yield expression to produce values.
+        this.doSomething();
+    }
+}
+`,
+		},
+		{
+			code: `
+function* generatorWithNestedFunction() {
+    function inner() {
+        yield 42;
+    }
+}
+`,
+			snapshot: `
+function* generatorWithNestedFunction() {
+        ~
+        Generator functions must contain at least one yield expression to produce values.
+    function inner() {
+        yield 42;
+    }
+}
+`,
+		},
+		{
+			code: `
+function* generatorWithNestedGeneratorFunction() {
+    function* inner() {
+        yield 42;
+    }
+}
+`,
+			snapshot: `
+function* generatorWithNestedGeneratorFunction() {
+        ~
+        Generator functions must contain at least one yield expression to produce values.
+    function* inner() {
+        yield 42;
+    }
+}
+`,
+		},
+	],
+	valid: [
+		`
+function* validGenerator() {
+    yield 1;
+}
+`,
+		`
+function* validGeneratorMultiple() {
+    yield 1;
+    yield 2;
+    yield 3;
+}
+`,
+		`
+const generator = function* () {
+    yield 42;
+};
+`,
+		`
+class MyClass {
+    *generatorMethod() {
+        yield this.value;
+    }
+}
+`,
+		`
+function* conditionalYield(condition: boolean) {
+    if (condition) {
+        yield 1;
+    }
+}
+`,
+		`
+function* yieldInLoop() {
+    for (let i = 0; i < 10; i++) {
+        yield i;
+    }
+}
+`,
+		`
+function* yieldDelegate() {
+    yield* [1, 2, 3];
+}
+`,
+		`
+function regularFunction() {
+    return 42;
+}
+`,
+		`
+const arrow = () => {
+    return 42;
+};
+`,
+		`
+function* generatorWithNestedGenerator() {
+    yield 1;
+    function* inner() {
+        yield 2;
+    }
+}
+`,
+	],
+});

package/src/rules/generatorFunctionYields.ts

@@ -0,0 +1,71 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports generator functions that do not yield values.",
+		id: "generatorFunctionYields",
+		preset: "logical",
+	},
+	messages: {
+		missingYield: {
+			primary:
+				"Generator functions must contain at least one yield expression to produce values.",
+			secondary: [
+				"Generator functions use the `function*` syntax to create iterators that can produce multiple values over time.",
+				"Without a yield expression, the generator will not produce any values and behaves like an empty iterator.",
+				"This is likely unintentional and indicates incomplete implementation or a misunderstanding of generator functions.",
+			],
+			suggestions: [
+				"Add a `yield` expression to produce values from the generator.",
+				"If the function should not be a generator, remove the asterisk (`*`) from the function declaration.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				FunctionDeclaration: checkFunction,
+				FunctionExpression: checkFunction,
+				MethodDeclaration: checkFunction,
+			},
+		};
+
+		function checkFunction(
+			node:
+				| ts.FunctionDeclaration
+				| ts.FunctionExpression
+				| ts.MethodDeclaration,
+		): void {
+			if (!node.asteriskToken || !node.body || blockContainsYield(node.body)) {
+				return;
+			}
+
+			context.report({
+				message: "missingYield",
+				range: {
+					begin: node.asteriskToken.getStart(context.sourceFile),
+					end: node.asteriskToken.getEnd(),
+				},
+			});
+		}
+	},
+});
+
+function blockContainsYield(block: ts.Block) {
+	function checkForYield(node: ts.Node): boolean | undefined {
+		if (ts.isYieldExpression(node)) {
+			return true;
+		}
+
+		if (tsutils.isFunctionScopeBoundary(node)) {
+			return false;
+		}
+
+		return ts.forEachChild(node, checkForYield);
+	}
+
+	return ts.forEachChild(block, checkForYield);
+}

package/src/rules/globalAssignments.test.ts

@@ -0,0 +1,216 @@
+import rule from "./globalAssignments.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+undefined = 1;
+`,
+			snapshot: `
+undefined = 1;
+~~~~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+NaN = 42;
+`,
+			snapshot: `
+NaN = 42;
+~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+Infinity = 100;
+`,
+			snapshot: `
+Infinity = 100;
+~~~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+Object = null;
+`,
+			snapshot: `
+Object = null;
+~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+Array = function() {};
+`,
+			snapshot: `
+Array = function() {};
+~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+String = "test";
+`,
+			snapshot: `
+String = "test";
+~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+Number = 123;
+`,
+			snapshot: `
+Number = 123;
+~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+Boolean = true;
+`,
+			snapshot: `
+Boolean = true;
+~~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+Math = {};
+`,
+			snapshot: `
+Math = {};
+~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+JSON = null;
+`,
+			snapshot: `
+JSON = null;
+~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+window = {};
+`,
+			snapshot: `
+window = {};
+~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+undefined += 1;
+`,
+			snapshot: `
+undefined += 1;
+~~~~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+NaN *= 2;
+`,
+			snapshot: `
+NaN *= 2;
+~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+++undefined;
+`,
+			snapshot: `
+++undefined;
+  ~~~~~~~~~
+  Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+NaN++;
+`,
+			snapshot: `
+NaN++;
+~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+--Infinity;
+`,
+			snapshot: `
+--Infinity;
+  ~~~~~~~~
+  Read-only global variables should not be reassigned or modified.
+`,
+		},
+		{
+			code: `
+Object--;
+`,
+			snapshot: `
+Object--;
+~~~~~~
+Read-only global variables should not be reassigned or modified.
+`,
+		},
+	],
+	valid: [
+		`let undefined = 1;`,
+		`const NaN = 42;`,
+		`var Infinity = 100;`,
+		`function Object() {}`,
+		`let value = undefined;`,
+		`const result = NaN;`,
+		`if (value === undefined) {}`,
+		`const obj = { undefined: 1 };`,
+		`obj.undefined = 2;`,
+		`const custom = { NaN: 42 }; custom.NaN = 100;`,
+		`let myVar = 5; myVar = 10;`,
+		`const data = { value: 1 }; data.value = 2;`,
+		`let counter = 0; counter++;`,
+		`let index = 10; --index;`,
+		`
+function test() {
+    let undefined = 5;
+    undefined = 10;
+}
+`,
+		`
+const obj = {
+    undefined: 1,
+    NaN: 2,
+};
+obj.undefined = 5;
+`,
+		`
+const fn = (undefined: number) => {
+    undefined = 10;
+};
+`,
+		`
+function test(NaN: string) {
+    NaN = "updated";
+}
+`,
+	],
+});