@flint.fyi/ts 0.14.5 → 0.15.0

package/src/rules/classAssignments.test.ts

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

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

@@ -1,33 +0,0 @@
-import rule from "./consecutiveNonNullAssertions.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-declare const outer: { inner: number } | null;
-outer!!.inner;
-`,
-			output: `
-declare const outer: { inner: number } | null;
-outer!.inner;
-`,
-			snapshot: `
-declare const outer: { inner: number } | null;
-outer!!.inner;
-     ~~
-     Consecutive non-null assertion operators are unnecessary.
-`,
-		},
-	],
-	valid: [
-		`
-declare const outer: { inner: number } | null;
-outer!.inner;
-`,
-		`
-declare const outer: { inner: number } | null;
-outer?.inner!;
-`,
-	],
-});

package/src/rules/consecutiveNonNullAssertions.ts

@@ -1,46 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description: "Reports unnecessary extra non-null assertions.",
-		id: "consecutiveNonNullAssertions",
-		preset: "logical",
-	},
-	messages: {
-		consecutiveNonNullAssertion: {
-			primary: "Consecutive non-null assertion operators are unnecessary.",
-			secondary: [
-				"The non-null assertion operator (`!`) is used to assert that a value is not null or undefined.",
-				"Using it multiple times in a row does not do anything, and just takes up space unnecessarily.",
-			],
-			suggestions: ["Remove the redundant non-null assertion operator."],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				NonNullExpression: (node) => {
-					if (node.parent.kind !== ts.SyntaxKind.NonNullExpression) {
-						return;
-					}
-
-					const range = {
-						begin: node.end - 1,
-						end: node.parent.end,
-					};
-
-					context.report({
-						fix: {
-							range,
-							text: "",
-						},
-						message: "consecutiveNonNullAssertion",
-						range,
-					});
-				},
-			},
-		};
-	},
-});

package/src/rules/constantAssignments.test.ts

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

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

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