@flint.fyi/ts 0.14.2 → 0.14.3

package/src/rules/caseDeclarations.test.ts

@@ -0,0 +1,228 @@
+import rule from "./caseDeclarations.js";
+import { ruleTester } from "./ruleTester.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+switch (value) {
+    case 1:
+        let x = 1;
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        let x = 1;
+        ~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+        const x = 1;
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        const x = 1;
+        ~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+        function foo() {}
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        function foo() {}
+        ~~~~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+        class Foo {}
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        class Foo {}
+        ~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    default:
+        let x = 1;
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    default:
+        let x = 1;
+        ~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    default:
+        const x = 1;
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    default:
+        const x = 1;
+        ~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+        let x = 1;
+    case 2:
+        let y = 2;
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        let x = 1;
+        ~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+    case 2:
+        let y = 2;
+        ~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        break;
+}
+`,
+		},
+		{
+			code: `
+switch (value) {
+    case 1:
+        const x = 1;
+        console.log(x);
+        break;
+}
+`,
+			snapshot: `
+switch (value) {
+    case 1:
+        const x = 1;
+        ~~~~~
+        Variables declared in case clauses without braces leak into the surrounding scope.
+        console.log(x);
+        break;
+}
+`,
+		},
+	],
+	valid: [
+		`switch (value) { case 1: { let x = 1; break; } }`,
+		`switch (value) { case 1: { const x = 1; break; } }`,
+		`switch (value) { case 1: { function foo() {} break; } }`,
+		`switch (value) { case 1: { class Foo {} break; } }`,
+		`switch (value) { default: { let x = 1; break; } }`,
+		`switch (value) { default: { const x = 1; break; } }`,
+		`switch (value) { case 1: var x = 1; break; }`,
+		`switch (value) { case 1: break; }`,
+		`switch (value) { case 1: console.log("test"); break; }`,
+		`
+switch (value) {
+    case 1: {
+        let x = 1;
+        break;
+    }
+}
+`,
+		`
+switch (value) {
+    case 1: {
+        const x = 1;
+        break;
+    }
+}
+`,
+		`
+switch (value) {
+    case 1: {
+        function foo() {}
+        break;
+    }
+}
+`,
+		`
+switch (value) {
+    case 1: {
+        class Foo {}
+        break;
+    }
+}
+`,
+		`
+switch (value) {
+    case 1:
+        var x = 1;
+        break;
+}
+`,
+		`
+switch (value) {
+    case 1: {
+        let x = 1;
+    }
+    case 2: {
+        let y = 2;
+        break;
+    }
+}
+`,
+		`
+switch (value) {
+    default: {
+        let x = 1;
+        break;
+    }
+}
+`,
+	],
+});

package/src/rules/caseDeclarations.ts

@@ -0,0 +1,70 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports lexical declarations in case clauses without wrapping them in blocks.",
+		id: "caseDeclarations",
+		preset: "untyped",
+	},
+	messages: {
+		unexpectedLexicalDeclaration: {
+			primary:
+				"Variables declared in case clauses without braces leak into the surrounding scope.",
+			secondary: [
+				"Lexical declarations (let, const, function, class) are scoped to the entire switch statement, not just the case clause where they are declared.",
+				"This can lead to unexpected behavior when the same variable name is used in multiple case clauses, as they will conflict in the same scope.",
+			],
+			suggestions: [
+				"Wrap the case clause contents in curly braces {} to create a block scope.",
+			],
+		},
+	},
+	setup(context) {
+		function getLexicalDeclaration(
+			statements: ts.NodeArray<ts.Statement>,
+		): ts.Node | undefined {
+			for (const statement of statements) {
+				if (
+					ts.isVariableStatement(statement) &&
+					tsutils.isNodeFlagSet(
+						statement.declarationList,
+						ts.NodeFlags.Let | ts.NodeFlags.Const,
+					)
+				) {
+					return statement.declarationList.getChildAt(0, context.sourceFile);
+				}
+
+				if (
+					ts.isClassDeclaration(statement) ||
+					ts.isFunctionDeclaration(statement)
+				) {
+					return statement.getChildAt(0, context.sourceFile);
+				}
+			}
+
+			return undefined;
+		}
+
+		function checkClause(node: ts.CaseClause | ts.DefaultClause): void {
+			const declarationNode = getLexicalDeclaration(node.statements);
+			if (declarationNode) {
+				context.report({
+					message: "unexpectedLexicalDeclaration",
+					range: getTSNodeRange(declarationNode, context.sourceFile),
+				});
+			}
+		}
+
+		return {
+			visitors: {
+				CaseClause: checkClause,
+				DefaultClause: checkClause,
+			},
+		};
+	},
+});

package/src/rules/chainedAssignments.test.ts

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

package/src/rules/chainedAssignments.ts

@@ -0,0 +1,55 @@
+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)) {
+						return;
+					}
+
+					const parent = unwrapParenthesizedExpressionsParent(node);
+					if (ts.isBinaryExpression(parent)) {
+						return;
+					}
+
+					context.report({
+						message: "noChainedAssignment",
+						range: getTSNodeRange(node.operatorToken, context.sourceFile),
+					});
+				},
+			},
+		};
+	},
+});