@flint.fyi/ts 0.14.3 → 0.14.5

package/lib/rules/typeofComparisons.js

@@ -0,0 +1,78 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+const validTypeofValues = new Set([
+    "bigint",
+    "boolean",
+    "function",
+    "number",
+    "object",
+    "string",
+    "symbol",
+    "undefined",
+]);
+// TODO: Reuse a shared getStaticValue-style utility?
+function getStringValue(node) {
+    return ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)
+        ? node.text
+        : undefined;
+}
+function getTypeofOperand(node) {
+    return ts.isTypeOfExpression(node) && node.expression;
+}
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports typeof expressions that compare impossible string literals.",
+        id: "typeofComparisons",
+        preset: "untyped",
+    },
+    messages: {
+        invalidValue: {
+            primary: "This string literal is not one that the typeof operator will ever produce.",
+            secondary: [
+                "The typeof operator returns one of a specific set of string values.",
+                "Comparing typeof to an invalid string is usually a typo and will never match.",
+                'The only valid values are: "bigint", "boolean", "function", "number", "object", "string", "symbol", and "undefined".',
+            ],
+            suggestions: [
+                "Check for typos and use one of the valid typeof return values.",
+            ],
+        },
+    },
+    setup(context) {
+        function checkComparison(node) {
+            const leftTypeofOperand = getTypeofOperand(node.left);
+            const rightTypeofOperand = getTypeofOperand(node.right);
+            let comparisonValue;
+            if (leftTypeofOperand) {
+                comparisonValue = node.right;
+            }
+            else if (rightTypeofOperand) {
+                comparisonValue = node.left;
+            }
+            else {
+                return;
+            }
+            const stringValue = getStringValue(comparisonValue);
+            if (stringValue != null && !validTypeofValues.has(stringValue)) {
+                context.report({
+                    message: "invalidValue",
+                    range: getTSNodeRange(comparisonValue, context.sourceFile),
+                });
+            }
+        }
+        return {
+            visitors: {
+                BinaryExpression: (node) => {
+                    if (node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken ||
+                        node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+                        node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken ||
+                        node.operatorToken.kind ===
+                            ts.SyntaxKind.ExclamationEqualsEqualsToken) {
+                        checkComparison(node);
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/typeofComparisons.test.js

@@ -0,0 +1,85 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./typeofComparisons.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+if (typeof value === "") {
+    process();
+}
+`,
+            snapshot: `
+if (typeof value === "") {
+                     ~~
+                     This string literal is not one that the typeof operator will ever produce.
+    process();
+}
+`,
+        },
+        {
+            code: `
+if (typeof data != "invalid") {
+    reject();
+}
+`,
+            snapshot: `
+if (typeof data != "invalid") {
+                   ~~~~~~~~~
+                   This string literal is not one that the typeof operator will ever produce.
+    reject();
+}
+`,
+        },
+        {
+            code: `
+if ("invalid" === typeof flag) {
+    toggle();
+}
+`,
+            snapshot: `
+if ("invalid" === typeof flag) {
+    ~~~~~~~~~
+    This string literal is not one that the typeof operator will ever produce.
+    toggle();
+}
+`,
+        },
+        {
+            code: `
+if (typeof value === "String") {
+    process();
+}
+`,
+            snapshot: `
+if (typeof value === "String") {
+                     ~~~~~~~~
+                     This string literal is not one that the typeof operator will ever produce.
+    process();
+}
+`,
+        },
+        {
+            code: `
+const isValid = typeof input !== "array";
+`,
+            snapshot: `
+const isValid = typeof input !== "array";
+                                 ~~~~~~~
+                                 This string literal is not one that the typeof operator will ever produce.
+`,
+        },
+    ],
+    valid: [
+        `if (typeof value === "string") { process(); }`,
+        `if (typeof variable == "undefined") { handle(); }`,
+        `if (typeof data != "number") { reject(); }`,
+        `if (typeof callback !== "function") { throw new Error("Invalid callback"); }`,
+        `if (typeof flag === "boolean") { toggle(); }`,
+        `if (typeof value === "object") { parse(); }`,
+        `if (typeof value === "symbol") { handle(); }`,
+        `if (typeof value === "bigint") { compute(); }`,
+        `if (typeof value === other) { process(); }`,
+        `if (typeof value === typeof other) { compare(); }`,
+        `const type = typeof value;`,
+    ],
+});

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/utils/discriminateAnyType.d.ts

@@ -0,0 +1,12 @@
+import * as ts from "typescript";
+export declare enum AnyType {
+    Any = 0,
+    PromiseAny = 1,
+    AnyArray = 2,
+    Safe = 3
+}
+/**
+ * @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise<any>`,
+ * otherwise it returns `AnyType.Safe`.
+ */
+export declare function discriminateAnyType(type: ts.Type, checker: ts.TypeChecker, program: ts.Program, tsNode: ts.Node): AnyType;

package/lib/rules/utils/discriminateAnyType.js

@@ -0,0 +1,41 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+export var AnyType;
+(function (AnyType) {
+    AnyType[AnyType["Any"] = 0] = "Any";
+    AnyType[AnyType["PromiseAny"] = 1] = "PromiseAny";
+    AnyType[AnyType["AnyArray"] = 2] = "AnyArray";
+    AnyType[AnyType["Safe"] = 3] = "Safe";
+})(AnyType || (AnyType = {}));
+/**
+ * @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise<any>`,
+ * otherwise it returns `AnyType.Safe`.
+ */
+export function discriminateAnyType(type, checker, program, tsNode) {
+    return discriminateAnyTypeWorker(type, checker, program, tsNode, new Set());
+}
+function discriminateAnyTypeWorker(type, checker, program, tsNode, visited) {
+    if (visited.has(type)) {
+        return AnyType.Safe;
+    }
+    visited.add(type);
+    if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any)) {
+        return AnyType.Any;
+    }
+    if (checker.isArrayType(type) &&
+        tsutils.isTypeFlagSet(checker.getTypeArguments(type)[0], ts.TypeFlags.Any)) {
+        return AnyType.AnyArray;
+    }
+    for (const part of tsutils.typeConstituents(type)) {
+        if (tsutils.isThenableType(checker, tsNode, part)) {
+            const awaitedType = checker.getAwaitedType(part);
+            if (awaitedType) {
+                const awaitedAnyType = discriminateAnyTypeWorker(awaitedType, checker, program, tsNode, visited);
+                if (awaitedAnyType === AnyType.Any) {
+                    return AnyType.PromiseAny;
+                }
+            }
+        }
+    }
+    return AnyType.Safe;
+}

package/lib/rules/utils/getThisExpression.d.ts

@@ -0,0 +1,2 @@
+import * as ts from "typescript";
+export declare function getThisExpression(node: ts.Node): null | ts.ThisExpression;

package/lib/rules/utils/getThisExpression.js

@@ -0,0 +1,23 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+export function getThisExpression(node) {
+    while (true) {
+        node = skipParentheses(node);
+        if (ts.isCallExpression(node) || tsutils.isAccessExpression(node)) {
+            node = node.expression;
+        }
+        else if (tsutils.isThisExpression(node)) {
+            return node;
+        }
+        else {
+            break;
+        }
+    }
+    return null;
+}
+function skipParentheses(node) {
+    while (ts.isParenthesizedExpression(node)) {
+        node = node.expression;
+    }
+    return node;
+}

package/lib/rules/utils/isUnsafeAssignment.d.ts

@@ -0,0 +1,13 @@
+import * as ts from "typescript";
+/**
+ * Does a simple check to see if there is an any being assigned to a non-any type.
+ *
+ * This also checks generic positions to ensure there's no unsafe sub-assignments.
+ * Note: in the case of generic positions, it makes the assumption that the two types are the same.
+ * @example See tests for examples
+ * @returns false if it's safe, or an object with the two types if it's unsafe
+ */
+export declare function isUnsafeAssignment(type: ts.Type, receiver: ts.Type, checker: ts.TypeChecker, senderNode: null | ts.Node): false | {
+    receiver: ts.Type;
+    sender: ts.Type;
+};