@flint.fyi/ts 0.14.3 → 0.14.4

package/lib/rules/selfAssignments.js

@@ -0,0 +1,44 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { hasSameTokens } from "../utils/hasSameTokens.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports self-assignments which have no effect and are likely errors.",
+        id: "selfAssignments",
+        preset: "logical",
+    },
+    messages: {
+        selfAssignment: {
+            primary: "This value is being assigned to itself, which does nothing.",
+            secondary: [
+                "Self-assignments have no effect and typically indicate an incomplete refactoring or copy-paste error.",
+            ],
+            suggestions: [
+                "Review the assignment and ensure you're assigning the correct value.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                BinaryExpression: (node) => {
+                    if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken &&
+                        node.operatorToken.kind !==
+                            ts.SyntaxKind.AmpersandAmpersandEqualsToken &&
+                        node.operatorToken.kind !== ts.SyntaxKind.BarBarEqualsToken &&
+                        node.operatorToken.kind !==
+                            ts.SyntaxKind.QuestionQuestionEqualsToken) {
+                        return;
+                    }
+                    if (hasSameTokens(node.left, node.right, context.sourceFile)) {
+                        context.report({
+                            message: "selfAssignment",
+                            range: getTSNodeRange(node, context.sourceFile),
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/selfAssignments.test.js

@@ -0,0 +1,66 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./selfAssignments.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+value = value;
+`,
+            snapshot: `
+value = value;
+~~~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+        },
+        {
+            code: `
+count &&= count;
+`,
+            snapshot: `
+count &&= count;
+~~~~~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+        },
+        {
+            code: `
+flag ||= flag;
+`,
+            snapshot: `
+flag ||= flag;
+~~~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+        },
+        {
+            code: `
+data ??= data;
+`,
+            snapshot: `
+data ??= data;
+~~~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+        },
+        {
+            code: `
+a.b ??= a.b;
+`,
+            snapshot: `
+a.b ??= a.b;
+~~~~~~~~~~~
+This value is being assigned to itself, which does nothing.
+`,
+        },
+    ],
+    valid: [
+        `value = other;`,
+        `first = second;`,
+        `let value = value;`,
+        `const data = data;`,
+        `value += value;`,
+        `count -= count;`,
+        `a ||= b;`,
+        `a.b ||= a.c;`,
+    ],
+});

package/lib/rules/selfComparisons.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports comparing a value to itself.";
+    readonly id: "selfComparisons";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noSelfComparison", undefined>;
+export default _default;

package/lib/rules/selfComparisons.js

@@ -0,0 +1,41 @@
+import { typescriptLanguage } from "../language.js";
+import { hasSameTokens } from "../utils/hasSameTokens.js";
+import { isComparisonOperator } from "./utils/operators.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports comparing a value to itself.",
+        id: "selfComparisons",
+        preset: "logical",
+    },
+    messages: {
+        noSelfComparison: {
+            primary: "Comparing a value to itself is unnecessary and likely indicates a logic error.",
+            secondary: [
+                "Self-comparisons always evaluate to the same result for a given operator.",
+                "This pattern often indicates a copy-paste error or typo where different variables were intended.",
+            ],
+            suggestions: [
+                "Verify that you intended to compare two different values.",
+                "If checking for NaN, use `Number.isNaN()` or `isNaN()` instead.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                BinaryExpression: (node) => {
+                    if (isComparisonOperator(node.operatorToken) &&
+                        hasSameTokens(node.left, node.right, context.sourceFile)) {
+                        context.report({
+                            message: "noSelfComparison",
+                            range: {
+                                begin: node.getStart(context.sourceFile),
+                                end: node.getEnd(),
+                            },
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/selfComparisons.test.js

@@ -0,0 +1,297 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./selfComparisons.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+if (value === value) {
+	console.log("always true");
+}
+`,
+            snapshot: `
+if (value === value) {
+    ~~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("always true");
+}
+`,
+        },
+        {
+            code: `
+if (value == value) {
+	console.log("always true");
+}
+`,
+            snapshot: `
+if (value == value) {
+    ~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("always true");
+}
+`,
+        },
+        {
+            code: `
+if (value !== value) {
+	console.log("always false");
+}
+`,
+            snapshot: `
+if (value !== value) {
+    ~~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("always false");
+}
+`,
+        },
+        {
+            code: `
+if (value != value) {
+	console.log("always false");
+}
+`,
+            snapshot: `
+if (value != value) {
+    ~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("always false");
+}
+`,
+        },
+        {
+            code: `
+if (value < value) {
+	console.log("always false");
+}
+`,
+            snapshot: `
+if (value < value) {
+    ~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("always false");
+}
+`,
+        },
+        {
+            code: `
+if (value <= value) {
+	console.log("always true");
+}
+`,
+            snapshot: `
+if (value <= value) {
+    ~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("always true");
+}
+`,
+        },
+        {
+            code: `
+if (value > value) {
+	console.log("always false");
+}
+`,
+            snapshot: `
+if (value > value) {
+    ~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("always false");
+}
+`,
+        },
+        {
+            code: `
+if (value >= value) {
+	console.log("always true");
+}
+`,
+            snapshot: `
+if (value >= value) {
+    ~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("always true");
+}
+`,
+        },
+        {
+            code: `
+const result = object.property === object.property;
+`,
+            snapshot: `
+const result = object.property === object.property;
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+               Comparing a value to itself is unnecessary and likely indicates a logic error.
+`,
+        },
+        {
+            code: `
+const result = array[0] === array[0];
+`,
+            snapshot: `
+const result = array[0] === array[0];
+               ~~~~~~~~~~~~~~~~~~~~~
+               Comparing a value to itself is unnecessary and likely indicates a logic error.
+`,
+        },
+        {
+            code: `
+if (calculate() === calculate()) {
+	console.log("functions");
+}
+`,
+            snapshot: `
+if (calculate() === calculate()) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("functions");
+}
+`,
+        },
+        {
+            code: `
+if (value /* comment */ === value) {
+	console.log("with comment");
+}
+`,
+            snapshot: `
+if (value /* comment */ === value) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("with comment");
+}
+`,
+        },
+        {
+            code: `
+if (object.property /* comment */ === object.property) {
+	console.log("with comment in property access");
+}
+`,
+            snapshot: `
+if (object.property /* comment */ === object.property) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("with comment in property access");
+}
+`,
+        },
+        {
+            code: `
+if (array /* comment */ [0] === array[0]) {
+	console.log("with comment in array access");
+}
+`,
+            snapshot: `
+if (array /* comment */ [0] === array[0]) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("with comment in array access");
+}
+`,
+        },
+        {
+            code: `
+if (value === value /* comment */) {
+	console.log("comment on right side");
+}
+`,
+            snapshot: `
+if (value === value /* comment */) {
+    ~~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("comment on right side");
+}
+`,
+        },
+        {
+            code: `
+if (value /* left */ === value /* right */) {
+	console.log("comments on both sides");
+}
+`,
+            snapshot: `
+if (value /* left */ === value /* right */) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("comments on both sides");
+}
+`,
+        },
+        {
+            code: `
+if (object.property === object /* comment */ .property) {
+	console.log("comment on right property access");
+}
+`,
+            snapshot: `
+if (object.property === object /* comment */ .property) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("comment on right property access");
+}
+`,
+        },
+        {
+            code: `
+if (array[0] === array /* comment */ [0]) {
+	console.log("comment on right array access");
+}
+`,
+            snapshot: `
+if (array[0] === array /* comment */ [0]) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("comment on right array access");
+}
+`,
+        },
+        {
+            code: `
+if (/* before */ value === value /* after */) {
+	console.log("comments before and after");
+}
+`,
+            snapshot: `
+if (/* before */ value === value /* after */) {
+                 ~~~~~~~~~~~~~~~
+                 Comparing a value to itself is unnecessary and likely indicates a logic error.
+	console.log("comments before and after");
+}
+`,
+        },
+        {
+            code: `
+const result = value /* a */ /* b */ === value /* c */ /* d */;
+`,
+            snapshot: `
+const result = value /* a */ /* b */ === value /* c */ /* d */;
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+               Comparing a value to itself is unnecessary and likely indicates a logic error.
+`,
+        },
+    ],
+    valid: [
+        `if (value1 === value2) { console.log("different values"); }`,
+        `if (value === other) { console.log("different values"); }`,
+        `if (object.property === object.otherProperty) { console.log("different properties"); }`,
+        `if (array[0] === array[1]) { console.log("different elements"); }`,
+        `const result = value1 == value2;`,
+        `const result = value1 != value2;`,
+        `const result = value1 !== value2;`,
+        `const result = value1 < value2;`,
+        `const result = value1 <= value2;`,
+        `const result = value1 > value2;`,
+        `const result = value1 >= value2;`,
+        `if (Number.isNaN(value)) { console.log("checking for NaN correctly"); }`,
+        `if (value1 /* comment */ === value2) { console.log("different with comment on left"); }`,
+        `if (value1 === value2 /* comment */) { console.log("different with comment on right"); }`,
+        `if (value1 /* left */ === value2 /* right */) { console.log("different with comments on both"); }`,
+        `if (object /* comment */ .property === object.otherProperty) { console.log("different properties with comment"); }`,
+        `if (object.property === object /* comment */ .otherProperty) { console.log("different properties with comment on right"); }`,
+        `if (array /* comment */ [0] === array[1]) { console.log("different elements with comment on left"); }`,
+        `if (array[0] === array /* comment */ [1]) { console.log("different elements with comment on right"); }`,
+        `if (/* before */ value1 === value2 /* after */) { console.log("different with surrounding comments"); }`,
+        `const result = value1 /* a */ /* b */ === value2 /* c */ /* d */;`,
+    ],
+});

package/lib/rules/sequences.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the comma operator in expressions.";
+    readonly id: "sequences";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noSequences", undefined>;
+export default _default;

package/lib/rules/sequences.js

@@ -0,0 +1,34 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports using the comma operator in expressions.",
+        id: "sequences",
+        preset: "untyped",
+    },
+    messages: {
+        noSequences: {
+            primary: 'The "sequence" (comma) operator is often confusing and a sign of mistaken logic.',
+            secondary: [
+                "The comma operator can make code harder to read and may hide side effects.",
+                "Prefer separate expressions instead of using a single sequence.",
+            ],
+            suggestions: ["Split the expression into separate statements."],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                BinaryExpression: (node) => {
+                    if (node.operatorToken.kind === ts.SyntaxKind.CommaToken) {
+                        context.report({
+                            message: "noSequences",
+                            range: getTSNodeRange(node.operatorToken, context.sourceFile),
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/sequences.test.js

@@ -0,0 +1,48 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./sequences.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const a = (1, 2);
+`,
+            snapshot: `
+const a = (1, 2);
+            ~
+            The "sequence" (comma) operator is often confusing and a sign of mistaken logic.
+`,
+        },
+        {
+            code: `
+function f() {
+    return (g(), h());
+}
+`,
+            snapshot: `
+function f() {
+    return (g(), h());
+               ~
+               The "sequence" (comma) operator is often confusing and a sign of mistaken logic.
+}
+`,
+        },
+        {
+            code: `
+for ((a = 1, b = 2); ; ) {
+}
+`,
+            snapshot: `
+for ((a = 1, b = 2); ; ) {
+           ~
+           The "sequence" (comma) operator is often confusing and a sign of mistaken logic.
+}
+`,
+        },
+    ],
+    valid: [
+        `const a = [1, 2];`,
+        `const a = (1 + 2);`,
+        `function f() { g(); h(); }`,
+        `for (let i = 0; i < 10; i += 1) {}`,
+    ],
+});

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