@flint.fyi/ts 0.14.4 → 0.14.5

package/src/plugin.ts

@@ -13,6 +13,7 @@ import debuggerStatements from "./rules/debuggerStatements.js";
 import defaultCaseLast from "./rules/defaultCaseLast.js";
 import duplicateArguments from "./rules/duplicateArguments.js";
 import elseIfDuplicates from "./rules/elseIfDuplicates.js";
+import emptyBlocks from "./rules/emptyBlocks.js";
 import emptyDestructures from "./rules/emptyDestructures.js";
 import emptyStaticBlocks from "./rules/emptyStaticBlocks.js";
 import exceptionAssignments from "./rules/exceptionAssignments.js";
@@ -36,13 +37,16 @@ import returnAssignments from "./rules/returnAssignments.js";
 import selfAssignments from "./rules/selfAssignments.js";
 import selfComparisons from "./rules/selfComparisons.js";
 import sequences from "./rules/sequences.js";
+import shadowedRestrictedNames from "./rules/shadowedRestrictedNames.js";
 import sparseArrays from "./rules/sparseArrays.js";
 import symbolDescriptions from "./rules/symbolDescriptions.js";
 import typeofComparisons from "./rules/typeofComparisons.js";
 import unassignedVariables from "./rules/unassignedVariables.js";
 import undefinedVariables from "./rules/undefinedVariables.js";
 import unicodeBOMs from "./rules/unicodeBOMs.js";
+import unnecessaryBlocks from "./rules/unnecessaryBlocks.js";
 import unnecessaryCatches from "./rules/unnecessaryCatches.js";
+import unnecessaryConcatenation from "./rules/unnecessaryConcatenation.js";
 import unsafeNegations from "./rules/unsafeNegations.js";
 import variableDeletions from "./rules/variableDeletions.js";
 import voidOperator from "./rules/voidOperator.js";
@@ -66,6 +70,7 @@ export const ts = createPlugin({
 		defaultCaseLast,
 		duplicateArguments,
 		elseIfDuplicates,
+		emptyBlocks,
 		emptyDestructures,
 		emptyStaticBlocks,
 		exceptionAssignments,
@@ -89,13 +94,16 @@ export const ts = createPlugin({
 		selfAssignments,
 		selfComparisons,
 		sequences,
+		shadowedRestrictedNames,
 		sparseArrays,
 		symbolDescriptions,
 		typeofComparisons,
 		unassignedVariables,
 		undefinedVariables,
 		unicodeBOMs,
+		unnecessaryBlocks,
 		unnecessaryCatches,
+		unnecessaryConcatenation,
 		unsafeNegations,
 		variableDeletions,
 		voidOperator,

package/src/rules/chainedAssignments.test.ts

@@ -234,6 +234,30 @@ class MyClass {
         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

@@ -35,7 +35,10 @@ export default typescriptLanguage.createRule({
 					}
 
 					const rightSide = unwrapParenthesizedExpression(node.right);
-					if (!ts.isBinaryExpression(rightSide)) {
+					if (
+						!ts.isBinaryExpression(rightSide) ||
+						!tsutils.isAssignmentKind(rightSide.operatorToken.kind)
+					) {
 						return;
 					}
 

package/src/rules/debuggerStatements.test.ts

@@ -30,8 +30,8 @@ function test() {
 			snapshot: `
 function test() {
 	debugger;
- ~~~~~~~~~
- Debugger statements should not be used in production code.
+	~~~~~~~~~
+	Debugger statements should not be used in production code.
 }
 `,
 			suggestions: [
@@ -54,8 +54,8 @@ if (condition) {
 			snapshot: `
 if (condition) {
 	debugger;
- ~~~~~~~~~
- Debugger statements should not be used in production code.
+	~~~~~~~~~
+	Debugger statements should not be used in production code.
 }
 `,
 			suggestions: [

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/octalNumbers.test.ts

@@ -160,8 +160,8 @@ function calculate() {
 			snapshot: `
 function calculate() {
 	return 077;
-        ~~~
-        This legacy octal numeric literal evaluates to 63. Did you mean that value, or to use a modern octal syntax such as 0o77?
+	       ~~~
+	       This legacy octal numeric literal evaluates to 63. Did you mean that value, or to use a modern octal syntax such as 0o77?
 }
 `,
 			suggestions: [

package/src/rules/shadowedRestrictedNames.test.ts

@@ -0,0 +1,148 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./shadowedRestrictedNames.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+let undefined = 5;
+`,
+			snapshot: `
+let undefined = 5;
+    ~~~~~~~~~
+    This variable misleadingly shadows the global \`undefined\`.
+`,
+		},
+		{
+			code: `
+const NaN = 123;
+`,
+			snapshot: `
+const NaN = 123;
+      ~~~
+      This variable misleadingly shadows the global \`NaN\`.
+`,
+		},
+		{
+			code: `
+var Infinity = 100;
+`,
+			snapshot: `
+var Infinity = 100;
+    ~~~~~~~~
+    This variable misleadingly shadows the global \`Infinity\`.
+`,
+		},
+		{
+			code: `
+function test(arguments) {
+    return arguments.length;
+}
+`,
+			snapshot: `
+function test(arguments) {
+              ~~~~~~~~~
+              This variable misleadingly shadows the global \`arguments\`.
+    return arguments.length;
+}
+`,
+		},
+		{
+			code: `
+function eval() {
+    return 42;
+}
+`,
+			snapshot: `
+function eval() {
+         ~~~~
+         This variable misleadingly shadows the global \`eval\`.
+    return 42;
+}
+`,
+		},
+		{
+			code: `
+const arrowFunc = (undefined) => undefined;
+`,
+			snapshot: `
+const arrowFunc = (undefined) => undefined;
+                   ~~~~~~~~~
+                   This variable misleadingly shadows the global \`undefined\`.
+`,
+		},
+		{
+			code: `
+class NaN {
+    constructor() {}
+}
+`,
+			snapshot: `
+class NaN {
+      ~~~
+      This variable misleadingly shadows the global \`NaN\`.
+    constructor() {}
+}
+`,
+		},
+		{
+			code: `
+const obj = {
+    method(eval) {
+        return eval;
+    }
+};
+`,
+			snapshot: `
+const obj = {
+    method(eval) {
+           ~~~~
+           This variable misleadingly shadows the global \`eval\`.
+        return eval;
+    }
+};
+`,
+		},
+		{
+			code: `
+function test() {
+    const { undefined } = obj;
+}
+`,
+			snapshot: `
+function test() {
+    const { undefined } = obj;
+            ~~~~~~~~~
+            This variable misleadingly shadows the global \`undefined\`.
+}
+`,
+		},
+		{
+			code: `
+function test() {
+    const [NaN] = array;
+}
+`,
+			snapshot: `
+function test() {
+    const [NaN] = array;
+           ~~~
+           This variable misleadingly shadows the global \`NaN\`.
+}
+`,
+		},
+	],
+	valid: [
+		`let value = undefined;`,
+		`const result = NaN;`,
+		`const max = Infinity;`,
+		`function test() { return arguments; }`,
+		`const code = eval("1 + 1");`,
+		`let myValue = 5;`,
+		`function myFunction() {}`,
+		`class MyClass {}`,
+		`const obj = { undefined: 5 };`,
+		`const key = "undefined";`,
+		`obj.undefined = 5;`,
+	],
+});

package/src/rules/shadowedRestrictedNames.ts

@@ -0,0 +1,105 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+
+const restrictedNames = new Set([
+	"arguments",
+	"eval",
+	"Infinity",
+	"NaN",
+	"undefined",
+]);
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports variable declarations that shadow JavaScript's restricted names.",
+		id: "shadowedRestrictedNames",
+		preset: "untyped",
+	},
+	messages: {
+		shadowedRestrictedName: {
+			primary: "This variable misleadingly shadows the global `{{ name }}`.",
+			secondary: [
+				"JavaScript has certain built-in global identifiers that are considered restricted because shadowing them can lead to confusing or erroneous code.",
+				"When you declare a variable with a restricted name, it shadows the global identifier and can cause unexpected behavior.",
+			],
+			suggestions: [
+				"Use a different variable name that doesn't shadow a restricted name.",
+			],
+		},
+	},
+	setup(context) {
+		function checkIdentifier(node: ts.Identifier): void {
+			if (restrictedNames.has(node.text)) {
+				context.report({
+					data: {
+						name: node.text,
+					},
+					message: "shadowedRestrictedName",
+					range: getTSNodeRange(node, context.sourceFile),
+				});
+			}
+		}
+
+		function checkBindingName(name: ts.BindingName): void {
+			if (ts.isIdentifier(name)) {
+				checkIdentifier(name);
+			} else if (
+				ts.isObjectBindingPattern(name) ||
+				ts.isArrayBindingPattern(name)
+			) {
+				for (const element of name.elements) {
+					if (ts.isBindingElement(element)) {
+						checkBindingName(element.name);
+					}
+				}
+			}
+		}
+
+		function checkParameters(
+			parameters: ts.NodeArray<ts.ParameterDeclaration>,
+		): void {
+			for (const parameter of parameters) {
+				checkBindingName(parameter.name);
+			}
+		}
+
+		return {
+			visitors: {
+				ArrowFunction: (node) => {
+					checkParameters(node.parameters);
+				},
+				ClassDeclaration: (node) => {
+					if (node.name) {
+						checkIdentifier(node.name);
+					}
+				},
+				ClassExpression: (node) => {
+					if (node.name) {
+						checkIdentifier(node.name);
+					}
+				},
+				FunctionDeclaration: (node) => {
+					if (node.name) {
+						checkIdentifier(node.name);
+					}
+					checkParameters(node.parameters);
+				},
+				FunctionExpression: (node) => {
+					if (node.name) {
+						checkIdentifier(node.name);
+					}
+					checkParameters(node.parameters);
+				},
+				MethodDeclaration: (node) => {
+					checkParameters(node.parameters);
+				},
+				VariableDeclaration: (node) => {
+					checkBindingName(node.name);
+				},
+			},
+		};
+	},
+});

package/src/rules/symbolDescriptions.test.ts

@@ -44,8 +44,8 @@ function createSymbol() {
 			snapshot: `
 function createSymbol() {
 	return Symbol();
-        ~~~~~~~~
-        Symbols without descriptions are more difficult to debug or reason about.
+	       ~~~~~~~~
+	       Symbols without descriptions are more difficult to debug or reason about.
 }
 `,
 		},
@@ -58,8 +58,8 @@ const obj = {
 			snapshot: `
 const obj = {
 	key: Symbol(),
-      ~~~~~~~~
-      Symbols without descriptions are more difficult to debug or reason about.
+	     ~~~~~~~~
+	     Symbols without descriptions are more difficult to debug or reason about.
 };
 `,
 		},

package/src/rules/unicodeBOMs.test.ts

@@ -1,3 +1,4 @@
+// flint-disable-file invalidCodeLines -- This rule checks the first character of code files.
 import { ruleTester } from "./ruleTester.js";
 import rule from "./unicodeBOMs.js";