@flint.fyi/ts 0.14.2 → 0.14.3

package/lib/rules/undefinedVariables.js

@@ -0,0 +1,76 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports using variables that are not defined.",
+        id: "undefinedVariables",
+        preset: "untyped",
+    },
+    messages: {
+        undefinedVariable: {
+            primary: "Variable '{{ name }}' is used but was never defined.",
+            secondary: [
+                "Variables must be declared before they can be used.",
+                "Using undefined variables will cause a ReferenceError at runtime.",
+            ],
+            suggestions: [
+                "Declare the variable before using it, or check if the variable name is spelled correctly.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                Identifier: (node) => {
+                    if (ts.isVariableDeclaration(node.parent) &&
+                        node.parent.name === node) {
+                        return;
+                    }
+                    if (ts.isParameter(node.parent) && node.parent.name === node) {
+                        return;
+                    }
+                    if ((ts.isFunctionDeclaration(node.parent) ||
+                        ts.isClassDeclaration(node.parent) ||
+                        ts.isInterfaceDeclaration(node.parent) ||
+                        ts.isTypeAliasDeclaration(node.parent) ||
+                        ts.isEnumDeclaration(node.parent) ||
+                        ts.isModuleDeclaration(node.parent)) &&
+                        node.parent.name === node) {
+                        return;
+                    }
+                    if (ts.isImportSpecifier(node.parent) ||
+                        ts.isImportClause(node.parent) ||
+                        ts.isNamespaceImport(node.parent)) {
+                        return;
+                    }
+                    if (ts.isPropertyAccessExpression(node.parent) &&
+                        node.parent.name === node) {
+                        return;
+                    }
+                    if (ts.isPropertyAssignment(node.parent) &&
+                        node.parent.name === node) {
+                        return;
+                    }
+                    if (ts.isTypeOfExpression(node.parent) &&
+                        node.parent.expression === node) {
+                        return;
+                    }
+                    // TODO: This rule is untyped, so it should use scope analysis
+                    // https://github.com/JoshuaKGoldberg/flint/issues/400
+                    if (!context.typeChecker.getSymbolAtLocation(node)) {
+                        context.report({
+                            data: {
+                                name: node.text,
+                            },
+                            message: "undefinedVariable",
+                            range: {
+                                begin: node.getStart(context.sourceFile),
+                                end: node.getEnd(),
+                            },
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/undefinedVariables.test.js

@@ -0,0 +1,80 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./undefinedVariables.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+console.log(undefinedVar);
+`,
+            snapshot: `
+console.log(undefinedVar);
+            ~~~~~~~~~~~~
+            Variable 'undefinedVar' is used but was never defined.
+`,
+        },
+        {
+            code: `
+function test() {
+    return notDefined;
+}
+`,
+            snapshot: `
+function test() {
+    return notDefined;
+           ~~~~~~~~~~
+           Variable 'notDefined' is used but was never defined.
+}
+`,
+        },
+        {
+            code: `
+const value = unknownVariable;
+`,
+            snapshot: `
+const value = unknownVariable;
+              ~~~~~~~~~~~~~~~
+              Variable 'unknownVariable' is used but was never defined.
+`,
+        },
+        {
+            code: `
+if (condition) {
+    doSomething();
+}
+`,
+            snapshot: `
+if (condition) {
+    ~~~~~~~~~
+    Variable 'condition' is used but was never defined.
+    doSomething();
+    ~~~~~~~~~~~
+    Variable 'doSomething' is used but was never defined.
+}
+`,
+        },
+        {
+            code: `
+const result = first + second;
+`,
+            snapshot: `
+const result = first + second;
+               ~~~~~
+               Variable 'first' is used but was never defined.
+                       ~~~~~~
+                       Variable 'second' is used but was never defined.
+`,
+        },
+    ],
+    valid: [
+        `const value = 5; console.log(value);`,
+        `function test(parameter: number) { return parameter; }`,
+        `let count = 0; count++;`,
+        `const obj = { prop: 1 }; console.log(obj.prop);`,
+        `typeof undefinedVar === "undefined"`,
+        `const obj = {}; const { prop } = obj;`,
+        `function fn() { return 1; } fn();`,
+        `class MyClass {} const instance = new MyClass();`,
+        `import { value } from "module"; console.log(value);`,
+        `const array = [1, 2, 3]; array.forEach(item => console.log(item));`,
+    ],
+});

package/lib/rules/unicodeBOMs.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports files with Unicode Byte Order Marks (BOMs).";
+    readonly id: "unicodeBOMs";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noBOM", undefined>;
+export default _default;

package/lib/rules/unicodeBOMs.js

@@ -0,0 +1,41 @@
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports files with Unicode Byte Order Marks (BOMs).",
+        id: "unicodeBOMs",
+        preset: "stylistic",
+    },
+    messages: {
+        noBOM: {
+            primary: "This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.",
+            secondary: [
+                "The Unicode BOM is a special character (U+FEFF) that can appear at the start of a file to indicate its byte order and encoding.",
+                "While it can be useful in some contexts, it does not improve tooling portability and is not generally helpful for editors.",
+            ],
+            suggestions: ["Remove the BOM from the beginning of the file."],
+        },
+    },
+    setup(context) {
+        const text = context.sourceFile.getFullText();
+        if (text.charCodeAt(0) !== 0xfeff) {
+            return {};
+        }
+        context.report({
+            message: "noBOM",
+            range: {
+                begin: 0,
+                end: 1,
+            },
+            suggestions: [
+                {
+                    id: "removeBOM",
+                    range: {
+                        begin: 0,
+                        end: 1,
+                    },
+                    text: "",
+                },
+            ],
+        });
+    },
+});

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

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

package/lib/rules/unicodeBOMs.test.js

@@ -0,0 +1,65 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./unicodeBOMs.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `\uFEFFconst value = 1;
+`,
+            snapshot: `\uFEFFconst value = 1;
+~
+This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.
+`,
+            suggestions: [
+                {
+                    id: "removeBOM",
+                    updated: `const value = 1;
+`,
+                },
+            ],
+        },
+        {
+            code: `\uFEFF// Comment
+const value = 1;
+`,
+            snapshot: `\uFEFF// Comment
+~
+This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.
+const value = 1;
+`,
+            suggestions: [
+                {
+                    id: "removeBOM",
+                    updated: `// Comment
+const value = 1;
+`,
+                },
+            ],
+        },
+        {
+            code: `\uFEFF
+const value = 1;
+`,
+            snapshot: `\uFEFF
+~
+This Unicode Byte Order Mark (BOM) is unnecessary and can cause issues with some tools.
+const value = 1;
+`,
+            suggestions: [
+                {
+                    id: "removeBOM",
+                    updated: `
+const value = 1;
+`,
+                },
+            ],
+        },
+    ],
+    valid: [
+        `const value = 1;`,
+        `// Comment at the start
+const value = 1;`,
+        `
+const value = 1;`,
+        `function test() { return 42; }`,
+    ],
+});

package/lib/rules/unnecessaryCatches.d.ts

@@ -0,0 +1,6 @@
+declare const _default: 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>;
+export default _default;

package/lib/rules/unnecessaryCatches.js

@@ -0,0 +1,68 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports catch clauses that only rethrow the caught error without modification.",
+        id: "unnecessaryCatches",
+        preset: "logical",
+    },
+    messages: {
+        unnecessaryCatch: {
+            primary: "This catch clause is unnecessary, as it only rethrows the exception without modification.",
+            secondary: [
+                "A catch clause that only rethrows the caught error adds no value and creates unnecessary code complexity.",
+                "Removing such catch clauses allows errors to propagate naturally without the overhead of an unnecessary try-catch block.",
+            ],
+            suggestions: [
+                "Remove the try-catch block if the catch clause only rethrows the error, or add meaningful error handling logic to the catch clause.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                CatchClause: (node) => {
+                    if (!node.variableDeclaration || !ts.isBlock(node.block)) {
+                        return;
+                    }
+                    const statements = node.block.statements;
+                    if (statements.length !== 1) {
+                        return;
+                    }
+                    const statement = statements[0];
+                    if (!ts.isThrowStatement(statement)) {
+                        return;
+                    }
+                    const catchVariable = node.variableDeclaration.name;
+                    const thrownExpression = statement.expression;
+                    if (!ts.isIdentifier(catchVariable) ||
+                        !ts.isIdentifier(thrownExpression)) {
+                        return;
+                    }
+                    if (catchVariable.text !== thrownExpression.text) {
+                        return;
+                    }
+                    const tryStatement = node.parent;
+                    if (!ts.isTryStatement(tryStatement)) {
+                        return;
+                    }
+                    const range = {
+                        begin: node.getStart(context.sourceFile),
+                        end: node.getStart(context.sourceFile) + "catch".length,
+                    };
+                    context.report({
+                        fix: {
+                            range: {
+                                begin: tryStatement.tryBlock.getEnd(),
+                                end: node.getEnd(),
+                            },
+                            text: "",
+                        },
+                        message: "unnecessaryCatch",
+                        range,
+                    });
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/unnecessaryCatches.test.js

@@ -0,0 +1,210 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./unnecessaryCatches.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+try {
+    doSomething();
+} catch (error) {
+    throw error;
+}
+`,
+            output: `
+try {
+    doSomething();
+}
+`,
+            snapshot: `
+try {
+    doSomething();
+} catch (error) {
+  ~~~~~
+  This catch clause is unnecessary, as it only rethrows the exception without modification.
+    throw error;
+}
+`,
+        },
+        {
+            code: `
+async function fetchData() {
+    try {
+        return await fetch("/api/data");
+    } catch (error) {
+        throw error;
+    }
+}
+`,
+            output: `
+async function fetchData() {
+    try {
+        return await fetch("/api/data");
+    }
+}
+`,
+            snapshot: `
+async function fetchData() {
+    try {
+        return await fetch("/api/data");
+    } catch (error) {
+      ~~~~~
+      This catch clause is unnecessary, as it only rethrows the exception without modification.
+        throw error;
+    }
+}
+`,
+        },
+        {
+            code: `
+try {
+    processData();
+} catch (exception) {
+    throw exception;
+}
+`,
+            output: `
+try {
+    processData();
+}
+`,
+            snapshot: `
+try {
+    processData();
+} catch (exception) {
+  ~~~~~
+  This catch clause is unnecessary, as it only rethrows the exception without modification.
+    throw exception;
+}
+`,
+        },
+        {
+            code: `
+function handleRequest() {
+    try {
+        const result = performOperation();
+        return result;
+    } catch (err) {
+        throw err;
+    }
+}
+`,
+            output: `
+function handleRequest() {
+    try {
+        const result = performOperation();
+        return result;
+    }
+}
+`,
+            snapshot: `
+function handleRequest() {
+    try {
+        const result = performOperation();
+        return result;
+    } catch (err) {
+      ~~~~~
+      This catch clause is unnecessary, as it only rethrows the exception without modification.
+        throw err;
+    }
+}
+`,
+        },
+        {
+            code: `
+try {
+    doSomething();
+} catch (error) {
+    throw error;
+} finally {
+    cleanup();
+}
+`,
+            output: `
+try {
+    doSomething();
+} finally {
+    cleanup();
+}
+`,
+            snapshot: `
+try {
+    doSomething();
+} catch (error) {
+  ~~~~~
+  This catch clause is unnecessary, as it only rethrows the exception without modification.
+    throw error;
+} finally {
+    cleanup();
+}
+`,
+        },
+    ],
+    valid: [
+        `try { doSomething(); } catch (error) { console.error(error); throw error; }`,
+        `try { doSomething(); } catch (error) { throw new Error("Failed"); }`,
+        `try { doSomething(); } catch (error) { logError(error); throw error; }`,
+        `try { doSomething(); } catch { throw new Error("Something went wrong"); }`,
+        `
+try {
+    doSomething();
+} catch (error) {
+    console.error("An error occurred:", error);
+    throw error;
+}
+`,
+        `
+try {
+    doSomething();
+} catch (error) {
+    throw new Error("Operation failed: " + error.message);
+}
+`,
+        `
+try {
+    doSomething();
+} catch (error) {
+    cleanup();
+    throw error;
+}
+`,
+        `
+try {
+    doSomething();
+} catch (error) {
+    throw error.originalError;
+}
+`,
+        `
+async function fetchData() {
+    try {
+        return await fetch("/api/data");
+    } catch (error) {
+        await logError(error);
+        throw error;
+    }
+}
+`,
+        `
+try {
+    doSomething();
+} catch ({ message }) {
+    throw message;
+}
+`,
+        `
+try {
+    doSomething();
+} catch (error) {
+}
+`,
+        `
+try {
+    doSomething();
+} catch (error) {
+    console.log("error");
+    cleanup();
+    throw error;
+}
+`,
+    ],
+});

package/lib/rules/unsafeNegations.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports negating the left operand of `in` or `instanceof` relations.";
+    readonly id: "unsafeNegations";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "preferNegatingRelation", undefined>;
+export default _default;

package/lib/rules/unsafeNegations.js

@@ -0,0 +1,50 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+import { unwrapParenthesizedExpression } from "../utils/unwrapParenthesizedExpression.js";
+const operatorStrings = new Map([
+    [ts.SyntaxKind.InKeyword, "in"],
+    [ts.SyntaxKind.InstanceOfKeyword, "instanceof"],
+]);
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports negating the left operand of `in` or `instanceof` relations.",
+        id: "unsafeNegations",
+        preset: "untyped",
+    },
+    messages: {
+        preferNegatingRelation: {
+            primary: "This negation applies before the `{{ operator }}` operator.",
+            secondary: [
+                "The logical not operator (!) has higher precedence than `in` and `instanceof`.",
+                "Write `!(left in right)` or `!(left instanceof Right)` to negate the relation as intended.",
+            ],
+            suggestions: ["Wrap the relation in parentheses and negate it."],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                BinaryExpression: (node) => {
+                    const operator = operatorStrings.get(node.operatorToken.kind);
+                    if (!operator) {
+                        return;
+                    }
+                    const left = unwrapParenthesizedExpression(node.left);
+                    if (!ts.isPrefixUnaryExpression(left) ||
+                        left.operator !== ts.SyntaxKind.ExclamationToken) {
+                        return;
+                    }
+                    const begin = left.getStart(context.sourceFile);
+                    context.report({
+                        data: { operator },
+                        message: "preferNegatingRelation",
+                        range: {
+                            begin,
+                            end: begin + 1,
+                        },
+                    });
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/unsafeNegations.test.js

@@ -0,0 +1,63 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./unsafeNegations.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+!key in object;
+`,
+            snapshot: `
+!key in object;
+~
+This negation applies before the \`in\` operator.
+`,
+        },
+        {
+            code: `
+!object instanceof Constructor;
+`,
+            snapshot: `
+!object instanceof Constructor;
+~
+This negation applies before the \`instanceof\` operator.
+`,
+        },
+        {
+            code: `
+(!key) in object;
+`,
+            snapshot: `
+(!key) in object;
+ ~
+ This negation applies before the \`in\` operator.
+`,
+        },
+        {
+            code: `
+(!object) instanceof Constructor;
+`,
+            snapshot: `
+(!object) instanceof Constructor;
+ ~
+ This negation applies before the \`instanceof\` operator.
+`,
+        },
+        {
+            code: `
+const exists = !key in object;
+`,
+            snapshot: `
+const exists = !key in object;
+               ~
+               This negation applies before the \`in\` operator.
+`,
+        },
+    ],
+    valid: [
+        `!(key in object);`,
+        `!(object instanceof Constructor);`,
+        `key in object;`,
+        `object instanceof Constructor;`,
+        `!flag && key in object;`,
+    ],
+});

package/lib/rules/variableDeletions.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports attempting to delete variables with the delete operator.";
+    readonly id: "variableDeletions";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noDeleteVar", undefined>;
+export default _default;