@flint.fyi/ts 0.14.2 → 0.14.4

package/src/rules/exceptionAssignments.ts

@@ -0,0 +1,77 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+import { getModifyingReferences } from "../utils/getModifyingReferences.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports reassigning exception parameters in catch clauses.",
+		id: "exceptionAssignments",
+		preset: "logical",
+	},
+	messages: {
+		noExAssign: {
+			primary:
+				"Exception parameters in catch clauses should not be reassigned.",
+			secondary: [
+				"Reassigning an exception parameter can make debugging more difficult by obscuring the original error.",
+				"The exception parameter contains important information about what went wrong, and reassigning it can make it harder to understand the root cause of an error.",
+			],
+			suggestions: [
+				"Use a different variable name for the new value instead of reassigning the exception parameter.",
+			],
+		},
+	},
+	setup(context) {
+		function collectBindingElements(name: ts.BindingName): ts.Identifier[] {
+			const identifiers: ts.Identifier[] = [];
+
+			if (ts.isIdentifier(name)) {
+				identifiers.push(name);
+			} else if (
+				ts.isObjectBindingPattern(name) ||
+				ts.isArrayBindingPattern(name)
+			) {
+				for (const element of name.elements) {
+					if (ts.isBindingElement(element)) {
+						identifiers.push(...collectBindingElements(element.name));
+					}
+				}
+			}
+
+			return identifiers;
+		}
+
+		return {
+			visitors: {
+				CatchClause: (node) => {
+					if (!node.variableDeclaration?.name) {
+						return;
+					}
+
+					const identifiers = collectBindingElements(
+						node.variableDeclaration.name,
+					);
+
+					for (const identifier of identifiers) {
+						const modifyingReferences = getModifyingReferences(
+							identifier,
+							context.sourceFile,
+							context.typeChecker,
+						);
+
+						for (const reference of modifyingReferences) {
+							context.report({
+								message: "noExAssign",
+								range: {
+									begin: reference.getStart(context.sourceFile),
+									end: reference.getEnd(),
+								},
+							});
+						}
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/forDirections.test.ts

@@ -0,0 +1,100 @@
+import rule from "./forDirections.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+for (let i = 0; i < 10; i--) {}
+`,
+			snapshot: `
+for (let i = 0; i < 10; i--) {}
+                        ~~~
+                        The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 0; index < 10; index--) {}
+`,
+			snapshot: `
+for (let index = 0; index < 10; index--) {}
+                                ~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 10; index >= 0; index++) {}
+`,
+			snapshot: `
+for (let index = 10; index >= 0; index++) {}
+                                 ~~~~~~~
+                                 The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 0; index > 10; index++) {}
+`,
+			snapshot: `
+for (let index = 0; index > 10; index++) {}
+                                ~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 0; 10 > index; index--) {}
+`,
+			snapshot: `
+for (let index = 0; 10 > index; index--) {}
+                                ~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 0; index < 10; index -= 1) {}
+`,
+			snapshot: `
+for (let index = 0; index < 10; index -= 1) {}
+                                ~~~~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 10; index > 0; index += 1) {}
+`,
+			snapshot: `
+for (let index = 10; index > 0; index += 1) {}
+                                ~~~~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 0; index < 10; index += -1) {}
+`,
+			snapshot: `
+for (let index = 0; index < 10; index += -1) {}
+                                ~~~~~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+	],
+	valid: [
+		`for (let i = 0; i < 10; i++) { }`,
+		`for (let index = 0; index < 10; index++) { }`,
+		`for (let index = 10; index >= 0; index--) { }`,
+		`for (let index = 0; 10 > index; index++) { }`,
+		`for (let index = 10; 0 < index; index--) { }`,
+		`for (let index = 10; index >= 0; index += step) { }`,
+		`for (let index = 0; index <= 10; index -= 0) { }`,
+		`for (let index = 0; index < 10; index += 1) { }`,
+		`for (let index = 10; index > 0; index -= 1) { }`,
+		`for (let index = 0; index < 10; index += 2) { }`,
+		`for (let index = 10; index > 0; index -= 2) { }`,
+	],
+});

package/src/rules/forDirections.ts

@@ -0,0 +1,163 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+
+function getConditionDirection(condition: ts.Expression, counterName: string) {
+	if (!ts.isBinaryExpression(condition)) {
+		return undefined;
+	}
+
+	const leftName = getCounterName(condition.left);
+	const rightName = getCounterName(condition.right);
+
+	const isCounterLeft = leftName === counterName;
+	const isCounterRight = rightName === counterName;
+
+	if (!isCounterLeft && !isCounterRight) {
+		return undefined;
+	}
+
+	const { operatorToken } = condition;
+
+	if (isCounterLeft) {
+		if (
+			operatorToken.kind === ts.SyntaxKind.LessThanToken ||
+			operatorToken.kind === ts.SyntaxKind.LessThanEqualsToken
+		) {
+			return 1;
+		}
+		if (
+			operatorToken.kind === ts.SyntaxKind.GreaterThanToken ||
+			operatorToken.kind === ts.SyntaxKind.GreaterThanEqualsToken
+		) {
+			return -1;
+		}
+	} else {
+		if (
+			operatorToken.kind === ts.SyntaxKind.LessThanToken ||
+			operatorToken.kind === ts.SyntaxKind.LessThanEqualsToken
+		) {
+			return -1;
+		}
+		if (
+			operatorToken.kind === ts.SyntaxKind.GreaterThanToken ||
+			operatorToken.kind === ts.SyntaxKind.GreaterThanEqualsToken
+		) {
+			return 1;
+		}
+	}
+
+	return undefined;
+}
+
+function getCounterName(node: ts.Expression) {
+	return ts.isIdentifier(node) ? node.text : undefined;
+}
+
+function getUpdateDirection(update: ts.Expression) {
+	if (
+		ts.isPostfixUnaryExpression(update) ||
+		ts.isPrefixUnaryExpression(update)
+	) {
+		switch (update.operator) {
+			case ts.SyntaxKind.MinusMinusToken:
+				return -1;
+			case ts.SyntaxKind.PlusPlusToken:
+				return 1;
+			default:
+				return undefined;
+		}
+	}
+
+	if (ts.isBinaryExpression(update)) {
+		const { operatorToken, right } = update;
+
+		if (
+			operatorToken.kind === ts.SyntaxKind.PlusEqualsToken ||
+			operatorToken.kind === ts.SyntaxKind.MinusEqualsToken
+		) {
+			if (ts.isNumericLiteral(right)) {
+				const value = Number(right.text);
+				if (operatorToken.kind === ts.SyntaxKind.PlusEqualsToken) {
+					return value > 0 ? 1 : value < 0 ? -1 : 0;
+				}
+				return value > 0 ? -1 : value < 0 ? 1 : 0;
+			}
+
+			if (
+				ts.isPrefixUnaryExpression(right) &&
+				right.operator === ts.SyntaxKind.MinusToken &&
+				ts.isNumericLiteral(right.operand)
+			) {
+				const value = Number(right.operand.text);
+				if (operatorToken.kind === ts.SyntaxKind.PlusEqualsToken) {
+					return value > 0 ? -1 : 1;
+				}
+				return value > 0 ? 1 : -1;
+			}
+		}
+	}
+
+	return undefined;
+}
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports for loops with counter variables that move in the wrong direction.",
+		id: "forDirections",
+		preset: "stylistic",
+	},
+	messages: {
+		wrongDirection: {
+			primary:
+				"The update moves the counter in the wrong direction for this loop condition.",
+			secondary: [
+				"A for loop with a counter that moves in the wrong direction relative to its stop condition will run infinitely or never execute.",
+				"When the counter increases but the condition expects it to decrease (or vice versa), the loop logic is incorrect.",
+			],
+			suggestions: [
+				"Verify the loop counter update direction matches the condition.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				ForStatement: (node) => {
+					if (
+						!node.condition ||
+						!node.incrementor ||
+						!node.initializer ||
+						!ts.isVariableDeclarationList(node.initializer)
+					) {
+						return;
+					}
+
+					const declaration = node.initializer.declarations.at(0);
+					if (!declaration || !ts.isIdentifier(declaration.name)) {
+						return;
+					}
+
+					const updateDirection = getUpdateDirection(node.incrementor);
+					if (!updateDirection) {
+						return;
+					}
+
+					const conditionDirection = getConditionDirection(
+						node.condition,
+						declaration.name.text,
+					);
+
+					if (updateDirection !== conditionDirection) {
+						context.report({
+							message: "wrongDirection",
+							range: getTSNodeRange(node.incrementor, context.sourceFile),
+						});
+					}
+				},
+			},
+		};
+	},
+});

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/functionNewCalls.test.ts

@@ -0,0 +1,116 @@
+import rule from "./functionNewCalls.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+const fn = new Function("a", "b", "return a + b");
+`,
+			snapshot: `
+const fn = new Function("a", "b", "return a + b");
+               ~~~~~~~~
+               Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+		},
+		{
+			code: `
+const fn = Function("a", "return a");
+`,
+			snapshot: `
+const fn = Function("a", "return a");
+           ~~~~~~~~
+           Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+		},
+		{
+			code: `
+const fn = new Function("return 1");
+`,
+			snapshot: `
+const fn = new Function("return 1");
+               ~~~~~~~~
+               Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+		},
+		{
+			code: `
+const fn = Function();
+`,
+			snapshot: `
+const fn = Function();
+           ~~~~~~~~
+           Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+		},
+		{
+			code: `
+const fn = new globalThis.Function("return 1");
+`,
+			snapshot: `
+const fn = new globalThis.Function("return 1");
+               ~~~~~~~~~~~~~~~~~~~
+               Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+		},
+		{
+			code: `
+const fn = globalThis.Function("return 1");
+`,
+			snapshot: `
+const fn = globalThis.Function("return 1");
+           ~~~~~~~~~~~~~~~~~~~
+           Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+		},
+		{
+			code: `
+const fn = new window.Function("return 1");
+`,
+			snapshot: `
+const fn = new window.Function("return 1");
+               ~~~~~~~~~~~~~~~
+               Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+		},
+		{
+			code: `
+const fn = window.Function("return 1");
+`,
+			snapshot: `
+const fn = window.Function("return 1");
+           ~~~~~~~~~~~~~~~
+           Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+		},
+		{
+			code: `
+const result = new Function("a", "b", "return a + b")(1, 2);
+`,
+			snapshot: `
+const result = new Function("a", "b", "return a + b")(1, 2);
+                   ~~~~~~~~
+                   Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+		},
+		{
+			code: `
+const CustomFunction = Function;
+const fn = new CustomFunction();
+`,
+			snapshot: `
+const CustomFunction = Function;
+const fn = new CustomFunction();
+               ~~~~~~~~~~~~~~
+               Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+		},
+	],
+	valid: [
+		`const fn = function(a, b) { return a + b; };`,
+		`const fn = (a, b) => a + b;`,
+		`function add(a, b) { return a + b; }`,
+		`class MyFunction {}`,
+		`const fn = new MyFunction();`,
+	],
+});