@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/anyReturns.js

@@ -1,187 +1,102 @@
-import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
+import { ruleCreator } from "./ruleCreator.js";
 import { AnyType, discriminateAnyType } from "./utils/discriminateAnyType.js";
+import { isUnsafeAssignment } from "./utils/isUnsafeAssignment.js";
 import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
 import { getThisExpression } from "./utils/getThisExpression.js";
-import { isUnsafeAssignment } from "./utils/isUnsafeAssignment.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports returning a value with type `any` from a function.",
-        id: "anyReturns",
-        preset: "logical",
-    },
-    messages: {
-        unsafeReturn: {
-            primary: "Unsafe return of a value of type {{ type }}.",
-            secondary: [
-                "Returning a value of type `any` or a similar unsafe type defeats TypeScript's type safety guarantees.",
-                "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors.",
-            ],
-            suggestions: [
-                "Ensure the returned value has a well-defined, specific type.",
-            ],
-        },
-        unsafeReturnAssignment: {
-            primary: "Unsafe return of type `{{ sender }}` from function with return type `{{ receiver }}`.",
-            secondary: [
-                "The function's declared return type does not safely accept the value being returned.",
-                "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors.",
-            ],
-            suggestions: [
-                "Adjust the return type of the function to match the returned value, if appropriate.",
-                "Otherwise, refine the returned value to ensure it matches the expected return type.",
-            ],
-        },
-        unsafeReturnThis: {
-            primary: "Unsafe return of a value of type `{{ type }}`. `this` is typed as `any`.",
-            secondary: [
-                "Returning `this` when it is implicitly typed as `any` introduces type-unsafe behavior.",
-                "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors.",
-            ],
-            suggestions: [
-                "Enable the `noImplicitThis` compiler option to enforce explicit `this` types.",
-                "Add an explicit `this` parameter to the function to clarify its type.",
-            ],
-        },
-    },
-    setup(context) {
-        const isNoImplicitThis = tsutils.isStrictCompilerOptionEnabled(context.program.getCompilerOptions(), "noImplicitThis");
-        function checkReturn(returnNode, reportingNode) {
-            const type = context.typeChecker.getTypeAtLocation(returnNode);
-            const anyType = discriminateAnyType(type, context.typeChecker, context.program, returnNode);
-            const functionNode = ts.findAncestor(returnNode, 
-            // TODO: I believe isFunctionLikeDeclaration was incorrectly marked
-            // as deprecated in https://github.com/JoshuaKGoldberg/ts-api-utils/pull/124
-            // It says "With TypeScript v5, in favor of typescript's `isFunctionLike`."
-            // However, isFunctionLike also checks for signature-like nodes,
-            // whereas isFunctionLikeDeclaration checks only for function-like nodes.
-            // eslint-disable-next-line @typescript-eslint/no-deprecated
-            tsutils.isFunctionLikeDeclaration);
-            if (!functionNode) {
-                return;
-            }
-            // function has an explicit return type, so ensure it's a safe return
-            const returnNodeType = getConstrainedTypeAtLocation(returnNode, context.typeChecker);
-            // function expressions will not have their return type modified based on receiver typing
-            // so we have to use the contextual typing in these cases, i.e.
-            // const foo1: () => Set<string> = () => new Set<any>();
-            // the return type of the arrow function is Set<any> even though the variable is typed as Set<string>
-            let functionType = ts.isFunctionExpression(functionNode) ||
-                ts.isArrowFunction(functionNode)
-                ? context.typeChecker.getContextualType(functionNode)
-                : context.typeChecker.getTypeAtLocation(functionNode);
-            functionType ??= context.typeChecker.getTypeAtLocation(functionNode);
-            const callSignatures = tsutils.getCallSignaturesOfType(functionType);
-            // If there is an explicit type annotation *and* that type matches the actual
-            // function return type, we shouldn't complain (it's intentional, even if unsafe)
-            if (functionNode.type) {
-                for (const signature of callSignatures) {
-                    const signatureReturnType = signature.getReturnType();
-                    if (returnNodeType === signatureReturnType ||
-                        tsutils.isTypeFlagSet(signatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) {
-                        return;
-                    }
-                    if (tsutils.includesModifier(functionNode.modifiers, ts.SyntaxKind.AsyncKeyword)) {
-                        const awaitedSignatureReturnType = context.typeChecker.getAwaitedType(signatureReturnType);
-                        const awaitedReturnNodeType = context.typeChecker.getAwaitedType(returnNodeType);
-                        if (awaitedReturnNodeType === awaitedSignatureReturnType ||
-                            (awaitedSignatureReturnType &&
-                                tsutils.isTypeFlagSet(awaitedSignatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown))) {
-                            return;
-                        }
-                    }
-                }
-            }
-            if (anyType !== AnyType.Safe) {
-                // Allow cases when the declared return type of the function is either unknown or unknown[]
-                // and the function is returning any or any[].
-                for (const signature of callSignatures) {
-                    const functionReturnType = signature.getReturnType();
-                    if (anyType === AnyType.Any &&
-                        tsutils.isTypeFlagSet(functionReturnType, ts.TypeFlags.Unknown)) {
-                        return;
-                    }
-                    if (anyType === AnyType.AnyArray &&
-                        context.typeChecker.isArrayType(functionReturnType) &&
-                        tsutils.isTypeFlagSet(context.typeChecker.getTypeArguments(functionReturnType)[0], ts.TypeFlags.Unknown)) {
-                        return;
-                    }
-                    const awaitedType = context.typeChecker.getAwaitedType(functionReturnType);
-                    if (awaitedType &&
-                        anyType === AnyType.PromiseAny &&
-                        tsutils.isTypeFlagSet(awaitedType, ts.TypeFlags.Unknown)) {
-                        return;
-                    }
-                }
-                if (anyType === AnyType.PromiseAny &&
-                    !tsutils.includesModifier(functionNode.modifiers, ts.SyntaxKind.AsyncKeyword)) {
-                    return;
-                }
-                let message = "unsafeReturn";
-                const isErrorType = tsutils.isIntrinsicErrorType(returnNodeType);
-                if (!isNoImplicitThis) {
-                    // `return this`
-                    const thisExpression = getThisExpression(returnNode);
-                    if (thisExpression &&
-                        tsutils.isTypeFlagSet(getConstrainedTypeAtLocation(thisExpression, context.typeChecker), ts.TypeFlags.Any)) {
-                        message = "unsafeReturnThis";
-                    }
-                }
-                // If the function return type was not unknown/unknown[], mark usage as unsafeReturn.
-                context.report({
-                    data: {
-                        type: isErrorType
-                            ? "error"
-                            : anyType === AnyType.Any
-                                ? "`any`"
-                                : anyType === AnyType.PromiseAny
-                                    ? "`Promise<any>`"
-                                    : "`any[]`",
-                    },
-                    message,
-                    range: {
-                        begin: reportingNode.getStart(),
-                        end: reportingNode.getEnd(),
-                    },
-                });
-                return;
-            }
-            const signature = functionType.getCallSignatures().at(0);
-            if (signature) {
-                const functionReturnType = signature.getReturnType();
-                const result = isUnsafeAssignment(returnNodeType, functionReturnType, context.typeChecker, returnNode);
-                if (!result) {
-                    return;
-                }
-                const { receiver, sender } = result;
-                context.report({
-                    data: {
-                        receiver: context.typeChecker.typeToString(receiver),
-                        sender: context.typeChecker.typeToString(sender),
-                    },
-                    message: "unsafeReturnAssignment",
-                    range: {
-                        begin: reportingNode.getStart(),
-                        end: reportingNode.getEnd(),
-                    },
-                });
-                return;
-            }
-        }
-        return {
-            visitors: {
-                ArrowFunction: (node) => {
-                    if (!ts.isBlock(node.body)) {
-                        checkReturn(node.body, node.body);
-                    }
-                },
-                ReturnStatement: (node) => {
-                    if (node.expression != null) {
-                        checkReturn(node.expression, node);
-                    }
-                },
-            },
-        };
-    },
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+import * as tsutils from "ts-api-utils";
+import { nullThrows } from "@flint.fyi/utils";
+//#region src/rules/anyReturns.ts
+var anyReturns_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports returning a value with type `any` from a function.",
+		id: "anyReturns",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: {
+		unsafeReturn: {
+			primary: "Unsafe return of a value of type `{{ type }}`.",
+			secondary: ["Returning a value of type `any` or a similar unsafe type defeats TypeScript's type safety guarantees.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
+			suggestions: ["Ensure the returned value has a well-defined, specific type."]
+		},
+		unsafeReturnAssignment: {
+			primary: "Unsafe return of type `{{ sender }}` from function with return type `{{ receiver }}`.",
+			secondary: ["The function's declared return type does not safely accept the value being returned.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
+			suggestions: ["Adjust the return type of the function to match the returned value, if appropriate.", "Otherwise, refine the returned value to ensure it matches the expected return type."]
+		},
+		unsafeReturnThis: {
+			primary: "Unsafe return of a value of type `{{ type }}`. `this` is typed as `any`.",
+			secondary: ["Returning `this` when it is implicitly typed as `any` introduces type-unsafe behavior.", "This can allow unexpected types to propagate through your codebase, potentially causing runtime errors."],
+			suggestions: ["Enable the `noImplicitThis` compiler option to enforce explicit `this` types.", "Add an explicit `this` parameter to the function to clarify its type."]
+		}
+	},
+	setup(context) {
+		function checkReturn(returnNode, reportingNode, { program, sourceFile, typeChecker }) {
+			const type = typeChecker.getTypeAtLocation(returnNode);
+			const functionNode = ts.findAncestor(returnNode, tsutils.isFunctionLikeDeclaration);
+			if (!functionNode) return;
+			const returnNodeType = getConstrainedTypeAtLocation(returnNode, typeChecker);
+			const anyType = tsutils.isIntrinsicErrorType(returnNodeType) ? AnyType.Error : discriminateAnyType(type, typeChecker, returnNode);
+			let functionType = functionNode.kind === SyntaxKind.FunctionExpression || functionNode.kind === SyntaxKind.ArrowFunction ? typeChecker.getContextualType(functionNode) : typeChecker.getTypeAtLocation(functionNode);
+			functionType ??= typeChecker.getTypeAtLocation(functionNode);
+			const callSignatures = tsutils.getCallSignaturesOfType(functionType);
+			if (functionNode.type) for (const signature of callSignatures) {
+				const signatureReturnType = signature.getReturnType();
+				if (returnNodeType === signatureReturnType || tsutils.isTypeFlagSet(signatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return;
+				if (tsutils.includesModifier(functionNode.modifiers, SyntaxKind.AsyncKeyword)) {
+					const awaitedSignatureReturnType = typeChecker.getAwaitedType(signatureReturnType);
+					if (typeChecker.getAwaitedType(returnNodeType) === awaitedSignatureReturnType || awaitedSignatureReturnType && tsutils.isTypeFlagSet(awaitedSignatureReturnType, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return;
+				}
+			}
+			if (anyType !== AnyType.Safe) {
+				for (const signature of callSignatures) {
+					const functionReturnType = signature.getReturnType();
+					if ((anyType === AnyType.Any || anyType === AnyType.Error) && tsutils.isTypeFlagSet(functionReturnType, ts.TypeFlags.Unknown)) return;
+					if (anyType === AnyType.AnyArray && typeChecker.isArrayType(functionReturnType) && tsutils.isTypeFlagSet(nullThrows(typeChecker.getTypeArguments(functionReturnType)[0], "Array type should have at least one type argument"), ts.TypeFlags.Unknown)) return;
+					const awaitedType = typeChecker.getAwaitedType(functionReturnType);
+					if (awaitedType && anyType === AnyType.PromiseAny && tsutils.isTypeFlagSet(awaitedType, ts.TypeFlags.Unknown)) return;
+				}
+				if (anyType === AnyType.PromiseAny && !tsutils.includesModifier(functionNode.modifiers, SyntaxKind.AsyncKeyword)) return;
+				let message = "unsafeReturn";
+				if (!tsutils.isStrictCompilerOptionEnabled(program.getCompilerOptions(), "noImplicitThis")) {
+					const thisExpression = getThisExpression(returnNode);
+					if (thisExpression && tsutils.isTypeFlagSet(getConstrainedTypeAtLocation(thisExpression, typeChecker), ts.TypeFlags.Any)) message = "unsafeReturnThis";
+				}
+				context.report({
+					data: { type: anyType },
+					message,
+					range: getTSNodeRange(reportingNode, sourceFile)
+				});
+				return;
+			}
+			const signature = functionType.getCallSignatures().at(0);
+			if (signature) {
+				const result = isUnsafeAssignment(returnNodeType, signature.getReturnType(), returnNode);
+				if (!result) return;
+				const { receiver, sender } = result;
+				context.report({
+					data: {
+						receiver: typeChecker.typeToString(receiver),
+						sender: typeChecker.typeToString(sender)
+					},
+					message: "unsafeReturnAssignment",
+					range: getTSNodeRange(reportingNode, sourceFile)
+				});
+				return;
+			}
+		}
+		return { visitors: {
+			ArrowFunction: (node, fileService) => {
+				if (node.body.kind !== SyntaxKind.Block) checkReturn(node.body, node.body, fileService);
+			},
+			ReturnStatement: (node, fileService) => {
+				if (node.expression != null) checkReturn(node.expression, node, fileService);
+			}
+		} };
+	}
 });
+//#endregion
+export { anyReturns_default as default };
+
+//# sourceMappingURL=anyReturns.js.map

package/lib/rules/arguments.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the arguments object instead of rest parameters.";
+    readonly id: "arguments";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferRestParameters", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arguments.d.ts.map

package/lib/rules/arguments.js

@@ -0,0 +1,38 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/arguments.ts
+function isNonArrowFunctionBoundary(node) {
+	if (ts$1.isArrowFunction(node)) return "quit";
+	return ts$1.isFunctionDeclaration(node) || ts$1.isFunctionExpression(node) || ts$1.isMethodDeclaration(node) || ts$1.isGetAccessorDeclaration(node) || ts$1.isSetAccessorDeclaration(node) || ts$1.isConstructorDeclaration(node);
+}
+var arguments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using the arguments object instead of rest parameters.",
+		id: "arguments",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { preferRestParameters: {
+		primary: "Use rest parameters instead of the `arguments` object.",
+		secondary: ["The `arguments` object is an array-like object that doesn't have Array methods like `map`, `filter`, or `forEach`.", "Rest parameters provide a real Array, making it easier to work with variadic functions."],
+		suggestions: ["Replace usage of `arguments` with a rest parameter like `...args`."]
+	} },
+	setup(context) {
+		return { visitors: { Identifier: (node, { sourceFile, typeChecker }) => {
+			if (node.text !== "arguments") return;
+			const { parent } = node;
+			if ((ts$1.isPropertyAccessExpression(parent) || ts$1.isPropertyAssignment(parent) || ts$1.isShorthandPropertyAssignment(parent) || ts$1.isParameter(parent) || ts$1.isVariableDeclaration(parent) || ts$1.isPropertyDeclaration(parent) || ts$1.isBindingElement(parent) || ts$1.isPropertySignature(parent)) && parent.name === node) return;
+			if (!ts$1.findAncestor(node, isNonArrowFunctionBoundary)) return;
+			const symbol = typeChecker.getSymbolAtLocation(node);
+			if (!symbol || symbol.getDeclarations()?.some((declaration) => ts$1.isParameter(declaration) || ts$1.isVariableDeclaration(declaration) || ts$1.isPropertyDeclaration(declaration) || ts$1.isBindingElement(declaration))) return;
+			context.report({
+				message: "preferRestParameters",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { arguments_default as default };
+
+//# sourceMappingURL=arguments.js.map

package/lib/rules/arrayCallbackReturns.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports missing return statements in callbacks of array methods.";
+    readonly id: "arrayCallbackReturns";
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "missingReturn", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayCallbackReturns.d.ts.map

package/lib/rules/arrayCallbackReturns.js

@@ -0,0 +1,73 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+import * as tsutils from "ts-api-utils";
+//#region src/rules/arrayCallbackReturns.ts
+const arrayMethodsRequiringReturn = new Set([
+	"every",
+	"filter",
+	"find",
+	"findIndex",
+	"findLast",
+	"findLastIndex",
+	"flatMap",
+	"map",
+	"reduce",
+	"reduceRight",
+	"some",
+	"sort",
+	"toSorted"
+]);
+var arrayCallbackReturns_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports missing return statements in callbacks of array methods.",
+		id: "arrayCallbackReturns",
+		presets: ["javascript"]
+	},
+	messages: { missingReturn: {
+		primary: "Array method `{{ method }}` callback expects a return value.",
+		secondary: ["Array methods like `map`, `filter`, `find`, and `reduce` rely on return values from their callbacks.", "A missing return statement is often a mistake that causes the array method to produce unexpected results."],
+		suggestions: ["Add a return statement to the callback function.", "If you don't need the return value, consider using `forEach` instead."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile }) => {
+			if (!ts$1.isPropertyAccessExpression(node.expression)) return;
+			const methodName = node.expression.name.text;
+			if (!arrayMethodsRequiringReturn.has(methodName)) return;
+			const callback = node.arguments[0];
+			if (!callback) return;
+			const body = getCallbackBody(callback);
+			if (!body) return;
+			if (!hasReturnWithValue(body)) context.report({
+				data: { method: methodName },
+				message: "missingReturn",
+				range: {
+					begin: callback.getStart(sourceFile),
+					end: callback.getEnd()
+				}
+			});
+		} } };
+	}
+});
+function getCallbackBody(node) {
+	if (ts$1.isArrowFunction(node)) return ts$1.isBlock(node.body) ? node.body : void 0;
+	if (ts$1.isFunctionExpression(node)) return node.body;
+}
+function hasReturnWithValue(block) {
+	let hasReturn = false;
+	function visit(node) {
+		if (hasReturn) return;
+		if (ts$1.isReturnStatement(node) && node.expression) {
+			hasReturn = true;
+			return;
+		}
+		if (tsutils.isFunctionScopeBoundary(node)) return;
+		ts$1.forEachChild(node, visit);
+	}
+	ts$1.forEachChild(block, visit);
+	return hasReturn;
+}
+//#endregion
+export { arrayCallbackReturns_default as default };
+
+//# sourceMappingURL=arrayCallbackReturns.js.map

package/lib/rules/arrayConstructors.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the `Array` constructor to create arrays instead of array literal syntax.";
+    readonly id: "arrayConstructors";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferLiteral", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayConstructors.d.ts.map

package/lib/rules/arrayConstructors.js

@@ -0,0 +1,47 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/arrayConstructors.ts
+var arrayConstructors_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using the `Array` constructor to create arrays instead of array literal syntax.",
+		id: "arrayConstructors",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { preferLiteral: {
+		primary: "Prefer array literal syntax over the `Array` constructor.",
+		secondary: ["The `Array` constructor has confusing behavior with a single numeric argument, creating a sparse array instead of an array containing that number.", "Array literal syntax is clearer and avoids potential pitfalls."],
+		suggestions: ["Use array literal syntax like `[]` or `[1, 2, 3]`."]
+	} },
+	setup(context) {
+		function checkNode(node, { sourceFile, typeChecker }) {
+			if (!ts$1.isIdentifier(node.expression) || node.expression.text !== "Array" || shouldAllowCallOrNew(node) || !isGlobalDeclarationOfName(node.expression, "Array", typeChecker)) return;
+			const argumentsText = node.arguments?.map((arg) => arg.getText(sourceFile)).join(", ");
+			const range = getTSNodeRange(node, sourceFile);
+			context.report({
+				fix: {
+					range,
+					text: `[${argumentsText}]`
+				},
+				message: "preferLiteral",
+				range
+			});
+		}
+		return { visitors: {
+			CallExpression: checkNode,
+			NewExpression: checkNode
+		} };
+	}
+});
+function getSoleArgument(node) {
+	return node.arguments?.length === 1 ? node.arguments[0] : void 0;
+}
+function shouldAllowCallOrNew(node) {
+	if (node.typeArguments && !!node.typeArguments.length) return true;
+	const soleArgument = getSoleArgument(node);
+	return !!soleArgument && ts$1.isNumericLiteral(soleArgument);
+}
+//#endregion
+export { arrayConstructors_default as default };
+
+//# sourceMappingURL=arrayConstructors.js.map

package/lib/rules/arrayDeleteUnnecessaryCounts.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#splice()` or `Array#toSpliced()`.";
+    readonly id: "arrayDeleteUnnecessaryCounts";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryCount", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayDeleteUnnecessaryCounts.d.ts.map

package/lib/rules/arrayDeleteUnnecessaryCounts.js

@@ -0,0 +1,54 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getConstrainedTypeAtLocation } from "./utils/getConstrainedType.js";
+import { getTSNodeRange, hasSameTokens, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/arrayDeleteUnnecessaryCounts.ts
+function isUnnecessaryCountArgument(argumentRoot, calleeObject, sourceFile) {
+	const argument = unwrapParenthesizedNode(argumentRoot);
+	switch (argument.kind) {
+		case ts$1.SyntaxKind.Identifier: return argument.text === "Infinity" ? "`Infinity`" : void 0;
+		case ts$1.SyntaxKind.PropertyAccessExpression:
+			if (ts$1.isIdentifier(argument.expression) && argument.expression.text === "Number" && ts$1.isIdentifier(argument.name) && argument.name.text === "POSITIVE_INFINITY") return "`Number.POSITIVE_INFINITY`";
+			if (ts$1.isIdentifier(argument.name) && argument.name.text === "length" && hasSameTokens(argument.expression, calleeObject, sourceFile)) return `\`${ts$1.isIdentifier(calleeObject) ? calleeObject.text : "…"}${argument.questionDotToken ? "?." : "."}length\``;
+	}
+}
+var arrayDeleteUnnecessaryCounts_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using `.length` or `Infinity` as the `deleteCount` or `skipCount` argument of `Array#splice()` or `Array#toSpliced()`.",
+		id: "arrayDeleteUnnecessaryCounts",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { unnecessaryCount: {
+		primary: "Passing {{ description }} as the {{ argumentName }} argument is unnecessary.",
+		secondary: ["When calling `splice` or `toSpliced`, omitting the second argument will delete or skip all elements after the start index.", "Using `.length` or `Infinity` is redundant and makes the code less clear."],
+		suggestions: ["Omit the second argument to achieve the same result."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (!ts$1.isPropertyAccessExpression(node.expression) || !ts$1.isIdentifier(node.expression.name)) return;
+			const methodName = node.expression.name.text;
+			if (methodName !== "splice" && methodName !== "toSpliced") return;
+			if (!typeChecker.isArrayType(getConstrainedTypeAtLocation(node.expression.expression, typeChecker))) return;
+			if (node.arguments.length !== 2) return;
+			const firstArg = node.arguments[0];
+			if (ts$1.isSpreadElement(firstArg)) return;
+			const secondArg = node.arguments[1];
+			if (ts$1.isSpreadElement(secondArg)) return;
+			const description = isUnnecessaryCountArgument(secondArg, node.expression.expression, sourceFile);
+			if (!description) return;
+			const argumentName = methodName === "splice" ? "`deleteCount`" : "`skipCount`";
+			context.report({
+				data: {
+					argumentName,
+					description
+				},
+				message: "unnecessaryCount",
+				range: getTSNodeRange(secondArg, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { arrayDeleteUnnecessaryCounts_default as default };
+
+//# sourceMappingURL=arrayDeleteUnnecessaryCounts.js.map

package/lib/rules/arrayElementDeletions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports using the `delete` operator on array values.";
+    readonly id: "arrayElementDeletions";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noArrayDelete", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayElementDeletions.d.ts.map

package/lib/rules/arrayElementDeletions.js

@@ -0,0 +1,43 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { isArrayOrTupleTypeAtLocation } from "./utils/isArrayOrTupleTypeAtLocation.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/arrayElementDeletions.ts
+function buildSpliceReplacement(node, elementAccess, sourceFile) {
+	const children = elementAccess.getChildren(sourceFile);
+	const openBracket = children.find((child) => child.kind === ts$1.SyntaxKind.OpenBracketToken);
+	const closeBracket = children.find((child) => child.kind === ts$1.SyntaxKind.CloseBracketToken);
+	return `${sourceFile.text.slice(node.getStart(sourceFile) + 6, openBracket?.getStart(sourceFile) ?? elementAccess.expression.getEnd())}.splice(${sourceFile.text.slice(openBracket?.getEnd() ?? elementAccess.argumentExpression.getStart(sourceFile), closeBracket?.getStart(sourceFile) ?? elementAccess.argumentExpression.getEnd())}, 1)`;
+}
+var arrayElementDeletions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using the `delete` operator on array values.",
+		id: "arrayElementDeletions",
+		presets: ["logical", "logicalStrict"]
+	},
+	messages: { noArrayDelete: {
+		primary: "Avoid using the `delete` operator on arrays.",
+		secondary: ["Using `delete` on an array element removes it but leaves an empty slot, which can lead to unexpected behavior.", "The array's `length` property is not affected, and the element becomes `undefined` with a hole in the array."],
+		suggestions: ["Use `Array#splice()` to remove elements."]
+	} },
+	setup(context) {
+		return { visitors: { DeleteExpression: (node, { sourceFile, typeChecker }) => {
+			if (!ts$1.isElementAccessExpression(node.expression) || !isArrayOrTupleTypeAtLocation(node.expression.expression, typeChecker)) return;
+			const range = getTSNodeRange(node, sourceFile);
+			const spliceText = buildSpliceReplacement(node, node.expression, sourceFile);
+			context.report({
+				message: "noArrayDelete",
+				range,
+				suggestions: [{
+					id: "useSplice",
+					range,
+					text: spliceText
+				}]
+			});
+		} } };
+	}
+});
+//#endregion
+export { arrayElementDeletions_default as default };
+
+//# sourceMappingURL=arrayElementDeletions.js.map

package/lib/rules/arrayEmptyCallbackSlots.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports array methods with callbacks that will never be invoked on arrays with empty slots.";
+    readonly id: "arrayEmptyCallbackSlots";
+    readonly presets: ["logical", "logicalStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "neverInvoked", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=arrayEmptyCallbackSlots.d.ts.map