@flint.fyi/ts 0.15.0 → 0.18.0

package/lib/rules/regexValidity.js

@@ -0,0 +1,146 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/regexValidity.ts
+const validFlags = new Set([
+	"d",
+	"g",
+	"i",
+	"m",
+	"s",
+	"u",
+	"v",
+	"y"
+]);
+var regexValidity_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports invalid regular expressions.",
+		id: "regexValidity",
+		presets: ["logical"]
+	},
+	messages: {
+		conflictingFlags: {
+			primary: "The `u` and `v` flags cannot be used together.",
+			secondary: ["These flags enable mutually exclusive Unicode modes."],
+			suggestions: ["Use either `u` or `v`, but not both."]
+		},
+		duplicateFlag: {
+			primary: "Duplicate regular expression flag `{{ flag }}`.",
+			secondary: ["Each flag can only appear once."],
+			suggestions: ["Remove the duplicate flag."]
+		},
+		invalidFlag: {
+			primary: "Invalid regular expression flag `{{ flag }}`.",
+			secondary: ["Valid flags are: d, g, i, m, s, u, v, y."],
+			suggestions: ["Remove the invalid flag."]
+		},
+		invalidPattern: {
+			primary: "Invalid regular expression pattern.",
+			secondary: ["This RegExp constructor call will throw at runtime."],
+			suggestions: ["Fix the regular expression syntax."]
+		}
+	},
+	setup(context) {
+		function checkFlags(flags, flagsStart) {
+			const seenFlags = /* @__PURE__ */ new Set();
+			let hasU = false;
+			let hasV = false;
+			let uPosition = -1;
+			let vPosition = -1;
+			let hasInvalidFlags = false;
+			for (let i = 0; i < flags.length; i += 1) {
+				const flag = flags[i];
+				if (!validFlags.has(flag)) {
+					hasInvalidFlags = true;
+					context.report({
+						data: { flag },
+						message: "invalidFlag",
+						range: {
+							begin: flagsStart + i,
+							end: flagsStart + i + 1
+						}
+					});
+					continue;
+				}
+				if (seenFlags.has(flag)) {
+					hasInvalidFlags = true;
+					context.report({
+						data: { flag },
+						message: "duplicateFlag",
+						range: {
+							begin: flagsStart + i,
+							end: flagsStart + i + 1
+						}
+					});
+					continue;
+				}
+				seenFlags.add(flag);
+				if (flag === "u") {
+					hasU = true;
+					uPosition = i;
+				} else if (flag === "v") {
+					hasV = true;
+					vPosition = i;
+				}
+			}
+			if (hasU && hasV) {
+				hasInvalidFlags = true;
+				const laterPosition = Math.max(uPosition, vPosition);
+				context.report({
+					message: "conflictingFlags",
+					range: {
+						begin: flagsStart + laterPosition,
+						end: flagsStart + laterPosition + 1
+					}
+				});
+			}
+			return hasInvalidFlags;
+		}
+		function checkPattern(pattern, flags, patternStart, patternEnd) {
+			if (parseRegexpAst(pattern, flags) === void 0) context.report({
+				message: "invalidPattern",
+				range: {
+					begin: patternStart,
+					end: patternEnd
+				}
+			});
+		}
+		function checkRegexLiteral(node, services) {
+			const details = getRegExpLiteralDetails(node, services);
+			const flagsStart = node.getStart(services.sourceFile) + node.text.length - details.flags.length;
+			if (checkFlags(details.flags, flagsStart)) return;
+			const patternStart = details.start;
+			const patternEnd = flagsStart - 1;
+			checkPattern(details.pattern, details.flags, patternStart, patternEnd);
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const firstArgument = construction.args[0];
+			let hasInvalidFlags = false;
+			if (construction.args.length >= 2) {
+				const secondArgument = construction.args[1];
+				if (secondArgument.kind === ts$1.SyntaxKind.StringLiteral) {
+					const flagsStart = secondArgument.getStart(services.sourceFile) + 1;
+					hasInvalidFlags = checkFlags(construction.flags, flagsStart);
+				}
+			}
+			if (hasInvalidFlags) return;
+			const patternStart = firstArgument.getStart(services.sourceFile) + 1;
+			const patternEnd = firstArgument.getEnd() - 1;
+			checkPattern(construction.raw, construction.flags, patternStart, patternEnd);
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexValidity_default as default };
+
+//# sourceMappingURL=regexValidity.js.map

package/lib/rules/regexWordMatchers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports character classes that match word characters and could use \\w or \\W instead.";
+    readonly id: "regexWordMatchers";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferWord", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexWordMatchers.d.ts.map

package/lib/rules/regexWordMatchers.js

@@ -0,0 +1,146 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexWordMatchers.ts
+function findIssues(pattern, flags) {
+	const issues = [];
+	const hasIgnoreCase = flags.includes("i");
+	const ast = parseRegexpAst(pattern, flags);
+	if (!ast) return issues;
+	visitRegExpAST(ast, { onCharacterClassEnter(characterClassNode) {
+		const expectedCount = hasIgnoreCase ? 3 : 4;
+		if (characterClassNode.elements.length !== expectedCount) return;
+		let hasDigit = false;
+		let hasLower = false;
+		let hasUpper = false;
+		let hasUnderscore = false;
+		for (const element of characterClassNode.elements) if (isDigitRange(element)) {
+			if (hasDigit) return;
+			hasDigit = true;
+		} else if (isLowerRange(element)) {
+			if (hasLower) return;
+			hasLower = true;
+		} else if (isUpperRange(element)) {
+			if (hasUpper) return;
+			hasUpper = true;
+		} else if (isUnderscore(element)) {
+			if (hasUnderscore) return;
+			hasUnderscore = true;
+		} else return;
+		if (!(hasIgnoreCase ? hasDigit && hasLower && hasUnderscore && !hasUpper : hasDigit && hasLower && hasUpper && hasUnderscore)) return;
+		issues.push({
+			end: characterClassNode.end,
+			negated: characterClassNode.negate,
+			raw: characterClassNode.raw,
+			start: characterClassNode.start
+		});
+	} });
+	return issues;
+}
+function isDigitRange(element) {
+	if (element.type === "CharacterSet" && element.kind === "digit") return true;
+	if (element.type === "CharacterClassRange") return element.min.value === 48 && element.max.value === 57;
+	return false;
+}
+function isLowerRange(element) {
+	if (element.type === "CharacterClassRange") return element.min.value === 97 && element.max.value === 122;
+	return false;
+}
+function isUnderscore(element) {
+	if (element.type === "Character") return element.value === 95;
+	return false;
+}
+function isUpperRange(element) {
+	if (element.type === "CharacterClassRange") return element.min.value === 65 && element.max.value === 90;
+	return false;
+}
+var regexWordMatchers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports character classes that match word characters and could use \\w or \\W instead.",
+		id: "regexWordMatchers",
+		presets: ["stylisticStrict"]
+	},
+	messages: { preferWord: {
+		primary: "Character class '{{ raw }}' can be replaced with '{{ replacement }}'.",
+		secondary: ["The \\w shorthand matches [a-zA-Z0-9_] (word characters)."],
+		suggestions: ["Replace with '{{ replacement }}'."]
+	} },
+	setup(context) {
+		function checkRegexLiteral(node, services) {
+			const { flags, pattern, start } = getRegExpLiteralDetails(node, services);
+			const issues = findIssues(pattern, flags);
+			for (const issue of issues) {
+				const replacement = issue.negated ? "\\W" : "\\w";
+				context.report({
+					data: {
+						raw: issue.raw,
+						replacement
+					},
+					fix: {
+						range: {
+							begin: start + issue.start,
+							end: start + issue.end
+						},
+						text: replacement
+					},
+					message: "preferWord",
+					range: {
+						begin: start + issue.start,
+						end: start + issue.end
+					}
+				});
+			}
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			const { flags, pattern, start } = construction;
+			const issues = findIssues(pattern.replace(/\\\\/g, "\\"), flags);
+			function mapPositionToSource(pos) {
+				let sourcePos = 0;
+				let patternPos = 0;
+				while (patternPos < pos && sourcePos < pattern.length) {
+					if (pattern[sourcePos] === "\\" && pattern[sourcePos + 1] === "\\") sourcePos += 2;
+					else sourcePos += 1;
+					patternPos += 1;
+				}
+				return sourcePos;
+			}
+			for (const issue of issues) {
+				const replacement = issue.negated ? "\\\\W" : "\\\\w";
+				const adjustedStart = mapPositionToSource(issue.start);
+				const adjustedEnd = mapPositionToSource(issue.end);
+				context.report({
+					data: {
+						raw: issue.raw,
+						replacement: issue.negated ? "\\W" : "\\w"
+					},
+					fix: {
+						range: {
+							begin: start + 1 + adjustedStart,
+							end: start + 1 + adjustedEnd
+						},
+						text: replacement
+					},
+					message: "preferWord",
+					range: {
+						begin: start + 1 + adjustedStart,
+						end: start + 1 + adjustedEnd
+					}
+				});
+			}
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexWordMatchers_default as default };
+
+//# sourceMappingURL=regexWordMatchers.js.map

package/lib/rules/regexZeroQuantifiers.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports quantifiers with a maximum of zero, which are useless.";
+    readonly id: "regexZeroQuantifiers";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "uselessZero", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=regexZeroQuantifiers.d.ts.map

package/lib/rules/regexZeroQuantifiers.js

@@ -0,0 +1,60 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { parseRegexpAst } from "./utils/parseRegexpAst.js";
+import { getRegExpConstruction } from "./utils/getRegExpConstruction.js";
+import { getRegExpLiteralDetails } from "./utils/getRegExpLiteralDetails.js";
+import { typescriptLanguage } from "@flint.fyi/typescript-language";
+import { visitRegExpAST } from "@eslint-community/regexpp";
+//#region src/rules/regexZeroQuantifiers.ts
+var regexZeroQuantifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports quantifiers with a maximum of zero, which are useless.",
+		id: "regexZeroQuantifiers",
+		presets: ["logical"]
+	},
+	messages: { uselessZero: {
+		primary: "Quantifier '{{ raw }}' has a maximum of 0 and is useless.",
+		secondary: ["This quantified element will always be repeated zero times and can be removed."],
+		suggestions: ["Remove the quantifier and its quantified element."]
+	} },
+	setup(context) {
+		function checkPattern(pattern, patternStart, flags, emptyReplacement) {
+			const regexpAst = parseRegexpAst(pattern, flags);
+			if (!regexpAst) return;
+			visitRegExpAST(regexpAst, { onQuantifierEnter(node) {
+				if (node.max !== 0) return;
+				const range = {
+					begin: patternStart + node.start,
+					end: patternStart + node.end
+				};
+				const isWholePattern = node.start === 0 && node.end === pattern.length;
+				context.report({
+					data: { raw: node.raw },
+					fix: {
+						range,
+						text: isWholePattern ? emptyReplacement : ""
+					},
+					message: "uselessZero",
+					range
+				});
+			} });
+		}
+		function checkRegexLiteral(node, { sourceFile }) {
+			const details = getRegExpLiteralDetails(node, { sourceFile });
+			checkPattern(details.pattern, details.start, details.flags, "(?:)");
+		}
+		function checkRegExpConstructor(node, services) {
+			const construction = getRegExpConstruction(node, services);
+			if (!construction) return;
+			checkPattern(construction.pattern, construction.start + 1, construction.flags, "");
+		}
+		return { visitors: {
+			CallExpression: checkRegExpConstructor,
+			NewExpression: checkRegExpConstructor,
+			RegularExpressionLiteral: checkRegexLiteral
+		} };
+	}
+});
+//#endregion
+export { regexZeroQuantifiers_default as default };
+
+//# sourceMappingURL=regexZeroQuantifiers.js.map

package/lib/rules/responseJsonMethods.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Prefer `Response.json()` over `new Response(JSON.stringify(...))` for JSON responses.";
+    readonly id: "responseJsonMethods";
+    readonly presets: ["stylistic"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferResponseJson", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=responseJsonMethods.d.ts.map

package/lib/rules/responseJsonMethods.js

@@ -0,0 +1,51 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import * as ts$1 from "typescript";
+//#region src/rules/responseJsonMethods.ts
+function isAcceptableSecondArgument(node) {
+	return isEmptyObjectLiteral(node) || isJsonContentTypeHeadersObject(node);
+}
+function isEmptyObjectLiteral(node) {
+	return ts$1.isObjectLiteralExpression(node) && !node.properties.length;
+}
+function isJsonContentTypeHeader(node) {
+	if (!ts$1.isObjectLiteralExpression(node) || node.properties.length !== 1) return false;
+	const property = node.properties[0];
+	return ts$1.isPropertyAssignment(property) && (ts$1.isIdentifier(property.name) || ts$1.isStringLiteral(property.name)) && property.name.text.toLowerCase() === "content-type" && ts$1.isStringLiteral(property.initializer) && property.initializer.text.toLowerCase().startsWith("application/json");
+}
+function isJsonContentTypeHeadersObject(node) {
+	if (!ts$1.isObjectLiteralExpression(node) || node.properties.length !== 1) return false;
+	const property = node.properties[0];
+	return ts$1.isPropertyAssignment(property) && (ts$1.isIdentifier(property.name) || ts$1.isStringLiteral(property.name)) && property.name.text.toLowerCase() === "headers" && isJsonContentTypeHeader(property.initializer);
+}
+function isJsonStringifyCall(node) {
+	return ts$1.isCallExpression(node) && ts$1.isPropertyAccessExpression(node.expression) && ts$1.isIdentifier(node.expression.expression) && node.expression.expression.text === "JSON" && ts$1.isIdentifier(node.expression.name) && node.expression.name.text === "stringify";
+}
+var responseJsonMethods_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Prefer `Response.json()` over `new Response(JSON.stringify(...))` for JSON responses.",
+		id: "responseJsonMethods",
+		presets: ["stylistic"]
+	},
+	messages: { preferResponseJson: {
+		primary: "Prefer the cleaner `Response.json()` instead of `new Response(JSON.stringify(...))`.",
+		secondary: ["Response.json() is more concise and sets the Content-Type header automatically."],
+		suggestions: ["Replace with `Response.json()`."]
+	} },
+	setup(context) {
+		return { visitors: { NewExpression: (node, { sourceFile }) => {
+			if (!ts$1.isIdentifier(node.expression) || node.expression.text !== "Response" || !node.arguments?.length || node.arguments.length > 2) return;
+			const firstArgument = node.arguments[0];
+			if (!isJsonStringifyCall(firstArgument) || firstArgument.arguments.length !== 1) return;
+			if (node.arguments.length === 2 && !isAcceptableSecondArgument(node.arguments[1])) return;
+			context.report({
+				message: "preferResponseJson",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { responseJsonMethods_default as default };
+
+//# sourceMappingURL=responseJsonMethods.js.map

package/lib/rules/restrictedIdentifiers.d.ts

@@ -0,0 +1,13 @@
+import z from "zod/v4";
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Disallows specific identifier names in binding positions.";
+    readonly id: "restrictedIdentifiers";
+    readonly presets: ["stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "restricted", {
+    readonly deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}>;
+export default _default;
+//# sourceMappingURL=restrictedIdentifiers.d.ts.map

package/lib/rules/restrictedIdentifiers.js

@@ -0,0 +1,41 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+import z$1 from "zod/v4";
+//#region src/rules/restrictedIdentifiers.ts
+var restrictedIdentifiers_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Disallows specific identifier names in binding positions.",
+		id: "restrictedIdentifiers",
+		presets: ["stylisticStrict"]
+	},
+	messages: { restricted: {
+		primary: "Identifier '{{ name }}' is restricted.",
+		secondary: ["This identifier name is on this project's denylist."],
+		suggestions: ["Rename the identifier to something allowed in the project."]
+	} },
+	options: { deny: z$1.array(z$1.string()).optional() },
+	setup(context) {
+		function checkNode(node, { options, sourceFile }) {
+			if (node.name?.kind !== ts.SyntaxKind.Identifier || !options.deny?.includes(node.name.text)) return;
+			context.report({
+				data: { name: node.name.text },
+				message: "restricted",
+				range: getTSNodeRange(node.name, sourceFile)
+			});
+		}
+		return { visitors: {
+			ClassDeclaration: checkNode,
+			FunctionDeclaration: checkNode,
+			ImportClause: checkNode,
+			ImportSpecifier: checkNode,
+			NamespaceImport: checkNode,
+			Parameter: checkNode,
+			VariableDeclaration: checkNode
+		} };
+	}
+});
+//#endregion
+export { restrictedIdentifiers_default as default };
+
+//# sourceMappingURL=restrictedIdentifiers.js.map

package/lib/rules/returnAssignments.d.ts

@@ -1,7 +1,10 @@
 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").TypeScriptFileServices, "noReturnAssign", undefined>;
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "noReturnAssign", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=returnAssignments.d.ts.map

package/lib/rules/returnAssignments.js

@@ -1,51 +1,38 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
 import * as tsutils from "ts-api-utils";
-import * as ts from "typescript";
-import { getTSNodeRange } from "../getTSNodeRange.js";
-import { typescriptLanguage } from "../language.js";
-import { unwrapParenthesizedExpression } from "../utils/unwrapParenthesizedExpression.js";
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports using assignment expressions in return statements.",
-        id: "returnAssignments",
-        preset: "stylistic",
-    },
-    messages: {
-        noReturnAssign: {
-            primary: "Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.",
-            secondary: [
-                "Using assignments in return statements can make code harder to read and can lead to confusion about whether the assignment or the returned value is the primary intent.",
-                "Assignment expressions return the assigned value, but mixing assignment with return makes the control flow less clear.",
-            ],
-            suggestions: [
-                "Perform the assignment on a separate line before the return statement.",
-            ],
-        },
-    },
-    setup(context) {
-        function checkForAssignment(node, sourceFile) {
-            const unwrapped = unwrapParenthesizedExpression(node);
-            if (ts.isBinaryExpression(unwrapped) &&
-                tsutils.isAssignmentKind(unwrapped.operatorToken.kind)) {
-                context.report({
-                    message: "noReturnAssign",
-                    range: getTSNodeRange(unwrapped.operatorToken, sourceFile),
-                });
-            }
-        }
-        return {
-            visitors: {
-                ArrowFunction: (node, { sourceFile }) => {
-                    if (!ts.isBlock(node.body)) {
-                        checkForAssignment(node.body, sourceFile);
-                    }
-                },
-                ReturnStatement: (node, { sourceFile }) => {
-                    if (node.expression) {
-                        checkForAssignment(node.expression, sourceFile);
-                    }
-                },
-            },
-        };
-    },
+//#region src/rules/returnAssignments.ts
+var returnAssignments_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports using assignment expressions in return statements.",
+		id: "returnAssignments",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: { noReturnAssign: {
+		primary: "Placing an assignment inside a return statement can be misleading and is often a sign of a logical mistake.",
+		secondary: ["Using assignments in return statements can make code harder to read and can lead to confusion about whether the assignment or the returned value is the primary intent.", "Assignment expressions return the assigned value, but mixing assignment with return makes the control flow less clear."],
+		suggestions: ["Perform the assignment on a separate line before the return statement."]
+	} },
+	setup(context) {
+		function checkForAssignment(node, sourceFile) {
+			const unwrapped = unwrapParenthesizedNode(node);
+			if (unwrapped.kind === SyntaxKind.BinaryExpression && tsutils.isAssignmentKind(unwrapped.operatorToken.kind)) context.report({
+				message: "noReturnAssign",
+				range: getTSNodeRange(unwrapped.operatorToken, sourceFile)
+			});
+		}
+		return { visitors: {
+			ArrowFunction: (node, { sourceFile }) => {
+				if (node.body.kind !== SyntaxKind.Block) checkForAssignment(node.body, sourceFile);
+			},
+			ReturnStatement: (node, { sourceFile }) => {
+				if (node.expression) checkForAssignment(node.expression, sourceFile);
+			}
+		} };
+	}
 });
+//#endregion
+export { returnAssignments_default as default };
+
 //# sourceMappingURL=returnAssignments.js.map

package/lib/rules/returnThisTypes.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Enforce that `this` is used when only `this` type is returned.";
+    readonly id: "returnThisTypes";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferThis", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=returnThisTypes.d.ts.map