@flint.fyi/ts 0.21.0 → 0.23.0

package/lib/rules/nestedStandaloneIfs.js

@@ -1,103 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/nestedStandaloneIfs.ts
-function hasCommentsInRange(sourceFile, start, end) {
-	const text = sourceFile.text.slice(start, end);
-	return text.includes("//") || text.includes("/*");
-}
-function isIfWithoutElse(node) {
-	return ts.isIfStatement(node) && node.elseStatement === void 0;
-}
-const lowerPrecedenceThanLogicalAnd = /* @__PURE__ */ new Set([
-	SyntaxKind.BinaryExpression,
-	SyntaxKind.ConditionalExpression,
-	SyntaxKind.YieldExpression
-]);
-function needsParentheses(node) {
-	if (node.kind !== SyntaxKind.BinaryExpression) return lowerPrecedenceThanLogicalAnd.has(node.kind);
-	const operator = node.operatorToken.kind;
-	return operator === SyntaxKind.BarBarToken || operator === SyntaxKind.QuestionQuestionToken || operator === SyntaxKind.CommaToken || operator === SyntaxKind.EqualsToken || operator === SyntaxKind.PlusEqualsToken || operator === SyntaxKind.MinusEqualsToken || operator === SyntaxKind.AsteriskEqualsToken || operator === SyntaxKind.SlashEqualsToken || operator === SyntaxKind.PercentEqualsToken || operator === SyntaxKind.AsteriskAsteriskEqualsToken || operator === SyntaxKind.LessThanLessThanEqualsToken || operator === SyntaxKind.GreaterThanGreaterThanEqualsToken || operator === SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken || operator === SyntaxKind.AmpersandEqualsToken || operator === SyntaxKind.BarEqualsToken || operator === SyntaxKind.CaretEqualsToken || operator === SyntaxKind.BarBarEqualsToken || operator === SyntaxKind.AmpersandAmpersandEqualsToken || operator === SyntaxKind.QuestionQuestionEqualsToken;
-}
-function wrapWithParenthesesIfNeeded(expression, sourceFile) {
-	const text = expression.getText(sourceFile);
-	return needsParentheses(expression) ? `(${text})` : text;
-}
-var nestedStandaloneIfs_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports `if` statements that are the only statement inside an `else` block or inside another `if` without an `else`.",
-		id: "nestedStandaloneIfs",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: {
-		lonelyIfInElse: {
-			primary: "This `if` is the only statement in an `else` block and can be written as `else if`.",
-			secondary: ["An `if` statement that is the only statement inside an `else` block can be collapsed into `else if`, which reduces nesting and improves readability."],
-			suggestions: ["Convert to `else if` to flatten the structure."]
-		},
-		lonelyIfInIf: {
-			primary: "This `if` is the only statement inside another `if` without an `else` and can be combined using `&&`.",
-			secondary: ["When an `if` statement is the only statement inside another `if` that has no `else`, the conditions can be combined with `&&` for simpler code."],
-			suggestions: ["Combine the conditions with `&&`."]
-		}
-	},
-	setup(context) {
-		function checkSoleBlockChild(node, sourceFile) {
-			if (node.parent.parent.kind === SyntaxKind.IfStatement && node.parent.parent.elseStatement === node.parent) {
-				const grandparent = node.parent.parent;
-				const openBrace = node.parent.getStart(sourceFile);
-				const closeBrace = node.parent.getEnd();
-				if (hasCommentsInRange(sourceFile, openBrace + 1, node.getStart(sourceFile))) return;
-				if (hasCommentsInRange(sourceFile, node.getEnd(), closeBrace - 1)) return;
-				if (!grandparent.getChildren(sourceFile).find((child) => child.kind === SyntaxKind.ElseKeyword)) return;
-				const nodeText = node.getText(sourceFile);
-				context.report({
-					fix: {
-						range: {
-							begin: node.parent.getStart(sourceFile),
-							end: node.parent.getEnd()
-						},
-						text: nodeText
-					},
-					message: "lonelyIfInElse",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-			if (!isIfWithoutElse(node)) return;
-			if (isIfWithoutElse(node.parent.parent) && node.parent.parent.thenStatement === node.parent) {
-				const outerIf = node.parent.parent;
-				const openBrace = node.parent.getStart(sourceFile);
-				const closeBrace = node.parent.getEnd();
-				if (hasCommentsInRange(sourceFile, openBrace + 1, node.getStart(sourceFile)) || hasCommentsInRange(sourceFile, node.getEnd(), closeBrace - 1)) return;
-				const fixedText = `if (${wrapWithParenthesesIfNeeded(outerIf.expression, sourceFile)} && ${wrapWithParenthesesIfNeeded(node.expression, sourceFile)}) ${node.thenStatement.getText(sourceFile)}`;
-				context.report({
-					fix: {
-						range: getTSNodeRange(outerIf, sourceFile),
-						text: fixedText
-					},
-					message: "lonelyIfInIf",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-		}
-		function checkChildOfIfWithoutElse(node, parent, sourceFile) {
-			const fixedText = `if (${wrapWithParenthesesIfNeeded(parent.expression, sourceFile)} && ${wrapWithParenthesesIfNeeded(node.expression, sourceFile)}) ${node.thenStatement.getText(sourceFile)}`;
-			context.report({
-				fix: {
-					range: getTSNodeRange(parent, sourceFile),
-					text: fixedText
-				},
-				message: "lonelyIfInIf",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: { IfStatement: (node, { sourceFile }) => {
-			if (node.parent.kind === SyntaxKind.Block && node.parent.statements.length === 1) checkSoleBlockChild(node, sourceFile);
-			else if (isIfWithoutElse(node.parent) && node.parent.thenStatement === node) checkChildOfIfWithoutElse(node, node.parent, sourceFile);
-		} } };
-	}
-});
-//#endregion
-export { nestedStandaloneIfs_default as default };

package/lib/rules/newDefinitions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports misleading constructor and `new` definitions in interfaces and classes.";
-    readonly id: "newDefinitions";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "classMethodNamedNew" | "interfaceConstructSignature" | "interfaceMethodNamedConstructor", undefined>;
-export default _default;

package/lib/rules/newDefinitions.js

@@ -1,82 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/newDefinitions.ts
-function getParentClassName(node) {
-	switch (node.parent.kind) {
-		case ts.SyntaxKind.ClassDeclaration:
-		case ts.SyntaxKind.ClassExpression: return node.parent.name?.text;
-		case ts.SyntaxKind.SourceFile: return;
-		default: return getParentClassName(node.parent);
-	}
-}
-function getParentInterface(node) {
-	switch (node.parent.kind) {
-		case ts.SyntaxKind.InterfaceDeclaration: return node.parent;
-		case ts.SyntaxKind.SourceFile: return;
-		default: return getParentInterface(node.parent);
-	}
-}
-function getTypeReferenceName(node) {
-	return node?.kind === ts.SyntaxKind.TypeReference && node.typeName.kind === ts.SyntaxKind.Identifier ? node.typeName.text : void 0;
-}
-var newDefinitions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports misleading constructor and `new` definitions in interfaces and classes.",
-		id: "newDefinitions",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		classMethodNamedNew: {
-			primary: "A class method named `new` that returns the class type is misleading.",
-			secondary: ["This looks like a constructor definition, but classes use `constructor` instead of `new`.", "A method named `new` suggests instantiation, which is confusing in a class context."],
-			suggestions: ["Rename the method if it's not meant to be a constructor.", "Use `constructor` to define the class constructor."]
-		},
-		interfaceConstructSignature: {
-			primary: "An interface cannot be constructed directly; only classes can be instantiated.",
-			secondary: [
-				"A `new()` signature in an interface that returns the interface type is misleading.",
-				"If you want to define a class, use `class` instead of `interface`.",
-				"If you want to define a constructor function type, the return type should differ from the interface name."
-			],
-			suggestions: ["Use a class declaration instead of an interface.", "Change the return type if this describes a constructor function."]
-		},
-		interfaceMethodNamedConstructor: {
-			primary: "Interfaces define `new()` signatures, not `constructor` methods.",
-			secondary: ["A method named `constructor` in an interface is misleading because interfaces cannot be instantiated.", "The `constructor` keyword is used in classes, not interfaces."],
-			suggestions: ["Use `new()` to define a construct signature in the interface.", "Convert this to a class if you need a constructor."]
-		}
-	},
-	setup(context) {
-		return { visitors: {
-			ConstructSignature: (node, { sourceFile }) => {
-				const parentInterface = getParentInterface(node);
-				if (!parentInterface?.name) return;
-				if (getTypeReferenceName(node.type) !== parentInterface.name.text) return;
-				context.report({
-					message: "interfaceConstructSignature",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			},
-			MethodDeclaration: (node, { sourceFile }) => {
-				if (node.body || node.parent.kind !== ts.SyntaxKind.ClassDeclaration && node.parent.kind !== ts.SyntaxKind.ClassExpression || node.name.kind !== ts.SyntaxKind.Identifier || node.name.text !== "new") return;
-				const parentName = getParentClassName(node);
-				if (!parentName) return;
-				if (getTypeReferenceName(node.type) !== parentName) return;
-				context.report({
-					message: "classMethodNamedNew",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			},
-			MethodSignature: (node, { sourceFile }) => {
-				if (node.name.kind !== ts.SyntaxKind.Identifier || node.name.text !== "constructor") return;
-				context.report({
-					message: "interfaceMethodNamedConstructor",
-					range: getTSNodeRange(node, sourceFile)
-				});
-			}
-		} };
-	}
-});
-//#endregion
-export { newDefinitions_default as default };

package/lib/rules/newExpressions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports standalone new expressions that don't use the constructed object.";
-    readonly id: "newExpressions";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noStandaloneNew", undefined>;
-export default _default;

package/lib/rules/newExpressions.js

@@ -1,36 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/newExpressions.ts
-var newExpressions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports standalone new expressions that don't use the constructed object.",
-		id: "newExpressions",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { noStandaloneNew: {
-		primary: "Constructors should only be called when their return value is used.",
-		secondary: ["Using `new` to construct an object but not storing or using the result is often a mistake or indicates unclear code intent.", "If the constructor has side effects you want to trigger, it's better to make that explicit by calling a separate method rather than relying on constructor side effects."],
-		suggestions: ["If you need to use the constructed object, assign it to a variable or return it.", "If you only need the constructor's side effects, consider refactoring to a function that makes the side effects explicit."]
-	} },
-	setup(context) {
-		function isStandaloneExpression(node) {
-			switch (node.parent.kind) {
-				case SyntaxKind.BinaryExpression:
-					if (node.parent.operatorToken.kind !== SyntaxKind.CommaToken) return false;
-					if (node.parent.right === node) return isStandaloneExpression(node.parent);
-					return true;
-				case SyntaxKind.ExpressionStatement: return true;
-				default: return false;
-			}
-		}
-		return { visitors: { NewExpression: (node, { sourceFile }) => {
-			if (isStandaloneExpression(node)) context.report({
-				message: "noStandaloneNew",
-				range: getTSNodeRange(node.getChildAt(0, sourceFile), sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { newExpressions_default as default };

package/lib/rules/newNativeNonConstructors.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.";
-    readonly id: "newNativeNonConstructors";
-    readonly presets: readonly ["javascript"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "noNewNonConstructor", undefined>;
-export default _default;

package/lib/rules/newNativeNonConstructors.js

@@ -1,37 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, isGlobalDeclaration, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/newNativeNonConstructors.ts
-var newNativeNonConstructors_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Disallows using `new` with global non-constructor functions like Symbol and BigInt.",
-		id: "newNativeNonConstructors",
-		presets: ["javascript"]
-	},
-	messages: { noNewNonConstructor: {
-		primary: "{{ name }} cannot be called with `new`.",
-		secondary: ["`Symbol` and `BigInt` are not constructors and will throw a `TypeError` when called with `new`.", "These functions should be called directly without the `new` keyword to create their respective values."],
-		suggestions: ["Remove the `new` keyword and call the function directly."]
-	} },
-	setup(context) {
-		return { visitors: { NewExpression: (node, { program, sourceFile, typeChecker }) => {
-			if (node.expression.kind !== SyntaxKind.Identifier) return;
-			const name = node.expression.text;
-			if (!["BigInt", "Symbol"].includes(name) || !isGlobalDeclaration(node.expression, typeChecker, program)) return;
-			context.report({
-				data: { name },
-				fix: {
-					range: {
-						begin: node.getStart(sourceFile),
-						end: node.expression.getStart(sourceFile)
-					},
-					text: ""
-				},
-				message: "noNewNonConstructor",
-				range: getTSNodeRange(node.getChildAt(0, sourceFile), sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { newNativeNonConstructors_default as default };

package/lib/rules/nonNullAssertedNullishCoalesces.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports non-null assertions on the left side of nullish coalescing operators.";
-    readonly id: "nonNullAssertedNullishCoalesces";
-    readonly presets: readonly ["logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryNonNullAssertion", undefined>;
-export default _default;

package/lib/rules/nonNullAssertedNullishCoalesces.js

@@ -1,61 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/nonNullAssertedNullishCoalesces.ts
-function hasNoAssignmentBeforeNode(identifier, node, sourceFile, typeChecker) {
-	const symbol = typeChecker.getSymbolAtLocation(identifier);
-	if (!symbol) return false;
-	const declarations = symbol.getDeclarations();
-	if (!declarations?.length) return false;
-	const nodeEnd = node.getEnd();
-	for (const declaration of declarations) {
-		if (declaration.getEnd() >= nodeEnd) continue;
-		if (ts$1.isVariableDeclaration(declaration)) {
-			if (declaration.exclamationToken || declaration.initializer) return false;
-		} else if (ts$1.isParameter(declaration) && declaration.initializer) return false;
-	}
-	const valueDeclaration = symbol.valueDeclaration;
-	if (!valueDeclaration) return true;
-	function findModifyingReference(current) {
-		if (ts$1.isIdentifier(current)) {
-			if (typeChecker.getSymbolAtLocation(current)?.valueDeclaration === valueDeclaration) {
-				const parent = current.parent;
-				if (ts$1.isBinaryExpression(parent) && tsutils.isAssignmentKind(parent.operatorToken.kind) && parent.left === current && parent.getEnd() < nodeEnd) return true;
-				if ((ts$1.isPostfixUnaryExpression(parent) || ts$1.isPrefixUnaryExpression(parent)) && parent.operand === current && parent.getEnd() < nodeEnd) return true;
-			}
-		}
-		return ts$1.forEachChild(current, findModifyingReference) ?? false;
-	}
-	return !findModifyingReference(sourceFile);
-}
-var nonNullAssertedNullishCoalesces_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports non-null assertions on the left side of nullish coalescing operators.",
-		id: "nonNullAssertedNullishCoalesces",
-		presets: ["logicalStrict"]
-	},
-	messages: { unnecessaryNonNullAssertion: {
-		primary: "The nullish coalescing operator handles null and undefined, making this non-null assertion redundant.",
-		secondary: ["The `??` operator returns its right operand when the left operand is null or undefined.", "Applying `!` to assert the value is non-null defeats the purpose of using `??`."],
-		suggestions: ["Remove the non-null assertion."]
-	} },
-	setup(context) {
-		return { visitors: { NonNullExpression: (node, { sourceFile, typeChecker }) => {
-			if (node.parent.kind !== ts$1.SyntaxKind.BinaryExpression || node.parent.operatorToken.kind !== ts$1.SyntaxKind.QuestionQuestionToken || node.parent.left !== node) return;
-			if (node.expression.kind === ts$1.SyntaxKind.Identifier && hasNoAssignmentBeforeNode(node.expression, node, sourceFile, typeChecker)) return;
-			const range = getTSNodeRange(node, sourceFile);
-			context.report({
-				message: "unnecessaryNonNullAssertion",
-				range,
-				suggestions: [{
-					id: "removeNonNullAssertion",
-					range,
-					text: node.expression.getText(sourceFile)
-				}]
-			});
-		} } };
-	}
-});
-//#endregion
-export { nonNullAssertedNullishCoalesces_default as default };

package/lib/rules/nonNullAssertedOptionalChains.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports non-null assertions on optional chain expressions.";
-    readonly id: "nonNullAssertedOptionalChains";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "nonNullOptionalChain", undefined>;
-export default _default;

package/lib/rules/nonNullAssertedOptionalChains.js

@@ -1,67 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-//#region src/rules/nonNullAssertedOptionalChains.ts
-function containsOptionalChain(node) {
-	let current = node;
-	let foundNonOptionalAccess = false;
-	while (true) {
-		if (ts$1.isParenthesizedExpression(current)) return !foundNonOptionalAccess && isOptionalChainRoot(current.expression);
-		if (ts$1.isNonNullExpression(current)) {
-			current = current.expression;
-			continue;
-		}
-		if (ts$1.isPropertyAccessExpression(current) || ts$1.isElementAccessExpression(current) || ts$1.isCallExpression(current)) {
-			if (current.questionDotToken) return true;
-			foundNonOptionalAccess = true;
-			current = current.expression;
-			continue;
-		}
-		return false;
-	}
-}
-function isNonNullExpressionContinued(node) {
-	if (ts$1.isParenthesizedExpression(node.expression)) return false;
-	if (ts$1.isPropertyAccessExpression(node.parent) || ts$1.isElementAccessExpression(node.parent) || ts$1.isCallExpression(node.parent)) return node.parent.expression === node;
-	return false;
-}
-function isOptionalChainRoot(node) {
-	let current = node;
-	while (true) {
-		if (ts$1.isNonNullExpression(current) || ts$1.isParenthesizedExpression(current)) {
-			current = current.expression;
-			continue;
-		}
-		if (ts$1.isPropertyAccessExpression(current) || ts$1.isElementAccessExpression(current) || ts$1.isCallExpression(current)) return Boolean(current.questionDotToken);
-		return false;
-	}
-}
-var nonNullAssertedOptionalChains_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports non-null assertions on optional chain expressions.",
-		id: "nonNullAssertedOptionalChains",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { nonNullOptionalChain: {
-		primary: "Non-null assertions are unsafe on optional chain expressions because they can still return undefined.",
-		secondary: ["Optional chain expressions (`?.`) return `undefined` when the left side is `null` or `undefined`.", "Applying a non-null assertion (`!`) doesn't change the runtime behavior and can mask potential bugs."],
-		suggestions: ["Remove the non-null assertion."]
-	} },
-	setup(context) {
-		return { visitors: { NonNullExpression: (node, { sourceFile }) => {
-			if (!containsOptionalChain(node.expression) || isNonNullExpressionContinued(node)) return;
-			const range = getTSNodeRange(node, sourceFile);
-			context.report({
-				message: "nonNullOptionalChain",
-				range,
-				suggestions: [{
-					id: "removeNonNullAssertion",
-					range,
-					text: node.expression.getText(sourceFile)
-				}]
-			});
-		} } };
-	}
-});
-//#endregion
-export { nonNullAssertedOptionalChains_default as default };

package/lib/rules/nonNullAssertionPlacement.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports confusing placement of non-null assertions next to comparison or assignment operators.";
-    readonly id: "nonNullAssertionPlacement";
-    readonly presets: readonly ["stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "confusingAssign" | "confusingEqual" | "confusingOperator", undefined>;
-export default _default;

package/lib/rules/nonNullAssertionPlacement.js

@@ -1,92 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/nonNullAssertionPlacement.ts
-function endsWithNonNullAssertion(node, sourceFile) {
-	return node.getLastToken(sourceFile)?.kind === SyntaxKind.ExclamationToken;
-}
-const confusingOperatorTexts = /* @__PURE__ */ new Map([
-	[SyntaxKind.EqualsEqualsEqualsToken, "==="],
-	[SyntaxKind.EqualsEqualsToken, "=="],
-	[SyntaxKind.EqualsToken, "="],
-	[SyntaxKind.InKeyword, "in"],
-	[SyntaxKind.InstanceOfKeyword, "instanceof"]
-]);
-var nonNullAssertionPlacement_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports confusing placement of non-null assertions next to comparison or assignment operators.",
-		id: "nonNullAssertionPlacement",
-		presets: ["stylisticStrict"]
-	},
-	messages: {
-		confusingAssign: {
-			primary: "Non-null assertion before assignment (`a! = b`) looks similar to not-equals (`a != b`).",
-			secondary: ["This placement creates visual confusion between the assignment `=` and the not-equals operator `!=`.", "Moving the non-null assertion or wrapping the left side in parentheses makes the intent clearer."],
-			suggestions: ["Remove the non-null assertion if it's unnecessary.", "Wrap the left-hand side in parentheses to clarify intent."]
-		},
-		confusingEqual: {
-			primary: "Non-null assertion before equality test (`a! == b`) looks similar to strict not-equals (`a !== b`).",
-			secondary: ["This placement creates visual confusion between the equality operators and the not-equals operators.", "Moving the non-null assertion or wrapping the left side in parentheses makes the intent clearer."],
-			suggestions: ["Remove the non-null assertion if it's unnecessary.", "Wrap the left-hand side in parentheses to clarify intent."]
-		},
-		confusingOperator: {
-			primary: "Non-null assertion before `{{ operator }}` operator (`a! {{ operator }} b`) might be misread as `!(a {{ operator }} b)`.",
-			secondary: ["This placement creates visual confusion that could suggest the entire expression is being negated.", "Moving the non-null assertion or wrapping the left side in parentheses makes the intent clearer."],
-			suggestions: ["Remove the non-null assertion if it's unnecessary.", "Wrap the left-hand side in parentheses to clarify intent."]
-		}
-	},
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			const operatorText = confusingOperatorTexts.get(node.operatorToken.kind);
-			if (!operatorText || !endsWithNonNullAssertion(node.left, sourceFile)) return;
-			const range = {
-				begin: node.left.end - 1,
-				end: node.left.end
-			};
-			const leftText = node.left.getText(sourceFile);
-			const innerExpression = node.left.kind === SyntaxKind.NonNullExpression && node.left.expression;
-			const suggestions = [...innerExpression ? [{
-				id: "removeAssertion",
-				range: {
-					begin: node.left.getStart(sourceFile),
-					end: node.left.end
-				},
-				text: innerExpression.getText(sourceFile)
-			}] : [], {
-				id: "wrapInParentheses",
-				range: {
-					begin: node.left.getStart(sourceFile),
-					end: node.left.end
-				},
-				text: `(${leftText})`
-			}];
-			switch (node.operatorToken.kind) {
-				case SyntaxKind.EqualsToken:
-					context.report({
-						message: "confusingAssign",
-						range,
-						suggestions
-					});
-					break;
-				case SyntaxKind.InKeyword:
-				case SyntaxKind.InstanceOfKeyword:
-					context.report({
-						data: { operator: operatorText },
-						message: "confusingOperator",
-						range,
-						suggestions
-					});
-					break;
-				default:
-					context.report({
-						message: "confusingEqual",
-						range,
-						suggestions
-					});
-					break;
-			}
-		} } };
-	}
-});
-//#endregion
-export { nonNullAssertionPlacement_default as default };

package/lib/rules/nonNullableTypeAssertions.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports type assertions that can be replaced with non-null assertions.";
-    readonly id: "nonNullableTypeAssertions";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferNonNullAssertion", undefined>;
-export default _default;

package/lib/rules/nonNullableTypeAssertions.js

@@ -1,76 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/nonNullableTypeAssertions.ts
-function couldBeNullish(type) {
-	if (type.flags & ts.TypeFlags.TypeParameter) {
-		const constraint = type.getConstraint();
-		return constraint === void 0 || couldBeNullish(constraint);
-	}
-	if (tsutils.isUnionType(type)) return type.types.some(couldBeNullish);
-	return (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) !== 0;
-}
-function getTypesIfNotLoose(node, typeChecker) {
-	const type = typeChecker.getTypeAtLocation(node);
-	if (tsutils.isTypeFlagSet(type, ts.TypeFlags.Any | ts.TypeFlags.Unknown)) return;
-	return tsutils.unionConstituents(type);
-}
-function isConstAssertion(node, sourceFile) {
-	return node.type.kind === ts.SyntaxKind.TypeReference && node.type.typeName.kind === ts.SyntaxKind.Identifier && node.type.typeName.getText(sourceFile) === "const";
-}
-function needsParentheses(expression) {
-	switch (expression.kind) {
-		case ts.SyntaxKind.ArrowFunction:
-		case ts.SyntaxKind.AwaitExpression:
-		case ts.SyntaxKind.BinaryExpression:
-		case ts.SyntaxKind.ConditionalExpression:
-		case ts.SyntaxKind.PrefixUnaryExpression:
-		case ts.SyntaxKind.YieldExpression: return true;
-		default: return false;
-	}
-}
-function sameTypeWithoutNullish(assertedTypes, originalTypes) {
-	const nonNullishOriginalTypes = originalTypes.filter((type) => (type.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)) === 0);
-	if (nonNullishOriginalTypes.length === originalTypes.length) return false;
-	for (const assertedType of assertedTypes) if (couldBeNullish(assertedType) || !nonNullishOriginalTypes.includes(assertedType)) return false;
-	for (const originalType of nonNullishOriginalTypes) if (!assertedTypes.includes(originalType)) return false;
-	return true;
-}
-var nonNullableTypeAssertions_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports type assertions that can be replaced with non-null assertions.",
-		id: "nonNullableTypeAssertions",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferNonNullAssertion: {
-		primary: "Use a non-null assertion (`!`) instead of an explicit type assertion.",
-		secondary: ["When the only difference between the original and asserted type is nullability, a non-null assertion is more concise.", "Non-null assertions clearly communicate that you're asserting the value is not null or undefined."],
-		suggestions: ["Replace the type assertion with a `!` assertion."]
-	} },
-	setup(context) {
-		function checkNode(node, { sourceFile, typeChecker }) {
-			if (isConstAssertion(node, sourceFile)) return;
-			const originalTypes = getTypesIfNotLoose(node.expression, typeChecker);
-			if (!originalTypes) return;
-			const assertedTypes = getTypesIfNotLoose(node.type, typeChecker);
-			if (!assertedTypes || !sameTypeWithoutNullish(assertedTypes, originalTypes)) return;
-			const expressionText = node.expression.getText(sourceFile);
-			const replacement = needsParentheses(node.expression) ? `(${expressionText})!` : `${expressionText}!`;
-			context.report({
-				fix: {
-					range: getTSNodeRange(node, sourceFile),
-					text: replacement
-				},
-				message: "preferNonNullAssertion",
-				range: getTSNodeRange(node, sourceFile)
-			});
-		}
-		return { visitors: {
-			AsExpression: checkNode,
-			TypeAssertionExpression: checkNode
-		} };
-	}
-});
-//#endregion
-export { nonNullableTypeAssertions_default as default };

package/lib/rules/nonOctalDecimalEscapes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports non-octal decimal escape sequences (\\8 and \\9) in string literals.";
-    readonly id: "nonOctalDecimalEscapes";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unexpectedEscape", undefined>;
-export default _default;