@flint.fyi/ts 0.14.2 → 0.14.4

package/lib/rules/sparseArrays.test.js

@@ -0,0 +1,110 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./sparseArrays.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const array = [1, , 3];
+`,
+            snapshot: `
+const array = [1, , 3];
+                  ~
+                  Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+`,
+        },
+        {
+            code: `
+const array = [, 2, 3];
+`,
+            snapshot: `
+const array = [, 2, 3];
+               ~
+               Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+`,
+        },
+        {
+            code: `
+const array = [1, , , 4];
+`,
+            snapshot: `
+const array = [1, , , 4];
+                  ~
+                  Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+                    ~
+                    Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+`,
+        },
+        {
+            code: `
+const nested = [[1, , 3], [4, 5, 6]];
+`,
+            snapshot: `
+const nested = [[1, , 3], [4, 5, 6]];
+                    ~
+                    Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+`,
+        },
+        {
+            code: `
+const result = [
+    1,
+    ,
+    3
+];
+`,
+            snapshot: `
+const result = [
+    1,
+    ,
+    ~
+    Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+    3
+];
+`,
+        },
+        {
+            code: `
+const matrix = [
+    [1, 2, 3],
+    [4, , 6],
+    [7, 8, 9]
+];
+`,
+            snapshot: `
+const matrix = [
+    [1, 2, 3],
+    [4, , 6],
+        ~
+        Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+    [7, 8, 9]
+];
+`,
+        },
+        {
+            code: `
+function getArray() {
+    return [1, , 3];
+}
+`,
+            snapshot: `
+function getArray() {
+    return [1, , 3];
+               ~
+               Sparse arrays with "holes" (empty slots) are misleading and behave differently from \`undefined\` values.
+}
+`,
+        },
+    ],
+    valid: [
+        `const array = [1, 2, 3];`,
+        `const array = [];`,
+        `const array = [1];`,
+        `const array = [1, undefined, 3];`,
+        `const array = [undefined, 2, 3];`,
+        `const array = [1, 2, undefined];`,
+        `const array = [1, 2, 3,];`,
+        `const nested = [[1, undefined, 3], [4, 5, 6]];`,
+        `const matrix = [[1, 2, 3], [4, undefined, 6], [7, 8, 9]];`,
+        `const values = [null, undefined, 0, false, ""];`,
+    ],
+});

package/lib/rules/symbolDescriptions.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports Symbol() calls without description arguments.";
+    readonly id: "symbolDescriptions";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "missingDescription", undefined>;
+export default _default;

package/lib/rules/symbolDescriptions.js

@@ -0,0 +1,41 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports Symbol() calls without description arguments.",
+        id: "symbolDescriptions",
+        preset: "stylistic",
+    },
+    messages: {
+        missingDescription: {
+            primary: "Symbols without descriptions are more difficult to debug or reason about.",
+            secondary: [
+                "Creating a symbol without a description makes debugging difficult, as the symbol's purpose isn't clear when inspecting it.",
+                "While the description doesn't affect the symbol's uniqueness, it appears in the symbol's string representation and can be accessed via `Symbol.prototype.description`.",
+            ],
+            suggestions: [
+                "Add a descriptive string argument to the Symbol constructor that explains the symbol's purpose.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                CallExpression: (node) => {
+                    if (!ts.isIdentifier(node.expression) ||
+                        node.expression.text !== "Symbol" ||
+                        node.arguments.length) {
+                        return;
+                    }
+                    context.report({
+                        message: "missingDescription",
+                        range: {
+                            begin: node.getStart(context.sourceFile),
+                            end: node.getEnd(),
+                        },
+                    });
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/symbolDescriptions.test.js

@@ -0,0 +1,89 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./symbolDescriptions.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const symbol = Symbol();
+`,
+            snapshot: `
+const symbol = Symbol();
+               ~~~~~~~~
+               Symbols without descriptions are more difficult to debug or reason about.
+`,
+        },
+        {
+            code: `
+const uniqueKey = Symbol();
+`,
+            snapshot: `
+const uniqueKey = Symbol();
+                  ~~~~~~~~
+                  Symbols without descriptions are more difficult to debug or reason about.
+`,
+        },
+        {
+            code: `
+const symbols = [Symbol(), Symbol()];
+`,
+            snapshot: `
+const symbols = [Symbol(), Symbol()];
+                 ~~~~~~~~
+                 Symbols without descriptions are more difficult to debug or reason about.
+                           ~~~~~~~~
+                           Symbols without descriptions are more difficult to debug or reason about.
+`,
+        },
+        {
+            code: `
+function createSymbol() {
+	return Symbol();
+}
+`,
+            snapshot: `
+function createSymbol() {
+	return Symbol();
+        ~~~~~~~~
+        Symbols without descriptions are more difficult to debug or reason about.
+}
+`,
+        },
+        {
+            code: `
+const obj = {
+	key: Symbol(),
+};
+`,
+            snapshot: `
+const obj = {
+	key: Symbol(),
+      ~~~~~~~~
+      Symbols without descriptions are more difficult to debug or reason about.
+};
+`,
+        },
+        {
+            code: `
+const value = condition ? Symbol() : null;
+`,
+            snapshot: `
+const value = condition ? Symbol() : null;
+                          ~~~~~~~~
+                          Symbols without descriptions are more difficult to debug or reason about.
+`,
+        },
+    ],
+    valid: [
+        `const symbol = Symbol("description");`,
+        `const uniqueKey = Symbol("uniqueKey");`,
+        `const mySymbol = Symbol("my symbol");`,
+        `const symbols = [Symbol("first"), Symbol("second")];`,
+        `function createSymbol() { return Symbol("created"); }`,
+        `const obj = { key: Symbol("key") };`,
+        `const value = Symbol.for("global");`,
+        `const iterator = Symbol.iterator;`,
+        `const hasInstance = Symbol.hasInstance;`,
+        `const primitiveValue = Symbol.toPrimitive;`,
+        `Symbol("valid")`,
+    ],
+});

package/lib/rules/typeofComparisons.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports typeof expressions that compare impossible string literals.";
+    readonly id: "typeofComparisons";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "invalidValue", undefined>;
+export default _default;

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

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports variables that are declared but never assigned a value.";
+    readonly id: "unassignedVariables";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noUnassigned", undefined>;
+export default _default;

package/lib/rules/unassignedVariables.js

@@ -0,0 +1,55 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+import { getModifyingReferences } from "../utils/getModifyingReferences.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports variables that are declared but never assigned a value.",
+        id: "unassignedVariables",
+        preset: "untyped",
+    },
+    messages: {
+        noUnassigned: {
+            primary: "Variable '{{ name }}' is declared but never assigned a value.",
+            secondary: [
+                "Declaring a variable without ever assigning it a value means it will always be `undefined`.",
+                "This is often a mistake, such as forgetting to initialize the variable or assign to it later.",
+            ],
+            suggestions: [
+                "Assign a value to the variable, either at declaration or before it is used.",
+                "If the variable is meant to be `undefined`, consider making that explicit for clarity.",
+            ],
+        },
+    },
+    setup(context) {
+        function hasAssignments(identifier, sourceFile, typeChecker) {
+            // TODO (#400): Switch to scope analysis
+            return !!getModifyingReferences(identifier, sourceFile, typeChecker)
+                .length;
+        }
+        return {
+            visitors: {
+                VariableDeclaration: (node) => {
+                    if (node.initializer || !ts.isIdentifier(node.name)) {
+                        return;
+                    }
+                    if (ts.isVariableDeclarationList(node.parent) &&
+                        !!(node.parent.flags & ts.NodeFlags.Const)) {
+                        return;
+                    }
+                    if (!hasAssignments(node.name, context.sourceFile, context.typeChecker)) {
+                        context.report({
+                            data: {
+                                name: node.name.text,
+                            },
+                            message: "noUnassigned",
+                            range: {
+                                begin: node.name.getStart(context.sourceFile),
+                                end: node.name.getEnd(),
+                            },
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/unassignedVariables.test.js

@@ -0,0 +1,72 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./unassignedVariables.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+let value;
+`,
+            snapshot: `
+let value;
+    ~~~~~
+    Variable 'value' is declared but never assigned a value.
+`,
+        },
+        {
+            code: `
+var variable;
+console.log(variable);
+`,
+            snapshot: `
+var variable;
+    ~~~~~~~~
+    Variable 'variable' is declared but never assigned a value.
+console.log(variable);
+`,
+        },
+        {
+            code: `
+let unassigned: number;
+console.log(unassigned);
+`,
+            snapshot: `
+let unassigned: number;
+    ~~~~~~~~~~
+    Variable 'unassigned' is declared but never assigned a value.
+console.log(unassigned);
+`,
+        },
+        {
+            code: `
+function example() {
+    let local;
+    return local;
+}
+`,
+            snapshot: `
+function example() {
+    let local;
+        ~~~~~
+        Variable 'local' is declared but never assigned a value.
+    return local;
+}
+`,
+        },
+    ],
+    valid: [
+        `let assigned = 5;`,
+        `const constant = 10;`,
+        `var variable = "hello";`,
+        `let value: number = 42;`,
+        `let x; x = 5;`,
+        `let y; y = 10; console.log(y);`,
+        `var z; z += 1;`,
+        `let counter; counter++;`,
+        `let value; value--;`,
+        `for (let index = 0; index < 10; index++) {}`,
+        `for (let item; item < 10; item++) {}`,
+        `let result; result ||= "default";`,
+        `let data; data &&= "value";`,
+        `let nullish; nullish ??= "fallback";`,
+    ],
+});

package/lib/rules/undefinedVariables.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using variables that are not defined.";
+    readonly id: "undefinedVariables";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "undefinedVariable", undefined>;
+export default _default;

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 {};