@flint.fyi/ts 0.14.2 → 0.14.4

package/src/rules/functionNewCalls.ts

@@ -0,0 +1,75 @@
+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,
+			},
+		};
+	},
+});

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";
+}
+`,
+	],
+});

package/src/rules/globalAssignments.ts

@@ -0,0 +1,67 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { isGlobalVariable } from "../utils/isGlobalVariable.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.",
+		id: "globalAssignments",
+		preset: "untyped",
+	},
+	messages: {
+		noGlobalAssign: {
+			primary:
+				"Read-only global variables should not be reassigned or modified.",
+			secondary: [
+				"Global variables like undefined, NaN, Infinity, and built-in objects like Object and Array are read-only and should not be modified.",
+				"Attempting to reassign these globals can lead to confusing behavior and potential bugs in your code.",
+				"In strict mode, reassigning these globals will throw a TypeError at runtime.",
+			],
+			suggestions: [
+				"Use a different variable name instead of shadowing or reassigning globals.",
+				"If you need a similar name, consider using a more specific name that doesn't conflict with global variables.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				BinaryExpression: (node) => {
+					if (
+						tsutils.isAssignmentKind(node.operatorToken.kind) &&
+						isGlobalVariable(node.left, context.typeChecker)
+					) {
+						context.report({
+							message: "noGlobalAssign",
+							range: getTSNodeRange(node.left, context.sourceFile),
+						});
+					}
+				},
+				PostfixUnaryExpression: (node) => {
+					if (isGlobalVariable(node.operand, context.typeChecker)) {
+						context.report({
+							message: "noGlobalAssign",
+							range: getTSNodeRange(node.operand, context.sourceFile),
+						});
+					}
+				},
+				PrefixUnaryExpression: (node) => {
+					if (
+						(node.operator === ts.SyntaxKind.PlusPlusToken ||
+							node.operator === ts.SyntaxKind.MinusMinusToken) &&
+						isGlobalVariable(node.operand, context.typeChecker)
+					) {
+						context.report({
+							message: "noGlobalAssign",
+							range: getTSNodeRange(node.operand, context.sourceFile),
+						});
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/globalObjectCalls.test.ts

@@ -0,0 +1,94 @@
+import rule from "./globalObjectCalls.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+const result = Math();
+`,
+			snapshot: `
+const result = Math();
+               ~~~~
+               Math is not a function and cannot be called directly.
+`,
+		},
+		{
+			code: `
+const data = JSON();
+`,
+			snapshot: `
+const data = JSON();
+             ~~~~
+             JSON is not a function and cannot be called directly.
+`,
+		},
+		{
+			code: `
+const reflected = Reflect();
+`,
+			snapshot: `
+const reflected = Reflect();
+                  ~~~~~~~
+                  Reflect is not a function and cannot be called directly.
+`,
+		},
+		{
+			code: `
+const atomic = Atomics();
+`,
+			snapshot: `
+const atomic = Atomics();
+               ~~~~~~~
+               Atomics is not a function and cannot be called directly.
+`,
+		},
+		{
+			code: `
+const instance = new Math();
+`,
+			snapshot: `
+const instance = new Math();
+                     ~~~~
+                     Math is not a function and cannot be called directly.
+`,
+		},
+		{
+			code: `
+const instance = new JSON();
+`,
+			snapshot: `
+const instance = new JSON();
+                     ~~~~
+                     JSON is not a function and cannot be called directly.
+`,
+		},
+		{
+			code: `
+const instance = new Reflect();
+`,
+			snapshot: `
+const instance = new Reflect();
+                     ~~~~~~~
+                     Reflect is not a function and cannot be called directly.
+`,
+		},
+		{
+			code: `
+const instance = new Atomics();
+`,
+			snapshot: `
+const instance = new Atomics();
+                     ~~~~~~~
+                     Atomics is not a function and cannot be called directly.
+`,
+		},
+	],
+	valid: [
+		`const value = Math.abs(-5);`,
+		`const parsed = JSON.parse("{}");`,
+		`const stringified = JSON.stringify({});`,
+		`const keys = Reflect.ownKeys({});`,
+		`const result = Atomics.add(buffer, 0, 1);`,
+	],
+});

package/src/rules/globalObjectCalls.ts

@@ -0,0 +1,52 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+
+const globalObjects = new Set(["Atomics", "JSON", "Math", "Reflect"]);
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports calling global objects like Math, JSON, or Reflect as functions.",
+		id: "globalObjectCalls",
+		preset: "untyped",
+	},
+	messages: {
+		noGlobalObjectCall: {
+			primary: "{{ name }} is not a function and cannot be called directly.",
+			secondary: [
+				"{{ name }} is a built-in global object that provides utility methods and properties.",
+				"It is not a constructor or function and cannot be called or instantiated.",
+			],
+			suggestions: [
+				"Use the static methods available on {{ name }} instead (e.g., {{ name }}.methodName()).",
+			],
+		},
+	},
+	setup(context) {
+		function reportGlobalObjectCall(
+			expression: ts.Expression,
+			name: string,
+		): void {
+			context.report({
+				data: { name },
+				message: "noGlobalObjectCall",
+				range: getTSNodeRange(expression, context.sourceFile),
+			});
+		}
+
+		function checkNode({ expression }: ts.CallExpression | ts.NewExpression) {
+			if (ts.isIdentifier(expression) && globalObjects.has(expression.text)) {
+				reportGlobalObjectCall(expression, expression.text);
+			}
+		}
+
+		return {
+			visitors: {
+				CallExpression: checkNode,
+				NewExpression: checkNode,
+			},
+		};
+	},
+});