@flint.fyi/ts 0.20.0 → 0.22.0

package/lib/rules/unnecessaryBinds.js

@@ -1,78 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/unnecessaryBinds.ts
-function containsThis(node) {
-	if (node.kind === ts.SyntaxKind.ThisKeyword) return true;
-	if (ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isArrowFunction(node)) return false;
-	let found = false;
-	node.forEachChild((child) => {
-		if (containsThis(child)) found = true;
-	});
-	return found;
-}
-function isStaticValue(node) {
-	if (ts.isParenthesizedExpression(node)) return isStaticValue(node.expression);
-	if (ts.isPrefixUnaryExpression(node)) return isStaticValue(node.operand);
-	if (ts.isIdentifier(node)) return true;
-	if (ts.isPropertyAccessExpression(node)) return isStaticValue(node.expression);
-	if (ts.isElementAccessExpression(node)) return isStaticValue(node.expression) && isStaticValue(node.argumentExpression);
-	return node.kind === ts.SyntaxKind.ThisKeyword || node.kind === ts.SyntaxKind.SuperKeyword || node.kind === ts.SyntaxKind.TrueKeyword || node.kind === ts.SyntaxKind.FalseKeyword || node.kind === ts.SyntaxKind.NullKeyword || ts.isBigIntLiteral(node) || ts.isNumericLiteral(node) || ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || node.kind === ts.SyntaxKind.RegularExpressionLiteral;
-}
-function unwrapParentheses(node) {
-	while (ts.isParenthesizedExpression(node)) node = node.expression;
-	return node;
-}
-var unnecessaryBinds_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary `.bind()` calls.",
-		id: "unnecessaryBinds",
-		presets: ["logical"]
-	},
-	messages: {
-		arrowBind: {
-			primary: "`.bind()` has no effect on arrow functions.",
-			secondary: ["Arrow functions have lexical 'this' binding.", "Calling .bind() on an arrow function has no effect."],
-			suggestions: ["Remove the `.bind()` call.", "Change the arrow function to a `function` that uses `this`"]
-		},
-		unnecessaryBinds: {
-			primary: "This `.bind()` call is unnecessary because the function does not use `this`.",
-			secondary: ["This function does not use `this`.", "`.bind()`'s purpose is to bind `this`, so using it on this function doesn't change anything."],
-			suggestions: ["Remove the `.bind()` call.", "Change the function to use `this` if that was intended."]
-		}
-	},
-	setup(context) {
-		return { visitors: { CallExpression(node, { sourceFile }) {
-			if (!ts.isPropertyAccessExpression(node.expression) || node.expression.name.text !== "bind" || node.arguments.length !== 1) return;
-			const boundArgument = node.arguments[0];
-			const boundFunction = unwrapParentheses(node.expression.expression);
-			const fix = isStaticValue(boundArgument) ? {
-				range: getTSNodeRange(node, sourceFile),
-				text: node.expression.expression.getText(sourceFile)
-			} : void 0;
-			if (ts.isArrowFunction(boundFunction)) {
-				context.report({
-					fix,
-					message: "arrowBind",
-					range: {
-						begin: node.expression.name.getStart(sourceFile),
-						end: node.end
-					}
-				});
-				return;
-			}
-			if (ts.isFunctionExpression(boundFunction) && !containsThis(boundFunction.body)) context.report({
-				fix,
-				message: "unnecessaryBinds",
-				range: {
-					begin: node.expression.name.getStart(sourceFile),
-					end: node.end
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryBinds_default as default };
-
-//# sourceMappingURL=unnecessaryBinds.js.map

package/lib/rules/unnecessaryBlocks.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports standalone block statements that don't create a meaningful scope.";
-    readonly id: "unnecessaryBlocks";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryBlock", undefined>;
-export default _default;
-//# sourceMappingURL=unnecessaryBlocks.d.ts.map

package/lib/rules/unnecessaryBlocks.js

@@ -1,60 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-import { isNodeFlagSet } from "ts-api-utils";
-//#region src/rules/unnecessaryBlocks.ts
-function isUsingVariableStatement(node) {
-	return node.kind === SyntaxKind.VariableStatement && isNodeFlagSet(node.declarationList, ts.NodeFlags.Using);
-}
-function isValidBlock(node) {
-	switch (node.parent.kind) {
-		case SyntaxKind.ArrowFunction:
-		case SyntaxKind.CaseClause:
-		case SyntaxKind.CatchClause:
-		case SyntaxKind.Constructor:
-		case SyntaxKind.DefaultClause:
-		case SyntaxKind.DoStatement:
-		case SyntaxKind.ForInStatement:
-		case SyntaxKind.ForOfStatement:
-		case SyntaxKind.ForStatement:
-		case SyntaxKind.FunctionDeclaration:
-		case SyntaxKind.FunctionExpression:
-		case SyntaxKind.GetAccessor:
-		case SyntaxKind.IfStatement:
-		case SyntaxKind.LabeledStatement:
-		case SyntaxKind.MethodDeclaration:
-		case SyntaxKind.ModuleBlock:
-		case SyntaxKind.SetAccessor:
-		case SyntaxKind.TryStatement:
-		case SyntaxKind.WhileStatement:
-		case SyntaxKind.WithStatement: return true;
-		default: return node.statements.some(isUsingVariableStatement);
-	}
-}
-var unnecessaryBlocks_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports standalone block statements that don't create a meaningful scope.",
-		id: "unnecessaryBlocks",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { unnecessaryBlock: {
-		primary: "This standalone block statement is unnecessary and doesn't change any variable scopes.",
-		secondary: ["Standalone block statements that aren't part of control flow (if/else, loops, switch) or don't create a meaningful lexical scope can be confusing and should be avoided.", "In modern JavaScript and TypeScript, blocks primarily serve to create lexical scope for `let` and `const` variables, but this is often better achieved through other means."],
-		suggestions: ["Remove the block statement and move its contents to the parent scope.", "If you need lexical scoping, consider using an IIFE (Immediately Invoked Function Expression) or extracting to a separate function."]
-	} },
-	setup(context) {
-		return { visitors: { Block: (node, { sourceFile }) => {
-			if (!isValidBlock(node)) context.report({
-				message: "unnecessaryBlock",
-				range: {
-					begin: node.getStart(sourceFile),
-					end: node.getStart(sourceFile) + 1
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryBlocks_default as default };
-
-//# sourceMappingURL=unnecessaryBlocks.js.map

package/lib/rules/unnecessaryBooleanCasts.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary boolean casts.";
-    readonly id: "unnecessaryBooleanCasts";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessary", undefined>;
-export default _default;
-//# sourceMappingURL=unnecessaryBooleanCasts.d.ts.map

package/lib/rules/unnecessaryBooleanCasts.js

@@ -1,58 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isInBooleanContext } from "./utils/isInBooleanContext.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-//#region src/rules/unnecessaryBooleanCasts.ts
-function getNodeText(node, sourceFile) {
-	return sourceFile.text.slice(node.getStart(sourceFile), node.getEnd());
-}
-function isBooleanCall(node) {
-	return ts.isIdentifier(node.expression) && node.expression.text === "Boolean";
-}
-function isDoubleNegation(node) {
-	if (node.operator !== ts.SyntaxKind.ExclamationToken) return false;
-	const operand = node.operand;
-	if (ts.isPrefixUnaryExpression(operand) && operand.operator === ts.SyntaxKind.ExclamationToken) return true;
-	return false;
-}
-var unnecessaryBooleanCasts_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports unnecessary boolean casts.",
-		id: "unnecessaryBooleanCasts",
-		presets: ["logical"]
-	},
-	messages: { unnecessary: {
-		primary: "Casting this value to a boolean is unnecessary in this context.",
-		secondary: ["The value is already in a boolean context.", "Using `{{ cast }}` to cast it does not change program behavior."],
-		suggestions: ["Remove the `{{ cast }}` call."]
-	} },
-	setup(context) {
-		function reportCast(cast, outer, inner, sourceFile) {
-			const range = getTSNodeRange(outer, sourceFile);
-			context.report({
-				data: { cast },
-				fix: {
-					range,
-					text: getNodeText(inner, sourceFile)
-				},
-				message: "unnecessary",
-				range
-			});
-		}
-		return { visitors: {
-			CallExpression(node, { sourceFile }) {
-				if (!isBooleanCall(node) || !isInBooleanContext(node)) return;
-				const argument = node.arguments[0];
-				reportCast("Boolean()", node, argument, sourceFile);
-			},
-			PrefixUnaryExpression(node, { sourceFile }) {
-				if (!isDoubleNegation(node) || !isInBooleanContext(node)) return;
-				reportCast("!!", node, node.operand.operand, sourceFile);
-			}
-		} };
-	}
-});
-//#endregion
-export { unnecessaryBooleanCasts_default as default };
-
-//# sourceMappingURL=unnecessaryBooleanCasts.js.map

package/lib/rules/unnecessaryCatches.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports catch clauses that only rethrow the caught error without modification.";
-    readonly id: "unnecessaryCatches";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryCatch", undefined>;
-export default _default;
-//# sourceMappingURL=unnecessaryCatches.d.ts.map

package/lib/rules/unnecessaryCatches.js

@@ -1,48 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/unnecessaryCatches.ts
-var unnecessaryCatches_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports catch clauses that only rethrow the caught error without modification.",
-		id: "unnecessaryCatches",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { unnecessaryCatch: {
-		primary: "This catch clause is unnecessary, as it only rethrows the exception without modification.",
-		secondary: ["A catch clause that only rethrows the caught error adds no value and creates unnecessary code complexity.", "Removing such catch clauses allows errors to propagate naturally without the overhead of an unnecessary try-catch block."],
-		suggestions: ["Remove the try-catch block if the catch clause only rethrows the error, or add meaningful error handling logic to the catch clause."]
-	} },
-	setup(context) {
-		return { visitors: { CatchClause: (node, { sourceFile }) => {
-			if (!node.variableDeclaration) return;
-			const statements = node.block.statements;
-			if (statements.length !== 1) return;
-			const statement = statements[0];
-			if (statement.kind !== SyntaxKind.ThrowStatement) return;
-			const catchVariable = node.variableDeclaration.name;
-			const thrownExpression = statement.expression;
-			if (catchVariable.kind !== SyntaxKind.Identifier || thrownExpression.kind !== SyntaxKind.Identifier) return;
-			if (catchVariable.text !== thrownExpression.text) return;
-			const range = {
-				begin: node.getStart(sourceFile),
-				end: node.getStart(sourceFile) + 5
-			};
-			context.report({
-				fix: {
-					range: {
-						begin: node.parent.tryBlock.getEnd(),
-						end: node.getEnd()
-					},
-					text: ""
-				},
-				message: "unnecessaryCatch",
-				range
-			});
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryCatches_default as default };
-
-//# sourceMappingURL=unnecessaryCatches.js.map

package/lib/rules/unnecessaryComparisons.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports comparisons that are always true, always false, or can be simplified.";
-    readonly id: "unnecessaryComparisons";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "impossibleRange" | "ineffectiveCheck" | "redundantComparison" | "selfComparison", undefined>;
-export default _default;
-//# sourceMappingURL=unnecessaryComparisons.d.ts.map

package/lib/rules/unnecessaryComparisons.js

@@ -1,300 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { isComparisonOperator } from "./utils/operators.js";
-import { getTSNodeRange, hasSameTokens, typescriptLanguage, unwrapParenthesizedNode } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/unnecessaryComparisons.ts
-function checkImpossibleRange(comparisons, sourceFile) {
-	for (const [i, a] of comparisons.entries()) for (const b of comparisons.slice(i + 1)) {
-		if (a.numericValue === null || b.numericValue === null) continue;
-		if (!hasSameTokens(a.variable, b.variable, sourceFile)) continue;
-		let lowerBound;
-		let upperBound;
-		if (a.direction === "upper" && b.direction === "lower") {
-			upperBound = a;
-			lowerBound = b;
-		} else if (a.direction === "lower" && b.direction === "upper") {
-			upperBound = b;
-			lowerBound = a;
-		}
-		if (!upperBound || !lowerBound) continue;
-		const upper = upperBound.numericValue;
-		const lower = lowerBound.numericValue;
-		if (upper === null || lower === null) continue;
-		if (upper < lower) return {
-			lowerBound,
-			upperBound
-		};
-		if (upper === lower) {
-			if (upperBound.isStrict || lowerBound.isStrict) return {
-				lowerBound,
-				upperBound
-			};
-		}
-	}
-	return null;
-}
-function checkIneffectiveChecks(comparisons, sourceFile) {
-	for (const [i, a] of comparisons.entries()) for (const b of comparisons.slice(i + 1)) {
-		if (a.numericValue === null || b.numericValue === null) continue;
-		if (!hasSameTokens(a.variable, b.variable, sourceFile)) continue;
-		if (a.direction !== b.direction) continue;
-		if (a.direction === "upper") {
-			if (a.numericValue < b.numericValue) return {
-				stronger: a,
-				weaker: b
-			};
-			if (b.numericValue < a.numericValue) return {
-				stronger: b,
-				weaker: a
-			};
-			if (a.numericValue === b.numericValue) {
-				if (a.isStrict && !b.isStrict) return {
-					stronger: a,
-					weaker: b
-				};
-				if (!a.isStrict && b.isStrict) return {
-					stronger: b,
-					weaker: a
-				};
-			}
-		}
-		if (a.direction === "lower") {
-			if (a.numericValue > b.numericValue) return {
-				stronger: a,
-				weaker: b
-			};
-			if (b.numericValue > a.numericValue) return {
-				stronger: b,
-				weaker: a
-			};
-			if (a.numericValue === b.numericValue) {
-				if (a.isStrict && !b.isStrict) return {
-					stronger: a,
-					weaker: b
-				};
-				if (!a.isStrict && b.isStrict) return {
-					stronger: b,
-					weaker: a
-				};
-			}
-		}
-	}
-	return null;
-}
-function checkRedundantOrComparison(comparisons, sourceFile) {
-	for (const [index, a] of comparisons.entries()) for (const b of comparisons.slice(index + 1)) {
-		if (!hasSameTokens(a.variable, b.variable, sourceFile) || !hasSameTokens(a.node.left, b.node.left, sourceFile) || !hasSameTokens(a.node.right, b.node.right, sourceFile)) {
-			if (!hasSameTokens(a.node.left, b.node.right, sourceFile) || !hasSameTokens(a.node.right, b.node.left, sourceFile)) continue;
-		}
-		const suggestion = getSimplifiedOperator(a.operatorKind, b.operatorKind);
-		if (suggestion) return {
-			first: a,
-			second: b,
-			suggestion
-		};
-	}
-	return null;
-}
-function collectComparisonsFromChain(node, operatorKind) {
-	const results = [];
-	function traverse(expr) {
-		const unwrapped = unwrapParenthesizedNode(expr);
-		if (unwrapped.kind !== SyntaxKind.BinaryExpression) return;
-		if (unwrapped.operatorToken.kind === operatorKind) {
-			traverse(unwrapped.left);
-			traverse(unwrapped.right);
-			return;
-		}
-		const info = extractComparisonInfo(unwrapped);
-		if (info) results.push(info);
-	}
-	traverse(node);
-	return results;
-}
-function extractComparisonInfo(node) {
-	if (!isComparisonOperator(node.operatorToken)) return null;
-	const leftNumeric = extractNumericLiteral(node.left);
-	const rightNumeric = extractNumericLiteral(node.right);
-	if (leftNumeric !== null && rightNumeric !== null || leftNumeric === null && rightNumeric === null) {
-		if (leftNumeric === null && rightNumeric === null) return {
-			direction: getComparisonDirection(node.operatorToken.kind),
-			isStrict: isStrictComparison(node.operatorToken.kind),
-			node,
-			numericValue: null,
-			operatorKind: node.operatorToken.kind,
-			variable: node.left
-		};
-		return null;
-	}
-	if (leftNumeric !== null) return {
-		direction: flipDirection(getComparisonDirection(node.operatorToken.kind)),
-		isStrict: isStrictComparison(node.operatorToken.kind),
-		node,
-		numericValue: leftNumeric,
-		operatorKind: flipOperator(node.operatorToken.kind),
-		variable: node.right
-	};
-	return {
-		direction: getComparisonDirection(node.operatorToken.kind),
-		isStrict: isStrictComparison(node.operatorToken.kind),
-		node,
-		numericValue: rightNumeric,
-		operatorKind: node.operatorToken.kind,
-		variable: node.left
-	};
-}
-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);
-	return null;
-}
-function flipDirection(direction) {
-	switch (direction) {
-		case "lower": return "upper";
-		case "upper": return "lower";
-		default: return direction;
-	}
-}
-function flipOperator(operatorKind) {
-	switch (operatorKind) {
-		case SyntaxKind.GreaterThanEqualsToken: return SyntaxKind.LessThanEqualsToken;
-		case SyntaxKind.GreaterThanToken: return SyntaxKind.LessThanToken;
-		case SyntaxKind.LessThanEqualsToken: return SyntaxKind.GreaterThanEqualsToken;
-		case SyntaxKind.LessThanToken: return SyntaxKind.GreaterThanToken;
-		default: return operatorKind;
-	}
-}
-function formatComparison(info, sourceFile) {
-	return info.node.getText(sourceFile);
-}
-function getComparisonDirection(operatorKind) {
-	switch (operatorKind) {
-		case SyntaxKind.EqualsEqualsEqualsToken:
-		case SyntaxKind.EqualsEqualsToken: return "equality";
-		case SyntaxKind.ExclamationEqualsEqualsToken:
-		case SyntaxKind.ExclamationEqualsToken: return "inequality";
-		case SyntaxKind.GreaterThanEqualsToken:
-		case SyntaxKind.GreaterThanToken: return "lower";
-		case SyntaxKind.LessThanEqualsToken:
-		case SyntaxKind.LessThanToken: return "upper";
-		default: return "equality";
-	}
-}
-function getSimplifiedOperator(op1, op2) {
-	const pairs = [
-		[
-			SyntaxKind.EqualsEqualsEqualsToken,
-			SyntaxKind.LessThanToken,
-			"<="
-		],
-		[
-			SyntaxKind.EqualsEqualsToken,
-			SyntaxKind.LessThanToken,
-			"<="
-		],
-		[
-			SyntaxKind.EqualsEqualsEqualsToken,
-			SyntaxKind.GreaterThanToken,
-			">="
-		],
-		[
-			SyntaxKind.EqualsEqualsToken,
-			SyntaxKind.GreaterThanToken,
-			">="
-		]
-	];
-	for (const [a, b, result] of pairs) if (op1 === a && op2 === b || op1 === b && op2 === a) return result;
-	return null;
-}
-function isStrictComparison(operatorKind) {
-	return operatorKind === SyntaxKind.LessThanToken || operatorKind === SyntaxKind.GreaterThanToken;
-}
-var unnecessaryComparisons_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports comparisons that are always true, always false, or can be simplified.",
-		id: "unnecessaryComparisons",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		impossibleRange: {
-			primary: "This range comparison can never be true.",
-			secondary: ["The upper bound {{ upperBound }} and lower bound {{ lowerBound }} create an impossible range.", "No value can satisfy both conditions simultaneously."],
-			suggestions: ["Check if the comparison operators or values are correct.", "This may indicate swapped values or operators."]
-		},
-		ineffectiveCheck: {
-			primary: "The check `{{ weaker }}` is redundant when `{{ stronger }}` is also checked.",
-			secondary: ["When `{{ stronger }}` is true, `{{ weaker }}` is automatically satisfied."],
-			suggestions: ["Remove the redundant check `{{ weaker }}`."]
-		},
-		redundantComparison: {
-			primary: "This comparison can be simplified to `{{ suggestion }}`.",
-			secondary: ["The combined comparisons are equivalent to a single `{{ suggestion }}` comparison."],
-			suggestions: ["Replace with a single `{{ suggestion }}` comparison for clearer intent."]
-		},
-		selfComparison: {
-			primary: "Comparing a value to itself is unnecessary and likely indicates a logic error.",
-			secondary: ["Self-comparisons always evaluate to the same result for a given operator.", "This pattern often indicates a copy-paste error or typo where different variables were intended."],
-			suggestions: ["Verify that you intended to compare two different values."]
-		}
-	},
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (isComparisonOperator(node.operatorToken) && hasSameTokens(node.left, node.right, sourceFile)) {
-				context.report({
-					message: "selfComparison",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-			if (node.operatorToken.kind === SyntaxKind.AmpersandAmpersandToken) {
-				const comparisons = collectComparisonsFromChain(node, SyntaxKind.AmpersandAmpersandToken);
-				if (comparisons.length >= 2) {
-					const impossibleRange = checkImpossibleRange(comparisons, sourceFile);
-					if (impossibleRange) {
-						context.report({
-							data: {
-								lowerBound: formatComparison(impossibleRange.lowerBound, sourceFile),
-								upperBound: formatComparison(impossibleRange.upperBound, sourceFile)
-							},
-							message: "impossibleRange",
-							range: getTSNodeRange(node, sourceFile)
-						});
-						return;
-					}
-					const ineffective = checkIneffectiveChecks(comparisons, sourceFile);
-					if (ineffective) {
-						context.report({
-							data: {
-								stronger: formatComparison(ineffective.stronger, sourceFile),
-								weaker: formatComparison(ineffective.weaker, sourceFile)
-							},
-							message: "ineffectiveCheck",
-							range: getTSNodeRange(ineffective.weaker.node, sourceFile)
-						});
-						return;
-					}
-				}
-			}
-			if (node.operatorToken.kind === SyntaxKind.BarBarToken) {
-				const comparisons = collectComparisonsFromChain(node, SyntaxKind.BarBarToken);
-				if (comparisons.length >= 2) {
-					const redundant = checkRedundantOrComparison(comparisons, sourceFile);
-					if (redundant) {
-						context.report({
-							data: { suggestion: redundant.suggestion },
-							message: "redundantComparison",
-							range: getTSNodeRange(node, sourceFile)
-						});
-						return;
-					}
-				}
-			}
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryComparisons_default as default };
-
-//# sourceMappingURL=unnecessaryComparisons.js.map

package/lib/rules/unnecessaryConcatenation.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports string concatenation using the + operator when both operands are string literals.";
-    readonly id: "unnecessaryConcatenation";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessaryConcatenation", undefined>;
-export default _default;
-//# sourceMappingURL=unnecessaryConcatenation.d.ts.map

package/lib/rules/unnecessaryConcatenation.js

@@ -1,28 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind } from "typescript";
-//#region src/rules/unnecessaryConcatenation.ts
-var unnecessaryConcatenation_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports string concatenation using the + operator when both operands are string literals.",
-		id: "unnecessaryConcatenation",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { unnecessaryConcatenation: {
-		primary: "This string concatenation can be streamlined into a single string literal.",
-		secondary: ["Concatenating string literals with the + operator is unnecessary and reduces code readability.", "String literals can be combined into a single literal, which is clearer and potentially more performant."],
-		suggestions: ["Combine the string literals into a single string literal."]
-	} },
-	setup(context) {
-		return { visitors: { BinaryExpression: (node, { sourceFile }) => {
-			if (node.operatorToken.kind === SyntaxKind.PlusToken && node.left.kind === SyntaxKind.StringLiteral && node.right.kind === SyntaxKind.StringLiteral) context.report({
-				message: "unnecessaryConcatenation",
-				range: getTSNodeRange(node.operatorToken, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { unnecessaryConcatenation_default as default };
-
-//# sourceMappingURL=unnecessaryConcatenation.js.map

package/lib/rules/unnecessaryEscapes.d.ts

@@ -1,10 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports unnecessary escape sequences in string literals and template strings.";
-    readonly id: "unnecessaryEscapes";
-    readonly presets: readonly ["stylistic"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "unnecessary", undefined>;
-export default _default;
-//# sourceMappingURL=unnecessaryEscapes.d.ts.map