@flint.fyi/ts 0.14.6 → 0.18.0

package/lib/rules/combinedPushes.js

@@ -0,0 +1,56 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/combinedPushes.ts
+var combinedPushes_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports consecutive array.push() calls that could be combined into a single call.",
+		id: "combinedPushes",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { combinePushes: {
+		primary: "Consecutive `.push()` calls can be combined into a single call.",
+		secondary: ["Multiple consecutive `.push()` calls on the same array can be combined.", "Use `.push(a, b, c)` instead of separate `.push(a)`, `.push(b)`, `.push(c)` calls."],
+		suggestions: ["Combine consecutive `.push()` calls into one."]
+	} },
+	setup(context) {
+		function isArrayPushCall(node, typeChecker) {
+			return ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "push" && typeChecker.isArrayType(typeChecker.getTypeAtLocation(node.expression.expression));
+		}
+		function getArrayName(node, sourceFile) {
+			return ts.isPropertyAccessExpression(node.expression) && node.expression.expression.getText(sourceFile);
+		}
+		function isPushCallStatement(statement, sourceFile, typeChecker) {
+			if (!ts.isExpressionStatement(statement) || !ts.isCallExpression(statement.expression) || !isArrayPushCall(statement.expression, typeChecker)) return;
+			const arrayName = getArrayName(statement.expression, sourceFile);
+			if (!arrayName) return;
+			return {
+				arrayName,
+				callExpression: statement.expression
+			};
+		}
+		function checkNode({ statements }, { sourceFile, typeChecker }) {
+			for (let i = 0; i < statements.length - 1; i += 1) {
+				const currentStatement = statements[i];
+				const currentPush = isPushCallStatement(currentStatement, sourceFile, typeChecker);
+				if (!currentPush) continue;
+				const nextStatement = statements[i + 1];
+				if (isPushCallStatement(nextStatement, sourceFile, typeChecker)?.arrayName === currentPush.arrayName) context.report({
+					message: "combinePushes",
+					range: {
+						begin: currentStatement.getStart(sourceFile),
+						end: nextStatement.getEnd()
+					}
+				});
+			}
+		}
+		return { visitors: {
+			Block: checkNode,
+			SourceFile: checkNode
+		} };
+	}
+});
+//#endregion
+export { combinedPushes_default as default };
+
+//# sourceMappingURL=combinedPushes.js.map

package/lib/rules/consecutiveNonNullAssertions.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports unnecessary extra non-null assertions.";
     readonly id: "consecutiveNonNullAssertions";
-    readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "consecutiveNonNullAssertion", undefined>;
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "consecutiveNonNullAssertion", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=consecutiveNonNullAssertions.d.ts.map

package/lib/rules/consecutiveNonNullAssertions.js

@@ -1,42 +1,39 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports unnecessary extra non-null assertions.",
-        id: "consecutiveNonNullAssertions",
-        preset: "logical",
-    },
-    messages: {
-        consecutiveNonNullAssertion: {
-            primary: "Consecutive non-null assertion operators are unnecessary.",
-            secondary: [
-                "The non-null assertion operator (`!`) is used to assert that a value is not null or undefined.",
-                "Using it multiple times in a row does not do anything, and just takes up space unnecessarily.",
-            ],
-            suggestions: ["Remove the redundant non-null assertion operator."],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                NonNullExpression: (node) => {
-                    if (node.parent.kind !== ts.SyntaxKind.NonNullExpression) {
-                        return;
-                    }
-                    const range = {
-                        begin: node.end - 1,
-                        end: node.parent.end,
-                    };
-                    context.report({
-                        fix: {
-                            range,
-                            text: "",
-                        },
-                        message: "consecutiveNonNullAssertion",
-                        range,
-                    });
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/consecutiveNonNullAssertions.ts
+var consecutiveNonNullAssertions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary extra non-null assertions.",
+		id: "consecutiveNonNullAssertions",
+		presets: ["logical"]
+	},
+	messages: { consecutiveNonNullAssertion: {
+		primary: "Consecutive non-null assertion operators are unnecessary.",
+		secondary: ["The non-null assertion operator (`!`) is used to assert that a value is not null or undefined.", "Using it multiple times in a row does not do anything, and just takes up space unnecessarily."],
+		suggestions: ["Remove the redundant non-null assertion operator."]
+	} },
+	setup(context) {
+		return { visitors: { NonNullExpression: (node) => {
+			if (node.parent.kind !== SyntaxKind.NonNullExpression) return;
+			context.report({
+				fix: {
+					range: {
+						begin: node.end,
+						end: node.parent.end
+					},
+					text: ""
+				},
+				message: "consecutiveNonNullAssertion",
+				range: {
+					begin: node.end - 1,
+					end: node.parent.end
+				}
+			});
+		} } };
+	}
 });
+//#endregion
+export { consecutiveNonNullAssertions_default as default };
+
+//# sourceMappingURL=consecutiveNonNullAssertions.js.map

package/lib/rules/consoleCalls.d.ts

@@ -0,0 +1,9 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports calls to console methods.";
+    readonly id: "consoleCalls";
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noConsole", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=consoleCalls.d.ts.map

package/lib/rules/consoleCalls.js

@@ -0,0 +1,28 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalVariable, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/consoleCalls.ts
+var consoleCalls_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports calls to console methods.",
+		id: "consoleCalls"
+	},
+	messages: { noConsole: {
+		primary: "Console method calls should not be used in production code.",
+		secondary: ["Console methods like `console.log`, `console.warn`, and `console.error` are useful during development but should typically be removed before shipping to production.", "Consider using a proper logging library that can be configured for different environments."],
+		suggestions: ["Remove the console call before shipping this code to users."]
+	} },
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			if (!ts.isPropertyAccessExpression(node.expression) || !ts.isIdentifier(node.expression.expression) || node.expression.expression.text !== "console" || !isGlobalVariable(node.expression.expression, typeChecker)) return;
+			context.report({
+				message: "noConsole",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { consoleCalls_default as default };
+
+//# sourceMappingURL=consoleCalls.js.map

package/lib/rules/constantAssignments.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports attempting to reassign variables declared with const.";
     readonly id: "constantAssignments";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noConstAssign", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noConstAssign", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=constantAssignments.d.ts.map

package/lib/rules/constantAssignments.js

@@ -1,61 +1,44 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-import { getModifyingReferences } from "../utils/getModifyingReferences.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports attempting to reassign variables declared with const.",
-        id: "constantAssignments",
-        preset: "untyped",
-    },
-    messages: {
-        noConstAssign: {
-            primary: "Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.",
-            secondary: [
-                "The const keyword creates a read-only reference to a value, preventing reassignment.",
-                "While properties of const objects and elements of const arrays can be mutated, the binding itself cannot be reassigned.",
-            ],
-            suggestions: [
-                "Use let instead of const if you need to reassign the variable.",
-            ],
-        },
-    },
-    setup(context) {
-        function collectBindingElements(name) {
-            if (ts.isIdentifier(name)) {
-                return [name];
-            }
-            const identifiers = [];
-            for (const element of name.elements) {
-                if (ts.isBindingElement(element)) {
-                    identifiers.push(...collectBindingElements(element.name));
-                }
-            }
-            return identifiers;
-        }
-        return {
-            visitors: {
-                VariableDeclarationList: (node) => {
-                    if (!(node.flags & ts.NodeFlags.Const) ||
-                        node.declarations.length === 0) {
-                        return;
-                    }
-                    for (const declaration of node.declarations) {
-                        const identifiers = collectBindingElements(declaration.name);
-                        for (const identifier of identifiers) {
-                            const modifyingReferences = getModifyingReferences(identifier, context.sourceFile, context.typeChecker);
-                            for (const reference of modifyingReferences) {
-                                context.report({
-                                    message: "noConstAssign",
-                                    range: {
-                                        begin: reference.getStart(context.sourceFile),
-                                        end: reference.getEnd(),
-                                    },
-                                });
-                            }
-                        }
-                    }
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { getModifyingReferences, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts, { SyntaxKind } from "typescript";
+//#region src/rules/constantAssignments.ts
+var constantAssignments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports attempting to reassign variables declared with const.",
+		id: "constantAssignments",
+		presets: ["javascript"]
+	},
+	messages: { noConstAssign: {
+		primary: "Variables declared with const cannot be reassigned; use let or var instead if reassignment is needed.",
+		secondary: ["The const keyword creates a read-only reference to a value, preventing reassignment.", "While properties of const objects and elements of const arrays can be mutated, the binding itself cannot be reassigned."],
+		suggestions: ["Use let instead of const if you need to reassign the variable."]
+	} },
+	setup(context) {
+		function collectBindingElements(name) {
+			if (name.kind === SyntaxKind.Identifier) return [name];
+			const identifiers = [];
+			for (const element of name.elements) if (element.kind === SyntaxKind.BindingElement) identifiers.push(...collectBindingElements(element.name));
+			return identifiers;
+		}
+		return { visitors: { VariableDeclarationList: (node, { sourceFile, typeChecker }) => {
+			if (!(node.flags & ts.NodeFlags.Const) || !node.declarations.length) return;
+			for (const declaration of node.declarations) {
+				const identifiers = collectBindingElements(declaration.name);
+				for (const identifier of identifiers) {
+					const modifyingReferences = getModifyingReferences(identifier, sourceFile, typeChecker);
+					for (const reference of modifyingReferences) context.report({
+						message: "noConstAssign",
+						range: {
+							begin: reference.getStart(sourceFile),
+							end: reference.getEnd()
+						}
+					});
+				}
+			}
+		} } };
+	}
 });
+//#endregion
+export { constantAssignments_default as default };
+
+//# sourceMappingURL=constantAssignments.js.map

package/lib/rules/constructorGenericCalls.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports inconsistent placement of type arguments in constructor calls.";
+    readonly id: "constructorGenericCalls";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferConstructor" | "preferTypeAnnotation", {
+    style: z.ZodDefault<z.ZodEnum<{
+        constructor: "constructor";
+        "type-annotation": "type-annotation";
+    }>>;
+}>;
+export default _default;
+//# sourceMappingURL=constructorGenericCalls.d.ts.map

package/lib/rules/constructorGenericCalls.js

@@ -0,0 +1,138 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import { z } from "zod/v4";
+//#region src/rules/constructorGenericCalls.ts
+const builtInTypedArrays = new Set([
+	"Float32Array",
+	"Float64Array",
+	"Int8Array",
+	"Int16Array",
+	"Int32Array",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Uint16Array",
+	"Uint32Array"
+]);
+function getTypeArgumentsRange(parent, typeArguments, sourceFile) {
+	const children = parent.getChildren(sourceFile);
+	let begin = typeArguments.pos;
+	let end = typeArguments.end;
+	for (const child of children) if (child.kind === ts.SyntaxKind.LessThanToken) begin = child.getStart(sourceFile);
+	else if (child.kind === ts.SyntaxKind.GreaterThanToken) end = child.getEnd();
+	return {
+		begin,
+		end
+	};
+}
+function getTypeArgumentsText(parent, typeArguments, sourceFile) {
+	const range = getTypeArgumentsRange(parent, typeArguments, sourceFile);
+	return sourceFile.text.slice(range.begin, range.end);
+}
+function isBuiltInTypedArray(name) {
+	return builtInTypedArrays.has(name);
+}
+const options = { style: z.enum(["constructor", "type-annotation"]).default("constructor").describe("Where to prefer type arguments: 'constructor' for the constructor call, 'type-annotation' for the type annotation.") };
+var constructorGenericCalls_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports inconsistent placement of type arguments in constructor calls.",
+		id: "constructorGenericCalls",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: {
+		preferConstructor: {
+			primary: "Prefer specifying the type argument on the constructor call instead of the type annotation.",
+			secondary: ["When type arguments are needed, specifying them on the constructor is more explicit.", "This makes the code more readable by keeping the type information with the value."],
+			suggestions: ["Move the type argument from the type annotation to the constructor call."]
+		},
+		preferTypeAnnotation: {
+			primary: "Prefer specifying the type argument on the type annotation instead of the constructor call.",
+			secondary: ["Specifying type arguments on the type annotation keeps the variable's type explicit.", "This approach can make refactoring easier when changing the right-hand side."],
+			suggestions: ["Move the type argument from the constructor call to the type annotation."]
+		}
+	},
+	options,
+	setup(context) {
+		function checkNode(node, { options, sourceFile }) {
+			const identifier = node.name;
+			const typeAnnotation = node.type;
+			const initializer = node.initializer;
+			const style = options.style;
+			if (!initializer || !ts.isNewExpression(initializer) || !ts.isIdentifier(initializer.expression)) return;
+			const constructorName = initializer.expression.text;
+			if (!typeAnnotation) {
+				if (style === "type-annotation" && initializer.typeArguments) {
+					const typeArgsText = getTypeArgumentsText(initializer, initializer.typeArguments, sourceFile);
+					const identifierEnd = identifier.getEnd();
+					const typeAnnotationText = `${constructorName}${typeArgsText}`;
+					const typeArgumentsRange = getTypeArgumentsRange(initializer, initializer.typeArguments, sourceFile);
+					context.report({
+						fix: [{
+							range: typeArgumentsRange,
+							text: ""
+						}, {
+							range: {
+								begin: identifierEnd,
+								end: identifierEnd
+							},
+							text: `: ${typeAnnotationText}`
+						}],
+						message: "preferTypeAnnotation",
+						range: typeArgumentsRange
+					});
+				}
+				return;
+			}
+			if (!ts.isTypeReferenceNode(typeAnnotation) || !ts.isIdentifier(typeAnnotation.typeName) || typeAnnotation.typeName.text !== constructorName || isBuiltInTypedArray(typeAnnotation.typeName.text) || !!typeAnnotation.typeArguments !== !initializer.typeArguments) return;
+			if (style === "constructor" && typeAnnotation.typeArguments && !initializer.typeArguments) {
+				const typeArgsText = getTypeArgumentsText(typeAnnotation, typeAnnotation.typeArguments, sourceFile);
+				const typeArgsRange = getTypeArgumentsRange(typeAnnotation, typeAnnotation.typeArguments, sourceFile);
+				const constructorEnd = initializer.expression.getEnd();
+				const hasParens = initializer.arguments !== void 0;
+				context.report({
+					fix: [{
+						range: {
+							begin: typeAnnotation.getStart(sourceFile),
+							end: typeAnnotation.getEnd()
+						},
+						text: constructorName
+					}, {
+						range: {
+							begin: constructorEnd,
+							end: constructorEnd
+						},
+						text: typeArgsText + (hasParens ? "" : "()")
+					}],
+					message: "preferConstructor",
+					range: typeArgsRange
+				});
+			} else if (style === "type-annotation" && !typeAnnotation.typeArguments && initializer.typeArguments) {
+				const typeArgumentsText = getTypeArgumentsText(initializer, initializer.typeArguments, sourceFile);
+				const typeArgumentsRange = getTypeArgumentsRange(initializer, initializer.typeArguments, sourceFile);
+				const newTypeAnnotation = `${typeAnnotation.typeName.text}${typeArgumentsText}`;
+				context.report({
+					fix: [{
+						range: {
+							begin: typeAnnotation.getStart(sourceFile),
+							end: typeAnnotation.getEnd()
+						},
+						text: newTypeAnnotation
+					}, {
+						range: typeArgumentsRange,
+						text: ""
+					}],
+					message: "preferTypeAnnotation",
+					range: typeArgumentsRange
+				});
+			}
+		}
+		return { visitors: {
+			PropertyDeclaration: checkNode,
+			VariableDeclaration: checkNode
+		} };
+	}
+});
+//#endregion
+export { constructorGenericCalls_default as default };
+
+//# sourceMappingURL=constructorGenericCalls.js.map

package/lib/rules/constructorReturns.d.ts

@@ -1,6 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports returning values from constructor functions.";
     readonly id: "constructorReturns";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noConstructorReturn", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noConstructorReturn", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
+//# sourceMappingURL=constructorReturns.d.ts.map

package/lib/rules/constructorReturns.js

@@ -1,52 +1,41 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
 import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports returning values from constructor functions.",
-        id: "constructorReturns",
-        preset: "untyped",
-    },
-    messages: {
-        noConstructorReturn: {
-            primary: "Returning a value from a constructor function overrides the newly created instance.",
-            secondary: [
-                "This behavior is often unintentional and can lead to unexpected results.",
-                "If you need to return a different object, consider using a factory function instead.",
-            ],
-            suggestions: [
-                "Remove the return statement, or return without a value to exit early.",
-            ],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                Constructor: (node) => {
-                    if (!node.body) {
-                        return;
-                    }
-                    function checkForReturnStatements(node) {
-                        if (ts.isReturnStatement(node)) {
-                            if (node.expression) {
-                                context.report({
-                                    message: "noConstructorReturn",
-                                    range: {
-                                        begin: node.getStart(context.sourceFile),
-                                        end: node.getEnd(),
-                                    },
-                                });
-                            }
-                            return;
-                        }
-                        if (tsutils.isFunctionScopeBoundary(node)) {
-                            return;
-                        }
-                        ts.forEachChild(node, checkForReturnStatements);
-                    }
-                    ts.forEachChild(node.body, checkForReturnStatements);
-                },
-            },
-        };
-    },
+//#region src/rules/constructorReturns.ts
+var constructorReturns_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports returning values from constructor functions.",
+		id: "constructorReturns",
+		presets: ["javascript"]
+	},
+	messages: { noConstructorReturn: {
+		primary: "Returning a value from a constructor function overrides the newly created instance.",
+		secondary: ["This behavior is often unintentional and can lead to unexpected results.", "If you need to return a different object, consider using a factory function instead."],
+		suggestions: ["Remove the return statement, or return without a value to exit early."]
+	} },
+	setup(context) {
+		return { visitors: { Constructor: (node, { sourceFile }) => {
+			if (!node.body) return;
+			function checkForReturnStatements(node) {
+				if (ts.isReturnStatement(node)) {
+					if (node.expression) context.report({
+						message: "noConstructorReturn",
+						range: {
+							begin: node.getStart(sourceFile),
+							end: node.getEnd()
+						}
+					});
+					return;
+				}
+				if (tsutils.isFunctionScopeBoundary(node)) return;
+				ts.forEachChild(node, checkForReturnStatements);
+			}
+			ts.forEachChild(node.body, checkForReturnStatements);
+		} } };
+	}
 });
+//#endregion
+export { constructorReturns_default as default };
+
+//# sourceMappingURL=constructorReturns.js.map

package/lib/rules/constructorSupers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports constructors of derived classes that do not call `super()`, and constructors of non-derived classes that call `super()`.";
+    readonly id: "constructorSupers";
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "missingSuperCall" | "unexpectedSuperCall", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=constructorSupers.d.ts.map