@flint.fyi/ts 0.14.5 → 0.15.0

package/lib/rules/emptyDestructures.js

@@ -19,12 +19,12 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function checkBindingPattern(node) {
+        function checkBindingPattern(node, { sourceFile }) {
             if (node.elements.length === 0) {
                 context.report({
                     message: "emptyPattern",
                     range: {
-                        begin: node.getStart(context.sourceFile),
+                        begin: node.getStart(sourceFile),
                         end: node.getEnd(),
                     },
                 });
@@ -38,3 +38,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=emptyDestructures.js.map

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

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

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

@@ -7,6 +7,13 @@ function getConditionDirection(condition, counterName) {
     }
     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;
     if (!isCounterLeft && !isCounterRight) {
@@ -38,10 +45,10 @@ function getConditionDirection(condition, counterName) {
 function getCounterName(node) {
     return ts.isIdentifier(node) ? node.text : undefined;
 }
-function getUpdateDirection(update) {
-    if (ts.isPostfixUnaryExpression(update) ||
-        ts.isPrefixUnaryExpression(update)) {
-        switch (update.operator) {
+function getIncrementorDirection(incrementor) {
+    if (ts.isPostfixUnaryExpression(incrementor) ||
+        ts.isPrefixUnaryExpression(incrementor)) {
+        switch (incrementor.operator) {
             case ts.SyntaxKind.MinusMinusToken:
                 return -1;
             case ts.SyntaxKind.PlusPlusToken:
@@ -50,8 +57,8 @@ function getUpdateDirection(update) {
                 return undefined;
         }
     }
-    if (ts.isBinaryExpression(update)) {
-        const { operatorToken, right } = update;
+    if (ts.isBinaryExpression(incrementor)) {
+        const { operatorToken, right } = incrementor;
         if (operatorToken.kind === ts.SyntaxKind.PlusEqualsToken ||
             operatorToken.kind === ts.SyntaxKind.MinusEqualsToken) {
             if (ts.isNumericLiteral(right)) {
@@ -95,7 +102,7 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                ForStatement: (node) => {
+                ForStatement: (node, { sourceFile }) => {
                     if (!node.condition ||
                         !node.incrementor ||
                         !node.initializer ||
@@ -106,15 +113,15 @@ export default typescriptLanguage.createRule({
                     if (!declaration || !ts.isIdentifier(declaration.name)) {
                         return;
                     }
-                    const updateDirection = getUpdateDirection(node.incrementor);
+                    const updateDirection = getIncrementorDirection(node.incrementor);
                     if (!updateDirection) {
                         return;
                     }
                     const conditionDirection = getConditionDirection(node.condition, declaration.name.text);
-                    if (updateDirection !== conditionDirection) {
+                    if (conditionDirection && conditionDirection !== updateDirection) {
                         context.report({
                             message: "wrongDirection",
-                            range: getTSNodeRange(node.incrementor, context.sourceFile),
+                            range: getTSNodeRange(node.incrementor, sourceFile),
                         });
                     }
                 },
@@ -122,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

@@ -80,6 +80,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.
 `,
         },
     ],
@@ -95,5 +119,7 @@ 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--) { }`,
     ],
 });
+//# 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