@flint.fyi/ts 0.14.5 → 0.15.0

package/src/rules/elseIfDuplicates.test.ts

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

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

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

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

@@ -1,187 +0,0 @@
-import rule from "./emptyDestructures.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-const {} = object;
-`,
-			snapshot: `
-const {} = object;
-      ~~
-      Destructuring patterns that don't extract at least one value are unnecessary.
-`,
-		},
-		{
-			code: `
-const [] = array;
-`,
-			snapshot: `
-const [] = array;
-      ~~
-      Destructuring patterns that don't extract at least one value are unnecessary.
-`,
-		},
-		{
-			code: `
-function process({}) {
-    console.log("processed");
-}
-`,
-			snapshot: `
-function process({}) {
-                 ~~
-                 Destructuring patterns that don't extract at least one value are unnecessary.
-    console.log("processed");
-}
-`,
-		},
-		{
-			code: `
-function process([]) {
-    console.log("processed");
-}
-`,
-			snapshot: `
-function process([]) {
-                 ~~
-                 Destructuring patterns that don't extract at least one value are unnecessary.
-    console.log("processed");
-}
-`,
-		},
-		{
-			code: `
-const process = ({}) => {
-    console.log("processed");
-};
-`,
-			snapshot: `
-const process = ({}) => {
-                 ~~
-                 Destructuring patterns that don't extract at least one value are unnecessary.
-    console.log("processed");
-};
-`,
-		},
-		{
-			code: `
-const process = ([]) => {
-    console.log("processed");
-};
-`,
-			snapshot: `
-const process = ([]) => {
-                 ~~
-                 Destructuring patterns that don't extract at least one value are unnecessary.
-    console.log("processed");
-};
-`,
-		},
-		{
-			code: `
-const { prop: {} } = object;
-`,
-			snapshot: `
-const { prop: {} } = object;
-              ~~
-              Destructuring patterns that don't extract at least one value are unnecessary.
-`,
-		},
-		{
-			code: `
-const { prop: [] } = object;
-`,
-			snapshot: `
-const { prop: [] } = object;
-              ~~
-              Destructuring patterns that don't extract at least one value are unnecessary.
-`,
-		},
-		{
-			code: `
-for (const {} of objects) {
-    console.log("iterating");
-}
-`,
-			snapshot: `
-for (const {} of objects) {
-           ~~
-           Destructuring patterns that don't extract at least one value are unnecessary.
-    console.log("iterating");
-}
-`,
-		},
-		{
-			code: `
-for (const [] of arrays) {
-    console.log("iterating");
-}
-`,
-			snapshot: `
-for (const [] of arrays) {
-           ~~
-           Destructuring patterns that don't extract at least one value are unnecessary.
-    console.log("iterating");
-}
-`,
-		},
-		{
-			code: `
-try {
-    doSomething();
-} catch ({}) {
-    console.log("error");
-}
-`,
-			snapshot: `
-try {
-    doSomething();
-} catch ({}) {
-         ~~
-         Destructuring patterns that don't extract at least one value are unnecessary.
-    console.log("error");
-}
-`,
-		},
-		{
-			code: `
-try {
-    doSomething();
-} catch ([]) {
-    console.log("error");
-}
-`,
-			snapshot: `
-try {
-    doSomething();
-} catch ([]) {
-         ~~
-         Destructuring patterns that don't extract at least one value are unnecessary.
-    console.log("error");
-}
-`,
-		},
-	],
-	valid: [
-		`const { a } = object;`,
-		`const { a, b } = object;`,
-		`const [ a ] = array;`,
-		`const [ a, b ] = array;`,
-		`function process({ a }) { console.log(a); }`,
-		`function process([ a ]) { console.log(a); }`,
-		`const process = ({ a }) => console.log(a);`,
-		`const process = ([ a ]) => console.log(a);`,
-		`const { prop: { nested } } = object;`,
-		`const { prop: [ element ] } = object;`,
-		`for (const { value } of objects) { console.log(value); }`,
-		`for (const [ value ] of arrays) { console.log(value); }`,
-		`try { doSomething(); } catch ({ message }) { console.log(message); }`,
-		`try { doSomething(); } catch ([ first ]) { console.log(first); }`,
-		`const object = {};`,
-		`const array = [];`,
-		`function returnEmpty() { return {}; }`,
-		`function returnEmptyArray() { return []; }`,
-	],
-});

package/src/rules/emptyDestructures.ts

@@ -1,48 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports using empty destructuring patterns that destructure no values.",
-		id: "emptyDestructures",
-		preset: "logical",
-	},
-	messages: {
-		emptyPattern: {
-			primary:
-				"Destructuring patterns that don't extract at least one value are unnecessary.",
-			secondary: [
-				"Empty destructuring patterns like `{}` or `[]` don't extract any values and serve no practical purpose.",
-				"These patterns are likely mistakes or leftover code from refactoring.",
-			],
-			suggestions: [
-				"Remove the empty destructuring pattern if it's not needed.",
-				"Add bindings to extract values if you intended to destructure specific properties.",
-			],
-		},
-	},
-	setup(context) {
-		function checkBindingPattern(
-			node: ts.ArrayBindingPattern | ts.ObjectBindingPattern,
-		) {
-			if (node.elements.length === 0) {
-				context.report({
-					message: "emptyPattern",
-					range: {
-						begin: node.getStart(context.sourceFile),
-						end: node.getEnd(),
-					},
-				});
-			}
-		}
-
-		return {
-			visitors: {
-				ArrayBindingPattern: checkBindingPattern,
-				ObjectBindingPattern: checkBindingPattern,
-			},
-		};
-	},
-});