@flint.fyi/ts 0.14.2 → 0.14.4

package/lib/rules/functionAssignments.test.js

@@ -0,0 +1,209 @@
+import rule from "./functionAssignments.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+function myFunction() {}
+myFunction = function() {};
+`,
+            snapshot: `
+function myFunction() {}
+myFunction = function() {};
+~~~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+        },
+        {
+            code: `
+function myFunction() {}
+myFunction = 123;
+`,
+            snapshot: `
+function myFunction() {}
+myFunction = 123;
+~~~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+        },
+        {
+            code: `
+function myFunction() {}
+myFunction += 1;
+`,
+            snapshot: `
+function myFunction() {}
+myFunction += 1;
+~~~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+        },
+        {
+            code: `
+function myFunction() {}
+myFunction++;
+`,
+            snapshot: `
+function myFunction() {}
+myFunction++;
+~~~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+        },
+        {
+            code: `
+function myFunction() {}
+++myFunction;
+`,
+            snapshot: `
+function myFunction() {}
+++myFunction;
+  ~~~~~~~~~~
+  Variables declared with function declarations should not be reassigned.
+`,
+        },
+        {
+            code: `
+function myFunction() {
+    return 42;
+}
+myFunction = () => 100;
+`,
+            snapshot: `
+function myFunction() {
+    return 42;
+}
+myFunction = () => 100;
+~~~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+        },
+        {
+            code: `
+function outer() {
+    function inner() {}
+    inner = function() {};
+}
+`,
+            snapshot: `
+function outer() {
+    function inner() {}
+    inner = function() {};
+    ~~~~~
+    Variables declared with function declarations should not be reassigned.
+}
+`,
+        },
+        {
+            code: `
+function myFunction() {}
+if (condition) {
+    myFunction = null;
+}
+`,
+            snapshot: `
+function myFunction() {}
+if (condition) {
+    myFunction = null;
+    ~~~~~~~~~~
+    Variables declared with function declarations should not be reassigned.
+}
+`,
+        },
+        {
+            code: `
+function getValue() {
+    return 1;
+}
+getValue ??= function() { return 0; };
+`,
+            snapshot: `
+function getValue() {
+    return 1;
+}
+getValue ??= function() { return 0; };
+~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+        },
+        {
+            code: `
+function getValue() {
+    return true;
+}
+getValue &&= false;
+`,
+            snapshot: `
+function getValue() {
+    return true;
+}
+getValue &&= false;
+~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+        },
+        {
+            code: `
+function getValue() {
+    return false;
+}
+getValue ||= () => true;
+`,
+            snapshot: `
+function getValue() {
+    return false;
+}
+getValue ||= () => true;
+~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+        },
+        {
+            code: `
+function calculate(value: number): number {
+    return value * 2;
+}
+calculate = (value: number) => value * 3;
+`,
+            snapshot: `
+function calculate(value: number): number {
+    return value * 2;
+}
+calculate = (value: number) => value * 3;
+~~~~~~~~~
+Variables declared with function declarations should not be reassigned.
+`,
+        },
+    ],
+    valid: [
+        `function myFunction() { return 42; }`,
+        `function myFunction() {} const result = myFunction();`,
+        `const myFunction = function() {}; myFunction = () => {};`,
+        `const myFunction = () => {}; myFunction = function() {};`,
+        `let myFunction = function() {}; myFunction = () => {};`,
+        `function outer() { const inner = function() {}; inner = () => {}; }`,
+        `
+function outer() {
+    const myFunction = "shadowed variable";
+    myFunction = "reassigning shadowed variable is ok";
+}
+`,
+        `
+let myFunction = "outer variable";
+function scope() {
+    function myFunction() {}
+    console.log(myFunction);
+}
+myFunction = "reassigning outer is ok";
+`,
+        `function myFunction() {} const copy = myFunction;`,
+        `function myFunction() {} if (condition) { callWith(myFunction); }`,
+        `
+function myFunction() {
+    return function nested() {
+        return 42;
+    };
+}
+`,
+    ],
+});

package/lib/rules/functionNewCalls.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the Function constructor to create functions from strings.";
+    readonly id: "functionNewCalls";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noFunctionConstructor", undefined>;
+export default _default;

package/lib/rules/functionNewCalls.js

@@ -0,0 +1,60 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { isGlobalDeclaration } from "../utils/isGlobalDeclaration.js";
+import { isGlobalDeclarationOfName } from "../utils/isGlobalDeclarationOfName.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports using the Function constructor to create functions from strings.",
+        id: "functionNewCalls",
+        preset: "logical",
+    },
+    messages: {
+        noFunctionConstructor: {
+            primary: "Dynamically creating functions with the Function constructor is insecure and slow.",
+            secondary: [
+                "Using the `Function` constructor to create functions from strings is similar to `eval()` and introduces security risks and performance issues.",
+                "Code passed to the Function constructor is executed in the global scope, making it harder to optimize and potentially allowing arbitrary code execution if user input is involved.",
+            ],
+            suggestions: [
+                "Define functions using function declarations (`function name() {}`) or arrow functions (`() => {}`) instead.",
+                "If dynamic code generation is truly necessary, consider safer alternatives like passing functions as parameters or using a more constrained domain-specific approach.",
+            ],
+        },
+    },
+    setup(context) {
+        function checkNode(node) {
+            if (isFunctionConstructor(node)) {
+                context.report({
+                    message: "noFunctionConstructor",
+                    range: getTSNodeRange(node.expression, context.sourceFile),
+                });
+            }
+        }
+        function isFunctionConstructor(node) {
+            if (ts.isIdentifier(node.expression)) {
+                if (isGlobalDeclarationOfName(node.expression, "Function", context.typeChecker)) {
+                    return true;
+                }
+            }
+            else if (ts.isPropertyAccessExpression(node.expression) &&
+                isGlobalDeclaration(node.expression, context.typeChecker)) {
+                const propertyName = node.expression.name.text;
+                if (propertyName !== "Function") {
+                    return false;
+                }
+                const object = node.expression.expression;
+                if (ts.isIdentifier(object)) {
+                    return object.text === "globalThis" || object.text === "window";
+                }
+            }
+            return false;
+        }
+        return {
+            visitors: {
+                CallExpression: checkNode,
+                NewExpression: checkNode,
+            },
+        };
+    },
+});

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

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

package/lib/rules/functionNewCalls.test.js

@@ -0,0 +1,115 @@
+import rule from "./functionNewCalls.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const fn = new Function("a", "b", "return a + b");
+`,
+            snapshot: `
+const fn = new Function("a", "b", "return a + b");
+               ~~~~~~~~
+               Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+        },
+        {
+            code: `
+const fn = Function("a", "return a");
+`,
+            snapshot: `
+const fn = Function("a", "return a");
+           ~~~~~~~~
+           Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+        },
+        {
+            code: `
+const fn = new Function("return 1");
+`,
+            snapshot: `
+const fn = new Function("return 1");
+               ~~~~~~~~
+               Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+        },
+        {
+            code: `
+const fn = Function();
+`,
+            snapshot: `
+const fn = Function();
+           ~~~~~~~~
+           Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+        },
+        {
+            code: `
+const fn = new globalThis.Function("return 1");
+`,
+            snapshot: `
+const fn = new globalThis.Function("return 1");
+               ~~~~~~~~~~~~~~~~~~~
+               Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+        },
+        {
+            code: `
+const fn = globalThis.Function("return 1");
+`,
+            snapshot: `
+const fn = globalThis.Function("return 1");
+           ~~~~~~~~~~~~~~~~~~~
+           Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+        },
+        {
+            code: `
+const fn = new window.Function("return 1");
+`,
+            snapshot: `
+const fn = new window.Function("return 1");
+               ~~~~~~~~~~~~~~~
+               Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+        },
+        {
+            code: `
+const fn = window.Function("return 1");
+`,
+            snapshot: `
+const fn = window.Function("return 1");
+           ~~~~~~~~~~~~~~~
+           Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+        },
+        {
+            code: `
+const result = new Function("a", "b", "return a + b")(1, 2);
+`,
+            snapshot: `
+const result = new Function("a", "b", "return a + b")(1, 2);
+                   ~~~~~~~~
+                   Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+        },
+        {
+            code: `
+const CustomFunction = Function;
+const fn = new CustomFunction();
+`,
+            snapshot: `
+const CustomFunction = Function;
+const fn = new CustomFunction();
+               ~~~~~~~~~~~~~~
+               Dynamically creating functions with the Function constructor is insecure and slow.
+`,
+        },
+    ],
+    valid: [
+        `const fn = function(a, b) { return a + b; };`,
+        `const fn = (a, b) => a + b;`,
+        `function add(a, b) { return a + b; }`,
+        `class MyFunction {}`,
+        `const fn = new MyFunction();`,
+    ],
+});

package/lib/rules/generatorFunctionYields.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports generator functions that do not yield values.";
+    readonly id: "generatorFunctionYields";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "missingYield", undefined>;
+export default _default;

package/lib/rules/generatorFunctionYields.js

@@ -0,0 +1,57 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports generator functions that do not yield values.",
+        id: "generatorFunctionYields",
+        preset: "logical",
+    },
+    messages: {
+        missingYield: {
+            primary: "Generator functions must contain at least one yield expression to produce values.",
+            secondary: [
+                "Generator functions use the `function*` syntax to create iterators that can produce multiple values over time.",
+                "Without a yield expression, the generator will not produce any values and behaves like an empty iterator.",
+                "This is likely unintentional and indicates incomplete implementation or a misunderstanding of generator functions.",
+            ],
+            suggestions: [
+                "Add a `yield` expression to produce values from the generator.",
+                "If the function should not be a generator, remove the asterisk (`*`) from the function declaration.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                FunctionDeclaration: checkFunction,
+                FunctionExpression: checkFunction,
+                MethodDeclaration: checkFunction,
+            },
+        };
+        function checkFunction(node) {
+            if (!node.asteriskToken || !node.body || blockContainsYield(node.body)) {
+                return;
+            }
+            context.report({
+                message: "missingYield",
+                range: {
+                    begin: node.asteriskToken.getStart(context.sourceFile),
+                    end: node.asteriskToken.getEnd(),
+                },
+            });
+        }
+    },
+});
+function blockContainsYield(block) {
+    function checkForYield(node) {
+        if (ts.isYieldExpression(node)) {
+            return true;
+        }
+        if (tsutils.isFunctionScopeBoundary(node)) {
+            return false;
+        }
+        return ts.forEachChild(node, checkForYield);
+    }
+    return ts.forEachChild(block, checkForYield);
+}

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

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

package/lib/rules/generatorFunctionYields.test.js

@@ -0,0 +1,151 @@
+import rule from "./generatorFunctionYields.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+function* emptyGenerator() {
+    console.log("No yield here");
+}
+`,
+            snapshot: `
+function* emptyGenerator() {
+        ~
+        Generator functions must contain at least one yield expression to produce values.
+    console.log("No yield here");
+}
+`,
+        },
+        {
+            code: `
+const generator = function* () {
+    return 42;
+};
+`,
+            snapshot: `
+const generator = function* () {
+                          ~
+                          Generator functions must contain at least one yield expression to produce values.
+    return 42;
+};
+`,
+        },
+        {
+            code: `
+class MyClass {
+    *generatorMethod() {
+        this.doSomething();
+    }
+}
+`,
+            snapshot: `
+class MyClass {
+    *generatorMethod() {
+    ~
+    Generator functions must contain at least one yield expression to produce values.
+        this.doSomething();
+    }
+}
+`,
+        },
+        {
+            code: `
+function* generatorWithNestedFunction() {
+    function inner() {
+        yield 42;
+    }
+}
+`,
+            snapshot: `
+function* generatorWithNestedFunction() {
+        ~
+        Generator functions must contain at least one yield expression to produce values.
+    function inner() {
+        yield 42;
+    }
+}
+`,
+        },
+        {
+            code: `
+function* generatorWithNestedGeneratorFunction() {
+    function* inner() {
+        yield 42;
+    }
+}
+`,
+            snapshot: `
+function* generatorWithNestedGeneratorFunction() {
+        ~
+        Generator functions must contain at least one yield expression to produce values.
+    function* inner() {
+        yield 42;
+    }
+}
+`,
+        },
+    ],
+    valid: [
+        `
+function* validGenerator() {
+    yield 1;
+}
+`,
+        `
+function* validGeneratorMultiple() {
+    yield 1;
+    yield 2;
+    yield 3;
+}
+`,
+        `
+const generator = function* () {
+    yield 42;
+};
+`,
+        `
+class MyClass {
+    *generatorMethod() {
+        yield this.value;
+    }
+}
+`,
+        `
+function* conditionalYield(condition: boolean) {
+    if (condition) {
+        yield 1;
+    }
+}
+`,
+        `
+function* yieldInLoop() {
+    for (let i = 0; i < 10; i++) {
+        yield i;
+    }
+}
+`,
+        `
+function* yieldDelegate() {
+    yield* [1, 2, 3];
+}
+`,
+        `
+function regularFunction() {
+    return 42;
+}
+`,
+        `
+const arrow = () => {
+    return 42;
+};
+`,
+        `
+function* generatorWithNestedGenerator() {
+    yield 1;
+    function* inner() {
+        yield 2;
+    }
+}
+`,
+    ],
+});

package/lib/rules/globalAssignments.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.";
+    readonly id: "globalAssignments";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noGlobalAssign", undefined>;
+export default _default;

package/lib/rules/globalAssignments.js

@@ -0,0 +1,59 @@
+import * as tsutils from "ts-api-utils";
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { isGlobalVariable } from "../utils/isGlobalVariable.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports attempting to assign to read-only global variables such as undefined, NaN, Infinity, Object, etc.",
+        id: "globalAssignments",
+        preset: "untyped",
+    },
+    messages: {
+        noGlobalAssign: {
+            primary: "Read-only global variables should not be reassigned or modified.",
+            secondary: [
+                "Global variables like undefined, NaN, Infinity, and built-in objects like Object and Array are read-only and should not be modified.",
+                "Attempting to reassign these globals can lead to confusing behavior and potential bugs in your code.",
+                "In strict mode, reassigning these globals will throw a TypeError at runtime.",
+            ],
+            suggestions: [
+                "Use a different variable name instead of shadowing or reassigning globals.",
+                "If you need a similar name, consider using a more specific name that doesn't conflict with global variables.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                BinaryExpression: (node) => {
+                    if (tsutils.isAssignmentKind(node.operatorToken.kind) &&
+                        isGlobalVariable(node.left, context.typeChecker)) {
+                        context.report({
+                            message: "noGlobalAssign",
+                            range: getTSNodeRange(node.left, context.sourceFile),
+                        });
+                    }
+                },
+                PostfixUnaryExpression: (node) => {
+                    if (isGlobalVariable(node.operand, context.typeChecker)) {
+                        context.report({
+                            message: "noGlobalAssign",
+                            range: getTSNodeRange(node.operand, context.sourceFile),
+                        });
+                    }
+                },
+                PrefixUnaryExpression: (node) => {
+                    if ((node.operator === ts.SyntaxKind.PlusPlusToken ||
+                        node.operator === ts.SyntaxKind.MinusMinusToken) &&
+                        isGlobalVariable(node.operand, context.typeChecker)) {
+                        context.report({
+                            message: "noGlobalAssign",
+                            range: getTSNodeRange(node.operand, context.sourceFile),
+                        });
+                    }
+                },
+            },
+        };
+    },
+});

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

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