@flint.fyi/ts 0.14.2 → 0.14.3

package/src/rules/returnAssignments.test.ts

@@ -0,0 +1,186 @@
+import rule from "./returnAssignments.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+function getValue() {
+    let value;
+    return value = 1;
+}
+`,
+			snapshot: `
+function getValue() {
+    let value;
+    return value = 1;
+                 ~
+                 Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+		},
+		{
+			code: `
+function process() {
+    let result;
+    return result = calculate();
+}
+`,
+			snapshot: `
+function process() {
+    let result;
+    return result = calculate();
+                  ~
+                  Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+		},
+		{
+			code: `
+function update() {
+    let status;
+    return (status = "updated");
+}
+`,
+			snapshot: `
+function update() {
+    let status;
+    return (status = "updated");
+                   ~
+                   Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+		},
+		{
+			code: `
+const arrow = () => {
+    let value;
+    return value = 42;
+};
+`,
+			snapshot: `
+const arrow = () => {
+    let value;
+    return value = 42;
+                 ~
+                 Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+};
+`,
+		},
+		{
+			code: `
+const arrowImplicit = () => (value = 100);
+`,
+			snapshot: `
+const arrowImplicit = () => (value = 100);
+                                   ~
+                                   Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+`,
+		},
+		{
+			code: `
+function multiply(factor: number) {
+    let result;
+    return result = factor * 2;
+}
+`,
+			snapshot: `
+function multiply(factor: number) {
+    let result;
+    return result = factor * 2;
+                  ~
+                  Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+		},
+		{
+			code: `
+function compound() {
+    let count;
+    return count += 5;
+}
+`,
+			snapshot: `
+function compound() {
+    let count;
+    return count += 5;
+                 ~~
+                 Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+		},
+		{
+			code: `
+function bitwise() {
+    let flags;
+    return flags |= 0x01;
+}
+`,
+			snapshot: `
+function bitwise() {
+    let flags;
+    return flags |= 0x01;
+                 ~~
+                 Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.
+}
+`,
+		},
+	],
+	valid: [
+		`function getValue() { return 1; }`,
+		`function getValue() { let value = 1; return value; }`,
+		`function process() { const result = calculate(); return result; }`,
+		`const arrow = () => { let value = 42; return value; };`,
+		`const arrowImplicit = () => getValue();`,
+		`
+function update() {
+    let status = "updated";
+    return status;
+}
+`,
+		`
+function multiply(factor: number) {
+    let result = factor * 2;
+    return result;
+}
+`,
+		`
+function compound() {
+    let count = 0;
+    count += 5;
+    return count;
+}
+`,
+		`
+function calculate() {
+    const value = 10;
+    return value;
+}
+`,
+		`
+const process = (input: number) => {
+    const result = input * 2;
+    return result;
+};
+`,
+		`
+class MyClass {
+    method() {
+        const value = 42;
+        return value;
+    }
+}
+`,
+		`
+function compare(a: number, b: number) {
+    return a === b;
+}
+`,
+		`
+function arrowReturn() {
+    const fn = () => 42;
+    return fn;
+}
+`,
+	],
+});

package/src/rules/returnAssignments.ts

@@ -0,0 +1,57 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { unwrapParenthesizedExpression } from "../utils/unwrapParenthesizedExpression.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports using assignment expressions in return statements.",
+		id: "returnAssignments",
+		preset: "stylistic",
+	},
+	messages: {
+		noReturnAssign: {
+			primary:
+				"Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.",
+			secondary: [
+				"Using assignments in return statements can make code harder to read and can lead to confusion about whether the assignment or the returned value is the primary intent.",
+				"Assignment expressions return the assigned value, but mixing assignment with return makes the control flow less clear.",
+			],
+			suggestions: [
+				"Perform the assignment on a separate line before the return statement.",
+			],
+		},
+	},
+	setup(context) {
+		function checkForAssignment(node: ts.Expression): void {
+			const unwrapped = unwrapParenthesizedExpression(node);
+
+			if (
+				ts.isBinaryExpression(unwrapped) &&
+				tsutils.isAssignmentKind(unwrapped.operatorToken.kind)
+			) {
+				context.report({
+					message: "noReturnAssign",
+					range: getTSNodeRange(unwrapped.operatorToken, context.sourceFile),
+				});
+			}
+		}
+
+		return {
+			visitors: {
+				ArrowFunction: (node) => {
+					if (!ts.isBlock(node.body)) {
+						checkForAssignment(node.body);
+					}
+				},
+				ReturnStatement: (node) => {
+					if (node.expression) {
+						checkForAssignment(node.expression);
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/sparseArrays.test.ts

@@ -0,0 +1,111 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./sparseArrays.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+const array = [1, , 3];
+`,
+			snapshot: `
+const array = [1, , 3];
+                  ~
+                  Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+`,
+		},
+		{
+			code: `
+const array = [, 2, 3];
+`,
+			snapshot: `
+const array = [, 2, 3];
+               ~
+               Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+`,
+		},
+		{
+			code: `
+const array = [1, , , 4];
+`,
+			snapshot: `
+const array = [1, , , 4];
+                  ~
+                  Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+                    ~
+                    Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+`,
+		},
+		{
+			code: `
+const nested = [[1, , 3], [4, 5, 6]];
+`,
+			snapshot: `
+const nested = [[1, , 3], [4, 5, 6]];
+                    ~
+                    Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+`,
+		},
+		{
+			code: `
+const result = [
+    1,
+    ,
+    3
+];
+`,
+			snapshot: `
+const result = [
+    1,
+    ,
+    ~
+    Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+    3
+];
+`,
+		},
+		{
+			code: `
+const matrix = [
+    [1, 2, 3],
+    [4, , 6],
+    [7, 8, 9]
+];
+`,
+			snapshot: `
+const matrix = [
+    [1, 2, 3],
+    [4, , 6],
+        ~
+        Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+    [7, 8, 9]
+];
+`,
+		},
+		{
+			code: `
+function getArray() {
+    return [1, , 3];
+}
+`,
+			snapshot: `
+function getArray() {
+    return [1, , 3];
+               ~
+               Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+}
+`,
+		},
+	],
+	valid: [
+		`const array = [1, 2, 3];`,
+		`const array = [];`,
+		`const array = [1];`,
+		`const array = [1, undefined, 3];`,
+		`const array = [undefined, 2, 3];`,
+		`const array = [1, 2, undefined];`,
+		`const array = [1, 2, 3,];`,
+		`const nested = [[1, undefined, 3], [4, 5, 6]];`,
+		`const matrix = [[1, 2, 3], [4, undefined, 6], [7, 8, 9]];`,
+		`const values = [null, undefined, 0, false, ""];`,
+	],
+});

package/src/rules/sparseArrays.ts

@@ -0,0 +1,61 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports array literals with holes (sparse arrays).",
+		id: "sparseArrays",
+		preset: "logical",
+	},
+	messages: {
+		noSparseArray: {
+			primary:
+				'Sparse arrays with "holes" (empty slots) are misleading and behave differently from `undefined` values.',
+			secondary: [
+				"Array methods treat holes inconsistently, which can lead to unexpected behavior and bugs.",
+				"Using explicit `undefined` values makes the intent clear and ensures consistent behavior.",
+			],
+			suggestions: [
+				"Replace holes with explicit `undefined` values.",
+				"Remove unintended commas if the holes are accidental.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				OmittedExpression: (node) => {
+					const parent = node.parent;
+					if (!ts.isArrayLiteralExpression(parent)) {
+						return;
+					}
+
+					const syntaxList = parent
+						.getChildren(context.sourceFile)
+						.find((child) => child.kind === ts.SyntaxKind.SyntaxList);
+
+					if (!syntaxList) {
+						return;
+					}
+
+					const children = syntaxList.getChildren(context.sourceFile);
+					const omittedIndex = children.indexOf(node);
+
+					for (let i = omittedIndex + 1; i < children.length; i++) {
+						if (children[i].kind === ts.SyntaxKind.CommaToken) {
+							context.report({
+								message: "noSparseArray",
+								range: {
+									begin: children[i].getStart(context.sourceFile),
+									end: children[i].getEnd(),
+								},
+							});
+							break;
+						}
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/symbolDescriptions.test.ts

@@ -0,0 +1,90 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./symbolDescriptions.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+const symbol = Symbol();
+`,
+			snapshot: `
+const symbol = Symbol();
+               ~~~~~~~~
+               Symbols without descriptions are more difficult to debug or reason about.
+`,
+		},
+		{
+			code: `
+const uniqueKey = Symbol();
+`,
+			snapshot: `
+const uniqueKey = Symbol();
+                  ~~~~~~~~
+                  Symbols without descriptions are more difficult to debug or reason about.
+`,
+		},
+		{
+			code: `
+const symbols = [Symbol(), Symbol()];
+`,
+			snapshot: `
+const symbols = [Symbol(), Symbol()];
+                 ~~~~~~~~
+                 Symbols without descriptions are more difficult to debug or reason about.
+                           ~~~~~~~~
+                           Symbols without descriptions are more difficult to debug or reason about.
+`,
+		},
+		{
+			code: `
+function createSymbol() {
+	return Symbol();
+}
+`,
+			snapshot: `
+function createSymbol() {
+	return Symbol();
+        ~~~~~~~~
+        Symbols without descriptions are more difficult to debug or reason about.
+}
+`,
+		},
+		{
+			code: `
+const obj = {
+	key: Symbol(),
+};
+`,
+			snapshot: `
+const obj = {
+	key: Symbol(),
+      ~~~~~~~~
+      Symbols without descriptions are more difficult to debug or reason about.
+};
+`,
+		},
+		{
+			code: `
+const value = condition ? Symbol() : null;
+`,
+			snapshot: `
+const value = condition ? Symbol() : null;
+                          ~~~~~~~~
+                          Symbols without descriptions are more difficult to debug or reason about.
+`,
+		},
+	],
+	valid: [
+		`const symbol = Symbol("description");`,
+		`const uniqueKey = Symbol("uniqueKey");`,
+		`const mySymbol = Symbol("my symbol");`,
+		`const symbols = [Symbol("first"), Symbol("second")];`,
+		`function createSymbol() { return Symbol("created"); }`,
+		`const obj = { key: Symbol("key") };`,
+		`const value = Symbol.for("global");`,
+		`const iterator = Symbol.iterator;`,
+		`const hasInstance = Symbol.hasInstance;`,
+		`const primitiveValue = Symbol.toPrimitive;`,
+		`Symbol("valid")`,
+	],
+});

package/src/rules/symbolDescriptions.ts

@@ -0,0 +1,47 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports Symbol() calls without description arguments.",
+		id: "symbolDescriptions",
+		preset: "stylistic",
+	},
+	messages: {
+		missingDescription: {
+			primary:
+				"Symbols without descriptions are more difficult to debug or reason about.",
+			secondary: [
+				"Creating a symbol without a description makes debugging difficult, as the symbol's purpose isn't clear when inspecting it.",
+				"While the description doesn't affect the symbol's uniqueness, it appears in the symbol's string representation and can be accessed via `Symbol.prototype.description`.",
+			],
+			suggestions: [
+				"Add a descriptive string argument to the Symbol constructor that explains the symbol's purpose.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				CallExpression: (node) => {
+					if (
+						!ts.isIdentifier(node.expression) ||
+						node.expression.text !== "Symbol" ||
+						node.arguments.length
+					) {
+						return;
+					}
+
+					context.report({
+						message: "missingDescription",
+						range: {
+							begin: node.getStart(context.sourceFile),
+							end: node.getEnd(),
+						},
+					});
+				},
+			},
+		};
+	},
+});

package/src/rules/unassignedVariables.test.ts

@@ -0,0 +1,73 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./unassignedVariables.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+let value;
+`,
+			snapshot: `
+let value;
+    ~~~~~
+    Variable 'value' is declared but never assigned a value.
+`,
+		},
+		{
+			code: `
+var variable;
+console.log(variable);
+`,
+			snapshot: `
+var variable;
+    ~~~~~~~~
+    Variable 'variable' is declared but never assigned a value.
+console.log(variable);
+`,
+		},
+		{
+			code: `
+let unassigned: number;
+console.log(unassigned);
+`,
+			snapshot: `
+let unassigned: number;
+    ~~~~~~~~~~
+    Variable 'unassigned' is declared but never assigned a value.
+console.log(unassigned);
+`,
+		},
+		{
+			code: `
+function example() {
+    let local;
+    return local;
+}
+`,
+			snapshot: `
+function example() {
+    let local;
+        ~~~~~
+        Variable 'local' is declared but never assigned a value.
+    return local;
+}
+`,
+		},
+	],
+	valid: [
+		`let assigned = 5;`,
+		`const constant = 10;`,
+		`var variable = "hello";`,
+		`let value: number = 42;`,
+		`let x; x = 5;`,
+		`let y; y = 10; console.log(y);`,
+		`var z; z += 1;`,
+		`let counter; counter++;`,
+		`let value; value--;`,
+		`for (let index = 0; index < 10; index++) {}`,
+		`for (let item; item < 10; item++) {}`,
+		`let result; result ||= "default";`,
+		`let data; data &&= "value";`,
+		`let nullish; nullish ??= "fallback";`,
+	],
+});

package/src/rules/unassignedVariables.ts

@@ -0,0 +1,69 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+import { getModifyingReferences } from "../utils/getModifyingReferences.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports variables that are declared but never assigned a value.",
+		id: "unassignedVariables",
+		preset: "untyped",
+	},
+	messages: {
+		noUnassigned: {
+			primary: "Variable '{{ name }}' is declared but never assigned a value.",
+			secondary: [
+				"Declaring a variable without ever assigning it a value means it will always be `undefined`.",
+				"This is often a mistake, such as forgetting to initialize the variable or assign to it later.",
+			],
+			suggestions: [
+				"Assign a value to the variable, either at declaration or before it is used.",
+				"If the variable is meant to be `undefined`, consider making that explicit for clarity.",
+			],
+		},
+	},
+	setup(context) {
+		function hasAssignments(
+			identifier: ts.Identifier,
+			sourceFile: ts.SourceFile,
+			typeChecker: ts.TypeChecker,
+		): boolean {
+			// TODO (#400): Switch to scope analysis
+			return !!getModifyingReferences(identifier, sourceFile, typeChecker)
+				.length;
+		}
+
+		return {
+			visitors: {
+				VariableDeclaration: (node) => {
+					if (node.initializer || !ts.isIdentifier(node.name)) {
+						return;
+					}
+
+					if (
+						ts.isVariableDeclarationList(node.parent) &&
+						!!(node.parent.flags & ts.NodeFlags.Const)
+					) {
+						return;
+					}
+
+					if (
+						!hasAssignments(node.name, context.sourceFile, context.typeChecker)
+					) {
+						context.report({
+							data: {
+								name: node.name.text,
+							},
+							message: "noUnassigned",
+							range: {
+								begin: node.name.getStart(context.sourceFile),
+								end: node.name.getEnd(),
+							},
+						});
+					}
+				},
+			},
+		};
+	},
+});