@flint.fyi/ts 0.14.3 → 0.14.5

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

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports variable declarations that shadow JavaScript's restricted names.";
+    readonly id: "shadowedRestrictedNames";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "shadowedRestrictedName", undefined>;
+export default _default;

package/lib/rules/shadowedRestrictedNames.js

@@ -0,0 +1,95 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+const restrictedNames = new Set([
+    "arguments",
+    "eval",
+    "Infinity",
+    "NaN",
+    "undefined",
+]);
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports variable declarations that shadow JavaScript's restricted names.",
+        id: "shadowedRestrictedNames",
+        preset: "untyped",
+    },
+    messages: {
+        shadowedRestrictedName: {
+            primary: "This variable misleadingly shadows the global `{{ name }}`.",
+            secondary: [
+                "JavaScript has certain built-in global identifiers that are considered restricted because shadowing them can lead to confusing or erroneous code.",
+                "When you declare a variable with a restricted name, it shadows the global identifier and can cause unexpected behavior.",
+            ],
+            suggestions: [
+                "Use a different variable name that doesn't shadow a restricted name.",
+            ],
+        },
+    },
+    setup(context) {
+        function checkIdentifier(node) {
+            if (restrictedNames.has(node.text)) {
+                context.report({
+                    data: {
+                        name: node.text,
+                    },
+                    message: "shadowedRestrictedName",
+                    range: getTSNodeRange(node, context.sourceFile),
+                });
+            }
+        }
+        function checkBindingName(name) {
+            if (ts.isIdentifier(name)) {
+                checkIdentifier(name);
+            }
+            else if (ts.isObjectBindingPattern(name) ||
+                ts.isArrayBindingPattern(name)) {
+                for (const element of name.elements) {
+                    if (ts.isBindingElement(element)) {
+                        checkBindingName(element.name);
+                    }
+                }
+            }
+        }
+        function checkParameters(parameters) {
+            for (const parameter of parameters) {
+                checkBindingName(parameter.name);
+            }
+        }
+        return {
+            visitors: {
+                ArrowFunction: (node) => {
+                    checkParameters(node.parameters);
+                },
+                ClassDeclaration: (node) => {
+                    if (node.name) {
+                        checkIdentifier(node.name);
+                    }
+                },
+                ClassExpression: (node) => {
+                    if (node.name) {
+                        checkIdentifier(node.name);
+                    }
+                },
+                FunctionDeclaration: (node) => {
+                    if (node.name) {
+                        checkIdentifier(node.name);
+                    }
+                    checkParameters(node.parameters);
+                },
+                FunctionExpression: (node) => {
+                    if (node.name) {
+                        checkIdentifier(node.name);
+                    }
+                    checkParameters(node.parameters);
+                },
+                MethodDeclaration: (node) => {
+                    checkParameters(node.parameters);
+                },
+                VariableDeclaration: (node) => {
+                    checkBindingName(node.name);
+                },
+            },
+        };
+    },
+});

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

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

package/lib/rules/shadowedRestrictedNames.test.js

@@ -0,0 +1,147 @@
+import { ruleTester } from "./ruleTester.js";
+import rule from "./shadowedRestrictedNames.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+let undefined = 5;
+`,
+            snapshot: `
+let undefined = 5;
+    ~~~~~~~~~
+    This variable misleadingly shadows the global \`undefined\`.
+`,
+        },
+        {
+            code: `
+const NaN = 123;
+`,
+            snapshot: `
+const NaN = 123;
+      ~~~
+      This variable misleadingly shadows the global \`NaN\`.
+`,
+        },
+        {
+            code: `
+var Infinity = 100;
+`,
+            snapshot: `
+var Infinity = 100;
+    ~~~~~~~~
+    This variable misleadingly shadows the global \`Infinity\`.
+`,
+        },
+        {
+            code: `
+function test(arguments) {
+    return arguments.length;
+}
+`,
+            snapshot: `
+function test(arguments) {
+              ~~~~~~~~~
+              This variable misleadingly shadows the global \`arguments\`.
+    return arguments.length;
+}
+`,
+        },
+        {
+            code: `
+function eval() {
+    return 42;
+}
+`,
+            snapshot: `
+function eval() {
+         ~~~~
+         This variable misleadingly shadows the global \`eval\`.
+    return 42;
+}
+`,
+        },
+        {
+            code: `
+const arrowFunc = (undefined) => undefined;
+`,
+            snapshot: `
+const arrowFunc = (undefined) => undefined;
+                   ~~~~~~~~~
+                   This variable misleadingly shadows the global \`undefined\`.
+`,
+        },
+        {
+            code: `
+class NaN {
+    constructor() {}
+}
+`,
+            snapshot: `
+class NaN {
+      ~~~
+      This variable misleadingly shadows the global \`NaN\`.
+    constructor() {}
+}
+`,
+        },
+        {
+            code: `
+const obj = {
+    method(eval) {
+        return eval;
+    }
+};
+`,
+            snapshot: `
+const obj = {
+    method(eval) {
+           ~~~~
+           This variable misleadingly shadows the global \`eval\`.
+        return eval;
+    }
+};
+`,
+        },
+        {
+            code: `
+function test() {
+    const { undefined } = obj;
+}
+`,
+            snapshot: `
+function test() {
+    const { undefined } = obj;
+            ~~~~~~~~~
+            This variable misleadingly shadows the global \`undefined\`.
+}
+`,
+        },
+        {
+            code: `
+function test() {
+    const [NaN] = array;
+}
+`,
+            snapshot: `
+function test() {
+    const [NaN] = array;
+           ~~~
+           This variable misleadingly shadows the global \`NaN\`.
+}
+`,
+        },
+    ],
+    valid: [
+        `let value = undefined;`,
+        `const result = NaN;`,
+        `const max = Infinity;`,
+        `function test() { return arguments; }`,
+        `const code = eval("1 + 1");`,
+        `let myValue = 5;`,
+        `function myFunction() {}`,
+        `class MyClass {}`,
+        `const obj = { undefined: 5 };`,
+        `const key = "undefined";`,
+        `obj.undefined = 5;`,
+    ],
+});

package/lib/rules/symbolDescriptions.test.js

@@ -43,8 +43,8 @@ function createSymbol() {
             snapshot: `
 function createSymbol() {
 	return Symbol();
-        ~~~~~~~~
-        Symbols without descriptions are more difficult to debug or reason about.
+	       ~~~~~~~~
+	       Symbols without descriptions are more difficult to debug or reason about.
 }
 `,
         },
@@ -57,8 +57,8 @@ const obj = {
             snapshot: `
 const obj = {
 	key: Symbol(),
-      ~~~~~~~~
-      Symbols without descriptions are more difficult to debug or reason about.
+	     ~~~~~~~~
+	     Symbols without descriptions are more difficult to debug or reason about.
 };
 `,
         },

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;