@flint.fyi/ts 0.15.0 → 0.18.1

package/lib/rules/unnecessaryMathClamps.js

@@ -0,0 +1,114 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/unnecessaryMathClamps.ts
+function extractNumericLiteral(node) {
+	const unwrapped = unwrapParenthesizedNode(node);
+	if (unwrapped.kind === SyntaxKind.NumericLiteral) return Number(unwrapped.text);
+	if (unwrapped.kind === SyntaxKind.PrefixUnaryExpression && unwrapped.operator === SyntaxKind.MinusToken && unwrapped.operand.kind === SyntaxKind.NumericLiteral) return -Number(unwrapped.operand.text);
+	if (unwrapped.kind === SyntaxKind.PrefixUnaryExpression && unwrapped.operator === SyntaxKind.PlusToken && unwrapped.operand.kind === SyntaxKind.NumericLiteral) return Number(unwrapped.operand.text);
+}
+function getMathMethodInfo(node, typeChecker) {
+	const unwrapped = unwrapParenthesizedNode(node);
+	if (unwrapped.kind !== SyntaxKind.CallExpression || unwrapped.questionDotToken || unwrapped.arguments.length < 1 || unwrapped.arguments.some((arg) => arg.kind === SyntaxKind.SpreadElement)) return;
+	if (isMathMethod(unwrapped.expression, "min", typeChecker)) return {
+		arguments: Array.from(unwrapped.arguments),
+		method: "min",
+		node: unwrapped
+	};
+	if (isMathMethod(unwrapped.expression, "max", typeChecker)) return {
+		arguments: Array.from(unwrapped.arguments),
+		method: "max",
+		node: unwrapped
+	};
+}
+function isMathMethod(node, methodName, typeChecker) {
+	return node.kind === SyntaxKind.PropertyAccessExpression && !node.questionDotToken && node.name.kind === SyntaxKind.Identifier && node.name.text === methodName && node.expression.kind === SyntaxKind.Identifier && isGlobalDeclarationOfName(node.expression, "Math", typeChecker);
+}
+var unnecessaryMathClamps_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary Math.min and Math.max calls with constant arguments or incorrect clamping patterns.",
+		id: "unnecessaryMathClamps",
+		presets: ["logical"]
+	},
+	messages: {
+		constantArguments: {
+			primary: "This `Math.{{ method }}` with all constant arguments will always return `{{ result }}`.",
+			secondary: ["When all arguments to `Math.{{ method }}` are constants, the result is always the same value.", "You can replace this call with the constant `{{ result }}` directly."],
+			suggestions: ["Replace with the constant value `{{ result }}`."]
+		},
+		incorrectClampOrder: {
+			primary: "Incorrect clamping pattern: `Math.{{ outerMethod }}({{ min }}, Math.{{ innerMethod }}({{ max }}, x))` should be `Math.min({{ max }}, Math.max({{ min }}, x))`.",
+			secondary: ["To clamp a value between a minimum and maximum, use `Math.min(max, Math.max(min, value))`.", "The current pattern will not correctly constrain the value to the intended range."],
+			suggestions: ["Use the correct clamping pattern: `Math.min(max, Math.max(min, value))`."]
+		}
+	},
+	setup(context) {
+		return { visitors: { CallExpression: (node, { sourceFile, typeChecker }) => {
+			const outerInfo = getMathMethodInfo(node, typeChecker);
+			if (!outerInfo) return;
+			const numericValues = [];
+			let allNumeric = true;
+			for (const arg of outerInfo.arguments) {
+				const value = extractNumericLiteral(arg);
+				if (value === void 0) {
+					allNumeric = false;
+					break;
+				}
+				numericValues.push(value);
+			}
+			if (allNumeric) {
+				const result = outerInfo.method === "min" ? Math.min(...numericValues) : Math.max(...numericValues);
+				context.report({
+					data: {
+						method: outerInfo.method,
+						result: String(result)
+					},
+					message: "constantArguments",
+					range: getTSNodeRange(node, sourceFile)
+				});
+				return;
+			}
+			if (outerInfo.arguments.length === 2) {
+				const firstArgument = outerInfo.arguments[0];
+				const secondArgument = outerInfo.arguments[1];
+				const innerInfo = getMathMethodInfo(secondArgument, typeChecker);
+				if (innerInfo && innerInfo.method !== outerInfo.method && innerInfo.arguments.length === 2) {
+					const innerFirstArg = innerInfo.arguments[0];
+					const innerSecondArg = innerInfo.arguments[1];
+					if (!innerFirstArg || !innerSecondArg) return;
+					const outerConstant = extractNumericLiteral(firstArgument);
+					const innerConstantFirst = extractNumericLiteral(innerFirstArg);
+					const innerConstantSecond = extractNumericLiteral(innerSecondArg);
+					if (outerInfo.method === "max" && innerInfo.method === "min" && outerConstant !== void 0 && innerConstantFirst !== void 0 && outerConstant < innerConstantFirst) {
+						context.report({
+							data: {
+								innerMethod: innerInfo.method,
+								max: String(innerConstantFirst),
+								min: String(outerConstant),
+								outerMethod: outerInfo.method
+							},
+							message: "incorrectClampOrder",
+							range: getTSNodeRange(node, sourceFile)
+						});
+						return;
+					}
+					if (outerInfo.method === "max" && innerInfo.method === "min" && outerConstant !== void 0 && innerConstantSecond !== void 0 && outerConstant < innerConstantSecond) context.report({
+						data: {
+							innerMethod: innerInfo.method,
+							max: String(innerConstantSecond),
+							min: String(outerConstant),
+							outerMethod: outerInfo.method
+						},
+						message: "incorrectClampOrder",
+						range: getTSNodeRange(node, sourceFile)
+					});
+				}
+			}
+		} } };
+	}
+});
+//#endregion
+export { unnecessaryMathClamps_default as default };
+
+//# sourceMappingURL=unnecessaryMathClamps.js.map

package/lib/rules/unnecessaryNumericFractions.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports numeric literals with unnecessary zero fractions or dangling dots.";
+    readonly id: "unnecessaryNumericFractions";
+    readonly presets: ["stylistic"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "danglingDot" | "zeroFraction", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=unnecessaryNumericFractions.d.ts.map

package/lib/rules/unnecessaryNumericFractions.js

@@ -0,0 +1,50 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+//#region src/rules/unnecessaryNumericFractions.ts
+var unnecessaryNumericFractions_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports numeric literals with unnecessary zero fractions or dangling dots.",
+		id: "unnecessaryNumericFractions",
+		presets: ["stylistic"]
+	},
+	messages: {
+		danglingDot: {
+			primary: "Prefer `{{ fixed }}` over `{{ raw }}` to avoid a dangling dot.",
+			secondary: ["Numeric literals with dangling dots (e.g., `1.`) are harder to read and can be confusing.", "The dot doesn't add any precision information to the number."],
+			suggestions: ["Remove the dangling dot from the numeric literal."]
+		},
+		zeroFraction: {
+			primary: "Prefer `{{ fixed }}` over `{{ raw }}` to avoid an unnecessary zero fraction.",
+			secondary: ["Numeric literals with zero fractions (e.g., `1.0`) are unnecessarily verbose.", "The zero fraction doesn't add any precision information to the number."],
+			suggestions: ["Remove the zero fraction from the numeric literal."]
+		}
+	},
+	setup(context) {
+		return { visitors: { NumericLiteral: (node, { sourceFile }) => {
+			const raw = node.getText(sourceFile);
+			const match = /^([\d_]*)(\.[\d_]*)(?:e[+-]?\d+)?$/.exec(raw);
+			if (!match) return;
+			const before = match[1];
+			const dotAndFractions = match[2];
+			const after = raw.slice(before.length + dotAndFractions.length);
+			const fixed = (before + dotAndFractions.replace(/[0_]+$/, "").replace(/\.$/, "") || "0") + after;
+			if (fixed === raw) return;
+			context.report({
+				data: {
+					fixed,
+					raw
+				},
+				fix: {
+					range: getTSNodeRange(node, sourceFile),
+					text: fixed
+				},
+				message: dotAndFractions === "." ? "danglingDot" : "zeroFraction",
+				range: getTSNodeRange(node, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { unnecessaryNumericFractions_default as default };
+
+//# sourceMappingURL=unnecessaryNumericFractions.js.map

package/lib/rules/unnecessaryRenames.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Renames that don't change the identifier name are unnecessary.";
+    readonly id: "unnecessaryRenames";
+    readonly presets: ["stylistic"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryRename", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=unnecessaryRenames.d.ts.map

package/lib/rules/unnecessaryRenames.js

@@ -0,0 +1,92 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { countCommentsInRange } from "./utils/countCommentsInRange.js";
+import { getTSNodeRange, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/unnecessaryRenames.ts
+function getModuleNameText(node) {
+	if (!node) return;
+	if (ts.isIdentifier(node) || ts.isStringLiteral(node)) return node.text;
+}
+function getPropertyAssignmentTargetInfo(node) {
+	if (node.initializer.kind === ts.SyntaxKind.BinaryExpression && node.initializer.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+		const targetParent = node.initializer.left;
+		return {
+			parenthesizesTarget: targetParent.kind === ts.SyntaxKind.ParenthesizedExpression,
+			replacementNode: node.initializer,
+			targetNode: unwrapParenthesizedNode(targetParent)
+		};
+	}
+	const targetNode = unwrapParenthesizedNode(node.initializer);
+	return {
+		parenthesizesTarget: false,
+		replacementNode: targetNode,
+		targetNode
+	};
+}
+var unnecessaryRenames_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Renames that don't change the identifier name are unnecessary.",
+		id: "unnecessaryRenames",
+		presets: ["stylistic"]
+	},
+	messages: { unnecessaryRename: {
+		primary: "Renaming to the same identifier name is unnecessary.",
+		secondary: ["Using the same name for both the source and target is redundant.", "Remove the rename and use the shorthand syntax instead."],
+		suggestions: ["Remove the unnecessary rename."]
+	} },
+	setup(context) {
+		function reportUnnecessaryRename(node, parenthesizesTarget, replacementRange, sourceFile) {
+			const range = getTSNodeRange(node, sourceFile);
+			const shouldSkipFix = parenthesizesTarget || countCommentsInRange(sourceFile.text, range) > countCommentsInRange(sourceFile.text, replacementRange);
+			context.report({
+				fix: shouldSkipFix ? void 0 : {
+					range,
+					text: sourceFile.text.slice(replacementRange.begin, replacementRange.end)
+				},
+				message: "unnecessaryRename",
+				range
+			});
+		}
+		function checkExportOrImportSpecifier(original, rangeNode, sourceFile) {
+			if (getModuleNameText(original.propertyName) !== getModuleNameText(original.name)) return;
+			reportUnnecessaryRename(original, false, getTSNodeRange(rangeNode, sourceFile), sourceFile);
+		}
+		function checkObjectLiteralDestructuring(node, sourceFile) {
+			for (const property of node.properties) {
+				if (!ts.isPropertyAssignment(property) || property.name.kind === ts.SyntaxKind.ComputedPropertyName) continue;
+				const { parenthesizesTarget, replacementNode, targetNode } = getPropertyAssignmentTargetInfo(property);
+				if (ts.isObjectLiteralExpression(targetNode)) {
+					checkObjectLiteralDestructuring(targetNode, sourceFile);
+					continue;
+				}
+				if (targetNode.kind !== ts.SyntaxKind.Identifier) continue;
+				if (getModuleNameText(property.name) !== targetNode.text) continue;
+				reportUnnecessaryRename(property, parenthesizesTarget, getTSNodeRange(replacementNode, sourceFile), sourceFile);
+			}
+		}
+		return { visitors: {
+			BinaryExpression: (node, { sourceFile }) => {
+				if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken) return;
+				const left = unwrapParenthesizedNode(node.left);
+				if (left.kind !== ts.SyntaxKind.ObjectLiteralExpression) return;
+				checkObjectLiteralDestructuring(left, sourceFile);
+			},
+			BindingElement: (node, { sourceFile }) => {
+				if (node.propertyName?.kind !== ts.SyntaxKind.ComputedPropertyName && node.name.kind === ts.SyntaxKind.Identifier && getModuleNameText(node.propertyName) === getModuleNameText(node.name)) reportUnnecessaryRename(node, false, {
+					begin: node.name.getStart(sourceFile),
+					end: node.getEnd()
+				}, sourceFile);
+			},
+			ExportSpecifier: (node, { sourceFile }) => {
+				if (node.propertyName) checkExportOrImportSpecifier(node, node.propertyName, sourceFile);
+			},
+			ImportSpecifier: (node, { sourceFile }) => {
+				checkExportOrImportSpecifier(node, node.name, sourceFile);
+			}
+		} };
+	}
+});
+//#endregion
+export { unnecessaryRenames_default as default };
+
+//# sourceMappingURL=unnecessaryRenames.js.map

package/lib/rules/unnecessaryTernaries.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports ternary expressions that can be simplified to boolean expressions or logical operators";
+    readonly id: "unnecessaryTernaries";
+    readonly presets: ["stylistic", "stylisticStrict"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryBooleanTernary" | "unnecessaryLogicalTernary", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=unnecessaryTernaries.d.ts.map

package/lib/rules/unnecessaryTernaries.js

@@ -0,0 +1,88 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, hasSameTokens, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/unnecessaryTernaries.ts
+function getNodeText(node, sourceFile) {
+	return sourceFile.text.slice(node.getStart(sourceFile), node.getEnd());
+}
+var unnecessaryTernaries_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports ternary expressions that can be simplified to boolean expressions or logical operators",
+		id: "unnecessaryTernaries",
+		presets: ["stylistic", "stylisticStrict"]
+	},
+	messages: {
+		unnecessaryBooleanTernary: {
+			primary: "This ternary expression can be simplified to a boolean expression.",
+			secondary: ["Using a ternary to return true or false based on a condition is redundant.", "The condition itself already evaluates to a boolean value."],
+			suggestions: ["Simplify to a boolean expression."]
+		},
+		unnecessaryLogicalTernary: {
+			primary: "This ternary expression can be simplified to a logical operator.",
+			secondary: ["Using a ternary where the consequent matches the condition is redundant.", "A logical OR operator (`||`) expresses the same logic more clearly."],
+			suggestions: ["Replace with logical OR operator."]
+		}
+	},
+	setup(context) {
+		return { visitors: { ConditionalExpression(node, { sourceFile }) {
+			const { condition, whenFalse, whenTrue } = node;
+			if (whenTrue.kind === ts.SyntaxKind.TrueKeyword && whenFalse.kind === ts.SyntaxKind.FalseKeyword) {
+				const range = getTSNodeRange(node, sourceFile);
+				context.report({
+					fix: {
+						range,
+						text: getNodeText(condition, sourceFile)
+					},
+					message: "unnecessaryBooleanTernary",
+					range
+				});
+				return;
+			}
+			if (whenTrue.kind === ts.SyntaxKind.FalseKeyword && whenFalse.kind === ts.SyntaxKind.TrueKeyword) {
+				const range = getTSNodeRange(node, sourceFile);
+				const conditionText = getNodeText(condition, sourceFile);
+				const negatedCondition = ts.isBinaryExpression(condition) || ts.isConditionalExpression(condition) ? `!(${conditionText})` : `!${conditionText}`;
+				context.report({
+					fix: {
+						range,
+						text: negatedCondition
+					},
+					message: "unnecessaryBooleanTernary",
+					range
+				});
+				return;
+			}
+			if (hasSameTokens(condition, whenTrue, sourceFile)) {
+				const range = getTSNodeRange(node, sourceFile);
+				const conditionText = getNodeText(condition, sourceFile);
+				const alternateText = getNodeText(whenFalse, sourceFile);
+				context.report({
+					fix: {
+						range,
+						text: `${conditionText} || ${alternateText}`
+					},
+					message: "unnecessaryLogicalTernary",
+					range
+				});
+				return;
+			}
+			if (ts.isPrefixUnaryExpression(condition) && condition.operator === ts.SyntaxKind.ExclamationToken && hasSameTokens(condition.operand, whenFalse, sourceFile)) {
+				const range = getTSNodeRange(node, sourceFile);
+				const operandText = getNodeText(condition.operand, sourceFile);
+				const alternateText = getNodeText(whenTrue, sourceFile);
+				context.report({
+					fix: {
+						range,
+						text: `${operandText} || ${alternateText}`
+					},
+					message: "unnecessaryLogicalTernary",
+					range
+				});
+			}
+		} } };
+	}
+});
+//#endregion
+export { unnecessaryTernaries_default as default };
+
+//# sourceMappingURL=unnecessaryTernaries.js.map

package/lib/rules/unnecessaryUseStricts.d.ts

@@ -0,0 +1,10 @@
+declare const _default: import("@flint.fyi/core").Rule<{
+    readonly description: "Reports unnecessary \"use strict\" directives in ES modules and classes.";
+    readonly id: "unnecessaryUseStricts";
+    readonly presets: ["logical"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "unnecessaryUseStrict", import("@flint.fyi/core").AnyOptionalSchema>;
+export default _default;
+//# sourceMappingURL=unnecessaryUseStricts.d.ts.map

package/lib/rules/unnecessaryUseStricts.js

@@ -0,0 +1,40 @@
+import { ruleCreator } from "./ruleCreator.js";
+import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+//#region src/rules/unnecessaryUseStricts.ts
+var unnecessaryUseStricts_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports unnecessary \"use strict\" directives in ES modules and classes.",
+		id: "unnecessaryUseStricts",
+		presets: ["logical"]
+	},
+	messages: { unnecessaryUseStrict: {
+		primary: "This `\"use strict\"` directive is redundant and can be safely removed.",
+		secondary: ["ECMAScript modules and class bodies are automatically in strict mode.", "The `\"use strict\"` directive has no effect and is redundant."],
+		suggestions: ["Remove the `\"use strict\"` directive."]
+	} },
+	setup(context) {
+		return { visitors: { SourceFile(node, { sourceFile }) {
+			if (!ts.isExternalModule(sourceFile)) return;
+			const firstStatement = node.statements[0];
+			if (!ts.isExpressionStatement(firstStatement) || !ts.isStringLiteral(firstStatement.expression) || firstStatement.expression.text !== "use strict") return;
+			const secondStatement = node.statements[1];
+			const fixEnd = secondStatement ? secondStatement.getStart(sourceFile) : firstStatement.getEnd();
+			context.report({
+				fix: {
+					range: {
+						begin: firstStatement.getStart(sourceFile),
+						end: fixEnd
+					},
+					text: ""
+				},
+				message: "unnecessaryUseStrict",
+				range: getTSNodeRange(firstStatement, sourceFile)
+			});
+		} } };
+	}
+});
+//#endregion
+export { unnecessaryUseStricts_default as default };
+
+//# sourceMappingURL=unnecessaryUseStricts.js.map

package/lib/rules/unsafeNegations.d.ts

@@ -1,7 +1,10 @@
 declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports negating the left operand of `in` or `instanceof` relations.";
     readonly id: "unsafeNegations";
-    readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "preferNegatingRelation", undefined>;
+    readonly presets: ["javascript"];
+} & {
+    presets?: ("javascript" | "logical" | "logicalStrict" | "stylistic" | "stylisticStrict")[];
+    url: string;
+}, object, object, "preferNegatingRelation", import("@flint.fyi/core").AnyOptionalSchema>;
 export default _default;
 //# sourceMappingURL=unsafeNegations.d.ts.map

package/lib/rules/unsafeNegations.js

@@ -1,51 +1,38 @@
-import * as ts from "typescript";
-import { typescriptLanguage } from "../language.js";
-import { unwrapParenthesizedExpression } from "../utils/unwrapParenthesizedExpression.js";
-const operatorStrings = new Map([
-    [ts.SyntaxKind.InKeyword, "in"],
-    [ts.SyntaxKind.InstanceOfKeyword, "instanceof"],
-]);
-export default typescriptLanguage.createRule({
-    about: {
-        description: "Reports negating the left operand of `in` or `instanceof` relations.",
-        id: "unsafeNegations",
-        preset: "untyped",
-    },
-    messages: {
-        preferNegatingRelation: {
-            primary: "This negation applies before the `{{ operator }}` operator.",
-            secondary: [
-                "The logical not operator (!) has higher precedence than `in` and `instanceof`.",
-                "Write `!(left in right)` or `!(left instanceof Right)` to negate the relation as intended.",
-            ],
-            suggestions: ["Wrap the relation in parentheses and negate it."],
-        },
-    },
-    setup(context) {
-        return {
-            visitors: {
-                BinaryExpression: (node, { sourceFile }) => {
-                    const operator = operatorStrings.get(node.operatorToken.kind);
-                    if (!operator) {
-                        return;
-                    }
-                    const left = unwrapParenthesizedExpression(node.left);
-                    if (!ts.isPrefixUnaryExpression(left) ||
-                        left.operator !== ts.SyntaxKind.ExclamationToken) {
-                        return;
-                    }
-                    const begin = left.getStart(sourceFile);
-                    context.report({
-                        data: { operator },
-                        message: "preferNegatingRelation",
-                        range: {
-                            begin,
-                            end: begin + 1,
-                        },
-                    });
-                },
-            },
-        };
-    },
+import { ruleCreator } from "./ruleCreator.js";
+import { typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
+import { SyntaxKind } from "typescript";
+//#region src/rules/unsafeNegations.ts
+const operatorStrings = new Map([[SyntaxKind.InKeyword, "in"], [SyntaxKind.InstanceOfKeyword, "instanceof"]]);
+var unsafeNegations_default = ruleCreator.createRule(typescriptLanguage, {
+	about: {
+		description: "Reports negating the left operand of `in` or `instanceof` relations.",
+		id: "unsafeNegations",
+		presets: ["javascript"]
+	},
+	messages: { preferNegatingRelation: {
+		primary: "This negation applies before the `{{ operator }}` operator.",
+		secondary: ["The logical not operator (!) has higher precedence than `in` and `instanceof`.", "Write `!(left in right)` or `!(left instanceof Right)` to negate the relation as intended."],
+		suggestions: ["Wrap the relation in parentheses and negate it."]
+	} },
+	setup(context) {
+		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
+			const operator = operatorStrings.get(node.operatorToken.kind);
+			if (!operator) return;
+			const left = unwrapParenthesizedNode(node.left);
+			if (left.kind !== SyntaxKind.PrefixUnaryExpression || left.operator !== SyntaxKind.ExclamationToken) return;
+			const begin = left.getStart(sourceFile);
+			context.report({
+				data: { operator },
+				message: "preferNegatingRelation",
+				range: {
+					begin,
+					end: begin + 1
+				}
+			});
+		} } };
+	}
 });
+//#endregion
+export { unsafeNegations_default as default };
+
 //# sourceMappingURL=unsafeNegations.js.map

package/lib/rules/utils/collectAccessorPairs.d.ts

@@ -0,0 +1,12 @@
+import type { AST } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+export interface AccessorInfo {
+    index: number;
+    node: AST.GetAccessorDeclaration | AST.SetAccessorDeclaration;
+}
+export interface AccessorPair {
+    getter?: AccessorInfo;
+    setter?: AccessorInfo;
+}
+export declare function collectAccessorPairs(members: ts.NodeArray<AST.AnyNode>, sourceFile: AST.SourceFile): Map<string, AccessorPair>;
+//# sourceMappingURL=collectAccessorPairs.d.ts.map

package/lib/rules/utils/collectAccessorPairs.js

@@ -0,0 +1,29 @@
+import ts from "typescript";
+//#region src/rules/utils/collectAccessorPairs.ts
+function collectAccessorPairs(members, sourceFile) {
+	const pairs = /* @__PURE__ */ new Map();
+	members.forEach((member, index) => {
+		if (member.kind !== ts.SyntaxKind.GetAccessor && member.kind !== ts.SyntaxKind.SetAccessor) return;
+		const name = getPropertyName(member, sourceFile);
+		let pair = pairs.get(name);
+		if (!pair) {
+			pair = {};
+			pairs.set(name, pair);
+		}
+		const entry = {
+			index,
+			node: member
+		};
+		if (member.kind === ts.SyntaxKind.GetAccessor) pair.getter = entry;
+		else pair.setter = entry;
+	});
+	return pairs;
+}
+function getPropertyName(accessor, sourceFile) {
+	if (ts.isIdentifier(accessor.name) || ts.isStringLiteral(accessor.name) || ts.isNumericLiteral(accessor.name)) return accessor.name.text;
+	return accessor.name.getText(sourceFile);
+}
+//#endregion
+export { collectAccessorPairs };
+
+//# sourceMappingURL=collectAccessorPairs.js.map

package/lib/rules/utils/countCommentsInRange.d.ts

@@ -0,0 +1,3 @@
+import type { CharacterReportRange } from "@flint.fyi/core";
+export declare function countCommentsInRange(sourceText: string, { begin, end }: CharacterReportRange): number;
+//# sourceMappingURL=countCommentsInRange.d.ts.map

package/lib/rules/utils/countCommentsInRange.js

@@ -0,0 +1,12 @@
+import ts from "typescript";
+//#region src/rules/utils/countCommentsInRange.ts
+function countCommentsInRange(sourceText, { begin, end }) {
+	const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.Standard, sourceText.slice(begin, end));
+	let count = 0;
+	for (let token = scanner.scan(); token !== ts.SyntaxKind.EndOfFileToken; token = scanner.scan()) if (token === ts.SyntaxKind.SingleLineCommentTrivia || token === ts.SyntaxKind.MultiLineCommentTrivia) count++;
+	return count;
+}
+//#endregion
+export { countCommentsInRange };
+
+//# sourceMappingURL=countCommentsInRange.js.map

package/lib/rules/utils/discriminateAnyType.d.ts

@@ -1,13 +1,16 @@
-import * as ts from "typescript";
-export declare enum AnyType {
-    Any = 0,
-    PromiseAny = 1,
-    AnyArray = 2,
-    Safe = 3
-}
+import type { Checker } from "@flint.fyi/typescript-language";
+import ts from "typescript";
+export declare const AnyType: {
+    readonly Any: "any";
+    readonly AnyArray: "any[]";
+    readonly Error: "error";
+    readonly PromiseAny: "Promise<any>";
+    readonly Safe: "safe";
+};
+export type AnyType = (typeof AnyType)[keyof typeof AnyType];
 /**
  * @returns `AnyType.Any` if the type is `any`, `AnyType.AnyArray` if the type is `any[]` or `readonly any[]`, `AnyType.PromiseAny` if the type is `Promise&lt;any>`,
- * otherwise it returns `AnyType.Safe`.
+ * `AnyType.Error` if the type is an intrinsic error type, otherwise it returns `AnyType.Safe`.
  */
-export declare function discriminateAnyType(type: ts.Type, checker: ts.TypeChecker, program: ts.Program, tsNode: ts.Node): AnyType;
+export declare function discriminateAnyType(type: ts.Type, checker: Checker, tsNode: ts.Node): AnyType;
 //# sourceMappingURL=discriminateAnyType.d.ts.map