@flint.fyi/ts 0.14.6 → 0.15.0

package/lib/rules/emptyDestructures.test.js

@@ -184,3 +184,4 @@ try {
         `function returnEmptyArray() { return []; }`,
     ],
 });
+//# sourceMappingURL=emptyDestructures.test.js.map

package/lib/rules/emptyStaticBlocks.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports empty static initialization blocks within class declarations.";
     readonly id: "emptyStaticBlocks";
     readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "emptyStaticBlock", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "emptyStaticBlock", undefined>;
 export default _default;
+//# sourceMappingURL=emptyStaticBlocks.d.ts.map

package/lib/rules/emptyStaticBlocks.js

@@ -20,17 +20,17 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                ClassStaticBlockDeclaration: (node) => {
+                ClassStaticBlockDeclaration: (node, { sourceFile }) => {
                     const statements = node.body.statements;
                     if (statements.length) {
                         return;
                     }
-                    const openBrace = node.body.getFirstToken(context.sourceFile);
+                    const openBrace = node.body.getFirstToken(sourceFile);
                     if (!openBrace) {
                         return;
                     }
                     const range = {
-                        begin: node.getStart(context.sourceFile),
+                        begin: node.getStart(sourceFile),
                         end: openBrace.getEnd(),
                     };
                     context.report({
@@ -40,7 +40,7 @@ export default typescriptLanguage.createRule({
                             {
                                 id: "removeEmptyStaticBlock",
                                 range: {
-                                    begin: node.getStart(context.sourceFile),
+                                    begin: node.getStart(sourceFile),
                                     end: node.getEnd(),
                                 },
                                 text: "",
@@ -52,3 +52,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=emptyStaticBlocks.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=emptyStaticBlocks.test.d.ts.map

package/lib/rules/emptyStaticBlocks.test.js

@@ -165,3 +165,4 @@ class Multiple {
 `,
     ],
 });
+//# sourceMappingURL=emptyStaticBlocks.test.js.map

package/lib/rules/exceptionAssignments.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports reassigning exception parameters in catch clauses.";
     readonly id: "exceptionAssignments";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noExAssign", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noExAssign", undefined>;
 export default _default;
+//# sourceMappingURL=exceptionAssignments.d.ts.map

package/lib/rules/exceptionAssignments.js

@@ -37,18 +37,18 @@ export default typescriptLanguage.createRule({
         }
         return {
             visitors: {
-                CatchClause: (node) => {
+                CatchClause: (node, { sourceFile, typeChecker }) => {
                     if (!node.variableDeclaration?.name) {
                         return;
                     }
                     const identifiers = collectBindingElements(node.variableDeclaration.name);
                     for (const identifier of identifiers) {
-                        const modifyingReferences = getModifyingReferences(identifier, context.sourceFile, context.typeChecker);
+                        const modifyingReferences = getModifyingReferences(identifier, sourceFile, typeChecker);
                         for (const reference of modifyingReferences) {
                             context.report({
                                 message: "noExAssign",
                                 range: {
-                                    begin: reference.getStart(context.sourceFile),
+                                    begin: reference.getStart(sourceFile),
                                     end: reference.getEnd(),
                                 },
                             });
@@ -59,3 +59,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=exceptionAssignments.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=exceptionAssignments.test.d.ts.map

package/lib/rules/exceptionAssignments.test.js

@@ -262,3 +262,4 @@ error = "reassigning outer is ok";
         `try { doSomething(); } catch ([first]) { console.log(first); }`,
     ],
 });
+//# sourceMappingURL=exceptionAssignments.test.js.map

package/lib/rules/finallyStatementSafety.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports control flow statements in `finally` blocks that can override control flow in `try`/`catch` blocks.";
+    readonly id: "finallyStatementSafety";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "unsafeFinally", undefined>;
+export default _default;
+//# sourceMappingURL=finallyStatementSafety.d.ts.map

package/lib/rules/finallyStatementSafety.js

@@ -0,0 +1,71 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports control flow statements in `finally` blocks that can override control flow in `try`/`catch` blocks.",
+        id: "finallyStatementSafety",
+        preset: "logical",
+    },
+    messages: {
+        unsafeFinally: {
+            primary: "Control flow statements in `finally` blocks misleadingly override control flow from `try`/`catch` blocks.",
+            secondary: [
+                "Control flow statements like `break`, `continue`, `return`, and `throw` in finally blocks can override control flow statements in the try or catch blocks.",
+                "This can lead to unexpected behavior, as the `finally` block will execute regardless of what happens in `try`/`catch`, and its control flow takes precedence.",
+            ],
+            suggestions: [
+                "Move the control flow statement out of the `finally` block.",
+                "Remove the control flow statement if the `finally` block is only used for cleanup operations.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                TryStatement: (node) => {
+                    if (!node.finallyBlock) {
+                        return;
+                    }
+                    function checkStatement(statement) {
+                        if (ts.isReturnStatement(statement) ||
+                            ts.isThrowStatement(statement) ||
+                            ts.isBreakStatement(statement) ||
+                            ts.isContinueStatement(statement)) {
+                            const firstToken = statement.getFirstToken(context.sourceFile);
+                            if (!firstToken) {
+                                return;
+                            }
+                            context.report({
+                                message: "unsafeFinally",
+                                range: {
+                                    begin: statement.getStart(context.sourceFile),
+                                    end: statement.getStart(context.sourceFile) +
+                                        firstToken.getText().length,
+                                },
+                            });
+                        }
+                        if (ts.isBlock(statement)) {
+                            statement.statements.forEach(checkStatement);
+                        }
+                        else if (ts.isIfStatement(statement)) {
+                            checkStatement(statement.thenStatement);
+                            if (statement.elseStatement) {
+                                checkStatement(statement.elseStatement);
+                            }
+                        }
+                        else if (ts.isSwitchStatement(statement)) {
+                            statement.caseBlock.clauses.forEach((clause) => {
+                                clause.statements.forEach(checkStatement);
+                            });
+                        }
+                        else if (ts.isLabeledStatement(statement)) {
+                            checkStatement(statement.statement);
+                        }
+                    }
+                    checkStatement(node.finallyBlock);
+                },
+            },
+        };
+    },
+});
+//# sourceMappingURL=finallyStatementSafety.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=finallyStatementSafety.test.d.ts.map

package/lib/rules/finallyStatementSafety.test.js

@@ -0,0 +1,307 @@
+import rule from "./finallyStatementSafety.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+try {
+    doSomething();
+} finally {
+    return 1;
+}
+`,
+            snapshot: `
+try {
+    doSomething();
+} finally {
+    return 1;
+    ~~~~~~
+    Control flow statements in \`finally\` blocks misleadingly override control flow from \`try\`/\`catch\` blocks.
+}
+`,
+        },
+        {
+            code: `
+try {
+    doSomething();
+} catch (error) {
+    console.error(error);
+} finally {
+    return;
+}
+`,
+            snapshot: `
+try {
+    doSomething();
+} catch (error) {
+    console.error(error);
+} finally {
+    return;
+    ~~~~~~
+    Control flow statements in \`finally\` blocks misleadingly override control flow from \`try\`/\`catch\` blocks.
+}
+`,
+        },
+        {
+            code: `
+try {
+    doSomething();
+} finally {
+    throw new Error("Error");
+}
+`,
+            snapshot: `
+try {
+    doSomething();
+} finally {
+    throw new Error("Error");
+    ~~~~~
+    Control flow statements in \`finally\` blocks misleadingly override control flow from \`try\`/\`catch\` blocks.
+}
+`,
+        },
+        {
+            code: `
+while (condition) {
+    try {
+        doSomething();
+    } finally {
+        break;
+    }
+}
+`,
+            snapshot: `
+while (condition) {
+    try {
+        doSomething();
+    } finally {
+        break;
+        ~~~~~
+        Control flow statements in \`finally\` blocks misleadingly override control flow from \`try\`/\`catch\` blocks.
+    }
+}
+`,
+        },
+        {
+            code: `
+for (let i = 0; i < 10; i++) {
+    try {
+        doSomething();
+    } finally {
+        continue;
+    }
+}
+`,
+            snapshot: `
+for (let i = 0; i < 10; i++) {
+    try {
+        doSomething();
+    } finally {
+        continue;
+        ~~~~~~~~
+        Control flow statements in \`finally\` blocks misleadingly override control flow from \`try\`/\`catch\` blocks.
+    }
+}
+`,
+        },
+        {
+            code: `
+function test() {
+    try {
+        doSomething();
+        return "success";
+    } finally {
+        return "override";
+    }
+}
+`,
+            snapshot: `
+function test() {
+    try {
+        doSomething();
+        return "success";
+    } finally {
+        return "override";
+        ~~~~~~
+        Control flow statements in \`finally\` blocks misleadingly override control flow from \`try\`/\`catch\` blocks.
+    }
+}
+`,
+        },
+        {
+            code: `
+try {
+    doSomething();
+} finally {
+    if (condition) {
+        return;
+    }
+}
+`,
+            snapshot: `
+try {
+    doSomething();
+} finally {
+    if (condition) {
+        return;
+        ~~~~~~
+        Control flow statements in \`finally\` blocks misleadingly override control flow from \`try\`/\`catch\` blocks.
+    }
+}
+`,
+        },
+        {
+            code: `
+try {
+    doSomething();
+} finally {
+    switch (value) {
+        case 1:
+            return;
+    }
+}
+`,
+            snapshot: `
+try {
+    doSomething();
+} finally {
+    switch (value) {
+        case 1:
+            return;
+            ~~~~~~
+            Control flow statements in \`finally\` blocks misleadingly override control flow from \`try\`/\`catch\` blocks.
+    }
+}
+`,
+        },
+        {
+            code: `
+try {
+    doSomething();
+} finally {
+    label: {
+        break label;
+    }
+}
+`,
+            snapshot: `
+try {
+    doSomething();
+} finally {
+    label: {
+        break label;
+        ~~~~~
+        Control flow statements in \`finally\` blocks misleadingly override control flow from \`try\`/\`catch\` blocks.
+    }
+}
+`,
+        },
+    ],
+    valid: [
+        `try { doSomething(); } finally { cleanup(); }`,
+        `try { doSomething(); } catch (error) { console.error(error); } finally { cleanup(); }`,
+        `try { return 1; } finally { cleanup(); }`,
+        `try { throw new Error("Error"); } finally { cleanup(); }`,
+        `
+try {
+    doSomething();
+} finally {
+    console.log("cleanup");
+}
+`,
+        `
+function test() {
+    try {
+        return doSomething();
+    } finally {
+        cleanup();
+    }
+}
+`,
+        `
+while (condition) {
+    try {
+        break;
+    } finally {
+        cleanup();
+    }
+}
+`,
+        `
+for (let i = 0; i < 10; i++) {
+    try {
+        continue;
+    } finally {
+        cleanup();
+    }
+}
+`,
+        `
+try {
+    doSomething();
+} finally {
+    if (condition) {
+        cleanup();
+    }
+}
+`,
+        `
+try {
+    doSomething();
+} finally {
+    for (let i = 0; i < 10; i++) {
+        cleanup();
+    }
+}
+`,
+        `
+try {
+    doSomething();
+} finally {
+    while (condition) {
+        cleanup();
+    }
+}
+`,
+        `
+try {
+    doSomething();
+} finally {
+    for (let i = 0; i < 10; i++) {
+        if (i === 5) break;
+    }
+}
+`,
+        `
+try {
+    doSomething();
+} finally {
+    while (condition) {
+        if (shouldExit) break;
+    }
+}
+`,
+        `
+try {
+    doSomething();
+} finally {
+    for (let i = 0; i < 10; i++) {
+        if (i === 0) continue;
+        process(i);
+    }
+}
+`,
+        `
+try {
+    doSomething();
+} finally {
+    try {
+        cleanup();
+    } finally {
+        log();
+    }
+}
+`,
+    ],
+});
+//# sourceMappingURL=finallyStatementSafety.test.js.map

package/lib/rules/forDirections.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports for loops with counter variables that move in the wrong direction.";
     readonly id: "forDirections";
     readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "wrongDirection", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "wrongDirection", undefined>;
 export default _default;
+//# sourceMappingURL=forDirections.d.ts.map

package/lib/rules/forDirections.js

@@ -102,7 +102,7 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                ForStatement: (node) => {
+                ForStatement: (node, { sourceFile }) => {
                     if (!node.condition ||
                         !node.incrementor ||
                         !node.initializer ||
@@ -121,7 +121,7 @@ export default typescriptLanguage.createRule({
                     if (conditionDirection && conditionDirection !== updateDirection) {
                         context.report({
                             message: "wrongDirection",
-                            range: getTSNodeRange(node.incrementor, context.sourceFile),
+                            range: getTSNodeRange(node.incrementor, sourceFile),
                         });
                     }
                 },
@@ -129,3 +129,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=forDirections.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=forDirections.test.d.ts.map

package/lib/rules/forDirections.test.js

@@ -122,3 +122,4 @@ for (let i = 10; text[i] !== " " && i >= 0; i++) { }
         `for (let i = 10; i >= 0 && text[i] === "\\"; i--) { }`,
     ],
 });
+//# sourceMappingURL=forDirections.test.js.map

package/lib/rules/forInArrays.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports iterating over an array with a for-in loop.";
     readonly id: "forInArrays";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "forIn", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "forIn", undefined>;
 export default _default;
+//# sourceMappingURL=forInArrays.d.ts.map

package/lib/rules/forInArrays.js

@@ -23,21 +23,21 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function hasNumberLikeLength(type) {
+        function hasNumberLikeLength(type, typeChecker) {
             const lengthProperty = type.getProperty("length");
             if (lengthProperty == null) {
                 return false;
             }
-            return tsutils.isTypeFlagSet(context.typeChecker.getTypeOfSymbol(lengthProperty), ts.TypeFlags.NumberLike);
+            return tsutils.isTypeFlagSet(typeChecker.getTypeOfSymbol(lengthProperty), ts.TypeFlags.NumberLike);
         }
-        function isArrayLike(type) {
-            return isTypeRecursive(type, (t) => t.getNumberIndexType() != null && hasNumberLikeLength(t));
+        function isArrayLike(type, typeChecker) {
+            return isTypeRecursive(type, (t) => t.getNumberIndexType() != null && hasNumberLikeLength(t, typeChecker));
         }
         return {
             visitors: {
-                ForInStatement: (node) => {
-                    const type = getConstrainedTypeAtLocation(node.expression, context.typeChecker);
-                    if (isArrayLike(type)) {
+                ForInStatement: (node, { typeChecker }) => {
+                    const type = getConstrainedTypeAtLocation(node.expression, typeChecker);
+                    if (isArrayLike(type, typeChecker)) {
                         context.report({
                             message: "forIn",
                             range: {
@@ -51,3 +51,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=forInArrays.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=forInArrays.test.d.ts.map

package/lib/rules/forInArrays.test.js

@@ -22,3 +22,4 @@ for (const i of array) {}
 `,
     ],
 });
+//# sourceMappingURL=forInArrays.test.js.map

package/lib/rules/functionAssignments.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports reassigning variables declared with function declarations.";
     readonly id: "functionAssignments";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noFunctionAssignment", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noFunctionAssignment", undefined>;
 export default _default;
+//# sourceMappingURL=functionAssignments.d.ts.map

package/lib/rules/functionAssignments.js

@@ -21,16 +21,16 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                FunctionDeclaration: (node) => {
+                FunctionDeclaration: (node, { sourceFile, typeChecker }) => {
                     if (!node.name) {
                         return;
                     }
-                    const modifyingReferences = getModifyingReferences(node.name, context.sourceFile, context.typeChecker);
+                    const modifyingReferences = getModifyingReferences(node.name, sourceFile, typeChecker);
                     for (const reference of modifyingReferences) {
                         context.report({
                             message: "noFunctionAssignment",
                             range: {
-                                begin: reference.getStart(context.sourceFile),
+                                begin: reference.getStart(sourceFile),
                                 end: reference.getEnd(),
                             },
                         });
@@ -40,3 +40,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=functionAssignments.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=functionAssignments.test.d.ts.map

package/lib/rules/functionAssignments.test.js

@@ -207,3 +207,4 @@ function myFunction() {
 `,
     ],
 });
+//# sourceMappingURL=functionAssignments.test.js.map

package/lib/rules/functionCurryingRedundancy.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using `.apply()` or `.call()` or  when the context (`this` value) provides no benefit.";
+    readonly id: "functionCurryingRedundancy";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "unnecessaryCall", undefined>;
+export default _default;
+//# sourceMappingURL=functionCurryingRedundancy.d.ts.map