@flint.fyi/ts 0.14.6 → 0.15.0

package/lib/rules/objectKeyDuplicates.js

@@ -0,0 +1,91 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports unnecessary duplicate keys that override previous values.",
+        id: "objectKeyDuplicates",
+        preset: "untyped",
+    },
+    messages: {
+        duplicateKey: {
+            primary: "This key is made redundant by an identical key later in the object.",
+            secondary: [
+                "Duplicate object keys are legal in JavaScript, but they can lead to unexpected behavior.",
+                "When duplicate keys exist, only the last value for a given key is used.",
+                "This can cause confusion and bugs, especially when maintaining the code.",
+            ],
+            suggestions: [
+                "If both values are meant to exist, change one of the keys to be different.",
+                "If only the last value is meant to exist, remove any prior values.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                ObjectLiteralExpression(node, { sourceFile }) {
+                    const seenKeys = {
+                        getters: new Map(),
+                        setters: new Map(),
+                        values: new Map(),
+                    };
+                    for (const property of node.properties.toReversed()) {
+                        const key = getPropertyKeyName(property);
+                        if (!key) {
+                            continue;
+                        }
+                        const existingNode = seenKeys[key.group].get(key.text);
+                        if (existingNode) {
+                            context.report({
+                                message: "duplicateKey",
+                                range: getTSNodeRange(key.node, sourceFile),
+                            });
+                        }
+                        seenKeys[key.group].set(key.text, property);
+                    }
+                },
+            },
+        };
+    },
+});
+// TODO: Reuse a shared getStaticValue-style utility?
+function getNameText(name) {
+    if (ts.isIdentifier(name) ||
+        ts.isStringLiteral(name) ||
+        ts.isNumericLiteral(name) ||
+        ts.isLiteralExpression(name)) {
+        return name.text;
+    }
+    if (ts.isPrivateIdentifier(name)) {
+        return `#${name.text}`;
+    }
+    return undefined;
+}
+function getPropertyKeyName(property) {
+    if (ts.isShorthandPropertyAssignment(property)) {
+        return {
+            group: "values",
+            node: property.name,
+            text: property.name.text,
+        };
+    }
+    if (ts.isPropertyAssignment(property) ||
+        ts.isMethodDeclaration(property) ||
+        ts.isGetAccessorDeclaration(property) ||
+        ts.isSetAccessorDeclaration(property)) {
+        const { name } = property;
+        const text = getNameText(name);
+        if (!text) {
+            return undefined;
+        }
+        const group = ts.isGetAccessorDeclaration(property)
+            ? "getters"
+            : ts.isSetAccessorDeclaration(property)
+                ? "setters"
+                : "values";
+        return { group, node: name, text };
+    }
+    return undefined;
+}
+//# sourceMappingURL=objectKeyDuplicates.js.map

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

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

package/lib/rules/objectKeyDuplicates.test.js

@@ -0,0 +1,180 @@
+import rule from "./objectKeyDuplicates.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const object = { a: 1, a: 2 };
+`,
+            snapshot: `
+const object = { a: 1, a: 2 };
+                 ~
+                 This key is made redundant by an identical key later in the object.
+`,
+        },
+        {
+            code: `
+const object = { "a": 1, "a": 2 };
+`,
+            snapshot: `
+const object = { "a": 1, "a": 2 };
+                 ~~~
+                 This key is made redundant by an identical key later in the object.
+`,
+        },
+        {
+            code: `
+const object = { a: 1, "a": 2 };
+`,
+            snapshot: `
+const object = { a: 1, "a": 2 };
+                 ~
+                 This key is made redundant by an identical key later in the object.
+`,
+        },
+        {
+            code: `
+const object = { "a": 1, a: 2 };
+`,
+            snapshot: `
+const object = { "a": 1, a: 2 };
+                 ~~~
+                 This key is made redundant by an identical key later in the object.
+`,
+        },
+        {
+            code: `
+const object = { 123: "first", 123: "second" };
+`,
+            snapshot: `
+const object = { 123: "first", 123: "second" };
+                 ~~~
+                 This key is made redundant by an identical key later in the object.
+`,
+        },
+        {
+            code: `
+const object = {
+    value: "first",
+    value: "second",
+};
+`,
+            snapshot: `
+const object = {
+    value: "first",
+    ~~~~~
+    This key is made redundant by an identical key later in the object.
+    value: "second",
+};
+`,
+        },
+        {
+            code: `
+const object = {
+    key: 1,
+    other: 2,
+    key: 3,
+};
+`,
+            snapshot: `
+const object = {
+    key: 1,
+    ~~~
+    This key is made redundant by an identical key later in the object.
+    other: 2,
+    key: 3,
+};
+`,
+        },
+        {
+            code: `
+const first = { a: 1, a: 2 };
+const second = { b: 1, b: 2 };
+`,
+            snapshot: `
+const first = { a: 1, a: 2 };
+                ~
+                This key is made redundant by an identical key later in the object.
+const second = { b: 1, b: 2 };
+                 ~
+                 This key is made redundant by an identical key later in the object.
+`,
+        },
+        {
+            code: `
+const object = {
+    method() { return 1; },
+    method() { return 2; },
+};
+`,
+            snapshot: `
+const object = {
+    method() { return 1; },
+    ~~~~~~
+    This key is made redundant by an identical key later in the object.
+    method() { return 2; },
+};
+`,
+        },
+        {
+            code: `
+const object = {
+    get accessor() { return 1; },
+    get accessor() { return 2; },
+};
+`,
+            snapshot: `
+const object = {
+    get accessor() { return 1; },
+        ~~~~~~~~
+        This key is made redundant by an identical key later in the object.
+    get accessor() { return 2; },
+};
+`,
+        },
+        {
+            code: `
+const object = {
+    set accessor(value: number) {},
+    set accessor(value: number) {},
+};
+`,
+            snapshot: `
+const object = {
+    set accessor(value: number) {},
+        ~~~~~~~~
+        This key is made redundant by an identical key later in the object.
+    set accessor(value: number) {},
+};
+`,
+        },
+        {
+            code: `
+const nested = { outer: { inner: 1, inner: 2 } };
+`,
+            snapshot: `
+const nested = { outer: { inner: 1, inner: 2 } };
+                          ~~~~~
+                          This key is made redundant by an identical key later in the object.
+`,
+        },
+    ],
+    valid: [
+        `const object = {};`,
+        `const object = { a: 1 };`,
+        `const object = { a: 1, b: 2 };`,
+        `const object = { a: 1, b: 2, c: 3 };`,
+        `const object = { "a": 1, "b": 2 };`,
+        `const object = { 123: 1, 456: 2 };`,
+        `const object = { a: 1, ...spread };`,
+        `const object = { [key]: 1, [key]: 2 };`,
+        `const object = { ["computed"]: 1, ["computed"]: 2 };`,
+        `const object = { a, b };`,
+        `const object = { a: 1, b };`,
+        `const object = { method() { return 1; } };`,
+        `const object = { get accessor() { return 1; } };`,
+        `const object = { set accessor(value: number) {} };`,
+        `const object = { get accessor() { return 1; }, set accessor(value: number) {} };`,
+    ],
+});
+//# sourceMappingURL=objectKeyDuplicates.test.js.map

package/lib/rules/objectProto.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using the deprecated __proto__ property to access or modify an object's prototype.";
     readonly id: "objectProto";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noProto", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noProto", undefined>;
 export default _default;
+//# sourceMappingURL=objectProto.d.ts.map

package/lib/rules/objectProto.js

@@ -24,25 +24,25 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                ElementAccessExpression: (node) => {
+                ElementAccessExpression: (node, { sourceFile }) => {
                     if (ts.isStringLiteral(node.argumentExpression) &&
                         node.argumentExpression.text === "__proto__") {
                         context.report({
                             message: "noProto",
                             range: {
-                                begin: node.argumentExpression.getStart(context.sourceFile),
+                                begin: node.argumentExpression.getStart(sourceFile),
                                 end: node.argumentExpression.getEnd(),
                             },
                         });
                     }
                 },
-                PropertyAccessExpression: (node) => {
+                PropertyAccessExpression: (node, { sourceFile }) => {
                     if (node.name.kind === ts.SyntaxKind.Identifier &&
                         node.name.text === "__proto__") {
                         context.report({
                             message: "noProto",
                             range: {
-                                begin: node.name.getStart(context.sourceFile),
+                                begin: node.name.getStart(sourceFile),
                                 end: node.name.getEnd(),
                             },
                         });
@@ -52,3 +52,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=objectProto.js.map

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

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

package/lib/rules/objectProto.test.js

@@ -94,3 +94,4 @@ function getProto(obj: object) {
         `const obj = { __proto__: null };`,
     ],
 });
+//# sourceMappingURL=objectProto.test.js.map

package/lib/rules/objectPrototypeBuiltIns.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports direct calls to Object.prototype methods on object instances.";
+    readonly id: "objectPrototypeBuiltIns";
+    readonly preset: "logical";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "prototypeBuiltIn", undefined>;
+export default _default;
+//# sourceMappingURL=objectPrototypeBuiltIns.d.ts.map

package/lib/rules/objectPrototypeBuiltIns.js

@@ -0,0 +1,65 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+const prototypeMethods = new Set([
+    "hasOwnProperty",
+    "isPrototypeOf",
+    "propertyIsEnumerable",
+]);
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Reports direct calls to Object.prototype methods on object instances.",
+        id: "objectPrototypeBuiltIns",
+        preset: "logical",
+    },
+    messages: {
+        prototypeBuiltIn: {
+            primary: "Prefer the safer `Object.prototype.{{ method }}.call()` over calling `{{ method }}()` directly on objects.",
+            secondary: [
+                "Objects can have properties that shadow built-in methods from `Object.prototype` such as `{{ method }}()`.",
+                "Objects created with `Object.create(null)` do not inherit from `Object.prototype` and will not have these methods.",
+                "Calling these methods directly can fail or execute unintended code if the object has shadowing properties.",
+            ],
+            suggestions: [
+                "Call the method through `Object.prototype` using `.call()`.",
+            ],
+        },
+    },
+    setup(context) {
+        return {
+            visitors: {
+                CallExpression: (node, { sourceFile }) => {
+                    if (!ts.isPropertyAccessExpression(node.expression) ||
+                        !ts.isIdentifier(node.expression.name)) {
+                        return;
+                    }
+                    const method = node.expression.name.text;
+                    if (!prototypeMethods.has(method)) {
+                        return;
+                    }
+                    const openParenthesisToken = findToken(node, ts.SyntaxKind.OpenParenToken, sourceFile);
+                    const closeParenthesisToken = findToken(node, ts.SyntaxKind.CloseParenToken, sourceFile);
+                    const objectText = sourceFile.text.slice(node.expression.expression.getStart(sourceFile), node.expression.expression.getEnd());
+                    const argumentsText = sourceFile.text.slice(openParenthesisToken.getEnd(), closeParenthesisToken.getStart(sourceFile));
+                    context.report({
+                        data: { method },
+                        message: "prototypeBuiltIn",
+                        range: getTSNodeRange(node, sourceFile),
+                        suggestions: [
+                            {
+                                id: "usePrototypeCall",
+                                range: getTSNodeRange(node, sourceFile),
+                                text: `Object.prototype.${method}.call(${objectText}, ${argumentsText})`,
+                            },
+                        ],
+                    });
+                },
+            },
+        };
+    },
+});
+function findToken(node, token, sourceFile) {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return node.getChildren(sourceFile).find((child) => child.kind === token);
+}
+//# sourceMappingURL=objectPrototypeBuiltIns.js.map

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

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

package/lib/rules/objectPrototypeBuiltIns.test.js

@@ -0,0 +1,146 @@
+import rule from "./objectPrototypeBuiltIns.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const has = object.hasOwnProperty("key");
+`,
+            snapshot: `
+const has = object.hasOwnProperty("key");
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+            Prefer the safer \`Object.prototype.hasOwnProperty.call()\` over calling \`hasOwnProperty()\` directly on objects.
+`,
+            suggestions: [
+                {
+                    id: "usePrototypeCall",
+                    updated: `
+const has = Object.prototype.hasOwnProperty.call(object, "key");
+`,
+                },
+            ],
+        },
+        {
+            code: `
+const isPrototype = object.isPrototypeOf(other);
+`,
+            snapshot: `
+const isPrototype = object.isPrototypeOf(other);
+                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                    Prefer the safer \`Object.prototype.isPrototypeOf.call()\` over calling \`isPrototypeOf()\` directly on objects.
+`,
+            suggestions: [
+                {
+                    id: "usePrototypeCall",
+                    updated: `
+const isPrototype = Object.prototype.isPrototypeOf.call(object, other);
+`,
+                },
+            ],
+        },
+        {
+            code: `
+const isEnum = object.propertyIsEnumerable("prop");
+`,
+            snapshot: `
+const isEnum = object.propertyIsEnumerable("prop");
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+               Prefer the safer \`Object.prototype.propertyIsEnumerable.call()\` over calling \`propertyIsEnumerable()\` directly on objects.
+`,
+            suggestions: [
+                {
+                    id: "usePrototypeCall",
+                    updated: `
+const isEnum = Object.prototype.propertyIsEnumerable.call(object, "prop");
+`,
+                },
+            ],
+        },
+        {
+            code: `
+if (data.hasOwnProperty(key)) {
+    process(data[key]);
+}
+`,
+            snapshot: `
+if (data.hasOwnProperty(key)) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~
+    Prefer the safer \`Object.prototype.hasOwnProperty.call()\` over calling \`hasOwnProperty()\` directly on objects.
+    process(data[key]);
+}
+`,
+            suggestions: [
+                {
+                    id: "usePrototypeCall",
+                    updated: `
+if (Object.prototype.hasOwnProperty.call(data, key)) {
+    process(data[key]);
+}
+`,
+                },
+            ],
+        },
+        {
+            code: `
+const has = object.hasOwnProperty/* comment */("key");
+`,
+            snapshot: `
+const has = object.hasOwnProperty/* comment */("key");
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+            Prefer the safer \`Object.prototype.hasOwnProperty.call()\` over calling \`hasOwnProperty()\` directly on objects.
+`,
+            suggestions: [
+                {
+                    id: "usePrototypeCall",
+                    updated: `
+const has = Object.prototype.hasOwnProperty.call(object, "key");
+`,
+                },
+            ],
+        },
+        {
+            code: `
+const has = object.hasOwnProperty/* :( */("key");
+`,
+            snapshot: `
+const has = object.hasOwnProperty/* :( */("key");
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+            Prefer the safer \`Object.prototype.hasOwnProperty.call()\` over calling \`hasOwnProperty()\` directly on objects.
+`,
+            suggestions: [
+                {
+                    id: "usePrototypeCall",
+                    updated: `
+const has = Object.prototype.hasOwnProperty.call(object, "key");
+`,
+                },
+            ],
+        },
+        {
+            code: `
+const has = object.hasOwnProperty(/* comment */ "key");
+`,
+            snapshot: `
+const has = object.hasOwnProperty(/* comment */ "key");
+            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+            Prefer the safer \`Object.prototype.hasOwnProperty.call()\` over calling \`hasOwnProperty()\` directly on objects.
+`,
+            suggestions: [
+                {
+                    id: "usePrototypeCall",
+                    updated: `
+const has = Object.prototype.hasOwnProperty.call(object, /* comment */ "key");
+`,
+                },
+            ],
+        },
+    ],
+    valid: [
+        `const has = Object.prototype.hasOwnProperty.call(object, "key");`,
+        `const isPrototype = Object.prototype.isPrototypeOf.call(object, other);`,
+        `const isEnum = {}.propertyIsEnumerable.call(object, "prop");`,
+        `const value = object.someOtherMethod("key");`,
+        `const result = hasOwnProperty("key");`,
+    ],
+});
+//# sourceMappingURL=objectPrototypeBuiltIns.test.js.map

package/lib/rules/octalEscapes.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using octal escape sequences in string literals.";
     readonly id: "octalEscapes";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noOctalEscape", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noOctalEscape", undefined>;
 export default _default;
+//# sourceMappingURL=octalEscapes.d.ts.map

package/lib/rules/octalEscapes.js

@@ -38,13 +38,13 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function checkNode(node) {
-            const text = node.getText(context.sourceFile);
+        function checkNode(node, sourceFile) {
+            const text = node.getText(sourceFile);
             const octalEscape = findOctalEscape(text);
             if (!octalEscape) {
                 return;
             }
-            const nodeStart = node.getStart(context.sourceFile);
+            const nodeStart = node.getStart(sourceFile);
             context.report({
                 message: "noOctalEscape",
                 range: {
@@ -55,17 +55,22 @@ export default typescriptLanguage.createRule({
         }
         return {
             visitors: {
-                NoSubstitutionTemplateLiteral: checkNode,
-                StringLiteral: checkNode,
-                TemplateExpression: (node) => {
+                NoSubstitutionTemplateLiteral: (node, { sourceFile }) => {
+                    checkNode(node, sourceFile);
+                },
+                StringLiteral: (node, { sourceFile }) => {
+                    checkNode(node, sourceFile);
+                },
+                TemplateExpression: (node, { sourceFile }) => {
                     // Check the head of the template
-                    checkNode(node.head);
+                    checkNode(node.head, sourceFile);
                     // Check each template span
                     for (const span of node.templateSpans) {
-                        checkNode(span.literal);
+                        checkNode(span.literal, sourceFile);
                     }
                 },
             },
         };
     },
 });
+//# sourceMappingURL=octalEscapes.js.map

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

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

package/lib/rules/octalEscapes.test.js

@@ -211,3 +211,4 @@ const a = \`\\01 value: \${x}\`;
         `const x = 5; const a = \`\\8 \${x} \\9\`;`,
     ],
 });
+//# sourceMappingURL=octalEscapes.test.js.map

package/lib/rules/octalNumbers.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using legacy octal numeric literals.";
     readonly id: "octalNumbers";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noOctalNumber", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noOctalNumber", undefined>;
 export default _default;
+//# sourceMappingURL=octalNumbers.d.ts.map

package/lib/rules/octalNumbers.js

@@ -22,8 +22,8 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                NumericLiteral: (node) => {
-                    const text = node.getText(context.sourceFile);
+                NumericLiteral: (node, { sourceFile }) => {
+                    const text = node.getText(sourceFile);
                     // Check for legacy octal literal: starts with 0 followed by octal digits (0-7)
                     // But not just "0" alone, and not modern formats like 0x, 0o, 0b
                     // cspell:ignore xobi
@@ -33,7 +33,7 @@ export default typescriptLanguage.createRule({
                         text[1] <= "7" &&
                         !/^0[xobi]/i.test(text)) {
                         const range = {
-                            begin: node.getStart(context.sourceFile),
+                            begin: node.getStart(sourceFile),
                             end: node.getEnd(),
                         };
                         // Parse the octal value
@@ -66,3 +66,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=octalNumbers.js.map

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

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

package/lib/rules/octalNumbers.test.js

@@ -243,3 +243,4 @@ const result = 010 + 20;
         `const alsoNotOctal = 09;`,
     ],
 });
+//# sourceMappingURL=octalNumbers.test.js.map

package/lib/rules/returnAssignments.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using assignment expressions in return statements.";
     readonly id: "returnAssignments";
     readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noReturnAssign", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noReturnAssign", undefined>;
 export default _default;
+//# sourceMappingURL=returnAssignments.d.ts.map