@flint.fyi/ts 0.14.3 → 0.14.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/typeofComparisons.test.ts

@@ -0,0 +1,86 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./typeofComparisons.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+if (typeof value === "") {
+    process();
+}
+`,
+			snapshot: `
+if (typeof value === "") {
+                     ~~
+                     This string literal is not one that the typeof operator will ever produce.
+    process();
+}
+`,
+		},
+		{
+			code: `
+if (typeof data != "invalid") {
+    reject();
+}
+`,
+			snapshot: `
+if (typeof data != "invalid") {
+                   ~~~~~~~~~
+                   This string literal is not one that the typeof operator will ever produce.
+    reject();
+}
+`,
+		},
+		{
+			code: `
+if ("invalid" === typeof flag) {
+    toggle();
+}
+`,
+			snapshot: `
+if ("invalid" === typeof flag) {
+    ~~~~~~~~~
+    This string literal is not one that the typeof operator will ever produce.
+    toggle();
+}
+`,
+		},
+		{
+			code: `
+if (typeof value === "String") {
+    process();
+}
+`,
+			snapshot: `
+if (typeof value === "String") {
+                     ~~~~~~~~
+                     This string literal is not one that the typeof operator will ever produce.
+    process();
+}
+`,
+		},
+		{
+			code: `
+const isValid = typeof input !== "array";
+`,
+			snapshot: `
+const isValid = typeof input !== "array";
+                                 ~~~~~~~
+                                 This string literal is not one that the typeof operator will ever produce.
+`,
+		},
+	],
+	valid: [
+		`if (typeof value === "string") { process(); }`,
+		`if (typeof variable == "undefined") { handle(); }`,
+		`if (typeof data != "number") { reject(); }`,
+		`if (typeof callback !== "function") { throw new Error("Invalid callback"); }`,
+		`if (typeof flag === "boolean") { toggle(); }`,
+		`if (typeof value === "object") { parse(); }`,
+		`if (typeof value === "symbol") { handle(); }`,
+		`if (typeof value === "bigint") { compute(); }`,
+		`if (typeof value === other) { process(); }`,
+		`if (typeof value === typeof other) { compare(); }`,
+		`const type = typeof value;`,
+	],
+});

package/src/rules/typeofComparisons.ts

@@ -0,0 +1,88 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+
+const validTypeofValues = new Set([
+	"bigint",
+	"boolean",
+	"function",
+	"number",
+	"object",
+	"string",
+	"symbol",
+	"undefined",
+]);
+
+// TODO: Reuse a shared getStaticValue-style utility?
+function getStringValue(node: ts.Expression) {
+	return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)
+		? node.text
+		: undefined;
+}
+
+function getTypeofOperand(node: ts.Expression) {
+	return ts.isTypeOfExpression(node) && node.expression;
+}
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports typeof expressions that compare impossible string literals.",
+		id: "typeofComparisons",
+		preset: "untyped",
+	},
+	messages: {
+		invalidValue: {
+			primary:
+				"This string literal is not one that the typeof operator will ever produce.",
+			secondary: [
+				"The typeof operator returns one of a specific set of string values.",
+				"Comparing typeof to an invalid string is usually a typo and will never match.",
+				'The only valid values are: "bigint", "boolean", "function", "number", "object", "string", "symbol", and "undefined".',
+			],
+			suggestions: [
+				"Check for typos and use one of the valid typeof return values.",
+			],
+		},
+	},
+	setup(context) {
+		function checkComparison(node: ts.BinaryExpression) {
+			const leftTypeofOperand = getTypeofOperand(node.left);
+			const rightTypeofOperand = getTypeofOperand(node.right);
+
+			let comparisonValue: ts.Expression | undefined;
+			if (leftTypeofOperand) {
+				comparisonValue = node.right;
+			} else if (rightTypeofOperand) {
+				comparisonValue = node.left;
+			} else {
+				return;
+			}
+
+			const stringValue = getStringValue(comparisonValue);
+			if (stringValue != null && !validTypeofValues.has(stringValue)) {
+				context.report({
+					message: "invalidValue",
+					range: getTSNodeRange(comparisonValue, context.sourceFile),
+				});
+			}
+		}
+
+		return {
+			visitors: {
+				BinaryExpression: (node) => {
+					if (
+						node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken ||
+						node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+						node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken ||
+						node.operatorToken.kind ===
+							ts.SyntaxKind.ExclamationEqualsEqualsToken
+					) {
+						checkComparison(node);
+					}
+				},
+			},
+		};
+	},
+});

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";
 

package/src/rules/unnecessaryBlocks.test.ts

@@ -0,0 +1,148 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./unnecessaryBlocks.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+{
+    const x = 1;
+}
+`,
+			snapshot: `
+{
+~
+This standalone block statement is unnecessary and doesn't change any variable scopes.
+    const x = 1;
+}
+`,
+		},
+		{
+			code: `
+function test() {
+    {
+        const y = 2;
+    }
+}
+`,
+			snapshot: `
+function test() {
+    {
+    ~
+    This standalone block statement is unnecessary and doesn't change any variable scopes.
+        const y = 2;
+    }
+}
+`,
+		},
+		{
+			code: `
+if (condition) {
+    doSomething();
+    {
+        const nested = true;
+    }
+}
+`,
+			snapshot: `
+if (condition) {
+    doSomething();
+    {
+    ~
+    This standalone block statement is unnecessary and doesn't change any variable scopes.
+        const nested = true;
+    }
+}
+`,
+		},
+		{
+			code: `
+{
+    console.log("standalone");
+}
+`,
+			snapshot: `
+{
+~
+This standalone block statement is unnecessary and doesn't change any variable scopes.
+    console.log("standalone");
+}
+`,
+		},
+		{
+			code: `
+function outer() {
+    {
+        console.log("inner");
+    }
+    {
+        console.log("another");
+    }
+}
+`,
+			snapshot: `
+function outer() {
+    {
+    ~
+    This standalone block statement is unnecessary and doesn't change any variable scopes.
+        console.log("inner");
+    }
+    {
+    ~
+    This standalone block statement is unnecessary and doesn't change any variable scopes.
+        console.log("another");
+    }
+}
+`,
+		},
+	],
+	valid: [
+		`if (condition) { doSomething(); }`,
+		`for (let i = 0; i < 10; i++) { console.log(i); }`,
+		`while (condition) { doWork(); }`,
+		`do { doWork(); } while (condition);`,
+		`function test() { return 42; }`,
+		`const arrow = () => { return 1; };`,
+		`
+switch (value) {
+    case 1: {
+        const x = 1;
+        break;
+    }
+    case 2: {
+        const y = 2;
+        break;
+    }
+}
+`,
+		`
+try {
+    doSomething();
+} catch (error) {
+    handleError(error);
+}
+`,
+		`
+class MyClass {
+    method() {
+        return 1;
+    }
+}
+`,
+		`
+for (const item of items) {
+    processItem(item);
+}
+`,
+		`
+for (const key in object) {
+    processKey(key);
+}
+`,
+		`
+label: {
+    break label;
+}
+`,
+	],
+});

package/src/rules/unnecessaryBlocks.ts

@@ -0,0 +1,89 @@
+import * as ts from "typescript";
+
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports standalone block statements that don't create a meaningful scope.",
+		id: "unnecessaryBlocks",
+		preset: "stylistic",
+	},
+	messages: {
+		unnecessaryBlock: {
+			primary:
+				"This standalone block statement is unnecessary and doesn't change any variable scopes.",
+			secondary: [
+				"Standalone block statements that aren't part of control flow (if/else, loops, switch) or don't create a meaningful lexical scope can be confusing and should be avoided.",
+				"In modern JavaScript and TypeScript, blocks primarily serve to create lexical scope for `let` and `const` variables, but this is often better achieved through other means.",
+			],
+			suggestions: [
+				"Remove the block statement and move its contents to the parent scope.",
+				"If you need lexical scoping, consider using an IIFE (Immediately Invoked Function Expression) or extracting to a separate function.",
+			],
+		},
+	},
+	setup(context) {
+		function isValidBlock(node: ts.Block): boolean {
+			const parent = node.parent;
+
+			// Valid blocks: function bodies, arrow functions, class/interface bodies, etc.
+			if (
+				ts.isFunctionDeclaration(parent) ||
+				ts.isFunctionExpression(parent) ||
+				ts.isArrowFunction(parent) ||
+				ts.isMethodDeclaration(parent) ||
+				ts.isConstructorDeclaration(parent) ||
+				ts.isGetAccessorDeclaration(parent) ||
+				ts.isSetAccessorDeclaration(parent) ||
+				ts.isModuleBlock(parent)
+			) {
+				return true;
+			}
+
+			// Valid blocks: control flow statements
+			if (
+				ts.isIfStatement(parent) ||
+				ts.isForStatement(parent) ||
+				ts.isForInStatement(parent) ||
+				ts.isForOfStatement(parent) ||
+				ts.isWhileStatement(parent) ||
+				ts.isDoStatement(parent) ||
+				ts.isWithStatement(parent) ||
+				ts.isTryStatement(parent) ||
+				ts.isCatchClause(parent)
+			) {
+				return true;
+			}
+
+			// Valid block: switch case/default clause with block
+			// In ES6+, blocks in switch cases create scope for let/const
+			if (ts.isCaseClause(parent) || ts.isDefaultClause(parent)) {
+				return true;
+			}
+
+			// Valid block: labeled statement
+			if (ts.isLabeledStatement(parent)) {
+				return true;
+			}
+
+			return false;
+		}
+
+		return {
+			visitors: {
+				Block: (node) => {
+					if (!isValidBlock(node)) {
+						context.report({
+							message: "unnecessaryBlock",
+							range: {
+								begin: node.getStart(context.sourceFile),
+								end: node.getStart(context.sourceFile) + 1,
+							},
+						});
+					}
+				},
+			},
+		};
+	},
+});

package/src/rules/unnecessaryConcatenation.test.ts

@@ -0,0 +1,88 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./unnecessaryConcatenation.js";
+
+ruleTester.describe(rule, {
+	invalid: [
+		{
+			code: `
+const message = "Hello" + "World";
+`,
+			snapshot: `
+const message = "Hello" + "World";
+                        ~
+                        This string concatenation can be streamlined into a single string literal.
+`,
+		},
+		{
+			code: `
+const path = 'foo' + 'bar';
+`,
+			snapshot: `
+const path = 'foo' + 'bar';
+                   ~
+                   This string concatenation can be streamlined into a single string literal.
+`,
+		},
+		{
+			code: `
+const result = "abc" + "def" + "ghi";
+`,
+			snapshot: `
+const result = "abc" + "def" + "ghi";
+                     ~
+                     This string concatenation can be streamlined into a single string literal.
+`,
+		},
+		{
+			code: `
+const text = "first" + "second";
+`,
+			snapshot: `
+const text = "first" + "second";
+                     ~
+                     This string concatenation can be streamlined into a single string literal.
+`,
+		},
+		{
+			code: `
+const mixed = 'single' + "double";
+`,
+			snapshot: `
+const mixed = 'single' + "double";
+                       ~
+                       This string concatenation can be streamlined into a single string literal.
+`,
+		},
+		{
+			code: `
+const withSpace = "Hello " + "World";
+`,
+			snapshot: `
+const withSpace = "Hello " + "World";
+                           ~
+                           This string concatenation can be streamlined into a single string literal.
+`,
+		},
+		{
+			code: `
+const longString = "This is a very long string that " +
+    "continues on the next line";
+`,
+			snapshot: `
+const longString = "This is a very long string that " +
+                                                      ~
+                                                      This string concatenation can be streamlined into a single string literal.
+    "continues on the next line";
+`,
+		},
+	],
+	valid: [
+		`const message = "Hello" + variable;`,
+		`const message = variable + "World";`,
+		`const result = variable1 + variable2;`,
+		`const template = \`Hello\${name}World\`;`,
+		`const number = 1 + 2;`,
+		`const mixed = "Hello" + getName() + "World";`,
+		`const value = "prefix" + getValue();`,
+	],
+});

package/src/rules/unnecessaryConcatenation.ts

@@ -0,0 +1,44 @@
+import * as ts from "typescript";
+
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+
+export default typescriptLanguage.createRule({
+	about: {
+		description:
+			"Reports string concatenation using the + operator when both operands are string literals.",
+		id: "unnecessaryConcatenation",
+		preset: "stylistic",
+	},
+	messages: {
+		unnecessaryConcatenation: {
+			primary:
+				"This string concatenation can be streamlined into a single string literal.",
+			secondary: [
+				"Concatenating string literals with the + operator is unnecessary and reduces code readability.",
+				"String literals can be combined into a single literal, which is clearer and potentially more performant.",
+			],
+			suggestions: [
+				"Combine the string literals into a single string literal.",
+			],
+		},
+	},
+	setup(context) {
+		return {
+			visitors: {
+				BinaryExpression: (node) => {
+					if (
+						node.operatorToken.kind === ts.SyntaxKind.PlusToken &&
+						ts.isStringLiteral(node.left) &&
+						ts.isStringLiteral(node.right)
+					) {
+						context.report({
+							message: "unnecessaryConcatenation",
+							range: getTSNodeRange(node.operatorToken, context.sourceFile),
+						});
+					}
+				},
+			},
+		};
+	},
+});