@flint.fyi/ts 0.14.4 → 0.14.5

package/lib/rules/shadowedRestrictedNames.test.js

@@ -0,0 +1,147 @@
+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/lib/rules/symbolDescriptions.test.js

@@ -43,8 +43,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.
 }
 `,
         },
@@ -57,8 +57,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/lib/rules/unicodeBOMs.test.js

@@ -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";
 ruleTester.describe(rule, {

package/lib/rules/unnecessaryBlocks.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports standalone block statements that don't create a meaningful scope.";
+    readonly id: "unnecessaryBlocks";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unnecessaryBlock", undefined>;
+export default _default;

package/lib/rules/unnecessaryBlocks.js

@@ -0,0 +1,75 @@
+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) {
+            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/lib/rules/unnecessaryBlocks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/rules/unnecessaryBlocks.test.js

@@ -0,0 +1,147 @@
+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/lib/rules/unnecessaryConcatenation.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports string concatenation using the + operator when both operands are string literals.";
+    readonly id: "unnecessaryConcatenation";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unnecessaryConcatenation", undefined>;
+export default _default;

package/lib/rules/unnecessaryConcatenation.js

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

package/lib/rules/unnecessaryConcatenation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/rules/unnecessaryConcatenation.test.js

@@ -0,0 +1,87 @@
+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/lib/rules/voidOperator.test.js

@@ -71,8 +71,8 @@ function process() {
             snapshot: `
 function process() {
 	void doSomething();
- ~~~~~~~~~~~~~~~~~~
- Prefer an explicit value over using the void operator to produce undefined.
+	~~~~~~~~~~~~~~~~~~
+	Prefer an explicit value over using the void operator to produce undefined.
 }
 `,
         },

package/lib/utils/getDeclarationsIfGlobal.d.ts

@@ -0,0 +1,2 @@
+import * as ts from "typescript";
+export declare function getDeclarationsIfGlobal(node: ts.Expression, typeChecker: ts.TypeChecker): ts.Declaration[] | undefined;

package/lib/utils/getDeclarationsIfGlobal.js

@@ -0,0 +1,7 @@
+import { declarationsIncludeGlobal } from "./declarationsIncludeGlobal.js";
+export function getDeclarationsIfGlobal(node, typeChecker) {
+    const declarations = typeChecker.getSymbolAtLocation(node)?.getDeclarations();
+    return !!declarations && declarationsIncludeGlobal(declarations)
+        ? declarations
+        : undefined;
+}

package/lib/utils/isGlobalDeclaration.js

@@ -1,5 +1,4 @@
-import { declarationsIncludeGlobal } from "./declarationsIncludeGlobal.js";
+import { getDeclarationsIfGlobal } from "./getDeclarationsIfGlobal.js";
 export function isGlobalDeclaration(node, typeChecker) {
-    const declarations = typeChecker.getSymbolAtLocation(node)?.getDeclarations();
-    return !!declarations && declarationsIncludeGlobal(declarations);
+    return !!getDeclarationsIfGlobal(node, typeChecker);
 }

package/lib/utils/isGlobalDeclarationOfName.d.ts

@@ -2,4 +2,4 @@ import * as ts from "typescript";
 /**
  * TODO: Use a scope analyzer (#400).
  */
-export declare function isGlobalDeclarationOfName(node: ts.Expression, name: string, typeChecker: ts.TypeChecker): boolean;
+export declare function isGlobalDeclarationOfName(node: ts.Node, name: string, typeChecker: ts.TypeChecker): boolean;

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.5",
   "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/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";