@flint.fyi/ts 0.14.5 → 0.15.0

package/src/rules/forDirections.ts

@@ -1,163 +0,0 @@
-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/forInArrays.test.ts

@@ -1,25 +0,0 @@
-import rule from "./forInArrays.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-declare const array: string[];
-for (const i in array) {}
-`,
-			snapshot: `
-declare const array: string[];
-for (const i in array) {}
-~~~~~~~~~~~~~~~~~~~~~~
-For-in loops over arrays have surprising behavior that often leads to bugs.
-`,
-		},
-	],
-	valid: [
-		`
-declare const array: string[];
-for (const i of array) {}
-`,
-	],
-});

package/src/rules/forInArrays.ts

@@ -1,70 +0,0 @@
-import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
-import { isTypeRecursive } from "./utils/isTypeRecursive.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports iterating over an array with a for-in loop.",
-		id: "forInArrays",
-		preset: "logical",
-	},
-	messages: {
-		forIn: {
-			primary:
-				"For-in loops over arrays have surprising behavior that often leads to bugs.",
-			secondary: [
-				"A for-in loop (`for (const i in o)`) iterates over all enumerable properties of an object, including those that are not array indices.",
-				"This can lead to unexpected behavior when used with arrays, as it may include properties that are not part of the array's numeric indices.",
-				"It also returns the index key (`i`) as a string, which is not the expected numeric type for array indices.",
-			],
-			suggestions: [
-				"Use a construct more suited for arrays, such as a for-of loop (`for (const i of o)`).",
-			],
-		},
-	},
-	setup(context) {
-		function hasNumberLikeLength(type: ts.Type): boolean {
-			const lengthProperty = type.getProperty("length");
-
-			if (lengthProperty == null) {
-				return false;
-			}
-
-			return tsutils.isTypeFlagSet(
-				context.typeChecker.getTypeOfSymbol(lengthProperty),
-				ts.TypeFlags.NumberLike,
-			);
-		}
-
-		function isArrayLike(type: ts.Type): boolean {
-			return isTypeRecursive(
-				type,
-				(t) => t.getNumberIndexType() != null && hasNumberLikeLength(t),
-			);
-		}
-
-		return {
-			visitors: {
-				ForInStatement: (node) => {
-					const type = getConstrainedTypeAtLocation(
-						node.expression,
-						context.typeChecker,
-					);
-
-					if (isArrayLike(type)) {
-						context.report({
-							message: "forIn",
-							range: {
-								begin: node.getStart(),
-								end: node.statement.getStart() - 1,
-							},
-						});
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/functionAssignments.test.ts

@@ -1,210 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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();`,
-	],
-});

package/src/rules/functionNewCalls.ts

@@ -1,75 +0,0 @@
-import * as ts from "typescript";
-
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
-import { isGlobalDeclarationOfName } from "../utils/isGlobalDeclarationOfName.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports using the Function constructor to create functions from strings.",
-		id: "functionNewCalls",
-		preset: "logical",
-	},
-	messages: {
-		noFunctionConstructor: {
-			primary:
-				"Dynamically creating functions with the Function constructor is insecure and slow.",
-			secondary: [
-				"Using the `Function` constructor to create functions from strings is similar to `eval()` and introduces security risks and performance issues.",
-				"Code passed to the Function constructor is executed in the global scope, making it harder to optimize and potentially allowing arbitrary code execution if user input is involved.",
-			],
-			suggestions: [
-				"Define functions using function declarations (`function name() {}`) or arrow functions (`() => {}`) instead.",
-				"If dynamic code generation is truly necessary, consider safer alternatives like passing functions as parameters or using a more constrained domain-specific approach.",
-			],
-		},
-	},
-	setup(context) {
-		function checkNode(node: ts.CallExpression | ts.NewExpression) {
-			if (isFunctionConstructor(node)) {
-				context.report({
-					message: "noFunctionConstructor",
-					range: getTSNodeRange(node.expression, context.sourceFile),
-				});
-			}
-		}
-
-		function isFunctionConstructor(node: ts.CallExpression | ts.NewExpression) {
-			if (ts.isIdentifier(node.expression)) {
-				if (
-					isGlobalDeclarationOfName(
-						node.expression,
-						"Function",
-						context.typeChecker,
-					)
-				) {
-					return true;
-				}
-			} else if (
-				ts.isPropertyAccessExpression(node.expression) &&
-				isGlobalDeclaration(node.expression, context.typeChecker)
-			) {
-				const propertyName = node.expression.name.text;
-				if (propertyName !== "Function") {
-					return false;
-				}
-
-				const object = node.expression.expression;
-				if (ts.isIdentifier(object)) {
-					return object.text === "globalThis" || object.text === "window";
-				}
-			}
-
-			return false;
-		}
-
-		return {
-			visitors: {
-				CallExpression: checkNode,
-				NewExpression: checkNode,
-			},
-		};
-	},
-});