@flint.fyi/ts 0.14.2 → 0.14.4

package/src/rules/classAssignments.test.ts

@@ -0,0 +1,157 @@
+import rule from "./classAssignments.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+class A {}
+A = 0;
+`,
+			snapshot: `
+class A {}
+A = 0;
+~
+Reassigning a class declaration is misleading and makes the class harder to use.
+`,
+		},
+		{
+			code: `
+class MyClass {}
+MyClass = "string";
+`,
+			snapshot: `
+class MyClass {}
+MyClass = "string";
+~~~~~~~
+Reassigning a class declaration is misleading and makes the class harder to use.
+`,
+		},
+		{
+			code: `
+class Counter {}
+Counter++;
+`,
+			snapshot: `
+class Counter {}
+Counter++;
+~~~~~~~
+Reassigning a class declaration is misleading and makes the class harder to use.
+`,
+		},
+		{
+			code: `
+class Value {}
+++Value;
+`,
+			snapshot: `
+class Value {}
+++Value;
+  ~~~~~
+  Reassigning a class declaration is misleading and makes the class harder to use.
+`,
+		},
+		{
+			code: `
+class MyClass {}
+MyClass += "suffix";
+`,
+			snapshot: `
+class MyClass {}
+MyClass += "suffix";
+~~~~~~~
+Reassigning a class declaration is misleading and makes the class harder to use.
+`,
+		},
+		{
+			code: `
+class Example {}
+Example ??= null;
+`,
+			snapshot: `
+class Example {}
+Example ??= null;
+~~~~~~~
+Reassigning a class declaration is misleading and makes the class harder to use.
+`,
+		},
+		{
+			code: `
+class Test {}
+Test &&= false;
+`,
+			snapshot: `
+class Test {}
+Test &&= false;
+~~~~
+Reassigning a class declaration is misleading and makes the class harder to use.
+`,
+		},
+		{
+			code: `
+class Data {}
+Data ||= null;
+`,
+			snapshot: `
+class Data {}
+Data ||= null;
+~~~~
+Reassigning a class declaration is misleading and makes the class harder to use.
+`,
+		},
+		{
+			code: `
+class Outer {}
+function inner() {
+    Outer = null;
+}
+`,
+			snapshot: `
+class Outer {}
+function inner() {
+    Outer = null;
+    ~~~~~
+    Reassigning a class declaration is misleading and makes the class harder to use.
+}
+`,
+		},
+		{
+			code: `
+class MyClass {}
+if (true) {
+    MyClass = null;
+}
+`,
+			snapshot: `
+class MyClass {}
+if (true) {
+    MyClass = null;
+    ~~~~~~~
+    Reassigning a class declaration is misleading and makes the class harder to use.
+}
+`,
+		},
+	],
+	valid: [
+		`class A {}`,
+		`class MyClass {} const instance = new MyClass();`,
+		`class Counter {} const value = Counter;`,
+		`class Example {} if (Example) { console.log(Example); }`,
+		`const A = 0;`,
+		`class A {} function inner() { const A = "shadowed"; A = "reassigning shadowed is ok"; }`,
+		`let A = "outer"; class A {} A = "reassigning outer is ok";`,
+		`
+class MyClass {}
+const derived = class extends MyClass {};
+`,
+		`
+class Base {}
+class Derived extends Base {}
+`,
+		`
+class MyClass {}
+const instance = new MyClass();
+instance.property = "value";
+`,
+	],
+});

package/src/rules/classAssignments.ts

@@ -0,0 +1,50 @@
+import { typescriptLanguage } from "../language.js";
+import { getModifyingReferences } from "../utils/getModifyingReferences.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports reassigning class declarations.",
+		id: "classAssignments",
+		preset: "untyped",
+	},
+	messages: {
+		noClassAssign: {
+			primary:
+				"Reassigning a class declaration is misleading and makes the class harder to use.",
+			secondary: [
+				"Reassigning a class declaration can lead to unexpected behavior and makes code harder to understand.",
+				"Class declarations are typically intended to be immutable references, and reassigning them can cause confusion about which class is being used.",
+			],
+			suggestions: [
+				"Use a different variable name if you need to store a modified reference to a class.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				ClassDeclaration: (node) => {
+					if (!node.name) {
+						return;
+					}
+
+					const modifyingReferences = getModifyingReferences(
+						node.name,
+						context.sourceFile,
+						context.typeChecker,
+					);
+
+					for (const reference of modifyingReferences) {
+						context.report({
+							message: "noClassAssign",
+							range: {
+								begin: reference.getStart(context.sourceFile),
+								end: reference.getEnd(),
+							},
+						});
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/constantAssignments.test.ts

@@ -0,0 +1,222 @@
+import rule from "./constantAssignments.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+const value = 1;
+value = 2;
+`,
+			snapshot: `
+const value = 1;
+value = 2;
+~~~~~
+Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+`,
+		},
+		{
+			code: `
+const result = getValue();
+result = getOtherValue();
+`,
+			snapshot: `
+const result = getValue();
+result = getOtherValue();
+~~~~~~
+Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+`,
+		},
+		{
+			code: `
+const counter = 0;
+counter++;
+`,
+			snapshot: `
+const counter = 0;
+counter++;
+~~~~~~~
+Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+`,
+		},
+		{
+			code: `
+const counter = 0;
+++counter;
+`,
+			snapshot: `
+const counter = 0;
+++counter;
+  ~~~~~~~
+  Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+`,
+		},
+		{
+			code: `
+const total = 0;
+total += 5;
+`,
+			snapshot: `
+const total = 0;
+total += 5;
+~~~~~
+Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+`,
+		},
+		{
+			code: `
+const value = 10;
+value -= 3;
+`,
+			snapshot: `
+const value = 10;
+value -= 3;
+~~~~~
+Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+`,
+		},
+		{
+			code: `
+const { property } = object;
+property = "new value";
+`,
+			snapshot: `
+const { property } = object;
+property = "new value";
+~~~~~~~~
+Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+`,
+		},
+		{
+			code: `
+const [first, second] = array;
+first = 100;
+`,
+			snapshot: `
+const [first, second] = array;
+first = 100;
+~~~~~
+Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+`,
+		},
+		{
+			code: `
+const { nested: { deep } } = object;
+deep = "modified";
+`,
+			snapshot: `
+const { nested: { deep } } = object;
+deep = "modified";
+~~~~
+Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+`,
+		},
+		{
+			code: `
+const [first, ...rest] = array;
+rest = [];
+`,
+			snapshot: `
+const [first, ...rest] = array;
+rest = [];
+~~~~
+Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+`,
+		},
+		{
+			code: `
+for (const item of items) {
+    item = processItem(item);
+}
+`,
+			snapshot: `
+for (const item of items) {
+    item = processItem(item);
+    ~~~~
+    Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+}
+`,
+		},
+		{
+			code: `
+function process() {
+    const value = 1;
+    value = 2;
+}
+`,
+			snapshot: `
+function process() {
+    const value = 1;
+    value = 2;
+    ~~~~~
+    Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+}
+`,
+		},
+		{
+			code: `
+const data = getData();
+if (condition) {
+    data = getOtherData();
+}
+`,
+			snapshot: `
+const data = getData();
+if (condition) {
+    data = getOtherData();
+    ~~~~
+    Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.
+}
+`,
+		},
+	],
+	valid: [
+		`const value = 1;`,
+		`const result = getValue();`,
+		`let value = 1; value = 2;`,
+		`var value = 1; value = 2;`,
+		`const object = {}; object.property = "value";`,
+		`const array = []; array.push(1);`,
+		`const object = { value: 1 }; object.value = 2;`,
+		`const array = [1, 2, 3]; array[0] = 4;`,
+		`const value = 1; console.log(value);`,
+		`const { property } = object; console.log(property);`,
+		`const [first, second] = array; console.log(first);`,
+		`for (let item of items) { item = processItem(item); }`,
+		`for (const item of items) { console.log(item); }`,
+		`
+const outer = 1;
+function inner() {
+    const outer = 2;
+    return outer;
+}
+`,
+		`
+const value = 1;
+{
+    const value = 2;
+    console.log(value);
+}
+`,
+		`
+function process(value: number) {
+    const result = value * 2;
+    return result;
+}
+`,
+		`
+const calculate = (input: number) => {
+    const result = input + 10;
+    return result;
+};
+`,
+		`
+class MyClass {
+    method() {
+        const value = 0;
+        return value;
+    }
+}
+`,
+	],
+});

package/src/rules/constantAssignments.ts

@@ -0,0 +1,78 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+import { getModifyingReferences } from "../utils/getModifyingReferences.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports attempting to reassign variables declared with const.",
+		id: "constantAssignments",
+		preset: "untyped",
+	},
+	messages: {
+		noConstAssign: {
+			primary:
+				"Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.",
+			secondary: [
+				"The const keyword creates a read-only reference to a value, preventing reassignment.",
+				"While properties of const objects and elements of const arrays can be mutated, the binding itself cannot be reassigned.",
+			],
+			suggestions: [
+				"Use let instead of const if you need to reassign the variable.",
+			],
+		},
+	},
+	setup(context) {
+		function collectBindingElements(name: ts.BindingName): ts.Identifier[] {
+			if (ts.isIdentifier(name)) {
+				return [name];
+			}
+
+			const identifiers: ts.Identifier[] = [];
+
+			for (const element of name.elements) {
+				if (ts.isBindingElement(element)) {
+					identifiers.push(...collectBindingElements(element.name));
+				}
+			}
+
+			return identifiers;
+		}
+
+		return {
+			visitors: {
+				VariableDeclarationList: (node) => {
+					if (
+						!(node.flags & ts.NodeFlags.Const) ||
+						node.declarations.length === 0
+					) {
+						return;
+					}
+
+					for (const declaration of node.declarations) {
+						const identifiers = collectBindingElements(declaration.name);
+
+						for (const identifier of identifiers) {
+							const modifyingReferences = getModifyingReferences(
+								identifier,
+								context.sourceFile,
+								context.typeChecker,
+							);
+
+							for (const reference of modifyingReferences) {
+								context.report({
+									message: "noConstAssign",
+									range: {
+										begin: reference.getStart(context.sourceFile),
+										end: reference.getEnd(),
+									},
+								});
+							}
+						}
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/constructorReturns.test.ts

@@ -0,0 +1,97 @@
+import rule from "./constructorReturns.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+class Example {
+    constructor() {
+        return {};
+    }
+}
+`,
+			snapshot: `
+class Example {
+    constructor() {
+        return {};
+        ~~~~~~~~~~
+        Returning a value from a constructor function overrides the newly created instance.
+    }
+}
+`,
+		},
+		{
+			code: `
+class Example {
+    constructor() {
+        return { value: 1 };
+    }
+}
+`,
+			snapshot: `
+class Example {
+    constructor() {
+        return { value: 1 };
+        ~~~~~~~~~~~~~~~~~~~~
+        Returning a value from a constructor function overrides the newly created instance.
+    }
+}
+`,
+		},
+		{
+			code: `
+class Example {
+    constructor() {
+        if (condition) {
+            return new OtherClass();
+        }
+    }
+}
+`,
+			snapshot: `
+class Example {
+    constructor() {
+        if (condition) {
+            return new OtherClass();
+            ~~~~~~~~~~~~~~~~~~~~~~~~
+            Returning a value from a constructor function overrides the newly created instance.
+        }
+    }
+}
+`,
+		},
+		{
+			code: `
+class Example {
+    constructor(value: number) {
+        if (value < 0) {
+            return null;
+        }
+        this.value = value;
+    }
+}
+`,
+			snapshot: `
+class Example {
+    constructor(value: number) {
+        if (value < 0) {
+            return null;
+            ~~~~~~~~~~~~
+            Returning a value from a constructor function overrides the newly created instance.
+        }
+        this.value = value;
+    }
+}
+`,
+		},
+	],
+	valid: [
+		`class Example { constructor() {} }`,
+		`class Example { constructor() { this.value = 1; } }`,
+		`class Example { constructor() { return; } }`,
+		`class Example { constructor() { if (condition) { return; } this.value = 1; } }`,
+		`class Example { constructor() { const factory = () => { return {}; }; } }`,
+		`class Example { constructor() { function helper() { return 1; } } }`,
+	],
+});

package/src/rules/constructorReturns.ts

@@ -0,0 +1,59 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports returning values from constructor functions.",
+		id: "constructorReturns",
+		preset: "untyped",
+	},
+	messages: {
+		noConstructorReturn: {
+			primary:
+				"Returning a value from a constructor function overrides the newly created instance.",
+			secondary: [
+				"This behavior is often unintentional and can lead to unexpected results.",
+				"If you need to return a different object, consider using a factory function instead.",
+			],
+			suggestions: [
+				"Remove the return statement, or return without a value to exit early.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				Constructor: (node) => {
+					if (!node.body) {
+						return;
+					}
+
+					function checkForReturnStatements(node: ts.Node): void {
+						if (ts.isReturnStatement(node)) {
+							if (node.expression) {
+								context.report({
+									message: "noConstructorReturn",
+									range: {
+										begin: node.getStart(context.sourceFile),
+										end: node.getEnd(),
+									},
+								});
+							}
+							return;
+						}
+
+						if (tsutils.isFunctionScopeBoundary(node)) {
+							return;
+						}
+
+						ts.forEachChild(node, checkForReturnStatements);
+					}
+
+					ts.forEachChild(node.body, checkForReturnStatements);
+				},
+			},
+		};
+	},
+});