@flint.fyi/ts 0.14.5 → 0.15.0

package/lib/rules/forInArrays.js

@@ -23,21 +23,21 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function hasNumberLikeLength(type) {
+        function hasNumberLikeLength(type, typeChecker) {
             const lengthProperty = type.getProperty("length");
             if (lengthProperty == null) {
                 return false;
             }
-            return tsutils.isTypeFlagSet(context.typeChecker.getTypeOfSymbol(lengthProperty), ts.TypeFlags.NumberLike);
+            return tsutils.isTypeFlagSet(typeChecker.getTypeOfSymbol(lengthProperty), ts.TypeFlags.NumberLike);
         }
-        function isArrayLike(type) {
-            return isTypeRecursive(type, (t) => t.getNumberIndexType() != null && hasNumberLikeLength(t));
+        function isArrayLike(type, typeChecker) {
+            return isTypeRecursive(type, (t) => t.getNumberIndexType() != null && hasNumberLikeLength(t, typeChecker));
         }
         return {
             visitors: {
-                ForInStatement: (node) => {
-                    const type = getConstrainedTypeAtLocation(node.expression, context.typeChecker);
-                    if (isArrayLike(type)) {
+                ForInStatement: (node, { typeChecker }) => {
+                    const type = getConstrainedTypeAtLocation(node.expression, typeChecker);
+                    if (isArrayLike(type, typeChecker)) {
                         context.report({
                             message: "forIn",
                             range: {
@@ -51,3 +51,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=forInArrays.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=forInArrays.test.d.ts.map

package/lib/rules/forInArrays.test.js

@@ -22,3 +22,4 @@ for (const i of array) {}
 `,
     ],
 });
+//# sourceMappingURL=forInArrays.test.js.map

package/lib/rules/functionAssignments.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports reassigning variables declared with function declarations.";
     readonly id: "functionAssignments";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noFunctionAssignment", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noFunctionAssignment", undefined>;
 export default _default;
+//# sourceMappingURL=functionAssignments.d.ts.map

package/lib/rules/functionAssignments.js

@@ -21,16 +21,16 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                FunctionDeclaration: (node) => {
+                FunctionDeclaration: (node, { sourceFile, typeChecker }) => {
                     if (!node.name) {
                         return;
                     }
-                    const modifyingReferences = getModifyingReferences(node.name, context.sourceFile, context.typeChecker);
+                    const modifyingReferences = getModifyingReferences(node.name, sourceFile, typeChecker);
                     for (const reference of modifyingReferences) {
                         context.report({
                             message: "noFunctionAssignment",
                             range: {
-                                begin: reference.getStart(context.sourceFile),
+                                begin: reference.getStart(sourceFile),
                                 end: reference.getEnd(),
                             },
                         });
@@ -40,3 +40,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=functionAssignments.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=functionAssignments.test.d.ts.map

package/lib/rules/functionAssignments.test.js

@@ -207,3 +207,4 @@ function myFunction() {
 `,
     ],
 });
+//# sourceMappingURL=functionAssignments.test.js.map

package/lib/rules/functionCurryingRedundancy.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using `.apply()` or `.call()` or  when the context (`this` value) provides no benefit.";
+    readonly id: "functionCurryingRedundancy";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "unnecessaryCall", undefined>;
+export default _default;
+//# sourceMappingURL=functionCurryingRedundancy.d.ts.map

package/lib/rules/functionCurryingRedundancy.js

@@ -0,0 +1,77 @@
+import * as ts from "typescript";
+import { typescriptLanguage } from "../language.js";
+import { isFunction } from "../utils/isFunction.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports using `.apply()` or `.call()` or  when the context (`this` value) provides no benefit.",
+        id: "functionCurryingRedundancy",
+        preset: "logical",
+    },
+    messages: {
+        unnecessaryCall: {
+            primary: 'This "currying" of a function without a defined context does nothing and can be simplified.',
+            secondary: [
+                "Using `.{{ method }}()` with null or undefined as the context provides no benefit over a direct function call.",
+                "This adds unnecessary complexity and reduces code readability.",
+            ],
+            suggestions: [
+                "Replace the `.{{ method }}()` with a direct function call.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                CallExpression: (node, { sourceFile, typeChecker }) => {
+                    if (!ts.isPropertyAccessExpression(node.expression)) {
+                        return;
+                    }
+                    const method = node.expression.name.text;
+                    if ((method !== "call" && method !== "apply") ||
+                        !node.arguments.length ||
+                        !isFunction(node.expression.expression, typeChecker)) {
+                        return;
+                    }
+                    const firstArgument = node.arguments[0];
+                    if (firstArgument.kind !== ts.SyntaxKind.NullKeyword &&
+                        !(ts.isIdentifier(firstArgument) &&
+                            firstArgument.text === "undefined")) {
+                        return;
+                    }
+                    const fixTextCreator = method === "apply" ? createApplyFixText : createCallFixText;
+                    context.report({
+                        data: { method },
+                        fix: {
+                            range: {
+                                begin: node.getStart(sourceFile),
+                                end: node.getEnd(),
+                            },
+                            text: fixTextCreator(node.expression.expression.getText(sourceFile), node.arguments.slice(1), sourceFile),
+                        },
+                        message: "unnecessaryCall",
+                        range: {
+                            begin: node.expression.name.getStart(sourceFile) - 1,
+                            end: node.getEnd(),
+                        },
+                    });
+                },
+            },
+        };
+    },
+});
+function createApplyFixText(functionExpression, methodArguments, sourceFile) {
+    if (methodArguments.length > 0) {
+        const argsArray = methodArguments[0];
+        return `${functionExpression}(...${argsArray.getText(sourceFile)})`;
+    }
+    else {
+        return `${functionExpression}()`;
+    }
+}
+function createCallFixText(functionExpression, methodArguments, sourceFile) {
+    const argsText = methodArguments
+        .map((arg) => arg.getText(sourceFile))
+        .join(", ");
+    return `${functionExpression}(${argsText})`;
+}
+//# sourceMappingURL=functionCurryingRedundancy.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=functionCurryingRedundancy.test.d.ts.map

package/lib/rules/functionCurryingRedundancy.test.js

@@ -0,0 +1,172 @@
+import rule from "./functionCurryingRedundancy.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+function add(a, b) {
+    return a + b;
+}
+const result = add.call(undefined, 1, 2);
+`,
+            output: `
+function add(a, b) {
+    return a + b;
+}
+const result = add(1, 2);
+`,
+            snapshot: `
+function add(a, b) {
+    return a + b;
+}
+const result = add.call(undefined, 1, 2);
+                  ~~~~~~~~~~~~~~~~~~~~~~
+                  This "currying" of a function without a defined context does nothing and can be simplified.
+`,
+        },
+        {
+            code: `
+function add(a, b) {
+    return a + b;
+}
+const result = add.call(null, 1, 2);
+`,
+            output: `
+function add(a, b) {
+    return a + b;
+}
+const result = add(1, 2);
+`,
+            snapshot: `
+function add(a, b) {
+    return a + b;
+}
+const result = add.call(null, 1, 2);
+                  ~~~~~~~~~~~~~~~~~
+                  This "currying" of a function without a defined context does nothing and can be simplified.
+`,
+        },
+        {
+            code: `
+function add(a, b) {
+    return a + b;
+}
+const result = add.apply(undefined, [1, 2]);
+`,
+            output: `
+function add(a, b) {
+    return a + b;
+}
+const result = add(...[1, 2]);
+`,
+            snapshot: `
+function add(a, b) {
+    return a + b;
+}
+const result = add.apply(undefined, [1, 2]);
+                  ~~~~~~~~~~~~~~~~~~~~~~~~~
+                  This "currying" of a function without a defined context does nothing and can be simplified.
+`,
+        },
+        {
+            code: `
+function add(a, b) {
+    return a + b;
+}
+const result = add.apply(null, [1, 2]);
+`,
+            output: `
+function add(a, b) {
+    return a + b;
+}
+const result = add(...[1, 2]);
+`,
+            snapshot: `
+function add(a, b) {
+    return a + b;
+}
+const result = add.apply(null, [1, 2]);
+                  ~~~~~~~~~~~~~~~~~~~~
+                  This "currying" of a function without a defined context does nothing and can be simplified.
+`,
+        },
+        {
+            code: `
+const fn = (x: number) => x * 2;
+const value = fn.call(undefined, 5);
+`,
+            output: `
+const fn = (x: number) => x * 2;
+const value = fn(5);
+`,
+            snapshot: `
+const fn = (x: number) => x * 2;
+const value = fn.call(undefined, 5);
+                ~~~~~~~~~~~~~~~~~~~
+                This "currying" of a function without a defined context does nothing and can be simplified.
+`,
+        },
+        {
+            code: `
+const callback = function(name: string) {
+    return name.toUpperCase();
+};
+callback.apply(null, ["test"]);
+`,
+            output: `
+const callback = function(name: string) {
+    return name.toUpperCase();
+};
+callback(...["test"]);
+`,
+            snapshot: `
+const callback = function(name: string) {
+    return name.toUpperCase();
+};
+callback.apply(null, ["test"]);
+        ~~~~~~~~~~~~~~~~~~~~~~
+        This "currying" of a function without a defined context does nothing and can be simplified.
+`,
+        },
+    ],
+    valid: [
+        `function add(a, b) { return a + b; } const result = add(1, 2);`,
+        `const obj = { value: 10, getValue: function() { return this.value; } }; obj.getValue();`,
+        `const obj = { value: 10 }; function getValue() { return this.value; } const result = getValue.call(obj);`,
+        `const obj1 = { method: function() { return 42; } }; const obj2 = {}; obj1.method.call(obj2);`,
+        `
+function greet() {
+    return this.name;
+}
+const person = { name: "Alice" };
+const result = greet.call(person);
+`,
+        `
+const obj = {
+    value: 42,
+    getValue: function() {
+        return this.value;
+    }
+};
+const result = obj.getValue.call(obj);
+`,
+        // Test case for the bug: interface with apply/call methods that aren't from Function.prototype
+        `
+interface CustomInterface {
+    apply(...args: unknown[]): void;
+}
+
+declare const customObj: CustomInterface;
+customObj.apply(null, "abc");
+`,
+        `
+interface CustomInterface {
+    call(...args: unknown[]): void;
+}
+
+declare const customObj: CustomInterface;
+customObj.call(null, "abc");
+`,
+    ],
+});
+//# sourceMappingURL=functionCurryingRedundancy.test.js.map

package/lib/rules/functionNewCalls.d.ts

@@ -1,6 +1,8 @@
+import { TypeScriptFileServices } from "../language.js";
 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>;
+}, import("../nodes.js").TSNodesByName, TypeScriptFileServices, "noFunctionConstructor", undefined>;
 export default _default;
+//# sourceMappingURL=functionNewCalls.d.ts.map

package/lib/rules/functionNewCalls.js

@@ -23,22 +23,22 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function checkNode(node) {
-            if (isFunctionConstructor(node)) {
+        function checkNode(node, { sourceFile, typeChecker }) {
+            if (isFunctionConstructor(node, typeChecker)) {
                 context.report({
                     message: "noFunctionConstructor",
-                    range: getTSNodeRange(node.expression, context.sourceFile),
+                    range: getTSNodeRange(node.expression, sourceFile),
                 });
             }
         }
-        function isFunctionConstructor(node) {
+        function isFunctionConstructor(node, typeChecker) {
             if (ts.isIdentifier(node.expression)) {
-                if (isGlobalDeclarationOfName(node.expression, "Function", context.typeChecker)) {
+                if (isGlobalDeclarationOfName(node.expression, "Function", typeChecker)) {
                     return true;
                 }
             }
             else if (ts.isPropertyAccessExpression(node.expression) &&
-                isGlobalDeclaration(node.expression, context.typeChecker)) {
+                isGlobalDeclaration(node.expression, typeChecker)) {
                 const propertyName = node.expression.name.text;
                 if (propertyName !== "Function") {
                     return false;
@@ -58,3 +58,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=functionNewCalls.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=functionNewCalls.test.d.ts.map

package/lib/rules/functionNewCalls.test.js

@@ -113,3 +113,4 @@ const fn = new CustomFunction();
         `const fn = new MyFunction();`,
     ],
 });
+//# sourceMappingURL=functionNewCalls.test.js.map

package/lib/rules/generatorFunctionYields.d.ts

@@ -1,6 +1,8 @@
+import { TypeScriptFileServices } from "../language.js";
 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>;
+}, import("../nodes.js").TSNodesByName, TypeScriptFileServices, "missingYield", undefined>;
 export default _default;
+//# sourceMappingURL=generatorFunctionYields.d.ts.map

package/lib/rules/generatorFunctionYields.js

@@ -29,14 +29,14 @@ export default typescriptLanguage.createRule({
                 MethodDeclaration: checkFunction,
             },
         };
-        function checkFunction(node) {
+        function checkFunction(node, { sourceFile }) {
             if (!node.asteriskToken || !node.body || blockContainsYield(node.body)) {
                 return;
             }
             context.report({
                 message: "missingYield",
                 range: {
-                    begin: node.asteriskToken.getStart(context.sourceFile),
+                    begin: node.asteriskToken.getStart(sourceFile),
                     end: node.asteriskToken.getEnd(),
                 },
             });
@@ -55,3 +55,4 @@ function blockContainsYield(block) {
     }
     return ts.forEachChild(block, checkForYield);
 }
+//# sourceMappingURL=generatorFunctionYields.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=generatorFunctionYields.test.d.ts.map

package/lib/rules/generatorFunctionYields.test.js

@@ -149,3 +149,4 @@ function* generatorWithNestedGenerator() {
 `,
     ],
 });
+//# sourceMappingURL=generatorFunctionYields.test.js.map

package/lib/rules/globalAssignments.d.ts

@@ -2,5 +2,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>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noGlobalAssign", undefined>;
 export default _default;
+//# sourceMappingURL=globalAssignments.d.ts.map

package/lib/rules/globalAssignments.js

@@ -26,30 +26,30 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                BinaryExpression: (node) => {
+                BinaryExpression: (node, { sourceFile, typeChecker }) => {
                     if (tsutils.isAssignmentKind(node.operatorToken.kind) &&
-                        isGlobalVariable(node.left, context.typeChecker)) {
+                        isGlobalVariable(node.left, typeChecker)) {
                         context.report({
                             message: "noGlobalAssign",
-                            range: getTSNodeRange(node.left, context.sourceFile),
+                            range: getTSNodeRange(node.left, sourceFile),
                         });
                     }
                 },
-                PostfixUnaryExpression: (node) => {
-                    if (isGlobalVariable(node.operand, context.typeChecker)) {
+                PostfixUnaryExpression: (node, { sourceFile, typeChecker }) => {
+                    if (isGlobalVariable(node.operand, typeChecker)) {
                         context.report({
                             message: "noGlobalAssign",
-                            range: getTSNodeRange(node.operand, context.sourceFile),
+                            range: getTSNodeRange(node.operand, sourceFile),
                         });
                     }
                 },
-                PrefixUnaryExpression: (node) => {
+                PrefixUnaryExpression: (node, { sourceFile, typeChecker }) => {
                     if ((node.operator === ts.SyntaxKind.PlusPlusToken ||
                         node.operator === ts.SyntaxKind.MinusMinusToken) &&
-                        isGlobalVariable(node.operand, context.typeChecker)) {
+                        isGlobalVariable(node.operand, typeChecker)) {
                         context.report({
                             message: "noGlobalAssign",
-                            range: getTSNodeRange(node.operand, context.sourceFile),
+                            range: getTSNodeRange(node.operand, sourceFile),
                         });
                     }
                 },
@@ -57,3 +57,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=globalAssignments.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=globalAssignments.test.d.ts.map

package/lib/rules/globalAssignments.test.js

@@ -213,3 +213,4 @@ function test(NaN: string) {
 `,
     ],
 });
+//# sourceMappingURL=globalAssignments.test.js.map

package/lib/rules/globalObjectCalls.d.ts

@@ -1,6 +1,8 @@
+import { TypeScriptFileServices } from "../language.js";
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports calling global objects like Math, JSON, or Reflect as functions.";
     readonly id: "globalObjectCalls";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noGlobalObjectCall", undefined>;
+}, import("../nodes.js").TSNodesByName, TypeScriptFileServices, "noGlobalObjectCall", undefined>;
 export default _default;
+//# sourceMappingURL=globalObjectCalls.d.ts.map

package/lib/rules/globalObjectCalls.js

@@ -21,16 +21,16 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function reportGlobalObjectCall(expression, name) {
+        function reportGlobalObjectCall(expression, name, sourceFile) {
             context.report({
                 data: { name },
                 message: "noGlobalObjectCall",
-                range: getTSNodeRange(expression, context.sourceFile),
+                range: getTSNodeRange(expression, sourceFile),
             });
         }
-        function checkNode({ expression }) {
+        function checkNode({ expression }, { sourceFile }) {
             if (ts.isIdentifier(expression) && globalObjects.has(expression.text)) {
-                reportGlobalObjectCall(expression, expression.text);
+                reportGlobalObjectCall(expression, expression.text, sourceFile);
             }
         }
         return {
@@ -41,3 +41,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=globalObjectCalls.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=globalObjectCalls.test.d.ts.map

package/lib/rules/globalObjectCalls.test.js

@@ -91,3 +91,4 @@ const instance = new Atomics();
         `const result = Atomics.add(buffer, 0, 1);`,
     ],
 });
+//# sourceMappingURL=globalObjectCalls.test.js.map

package/lib/rules/namespaceDeclarations.d.ts

@@ -3,8 +3,9 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using legacy `namespace` declarations.";
     readonly id: "namespaceDeclarations";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "preferModules", {
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "preferModules", {
     readonly allowDeclarations: z.ZodDefault<z.ZodBoolean>;
     readonly allowDefinitionFiles: z.ZodDefault<z.ZodBoolean>;
 }>;
 export default _default;
+//# sourceMappingURL=namespaceDeclarations.d.ts.map

package/lib/rules/namespaceDeclarations.js

@@ -30,13 +30,13 @@ export default typescriptLanguage.createRule({
             .default(false)
             .describe("Whether to allow namespaces in `.d.ts` and other definition files."),
     },
-    setup(context, { allowDeclarations, allowDefinitionFiles }) {
-        if (allowDefinitionFiles && context.sourceFile.isDeclarationFile) {
-            return;
-        }
+    setup(context) {
         return {
             visitors: {
-                ModuleDeclaration: (node) => {
+                ModuleDeclaration: (node, { options: { allowDeclarations, allowDefinitionFiles }, sourceFile }) => {
+                    if (allowDefinitionFiles && sourceFile.isDeclarationFile) {
+                        return;
+                    }
                     if (node.parent.kind !== ts.SyntaxKind.SourceFile ||
                         node.name.kind !== ts.SyntaxKind.Identifier ||
                         node.name.text === "global") {
@@ -48,10 +48,11 @@ export default typescriptLanguage.createRule({
                     }
                     context.report({
                         message: "preferModules",
-                        range: getTSNodeRange(node.getChildAt(0), context.sourceFile),
+                        range: getTSNodeRange(node.getChildAt(0), sourceFile),
                     });
                 },
             },
         };
     },
 });
+//# sourceMappingURL=namespaceDeclarations.js.map

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

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=namespaceDeclarations.test.d.ts.map

package/lib/rules/namespaceDeclarations.test.js

@@ -38,3 +38,4 @@ declare namespace outer {
         },
     ],
 });
+//# sourceMappingURL=namespaceDeclarations.test.js.map

package/lib/rules/negativeZeroComparisons.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports comparisons with -0 that may not behave as expected.";
     readonly id: "negativeZeroComparisons";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unexpectedNegativeZeroComparison", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "unexpectedNegativeZeroComparison", undefined>;
 export default _default;
+//# sourceMappingURL=negativeZeroComparisons.d.ts.map