@flint.fyi/ts 0.14.6 → 0.15.0

package/src/rules/caseDuplicates.test.ts

@@ -1,308 +0,0 @@
-import rule from "./caseDuplicates.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-switch (value) {
-    case 1:
-        break;
-    case 1:
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    case 1:
-        break;
-    case 1:
-    ~~~~~~
-    This case duplicates a previous case, so it will never be reached.
-        break;
-}
-`,
-		},
-		{
-			code: `
-switch (value) {
-    case "a":
-        break;
-    case "b":
-        break;
-    case "a":
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    case "a":
-        break;
-    case "b":
-        break;
-    case "a":
-    ~~~~~~~~
-    This case duplicates a previous case, so it will never be reached.
-        break;
-}
-`,
-		},
-		{
-			code: `
-switch (value) {
-    case x + 1:
-        break;
-    case x + 1:
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    case x + 1:
-        break;
-    case x + 1:
-    ~~~~~~~~~~
-    This case duplicates a previous case, so it will never be reached.
-        break;
-}
-`,
-		},
-		{
-			code: `
-switch (value) {
-    case 1:
-        break;
-    case 2:
-        break;
-    case 1:
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    case 1:
-        break;
-    case 2:
-        break;
-    case 1:
-    ~~~~~~
-    This case duplicates a previous case, so it will never be reached.
-        break;
-}
-`,
-		},
-		{
-			code: `
-switch (value) {
-    case true:
-        break;
-    case false:
-        break;
-    case true:
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    case true:
-        break;
-    case false:
-        break;
-    case true:
-    ~~~~~~~~~
-    This case duplicates a previous case, so it will never be reached.
-        break;
-}
-`,
-		},
-		{
-			code: `
-switch (value) {
-    case obj.property:
-        break;
-    case obj.property:
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    case obj.property:
-        break;
-    case obj.property:
-    ~~~~~~~~~~~~~~~~~
-    This case duplicates a previous case, so it will never be reached.
-        break;
-}
-`,
-		},
-		{
-			code: `
-const result = (input: number) => {
-    switch (input) {
-        case 1:
-            return "one";
-        case 2:
-            return "two";
-        case 1:
-            return "duplicate";
-    }
-};
-`,
-			snapshot: `
-const result = (input: number) => {
-    switch (input) {
-        case 1:
-            return "one";
-        case 2:
-            return "two";
-        case 1:
-        ~~~~~~
-        This case duplicates a previous case, so it will never be reached.
-            return "duplicate";
-    }
-};
-`,
-		},
-		{
-			code: `
-switch (value) {
-    case 1: case 1: break;
-}
-`,
-			snapshot: `
-switch (value) {
-    case 1: case 1: break;
-            ~~~~~~
-            This case duplicates a previous case, so it will never be reached.
-}
-`,
-		},
-		{
-			code: `
-const condition = true;
-switch (value) {
-    case condition ? "a" : "b":
-        break;
-    case condition ? "a" : "b":
-        break;
-}
-`,
-			snapshot: `
-const condition = true;
-switch (value) {
-    case condition ? "a" : "b":
-        break;
-    case condition ? "a" : "b":
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~
-    This case duplicates a previous case, so it will never be reached.
-        break;
-}
-`,
-		},
-		{
-			code: `
-switch (value) {
-    case /* comment */ 1:
-        break;
-    case 1:
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    case /* comment */ 1:
-        break;
-    case 1:
-    ~~~~~~
-    This case duplicates a previous case, so it will never be reached.
-        break;
-}
-`,
-		},
-		{
-			code: `
-switch (value) {
-    case obj.property:
-        break;
-    case obj /* comment */ .property:
-        break;
-}
-`,
-			snapshot: `
-switch (value) {
-    case obj.property:
-        break;
-    case obj /* comment */ .property:
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    This case duplicates a previous case, so it will never be reached.
-        break;
-}
-`,
-		},
-	],
-	valid: [
-		`switch (value) { case 1: break; case 2: break; }`,
-		`switch (value) { case 1: break; case 2: break; case 3: break; }`,
-		`switch (value) { case "a": break; case "b": break; }`,
-		`switch (value) { case true: break; case false: break; }`,
-		`switch (value) { case 1: case 2: break; }`,
-		`switch (value) { default: break; }`,
-		`
-switch (value) {
-    case 1:
-        break;
-    case 2:
-        break;
-}
-`,
-		`
-switch (value) {
-    case x:
-        break;
-    case y:
-        break;
-}
-`,
-		`
-switch (value) {
-    case obj.a:
-        break;
-    case obj.b:
-        break;
-}
-`,
-		`
-switch (value) {
-    case 1:
-        console.log("one");
-        break;
-    case 2:
-        console.log("two");
-        break;
-    default:
-        console.log("default");
-        break;
-}
-`,
-		`
-switch (value) {
-    case x + 1:
-        break;
-    case x + 2:
-        break;
-}
-`,
-		`
-const result = (input: number) => {
-    switch (input) {
-        case 1:
-            return "one";
-        case 2:
-            return "two";
-        default:
-            return "unknown";
-    }
-};
-`,
-	],
-});

package/src/rules/caseDuplicates.ts

@@ -1,57 +0,0 @@
-import * as ts from "typescript";
-
-import { typescriptLanguage } from "../language.js";
-import { hasSameTokens } from "../utils/hasSameTokens.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports switch statements with duplicate case clause test expressions.",
-		id: "caseDuplicates",
-		preset: "logical",
-	},
-	messages: {
-		duplicateCase: {
-			primary:
-				"This case duplicates a previous case, so it will never be reached.",
-			secondary: [
-				"Having duplicate case clauses in a switch statement is a logic error.",
-				"The second case clause will never be reached because the first matching case will always execute first.",
-			],
-			suggestions: [
-				"Remove the duplicate case clause or modify its test expression to be unique.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				SwitchStatement: (node) => {
-					const seenCases: ts.Expression[] = [];
-
-					for (const clause of node.caseBlock.clauses) {
-						if (!ts.isCaseClause(clause)) {
-							continue;
-						}
-
-						const isDuplicate = seenCases.some((seenCase) =>
-							hasSameTokens(seenCase, clause.expression, context.sourceFile),
-						);
-
-						if (isDuplicate) {
-							context.report({
-								message: "duplicateCase",
-								range: {
-									begin: clause.getStart(context.sourceFile),
-									end: clause.expression.getEnd(),
-								},
-							});
-						} else {
-							seenCases.push(clause.expression);
-						}
-					}
-				},
-			},
-		};
-	},
-});

package/src/rules/chainedAssignments.test.ts

@@ -1,263 +0,0 @@
-import rule from "./chainedAssignments.js";
-import { ruleTester } from "./ruleTester.js";
-
-ruleTester.describe(rule, {
-	invalid: [
-		{
-			code: `
-let first;
-let second;
-first = second = 1;
-`,
-			snapshot: `
-let first;
-let second;
-first = second = 1;
-      ~
-      Prefer separate assignment statements for readability instead of chaining assignments.
-`,
-		},
-		{
-			code: `
-let first;
-let second;
-let third;
-first = second = third = 0;
-`,
-			snapshot: `
-let first;
-let second;
-let third;
-first = second = third = 0;
-      ~
-      Prefer separate assignment statements for readability instead of chaining assignments.
-`,
-		},
-		{
-			code: `
-let value;
-let another;
-value = another = getValue();
-`,
-			snapshot: `
-let value;
-let another;
-value = another = getValue();
-      ~
-      Prefer separate assignment statements for readability instead of chaining assignments.
-`,
-		},
-		{
-			code: `
-let first;
-let second;
-(first = second = 1);
-`,
-			snapshot: `
-let first;
-let second;
-(first = second = 1);
-       ~
-       Prefer separate assignment statements for readability instead of chaining assignments.
-`,
-		},
-		{
-			code: `
-const calculate = (value: number) => {
-    let first;
-    let second;
-    first = second = value;
-    return first + second;
-};
-`,
-			snapshot: `
-const calculate = (value: number) => {
-    let first;
-    let second;
-    first = second = value;
-          ~
-          Prefer separate assignment statements for readability instead of chaining assignments.
-    return first + second;
-};
-`,
-		},
-		{
-			code: `
-let first;
-let second;
-if (true) {
-    first = second = 10;
-}
-`,
-			snapshot: `
-let first;
-let second;
-if (true) {
-    first = second = 10;
-          ~
-          Prefer separate assignment statements for readability instead of chaining assignments.
-}
-`,
-		},
-		{
-			code: `
-class MyClass {
-    method() {
-        let first;
-        let second;
-        first = second = 0;
-    }
-}
-`,
-			snapshot: `
-class MyClass {
-    method() {
-        let first;
-        let second;
-        first = second = 0;
-              ~
-              Prefer separate assignment statements for readability instead of chaining assignments.
-    }
-}
-`,
-		},
-		{
-			code: `
-let first;
-let second;
-let third;
-first = (second = third = 5);
-`,
-			snapshot: `
-let first;
-let second;
-let third;
-first = (second = third = 5);
-      ~
-      Prefer separate assignment statements for readability instead of chaining assignments.
-`,
-		},
-		{
-			code: `
-let first;
-let second;
-first ||= second ||= 1;
-`,
-			snapshot: `
-let first;
-let second;
-first ||= second ||= 1;
-      ~~~
-      Prefer separate assignment statements for readability instead of chaining assignments.
-`,
-		},
-		{
-			code: `
-let first;
-let second;
-first ??= second ??= 0;
-`,
-			snapshot: `
-let first;
-let second;
-first ??= second ??= 0;
-      ~~~
-      Prefer separate assignment statements for readability instead of chaining assignments.
-`,
-		},
-		{
-			code: `
-let first;
-let second;
-first += second += 5;
-`,
-			snapshot: `
-let first;
-let second;
-first += second += 5;
-      ~~
-      Prefer separate assignment statements for readability instead of chaining assignments.
-`,
-		},
-		{
-			code: `
-let first;
-let second;
-first |= second |= 3;
-`,
-			snapshot: `
-let first;
-let second;
-first |= second |= 3;
-      ~~
-      Prefer separate assignment statements for readability instead of chaining assignments.
-`,
-		},
-	],
-	valid: [
-		`let first = 1;`,
-		`let first = 1, second = 2;`,
-		`let first = 1; let second = 2;`,
-		`let first; let second; first = 1; second = 2;`,
-		`let first; let second; first = 1; second = first;`,
-		`const value = getValue();`,
-		`let first; first = 1;`,
-		`
-let first;
-let second;
-first = 1;
-second = 2;
-`,
-		`
-let first;
-let second;
-let third;
-first = 1;
-second = 2;
-third = 3;
-`,
-		`
-const calculate = (value: number) => {
-    let first;
-    let second;
-    first = value;
-    second = value;
-    return first + second;
-};
-`,
-		`
-class MyClass {
-    method() {
-        let first;
-        let second;
-        first = 0;
-        second = 0;
-    }
-}
-`,
-		`
-let result = "";
-result += "a" + "b";
-`,
-		`
-let result = 0;
-result += 1 + 2;
-`,
-		`
-let result = 0;
-result += 1 * 2;
-`,
-		`
-let result = 0;
-result += 1 - 2;
-`,
-		`
-let result = 0;
-result += 1 / 2;
-`,
-		`
-let result = 0;
-result += 1 ** 2;
-`,
-	],
-});

package/src/rules/chainedAssignments.ts

@@ -1,58 +0,0 @@
-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";
-import { unwrapParenthesizedExpressionsParent } from "../utils/unwrapParentParenthesizedExpressions.js";
-
-export default typescriptLanguage.createRule({
-	about: {
-		description:
-			"Reports using chained assignment expressions (e.g., a = b = c).",
-		id: "chainedAssignments",
-		preset: "stylistic",
-	},
-	messages: {
-		noChainedAssignment: {
-			primary:
-				"Prefer separate assignment statements for readability instead of chaining assignments.",
-			secondary: [
-				"Chained assignments can be hard to read and can lead to unexpected behavior with variable scoping and type inference.",
-				"Each assignment creates a reference to the same value, which may cause confusion when dealing with mutable values.",
-			],
-			suggestions: [
-				"Break the chained assignment into separate assignment statements, one for each variable.",
-			],
-		},
-	},
-	setup(context) {
-		return {
-			visitors: {
-				BinaryExpression: (node) => {
-					if (!tsutils.isAssignmentKind(node.operatorToken.kind)) {
-						return;
-					}
-
-					const rightSide = unwrapParenthesizedExpression(node.right);
-					if (
-						!ts.isBinaryExpression(rightSide) ||
-						!tsutils.isAssignmentKind(rightSide.operatorToken.kind)
-					) {
-						return;
-					}
-
-					const parent = unwrapParenthesizedExpressionsParent(node);
-					if (ts.isBinaryExpression(parent)) {
-						return;
-					}
-
-					context.report({
-						message: "noChainedAssignment",
-						range: getTSNodeRange(node.operatorToken, context.sourceFile),
-					});
-				},
-			},
-		};
-	},
-});