@flint.fyi/ts 0.14.4 → 0.14.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @flint/ts
 
+## 0.14.5
+
+### Patch Changes
+
+- 7e21021: fix(ts): [chainedAssignments] allow non-assignment right-side operators
+
 ## 0.14.4
 
 ### Patch Changes

package/lib/createTypeScriptFileFromProgram.js

@@ -37,6 +37,9 @@ export function createTypeScriptFileFromProgram(program, sourceFile) {
                 report: (report) => {
                     reports.push({
                         ...report,
+                        fix: report.fix && !Array.isArray(report.fix)
+                            ? [report.fix]
+                            : report.fix,
                         message: rule.messages[report.message],
                         range: normalizeRange(report.range, sourceFile),
                     });
@@ -53,7 +56,7 @@ export function createTypeScriptFileFromProgram(program, sourceFile) {
                 visitors[NodeSyntaxKinds[node.kind]]?.(node);
                 node.forEachChild(visit);
             };
-            sourceFile.forEachChild(visit);
+            visit(sourceFile);
             return reports;
         },
     };

package/lib/index.d.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/lib/index.js

@@ -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/lib/plugin.d.ts

@@ -1,4 +1,4 @@
-export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout, string | undefined, [import("@flint.fyi/core").Rule<{
+export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/core").RuleAbout, "all", [import("@flint.fyi/core").Rule<{
     readonly description: "Reports returning a value with type `any` from a function.";
     readonly id: "anyReturns";
     readonly preset: "logical";
@@ -51,6 +51,10 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "elseIfDuplicates";
     readonly preset: "logical";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "duplicateCondition", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty block statements that should contain code.";
+    readonly id: "emptyBlocks";
+    readonly preset: "stylistic";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "emptyBlock", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports using empty destructuring patterns that destructure no values.";
     readonly id: "emptyDestructures";
     readonly preset: "logical";
@@ -146,6 +150,10 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "sequences";
     readonly preset: "untyped";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noSequences", undefined>, import("@flint.fyi/core").Rule<{
+    readonly description: "Reports variable declarations that shadow JavaScript's restricted names.";
+    readonly id: "shadowedRestrictedNames";
+    readonly preset: "untyped";
+}, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "shadowedRestrictedName", undefined>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports array literals with holes (sparse arrays).";
     readonly id: "sparseArrays";
     readonly preset: "logical";
@@ -170,10 +178,18 @@ export declare const ts: import("@flint.fyi/core").Plugin<import("@flint.fyi/cor
     readonly id: "unicodeBOMs";
     readonly preset: "stylistic";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "noBOM", undefined>, 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>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports catch clauses that only rethrow the caught error without modification.";
     readonly id: "unnecessaryCatches";
     readonly preset: "logical";
 }, import("./nodes.js").TSNodesByName, import("./language.js").TypeScriptServices, "unnecessaryCatch", undefined>, 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>, import("@flint.fyi/core").Rule<{
     readonly description: "Reports negating the left operand of `in` or `instanceof` relations.";
     readonly id: "unsafeNegations";
     readonly preset: "untyped";

package/lib/plugin.js

@@ -12,6 +12,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";
@@ -35,13 +36,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";
@@ -64,6 +68,7 @@ export const ts = createPlugin({
         defaultCaseLast,
         duplicateArguments,
         elseIfDuplicates,
+        emptyBlocks,
         emptyDestructures,
         emptyStaticBlocks,
         exceptionAssignments,
@@ -87,13 +92,16 @@ export const ts = createPlugin({
         selfAssignments,
         selfComparisons,
         sequences,
+        shadowedRestrictedNames,
         sparseArrays,
         symbolDescriptions,
         typeofComparisons,
         unassignedVariables,
         undefinedVariables,
         unicodeBOMs,
+        unnecessaryBlocks,
         unnecessaryCatches,
+        unnecessaryConcatenation,
         unsafeNegations,
         variableDeletions,
         voidOperator,

package/lib/rules/chainedAssignments.js

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

package/lib/rules/chainedAssignments.test.js

@@ -233,6 +233,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/lib/rules/debuggerStatements.test.js

@@ -29,8 +29,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: [
@@ -53,8 +53,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/lib/rules/emptyBlocks.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports empty block statements that should contain code.";
+    readonly id: "emptyBlocks";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "emptyBlock", undefined>;
+export default _default;

package/lib/rules/emptyBlocks.js

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

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

package/lib/rules/emptyBlocks.test.js

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

@@ -159,8 +159,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/lib/rules/shadowedRestrictedNames.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports variable declarations that shadow JavaScript's restricted names.";
+    readonly id: "shadowedRestrictedNames";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "shadowedRestrictedName", undefined>;
+export default _default;

package/lib/rules/shadowedRestrictedNames.js

@@ -0,0 +1,95 @@
+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) {
+            if (restrictedNames.has(node.text)) {
+                context.report({
+                    data: {
+                        name: node.text,
+                    },
+                    message: "shadowedRestrictedName",
+                    range: getTSNodeRange(node, context.sourceFile),
+                });
+            }
+        }
+        function checkBindingName(name) {
+            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) {
+            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/lib/rules/shadowedRestrictedNames.test.d.ts

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