@flint.fyi/ts 0.14.6 → 0.15.0

package/lib/rules/newNativeNonConstructors.js

@@ -21,29 +21,30 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                NewExpression: (node) => {
+                NewExpression: (node, { sourceFile, typeChecker }) => {
                     if (!ts.isIdentifier(node.expression)) {
                         return;
                     }
                     const name = node.expression.text;
                     if (!["BigInt", "Symbol"].includes(name) ||
-                        !isGlobalDeclaration(node.expression, context.typeChecker)) {
+                        !isGlobalDeclaration(node.expression, typeChecker)) {
                         return;
                     }
                     context.report({
                         data: { name },
                         fix: {
                             range: {
-                                begin: node.getStart(context.sourceFile),
-                                end: node.expression.getStart(context.sourceFile),
+                                begin: node.getStart(sourceFile),
+                                end: node.expression.getStart(sourceFile),
                             },
                             text: "",
                         },
                         message: "noNewNonConstructor",
-                        range: getTSNodeRange(node.getChildAt(0, context.sourceFile), context.sourceFile),
+                        range: getTSNodeRange(node.getChildAt(0, sourceFile), sourceFile),
                     });
                 },
             },
         };
     },
 });
+//# sourceMappingURL=newNativeNonConstructors.js.map

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

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

package/lib/rules/newNativeNonConstructors.test.js

@@ -92,3 +92,4 @@ function create() {
 		`,
     ],
 });
+//# sourceMappingURL=newNativeNonConstructors.test.js.map

package/lib/rules/nonOctalDecimalEscapes.d.ts

@@ -1,6 +1,8 @@
+import { TypeScriptFileServices } from "../language.js";
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.";
     readonly id: "nonOctalDecimalEscapes";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "unexpectedEscape", undefined>;
+}, import("../nodes.js").TSNodesByName, TypeScriptFileServices, "unexpectedEscape", undefined>;
 export default _default;
+//# sourceMappingURL=nonOctalDecimalEscapes.d.ts.map

package/lib/rules/nonOctalDecimalEscapes.js

@@ -21,8 +21,8 @@ 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 matches = [...text.matchAll(nonOctalDecimalEscapePattern)];
             for (const match of matches) {
                 // Ignore escapes where the backslash itself is escaped (e.g. "\\\\8" -> literal "\\8").
@@ -37,7 +37,7 @@ export default typescriptLanguage.createRule({
                 if (backslashesBefore % 2 === 1) {
                     continue;
                 }
-                const start = node.getStart(context.sourceFile) + matchIndex;
+                const start = node.getStart(sourceFile) + matchIndex;
                 context.report({
                     message: "unexpectedEscape",
                     range: {
@@ -55,3 +55,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=nonOctalDecimalEscapes.js.map

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

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

package/lib/rules/nonOctalDecimalEscapes.test.js

@@ -67,3 +67,4 @@ ruleTester.describe(rule, {
     ],
     valid: ['"8"', '"9"', '"w8less"', '"December 19"', '"\\\\8"', '"\\0\\u0038"'],
 });
+//# sourceMappingURL=nonOctalDecimalEscapes.test.js.map

package/lib/rules/numericLiteralParsing.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports parseInt calls with binary, hexadecimal, or octal strings that can be replaced with numeric literals.";
     readonly id: "numericLiteralParsing";
     readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "preferLiteral", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "preferLiteral", undefined>;
 export default _default;
+//# sourceMappingURL=numericLiteralParsing.d.ts.map

package/lib/rules/numericLiteralParsing.js

@@ -51,7 +51,7 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function checkParseIntCall(node) {
+        function checkParseIntCall(node, sourceFile) {
             if (node.arguments.length !== 2) {
                 return;
             }
@@ -69,16 +69,16 @@ export default typescriptLanguage.createRule({
                     radix: String(radixValue),
                 },
                 message: "preferLiteral",
-                range: getTSNodeRange(node, context.sourceFile),
+                range: getTSNodeRange(node, sourceFile),
             });
         }
         return {
             visitors: {
-                CallExpression: (node) => {
+                CallExpression: (node, { sourceFile, typeChecker }) => {
                     if (ts.isIdentifier(node.expression)) {
                         if (node.expression.text === "parseInt" &&
-                            isGlobalDeclaration(node.expression, context.typeChecker)) {
-                            checkParseIntCall(node);
+                            isGlobalDeclaration(node.expression, typeChecker)) {
+                            checkParseIntCall(node, sourceFile);
                         }
                     }
                     else if (ts.isPropertyAccessExpression(node.expression)) {
@@ -86,8 +86,8 @@ export default typescriptLanguage.createRule({
                             node.expression.expression.text === "Number" &&
                             ts.isIdentifier(node.expression.name) &&
                             node.expression.name.text === "parseInt" &&
-                            isGlobalDeclaration(node.expression.expression, context.typeChecker)) {
-                            checkParseIntCall(node);
+                            isGlobalDeclaration(node.expression.expression, typeChecker)) {
+                            checkParseIntCall(node, sourceFile);
                         }
                     }
                 },
@@ -95,3 +95,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=numericLiteralParsing.js.map

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

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

package/lib/rules/numericLiteralParsing.test.js

@@ -97,3 +97,4 @@ const value = parseInt(\`111110111\`, 2);
 		`,
     ],
 });
+//# sourceMappingURL=numericLiteralParsing.test.js.map

package/lib/rules/objectCalls.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer `{}` object literal notation or `Object.create` instead of calling or constructing `Object`.";
+    readonly id: "objectCalls";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "preferObjectLiteral", undefined>;
+export default _default;
+//# sourceMappingURL=objectCalls.d.ts.map

package/lib/rules/objectCalls.js

@@ -0,0 +1,47 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { isGlobalDeclarationOfName } from "../utils/isGlobalDeclarationOfName.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Prefer `{}` object literal notation or `Object.create` instead of calling or constructing `Object`.",
+        id: "objectCalls",
+        preset: "stylistic",
+    },
+    messages: {
+        preferObjectLiteral: {
+            primary: "Prefer directly using `{}` instead of calling or constructing `Object`.",
+            secondary: [
+                "Calling or constructing Object with `Object()` or `new Object()` is unnecessarily verbose and less idiomatic than using object literal syntax.",
+                "`{}` object literal notation is the preferred and more concise way to create plain objects.",
+                "For creating objects without a prototype, use `Object.create(null)`.",
+            ],
+            suggestions: [
+                "Replace `Object()` or `new Object()` with `{}` to create an empty object.",
+                "Use `Object.create(null)` when you need an object without a prototype.",
+            ],
+        },
+    },
+    setup(context) {
+        function checkNode(node) {
+            if (!ts.isIdentifier(node.expression) ||
+                !isGlobalDeclarationOfName(node.expression, "Object", context.typeChecker)) {
+                return;
+            }
+            const reportNode = node.kind === ts.SyntaxKind.NewExpression
+                ? node.getChildAt(0, context.sourceFile)
+                : node.expression;
+            context.report({
+                message: "preferObjectLiteral",
+                range: getTSNodeRange(reportNode, context.sourceFile),
+            });
+        }
+        return {
+            visitors: {
+                CallExpression: checkNode,
+                NewExpression: checkNode,
+            },
+        };
+    },
+});
+//# sourceMappingURL=objectCalls.js.map

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

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

package/lib/rules/objectCalls.test.js

@@ -0,0 +1,172 @@
+import rule from "./objectCalls.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const value = new Object();
+`,
+            snapshot: `
+const value = new Object();
+              ~~~
+              Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+`,
+        },
+        {
+            code: `
+const empty = new Object();
+const filled = new Object({ key: "value" });
+`,
+            snapshot: `
+const empty = new Object();
+              ~~~
+              Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+const filled = new Object({ key: "value" });
+               ~~~
+               Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+`,
+        },
+        {
+            code: `
+function createObject() {
+    return new Object();
+}
+`,
+            snapshot: `
+function createObject() {
+    return new Object();
+           ~~~
+           Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+}
+`,
+        },
+        {
+            code: `
+const config = condition ? new Object() : { default: true };
+`,
+            snapshot: `
+const config = condition ? new Object() : { default: true };
+                           ~~~
+                           Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+`,
+        },
+        {
+            code: `
+const array = [new Object(), new Object()];
+`,
+            snapshot: `
+const array = [new Object(), new Object()];
+               ~~~
+               Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+                             ~~~
+                             Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+`,
+        },
+        {
+            code: `
+const nested = { inner: new Object() };
+`,
+            snapshot: `
+const nested = { inner: new Object() };
+                        ~~~
+                        Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+`,
+        },
+        {
+            code: `
+processData(new Object());
+`,
+            snapshot: `
+processData(new Object());
+            ~~~
+            Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+`,
+        },
+        {
+            code: `
+const value = Object();
+`,
+            snapshot: `
+const value = Object();
+              ~~~~~~
+              Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+`,
+        },
+        {
+            code: `
+const filled = Object({ key: "value" });
+`,
+            snapshot: `
+const filled = Object({ key: "value" });
+               ~~~~~~
+               Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+`,
+        },
+        {
+            code: `
+function createObject() {
+    return Object();
+}
+`,
+            snapshot: `
+function createObject() {
+    return Object();
+           ~~~~~~
+           Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+}
+`,
+        },
+        {
+            code: `
+const config = condition ? Object() : { default: true };
+`,
+            snapshot: `
+const config = condition ? Object() : { default: true };
+                           ~~~~~~
+                           Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+`,
+        },
+        {
+            code: `
+const array = [Object(), Object()];
+`,
+            snapshot: `
+const array = [Object(), Object()];
+               ~~~~~~
+               Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+                         ~~~~~~
+                         Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+`,
+        },
+        {
+            code: `
+processData(Object());
+`,
+            snapshot: `
+processData(Object());
+            ~~~~~~
+            Prefer directly using \`{}\` instead of calling or constructing \`Object\`.
+`,
+        },
+    ],
+    valid: [
+        `const value = {};`,
+        `const filled = { key: "value" };`,
+        `const proto = Object.create(null);`,
+        `const inherited = Object.create(prototype);`,
+        `const assigned = Object.assign({}, source);`,
+        `const entries = Object.entries(data);`,
+        `const keys = Object.keys(data);`,
+        `const values = Object.values(data);`,
+        `function createEmpty() { return {}; }`,
+        `const array = [{}, { key: "value" }];`,
+        `const nested = { inner: {} };`,
+        `processData({});`,
+        `
+			class Object {}
+			new Object();
+			export {}
+		`,
+    ],
+});
+//# sourceMappingURL=objectCalls.test.js.map

package/lib/rules/objectHasOwns.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.";
+    readonly id: "objectHasOwns";
+    readonly preset: "stylistic";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "preferHasOwn", undefined>;
+export default _default;
+//# sourceMappingURL=objectHasOwns.d.ts.map

package/lib/rules/objectHasOwns.js

@@ -0,0 +1,74 @@
+import * as ts from "typescript";
+import { getTSNodeRange } from "../getTSNodeRange.js";
+import { typescriptLanguage } from "../language.js";
+import { isGlobalDeclarationOfName } from "../utils/isGlobalDeclarationOfName.js";
+export default typescriptLanguage.createRule({
+    about: {
+        description: "Prefer Object.hasOwn() over Object.prototype.hasOwnProperty.call() for checking own properties.",
+        id: "objectHasOwns",
+        preset: "stylistic",
+    },
+    messages: {
+        preferHasOwn: {
+            primary: "`hasOwnProperty()` calls can fail on objects without `Object.prototype` or with overridden properties.",
+            secondary: [
+                "`Object.hasOwn()` is a more modern and safer way to check if an object has its own property.",
+                "It avoids issues with objects that don't inherit from `Object.prototype` or have a modified hasOwnProperty property.",
+                "`Object.hasOwn()` was introduced in ES2022 and is more concise than the hasOwnProperty alternatives.",
+            ],
+            suggestions: [
+                "Use the safer, more modern `Object.hasOwn(obj, key)`.",
+                "Use an alternative key check such as the `in` operator.",
+            ],
+        },
+    },
+    setup(context) {
+        function isObjectPrototypeHasOwnProperty(node, typeChecker) {
+            return (ts.isPropertyAccessExpression(node) &&
+                ts.isIdentifier(node.name) &&
+                node.name.text === "prototype" &&
+                ts.isIdentifier(node.expression) &&
+                isGlobalDeclarationOfName(node.expression, "Object", typeChecker));
+        }
+        function isObjectLiteralHasOwnProperty(node) {
+            return ts.isObjectLiteralExpression(node) && node.properties.length === 0;
+        }
+        function isHasOwnProperty(node, typeChecker) {
+            if (!ts.isPropertyAccessExpression(node) ||
+                !ts.isIdentifier(node.name) ||
+                node.name.text !== "hasOwnProperty") {
+                return false;
+            }
+            return (isObjectPrototypeHasOwnProperty(node.expression, typeChecker) ||
+                isObjectLiteralHasOwnProperty(node.expression));
+        }
+        return {
+            visitors: {
+                CallExpression: (node, { sourceFile, typeChecker }) => {
+                    if (!ts.isPropertyAccessExpression(node.expression) ||
+                        !ts.isIdentifier(node.expression.name)) {
+                        return;
+                    }
+                    if (node.expression.name.text === "call" &&
+                        node.arguments.length >= 2 &&
+                        isHasOwnProperty(node.expression.expression, typeChecker)) {
+                        context.report({
+                            message: "preferHasOwn",
+                            range: getTSNodeRange(node, sourceFile),
+                        });
+                        return;
+                    }
+                    if (node.expression.name.text === "hasOwnProperty" &&
+                        node.arguments.length >= 1 &&
+                        !isHasOwnProperty(node.expression, typeChecker)) {
+                        context.report({
+                            message: "preferHasOwn",
+                            range: getTSNodeRange(node, sourceFile),
+                        });
+                    }
+                },
+            },
+        };
+    },
+});
+//# sourceMappingURL=objectHasOwns.js.map

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

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

package/lib/rules/objectHasOwns.test.js

@@ -0,0 +1,112 @@
+import rule from "./objectHasOwns.js";
+import { ruleTester } from "./ruleTester.js";
+ruleTester.describe(rule, {
+    invalid: [
+        {
+            code: `
+const hasKey = obj.hasOwnProperty("key");
+`,
+            snapshot: `
+const hasKey = obj.hasOwnProperty("key");
+               ~~~~~~~~~~~~~~~~~~~~~~~~~
+               \`hasOwnProperty()\` calls can fail on objects without \`Object.prototype\` or with overridden properties.
+`,
+        },
+        {
+            code: `
+if (obj.hasOwnProperty("prop")) {
+    console.log("Has property");
+}
+`,
+            snapshot: `
+if (obj.hasOwnProperty("prop")) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~
+    \`hasOwnProperty()\` calls can fail on objects without \`Object.prototype\` or with overridden properties.
+    console.log("Has property");
+}
+`,
+        },
+        {
+            code: `
+const result = Object.prototype.hasOwnProperty.call(obj, "key");
+`,
+            snapshot: `
+const result = Object.prototype.hasOwnProperty.call(obj, "key");
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+               \`hasOwnProperty()\` calls can fail on objects without \`Object.prototype\` or with overridden properties.
+`,
+        },
+        {
+            code: `
+if (Object.prototype.hasOwnProperty.call(obj, "prop")) {
+    console.log("Has property");
+}
+`,
+            snapshot: `
+if (Object.prototype.hasOwnProperty.call(obj, "prop")) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    \`hasOwnProperty()\` calls can fail on objects without \`Object.prototype\` or with overridden properties.
+    console.log("Has property");
+}
+`,
+        },
+        {
+            code: `
+const hasKey = {}.hasOwnProperty.call(obj, "key");
+`,
+            snapshot: `
+const hasKey = {}.hasOwnProperty.call(obj, "key");
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+               \`hasOwnProperty()\` calls can fail on objects without \`Object.prototype\` or with overridden properties.
+`,
+        },
+        {
+            code: `
+if ({}.hasOwnProperty.call(obj, "prop")) {
+    console.log("Has property");
+}
+`,
+            snapshot: `
+if ({}.hasOwnProperty.call(obj, "prop")) {
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    \`hasOwnProperty()\` calls can fail on objects without \`Object.prototype\` or with overridden properties.
+    console.log("Has property");
+}
+`,
+        },
+        {
+            code: `
+const value = someObj.hasOwnProperty(key);
+`,
+            snapshot: `
+const value = someObj.hasOwnProperty(key);
+              ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+              \`hasOwnProperty()\` calls can fail on objects without \`Object.prototype\` or with overridden properties.
+`,
+        },
+        {
+            code: `
+function check(obj: object, key: string) {
+    return obj.hasOwnProperty(key);
+}
+`,
+            snapshot: `
+function check(obj: object, key: string) {
+    return obj.hasOwnProperty(key);
+           ~~~~~~~~~~~~~~~~~~~~~~~
+           \`hasOwnProperty()\` calls can fail on objects without \`Object.prototype\` or with overridden properties.
+}
+`,
+        },
+    ],
+    valid: [
+        `const hasKey = Object.hasOwn(obj, "key");`,
+        `if (Object.hasOwn(obj, "prop")) { console.log("Has property"); }`,
+        `const result = Object.hasOwn(obj, key);`,
+        `function check(obj: object, key: string) { return Object.hasOwn(obj, key); }`,
+        `const descriptor = Object.getOwnPropertyDescriptor(obj, "key");`,
+        `const keys = Object.getOwnPropertyNames(obj);`,
+        `const symbols = Object.getOwnPropertySymbols(obj);`,
+    ],
+});
+//# sourceMappingURL=objectHasOwns.test.js.map

package/lib/rules/objectKeyDuplicates.d.ts

@@ -0,0 +1,7 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports unnecessary duplicate keys that override previous values.";
+    readonly id: "objectKeyDuplicates";
+    readonly preset: "untyped";
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "duplicateKey", undefined>;
+export default _default;
+//# sourceMappingURL=objectKeyDuplicates.d.ts.map