@flint.fyi/ts 0.14.4 → 0.14.6

package/lib/utils/isGlobalDeclarationOfName.js

@@ -16,6 +16,10 @@ export function isGlobalDeclarationOfName(node, name, typeChecker) {
             declaration.initializer.kind === ts.SyntaxKind.Identifier) {
             return isGlobalDeclarationOfName(declaration.initializer, name, typeChecker);
         }
+        // Special case: a property of an interface
+        if (ts.isPropertySignature(declaration)) {
+            return isGlobalDeclarationOfName(declaration.parent, name, typeChecker);
+        }
         return (isDeclarationOfName(declaration, name) &&
             declarationIncludesGlobal(declaration));
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flint.fyi/ts",
-  "version": "0.14.4",
+  "version": "0.14.6",
   "description": "[Experimental] TypeScript language plugin for Flint.",
   "repository": {
     "type": "git",
@@ -17,12 +17,12 @@
   "dependencies": {
     "@flint.fyi/core": "",
     "@flint.fyi/rule-tester": "",
-    "@typescript-eslint/project-service": "^8.35.0",
+    "@typescript-eslint/project-service": "^8.46.2",
     "@typescript/vfs": "^1.6.1",
     "cached-factory": "^0.1.0",
     "debug-for-file": "^0.2.0",
     "ts-api-utils": "^2.1.0",
-    "typescript": ">=5.8.0"
+    "typescript": ">=5.9.3"
   },
   "engines": {
     "node": ">=24.0.0"

package/src/createTypeScriptFileFromProgram.ts

@@ -53,6 +53,10 @@ export function createTypeScriptFileFromProgram(
 				report: (report: RuleReport) => {
 					reports.push({
 						...report,
+						fix:
+							report.fix && !Array.isArray(report.fix)
+								? [report.fix]
+								: report.fix,
 						message: rule.messages[report.message],
 						range: normalizeRange(report.range, sourceFile),
 					});
@@ -74,7 +78,7 @@ export function createTypeScriptFileFromProgram(
 				node.forEachChild(visit);
 			};
 
-			sourceFile.forEachChild(visit);
+			visit(sourceFile);
 
 			return reports;
 		},

package/src/formatDiagnostic.ts

@@ -138,7 +138,7 @@ function formatCodeSpan(
 			gutterSeparator;
 		context += squiggleColor;
 		if (i === firstLine) {
-			const lastCharForLine = i === lastLine ? lastLineChar : void 0;
+			const lastCharForLine = i === lastLine ? lastLineChar : undefined;
 			context += lineContent.slice(0, firstLineChar).replace(/\S/g, " ");
 			context += lineContent
 				.slice(firstLineChar, lastCharForLine)

package/src/index.ts

@@ -1,4 +1,7 @@
 export { getTSNodeRange } from "./getTSNodeRange.js";
 export * from "./language.js";
 export { ts } from "./plugin.js";
+export { getDeclarationsIfGlobal } from "./utils/getDeclarationsIfGlobal.js";
 export { isGlobalDeclaration } from "./utils/isGlobalDeclaration.js";
+export { isGlobalDeclarationOfName } from "./utils/isGlobalDeclarationOfName.js";
+export { isGlobalVariable } from "./utils/isGlobalVariable.js";

package/src/normalizeRange.ts

@@ -2,6 +2,7 @@ import type * as ts from "typescript";
 
 import {
 	CharacterReportRange,
+	getColumnAndLineOfPosition,
 	NormalizedReportRangeObject,
 } from "@flint.fyi/core";
 
@@ -14,17 +15,11 @@ export function normalizeRange(
 		: original;
 
 	return {
-		begin: normalizeRangePosition(onCharacters.begin, sourceFile),
-		end: normalizeRangePosition(onCharacters.end, sourceFile),
+		begin: getColumnAndLineOfPosition(sourceFile, onCharacters.begin),
+		end: getColumnAndLineOfPosition(sourceFile, onCharacters.end),
 	};
 }
 
 function isNode(value: unknown): value is ts.Node {
 	return typeof value === "object" && value !== null && "kind" in value;
 }
-
-function normalizeRangePosition(raw: number, sourceFile: ts.SourceFile) {
-	const { character, line } = sourceFile.getLineAndCharacterOfPosition(raw);
-
-	return { column: character, line, raw };
-}

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";
@@ -51,7 +55,7 @@ export const ts = createPlugin({
 	files: {
 		all: ["**/*.{cjs,js,jsx,mjs,ts,tsx}"],
 	},
-	name: "ts",
+	name: "TypeScript",
 	rules: [
 		anyReturns,
 		asyncPromiseExecutors,
@@ -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/forDirections.test.ts

@@ -81,6 +81,30 @@ for (let index = 0; index < 10; index += -1) {}
 for (let index = 0; index < 10; index += -1) {}
                                 ~~~~~~~~~~~
                                 The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+declare context text: string;
+for (let i = 10; i >= 0 && text[i] !== " "; i++) { }
+`,
+			snapshot: `
+declare context text: string;
+for (let i = 10; i >= 0 && text[i] !== " "; i++) { }
+                                            ~~~
+                                            The update moves the counter in the wrong direction for this loop condition.
+`,
+		},
+		{
+			code: `
+declare context text: string;
+for (let i = 10; text[i] !== " " && i >= 0; i++) { }
+`,
+			snapshot: `
+declare context text: string;
+for (let i = 10; text[i] !== " " && i >= 0; i++) { }
+                                            ~~~
+                                            The update moves the counter in the wrong direction for this loop condition.
 `,
 		},
 	],
@@ -96,5 +120,6 @@ for (let index = 0; index < 10; index += -1) {}
 		`for (let index = 10; index > 0; index -= 1) { }`,
 		`for (let index = 0; index < 10; index += 2) { }`,
 		`for (let index = 10; index > 0; index -= 2) { }`,
+		`for (let i = 10; i >= 0 && text[i] === "\\"; i--) { }`,
 	],
 });

package/src/rules/forDirections.ts

@@ -3,7 +3,10 @@ import * as ts from "typescript";
 import { getTSNodeRange } from "../getTSNodeRange.js";
 import { typescriptLanguage } from "../language.js";
 
-function getConditionDirection(condition: ts.Expression, counterName: string) {
+function getConditionDirection(
+	condition: ts.Expression,
+	counterName: string,
+): -1 | 1 | undefined {
 	if (!ts.isBinaryExpression(condition)) {
 		return undefined;
 	}
@@ -11,6 +14,14 @@ function getConditionDirection(condition: ts.Expression, counterName: string) {
 	const leftName = getCounterName(condition.left);
 	const rightName = getCounterName(condition.right);
 
+	if (!leftName && !rightName) {
+		return condition.operatorToken.kind ===
+			ts.SyntaxKind.AmpersandAmpersandToken
+			? (getConditionDirection(condition.left, counterName) ??
+					getConditionDirection(condition.right, counterName))
+			: undefined;
+	}
+
 	const isCounterLeft = leftName === counterName;
 	const isCounterRight = rightName === counterName;
 
@@ -55,12 +66,12 @@ function getCounterName(node: ts.Expression) {
 	return ts.isIdentifier(node) ? node.text : undefined;
 }
 
-function getUpdateDirection(update: ts.Expression) {
+function getIncrementorDirection(incrementor: ts.Expression) {
 	if (
-		ts.isPostfixUnaryExpression(update) ||
-		ts.isPrefixUnaryExpression(update)
+		ts.isPostfixUnaryExpression(incrementor) ||
+		ts.isPrefixUnaryExpression(incrementor)
 	) {
-		switch (update.operator) {
+		switch (incrementor.operator) {
 			case ts.SyntaxKind.MinusMinusToken:
 				return -1;
 			case ts.SyntaxKind.PlusPlusToken:
@@ -70,8 +81,8 @@ function getUpdateDirection(update: ts.Expression) {
 		}
 	}
 
-	if (ts.isBinaryExpression(update)) {
-		const { operatorToken, right } = update;
+	if (ts.isBinaryExpression(incrementor)) {
+		const { operatorToken, right } = incrementor;
 
 		if (
 			operatorToken.kind === ts.SyntaxKind.PlusEqualsToken ||
@@ -140,7 +151,7 @@ export default typescriptLanguage.createRule({
 						return;
 					}
 
-					const updateDirection = getUpdateDirection(node.incrementor);
+					const updateDirection = getIncrementorDirection(node.incrementor);
 					if (!updateDirection) {
 						return;
 					}
@@ -150,7 +161,7 @@ export default typescriptLanguage.createRule({
 						declaration.name.text,
 					);
 
-					if (updateDirection !== conditionDirection) {
+					if (conditionDirection && conditionDirection !== updateDirection) {
 						context.report({
 							message: "wrongDirection",
 							range: getTSNodeRange(node.incrementor, 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: [