@flint.fyi/ts 0.14.3 → 0.14.5

package/src/rules/elseIfDuplicates.test.ts

@@ -0,0 +1,177 @@
+import rule from "./elseIfDuplicates.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+if (isSomething(value)) {
+    doFirst();
+} else if (isSomething(value)) {
+    doSecond();
+}
+`,
+			snapshot: `
+if (isSomething(value)) {
+    doFirst();
+} else if (isSomething(value)) {
+           ~~~~~~~~~~~~~~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    doSecond();
+}
+`,
+		},
+		{
+			code: `
+if (isSomething /* ... */ (value)) {
+    doFirst();
+} else if (isSomething(value /* ... */)) {
+    doSecond();
+}
+`,
+			snapshot: `
+if (isSomething /* ... */ (value)) {
+    doFirst();
+} else if (isSomething(value /* ... */)) {
+           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    doSecond();
+}
+`,
+		},
+		{
+			code: `
+if (first) {
+    handleFirst();
+} else if (second) {
+    handleSecond();
+} else if (third && fourth) {
+    handleThird();
+} else if (third && fourth) {
+    handleFourth();
+}
+`,
+			snapshot: `
+if (first) {
+    handleFirst();
+} else if (second) {
+    handleSecond();
+} else if (third && fourth) {
+    handleThird();
+} else if (third && fourth) {
+           ~~~~~~~~~~~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    handleFourth();
+}
+`,
+		},
+		{
+			code: `
+if (count === 1) {
+    handleOne();
+} else if (count === 2) {
+    handleTwo();
+} else if (count === 3) {
+    handleThree();
+} else if (count === 2) {
+    handleFour();
+} else if (count === 5) {
+    handleFive();
+}
+`,
+			snapshot: `
+if (count === 1) {
+    handleOne();
+} else if (count === 2) {
+    handleTwo();
+} else if (count === 3) {
+    handleThree();
+} else if (count === 2) {
+           ~~~~~~~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    handleFour();
+} else if (count === 5) {
+    handleFive();
+}
+`,
+		},
+		{
+			code: `
+if (value === "first") {
+    process();
+} else if (value === "second") {
+    process();
+} else if (value === "first") {
+    process();
+}
+`,
+			snapshot: `
+if (value === "first") {
+    process();
+} else if (value === "second") {
+    process();
+} else if (value === "first") {
+           ~~~~~~~~~~~~~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    process();
+}
+`,
+		},
+		{
+			code: `
+if (isValid && isActive) {
+    execute();
+} else if (isPending) {
+    wait();
+} else if (isValid && isActive) {
+    execute();
+}
+`,
+			snapshot: `
+if (isValid && isActive) {
+    execute();
+} else if (isPending) {
+    wait();
+} else if (isValid && isActive) {
+           ~~~~~~~~~~~~~~~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    execute();
+}
+`,
+		},
+		{
+			code: `
+if (value) {
+    first();
+} else if (value) {
+    second();
+} else if (value) {
+    third();
+}
+`,
+			snapshot: `
+if (value) {
+    first();
+} else if (value) {
+           ~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    second();
+} else if (value) {
+           ~~~~~
+           This condition is identical to a previous condition in the if-else-if chain.
+    third();
+}
+`,
+		},
+	],
+	valid: [
+		`if (isSomething(value)) { doFirst(); } else if (isSomethingElse(value)) { doSecond(); }`,
+		`if (first) { handleFirst(); } else if (second) { handleSecond(); } else if (third && fourth) { handleThird(); } else if (third && fifth) { handleFourth(); }`,
+		`if (count === 1) { handleOne(); } else if (count === 2) { handleTwo(); } else if (count === 3) { handleThree(); } else if (count === 4) { handleFour(); }`,
+		`if (value === "first") { process(); } else if (value === "second") { process(); } else if (value === "third") { process(); }`,
+		`if (isValid) { execute(); } else if (isPending) { wait(); } else if (isInvalid) { reject(); }`,
+		`if (value) { process(); }`,
+		`if (first) { doFirst(); } else { doSecond(); }`,
+		`if (first) { doFirst(); } else if (second) { doSecond(); } else { doDefault(); }`,
+	],
+});

package/src/rules/elseIfDuplicates.ts

@@ -0,0 +1,69 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { hasSameTokens } from "../utils/hasSameTokens.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports duplicate conditions in if-else-if chains that make code unreachable.",
+		id: "elseIfDuplicates",
+		preset: "logical",
+	},
+	messages: {
+		duplicateCondition: {
+			primary:
+				"This condition is identical to a previous condition in the if-else-if chain.",
+			secondary: [
+				"When an if-else-if chain has duplicate conditions, the duplicate branch will never execute because the earlier identical condition will always be evaluated first.",
+				"This typically indicates a copy-paste error or logic mistake.",
+			],
+			suggestions: [
+				"Verify the condition logic is correct and update to check for the intended condition.",
+			],
+		},
+	},
+	setup(context) {
+		function checkIfStatement(node: ts.IfStatement) {
+			const seen: ts.Expression[] = [];
+			let current: ts.IfStatement = node;
+
+			while (true) {
+				if (
+					seen.some((previous) =>
+						hasSameTokens(previous, current.expression, context.sourceFile),
+					)
+				) {
+					context.report({
+						message: "duplicateCondition",
+						range: getTSNodeRange(current.expression, context.sourceFile),
+					});
+				}
+
+				if (
+					!current.elseStatement ||
+					!ts.isIfStatement(current.elseStatement)
+				) {
+					break;
+				}
+
+				seen.push(current.expression);
+				current = current.elseStatement;
+			}
+		}
+
+		return {
+			visitors: {
+				IfStatement: (node) => {
+					if (
+						!ts.isIfStatement(node.parent) ||
+						node.parent.elseStatement !== node
+					) {
+						checkIfStatement(node);
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/emptyBlocks.test.ts

@@ -0,0 +1,136 @@
+import rule from "./emptyBlocks.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+if (condition) {}
+`,
+			snapshot: `
+if (condition) {}
+               ~~
+               Empty block statements should be removed or contain code.
+`,
+		},
+		{
+			code: `
+if (condition) {
+} else {}
+`,
+			snapshot: `
+if (condition) {
+               ~
+               Empty block statements should be removed or contain code.
+} else {}
+~
+       ~~
+       Empty block statements should be removed or contain code.
+`,
+		},
+		{
+			code: `
+while (condition) {}
+`,
+			snapshot: `
+while (condition) {}
+                  ~~
+                  Empty block statements should be removed or contain code.
+`,
+		},
+		{
+			code: `
+for (let i = 0; i < 10; i++) {}
+`,
+			snapshot: `
+for (let i = 0; i < 10; i++) {}
+                             ~~
+                             Empty block statements should be removed or contain code.
+`,
+		},
+		{
+			code: `
+switch (value) {}
+`,
+			snapshot: `
+switch (value) {}
+               ~~
+               Empty block statements should be removed or contain code.
+`,
+		},
+		{
+			code: `
+do {} while (condition);
+`,
+			snapshot: `
+do {} while (condition);
+   ~~
+   Empty block statements should be removed or contain code.
+`,
+		},
+		{
+			code: `
+if (x) {
+    doSomething();
+} else if (y) {}
+`,
+			snapshot: `
+if (x) {
+    doSomething();
+} else if (y) {}
+              ~~
+              Empty block statements should be removed or contain code.
+`,
+		},
+		{
+			code: `
+try {
+    doSomething();
+} finally {}
+`,
+			snapshot: `
+try {
+    doSomething();
+} finally {}
+          ~~
+          Empty block statements should be removed or contain code.
+`,
+		},
+	],
+	valid: [
+		`if (condition) { doSomething(); }`,
+		`while (condition) { doSomething(); }`,
+		`for (let i = 0; i < 10; i++) { doSomething(); }`,
+		`switch (value) { case 1: break; }`,
+		`do { doSomething(); } while (condition);`,
+		`function test() {}`,
+		`const fn = function() {};`,
+		`const arrow = () => {};`,
+		`class MyClass { method() {} }`,
+		`class MyClass { constructor() {} }`,
+		`class MyClass { get value() {} }`,
+		`class MyClass { set value(v) {} }`,
+		`
+if (condition) {
+    // Intentionally empty
+}
+`,
+		`
+while (condition) {
+    /* Do nothing */
+}
+`,
+		`
+try {
+    doSomething();
+} catch (error) {}
+`,
+		`
+try {
+    doSomething();
+} catch (error) {
+    // Ignore errors
+}
+`,
+	],
+});

package/src/rules/emptyBlocks.ts

@@ -0,0 +1,73 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+
+const allowedParents = new Set([
+	ts.SyntaxKind.ArrowFunction,
+	ts.SyntaxKind.CatchClause,
+	ts.SyntaxKind.Constructor,
+	ts.SyntaxKind.FunctionDeclaration,
+	ts.SyntaxKind.FunctionExpression,
+	ts.SyntaxKind.GetAccessor,
+	ts.SyntaxKind.MethodDeclaration,
+	ts.SyntaxKind.SetAccessor,
+]);
+
+export default typescriptLanguage.createRule({
+	about: {
+		description: "Reports empty block statements that should contain code.",
+		id: "emptyBlocks",
+		preset: "stylistic",
+	},
+	messages: {
+		emptyBlock: {
+			primary: "Empty block statements should be removed or contain code.",
+			secondary: [
+				"Empty blocks can indicate incomplete code or areas where logic was removed but the block structure was left behind.",
+				"They can also reduce code readability by cluttering the codebase with unnecessary braces.",
+			],
+			suggestions: [
+				"Add a comment explaining why the block is intentionally empty, or remove the empty block entirely.",
+			],
+		},
+	},
+	setup(context) {
+		function hasComments(block: ts.Block): boolean {
+			const fullText = context.sourceFile.getFullText();
+
+			const openBrace = block.getStart(context.sourceFile);
+			const closeBrace = block.getEnd();
+			const innerText = fullText.substring(openBrace + 1, closeBrace - 1);
+
+			// Check if there are any non-whitespace characters (which would be comments)
+			// since we already know there are no statements
+			return /\S+/.test(innerText.trim());
+		}
+
+		function isEmptyBlock(block: ts.Block): boolean {
+			return block.statements.length === 0 && !hasComments(block);
+		}
+
+		return {
+			visitors: {
+				Block: (node) => {
+					if (!allowedParents.has(node.parent.kind) && isEmptyBlock(node)) {
+						context.report({
+							message: "emptyBlock",
+							range: getTSNodeRange(node, context.sourceFile),
+						});
+					}
+				},
+				CaseBlock: (node) => {
+					if (node.clauses.length === 0) {
+						context.report({
+							message: "emptyBlock",
+							range: getTSNodeRange(node, context.sourceFile),
+						});
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/forDirections.test.ts

@@ -0,0 +1,100 @@
+import rule from "./forDirections.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+for (let i = 0; i < 10; i--) {}
+`,
+			snapshot: `
+for (let i = 0; i < 10; i--) {}
+                        ~~~
+                        The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 0; index < 10; index--) {}
+`,
+			snapshot: `
+for (let index = 0; index < 10; index--) {}
+                                ~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 10; index >= 0; index++) {}
+`,
+			snapshot: `
+for (let index = 10; index >= 0; index++) {}
+                                 ~~~~~~~
+                                 The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 0; index > 10; index++) {}
+`,
+			snapshot: `
+for (let index = 0; index > 10; index++) {}
+                                ~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 0; 10 > index; index--) {}
+`,
+			snapshot: `
+for (let index = 0; 10 > index; index--) {}
+                                ~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 0; index < 10; index -= 1) {}
+`,
+			snapshot: `
+for (let index = 0; index < 10; index -= 1) {}
+                                ~~~~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 10; index > 0; index += 1) {}
+`,
+			snapshot: `
+for (let index = 10; index > 0; index += 1) {}
+                                ~~~~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+for (let index = 0; index < 10; index += -1) {}
+`,
+			snapshot: `
+for (let index = 0; index < 10; index += -1) {}
+                                ~~~~~~~~~~~
+                                The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+	],
+	valid: [
+		`for (let i = 0; i < 10; i++) { }`,
+		`for (let index = 0; index < 10; index++) { }`,
+		`for (let index = 10; index >= 0; index--) { }`,
+		`for (let index = 0; 10 > index; index++) { }`,
+		`for (let index = 10; 0 < index; index--) { }`,
+		`for (let index = 10; index >= 0; index += step) { }`,
+		`for (let index = 0; index <= 10; index -= 0) { }`,
+		`for (let index = 0; index < 10; index += 1) { }`,
+		`for (let index = 10; index > 0; index -= 1) { }`,
+		`for (let index = 0; index < 10; index += 2) { }`,
+		`for (let index = 10; index > 0; index -= 2) { }`,
+	],
+});

package/src/rules/forDirections.ts

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