@flint.fyi/ts 0.14.2 → 0.14.4

package/src/rules/defaultCaseLast.test.ts

@@ -0,0 +1,196 @@
+import rule from "./defaultCaseLast.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+switch (value) {
+    default:
+        break;
+    case 1:
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    default:
+    ~~~~~~~
+    Default clauses in switch statements should be last.
+        break;
+    case 1:
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+        break;
+    default:
+        break;
+    case 2:
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        break;
+    default:
+    ~~~~~~~
+    Default clauses in switch statements should be last.
+        break;
+    case 2:
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+    case 2:
+        break;
+    default:
+        break;
+    case 3:
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+    case 2:
+        break;
+    default:
+    ~~~~~~~
+    Default clauses in switch statements should be last.
+        break;
+    case 3:
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    default:
+        console.log("default");
+        break;
+    case 1:
+        console.log("one");
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    default:
+    ~~~~~~~
+    Default clauses in switch statements should be last.
+        console.log("default");
+        break;
+    case 1:
+        console.log("one");
+        break;
+}
+`,
+		},
+		{
+			code: `
+const result = (value: number) => {
+    switch (value) {
+        case 1:
+            return "one";
+        default:
+            return "default";
+        case 2:
+            return "two";
+    }
+};
+`,
+			snapshot: `
+const result = (value: number) => {
+    switch (value) {
+        case 1:
+            return "one";
+        default:
+        ~~~~~~~
+        Default clauses in switch statements should be last.
+            return "default";
+        case 2:
+            return "two";
+    }
+};
+`,
+		},
+		{
+			code: `
+switch (value) {
+    default:
+    case 1:
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    default:
+    ~~~~~~~
+    Default clauses in switch statements should be last.
+    case 1:
+        break;
+}
+`,
+		},
+	],
+	valid: [
+		`switch (value) { case 1: break; default: break; }`,
+		`switch (value) { case 1: break; case 2: break; default: break; }`,
+		`switch (value) { case 1: break; case 2: break; }`,
+		`switch (value) { default: break; }`,
+		`switch (value) { case 1: case 2: break; default: break; }`,
+		`
+switch (value) {
+    case 1:
+        break;
+    default:
+        break;
+}
+`,
+		`
+switch (value) {
+    case 1:
+        console.log("one");
+        break;
+    case 2:
+        console.log("two");
+        break;
+    default:
+        console.log("default");
+        break;
+}
+`,
+		`
+const result = (value: number) => {
+    switch (value) {
+        case 1:
+            return "one";
+        case 2:
+            return "two";
+        default:
+            return "default";
+    }
+};
+`,
+		`
+switch (value) {
+    case 1:
+    case 2:
+        break;
+    default:
+        break;
+}
+`,
+	],
+});

package/src/rules/defaultCaseLast.ts

@@ -0,0 +1,54 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports switch statements where the default clause is not last.",
+		id: "defaultCaseLast",
+		preset: "logical",
+	},
+	messages: {
+		defaultCaseShouldBeLast: {
+			primary: "Default clauses in switch statements should be last.",
+			secondary: [
+				"Placing the default clause in a position other than last can lead to confusion and unexpected behavior.",
+				"While the default clause is executed when no case matches, having it in the middle of other cases makes the control flow harder to follow.",
+			],
+			suggestions: [
+				"Move the default clause to the end of the switch statement to improve code clarity.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				SwitchStatement: (node) => {
+					const clauses = node.caseBlock.clauses;
+					const defaultClauseIndex = clauses.findIndex(
+						(clause) => clause.kind === ts.SyntaxKind.DefaultClause,
+					);
+
+					if (
+						defaultClauseIndex === -1 ||
+						defaultClauseIndex === clauses.length - 1
+					) {
+						return;
+					}
+
+					const defaultClause = clauses[defaultClauseIndex];
+
+					context.report({
+						message: "defaultCaseShouldBeLast",
+						range: {
+							begin: defaultClause.getStart(context.sourceFile),
+							end:
+								defaultClause.getStart(context.sourceFile) + "default".length,
+						},
+					});
+				},
+			},
+		};
+	},
+});

package/src/rules/duplicateArguments.test.ts

@@ -0,0 +1,140 @@
+import rule from "./duplicateArguments.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+function test(value, value) {
+    return value;
+}
+`,
+			snapshot: `
+function test(value, value) {
+                     ~~~~~
+                     This parameter overrides the previous parameter of the same name.
+    return value;
+}
+`,
+		},
+		{
+			code: `
+function test(first, second, first) {
+    return first + second;
+}
+`,
+			snapshot: `
+function test(first, second, first) {
+                             ~~~~~
+                             This parameter overrides the previous parameter of the same name.
+    return first + second;
+}
+`,
+		},
+		{
+			code: `
+const arrow = (value, value) => value;
+`,
+			snapshot: `
+const arrow = (value, value) => value;
+                      ~~~~~
+                      This parameter overrides the previous parameter of the same name.
+`,
+		},
+		{
+			code: `
+const func = function (value, value) {
+    return value;
+};
+`,
+			snapshot: `
+const func = function (value, value) {
+                              ~~~~~
+                              This parameter overrides the previous parameter of the same name.
+    return value;
+};
+`,
+		},
+		{
+			code: `
+class Example {
+    method(value, value) {
+        return value;
+    }
+}
+`,
+			snapshot: `
+class Example {
+    method(value, value) {
+                  ~~~~~
+                  This parameter overrides the previous parameter of the same name.
+        return value;
+    }
+}
+`,
+		},
+		{
+			code: `
+class Example {
+    constructor(value, value) {
+        this.value = value;
+    }
+}
+`,
+			snapshot: `
+class Example {
+    constructor(value, value) {
+                       ~~~~~
+                       This parameter overrides the previous parameter of the same name.
+        this.value = value;
+    }
+}
+`,
+		},
+		{
+			code: `
+function test(first, second, third, second) {
+    return first + second + third;
+}
+`,
+			snapshot: `
+function test(first, second, third, second) {
+                                    ~~~~~~
+                                    This parameter overrides the previous parameter of the same name.
+    return first + second + third;
+}
+`,
+		},
+		{
+			code: `
+function test(value, value, value) {
+    return value;
+}
+`,
+			snapshot: `
+function test(value, value, value) {
+                     ~~~~~
+                     This parameter overrides the previous parameter of the same name.
+                            ~~~~~
+                            This parameter overrides the previous parameter of the same name.
+    return value;
+}
+`,
+		},
+	],
+	valid: [
+		`function test(value) { return value; }`,
+		`function test(first, second) { return first + second; }`,
+		`const arrow = (value) => value;`,
+		`const arrow = (first, second) => first + second;`,
+		`const func = function (value) { return value; };`,
+		`const func = function (first, second) { return first + second; };`,
+		`class Example { method(value) { return value; } }`,
+		`class Example { method(first, second) { return first + second; } }`,
+		`class Example { constructor(value) { this.value = value; } }`,
+		`class Example { constructor(first, second) { this.first = first; this.second = second; } }`,
+		`function test({ value }) { return value; }`,
+		`function test({ first, second }) { return first + second; }`,
+		`function test([first, second]) { return first + second; }`,
+	],
+});

package/src/rules/duplicateArguments.ts

@@ -0,0 +1,58 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports functions with duplicate parameter names in their signatures.",
+		id: "duplicateArguments",
+		preset: "untyped",
+	},
+	messages: {
+		duplicateParam: {
+			primary:
+				"This parameter overrides the previous parameter of the same name.",
+			secondary: [
+				"Duplicate parameter names in functions can lead to unexpected behavior and make code harder to understand.",
+				"In strict mode, duplicate parameter names are a syntax error.",
+				"Even in non-strict mode, only the last parameter with a given name is accessible.",
+			],
+			suggestions: ["Rename one of the duplicate parameters to a unique name."],
+		},
+	},
+	setup(context) {
+		function checkNode({ parameters }: ts.FunctionLikeDeclaration) {
+			const seenNames = new Set<string>();
+
+			for (const parameter of parameters) {
+				if (!ts.isIdentifier(parameter.name)) {
+					continue;
+				}
+
+				const parameterName = parameter.name.text;
+				const existingParameter = seenNames.has(parameterName);
+
+				if (existingParameter) {
+					context.report({
+						message: "duplicateParam",
+						range: getTSNodeRange(parameter.name, context.sourceFile),
+					});
+				} else {
+					seenNames.add(parameterName);
+				}
+			}
+		}
+
+		return {
+			visitors: {
+				ArrowFunction: checkNode,
+				Constructor: checkNode,
+				FunctionDeclaration: checkNode,
+				FunctionExpression: checkNode,
+				MethodDeclaration: checkNode,
+			},
+		};
+	},
+});

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