@flint.fyi/ts 0.21.0 → 0.22.0

package/lib/rules/overloadSignaturesAdjacent.js

@@ -1,138 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts, { SyntaxKind } from "typescript";
-//#region src/rules/overloadSignaturesAdjacent.ts
-function getMemberMethod(member) {
-	switch (member.kind) {
-		case SyntaxKind.CallSignature: return {
-			callSignature: true,
-			name: "call",
-			static: false,
-			type: "normal"
-		};
-		case SyntaxKind.Constructor: return {
-			callSignature: false,
-			name: "constructor",
-			static: false,
-			type: "normal"
-		};
-		case SyntaxKind.ConstructSignature: return {
-			callSignature: false,
-			name: "new",
-			static: false,
-			type: "normal"
-		};
-		case SyntaxKind.ExportAssignment:
-		case SyntaxKind.ExportDeclaration: return;
-		case SyntaxKind.FunctionDeclaration: {
-			const name = member.name?.text;
-			if (name == null) return;
-			return {
-				callSignature: false,
-				name,
-				static: false,
-				type: "normal"
-			};
-		}
-		case SyntaxKind.MethodDeclaration:
-		case SyntaxKind.MethodSignature: {
-			const nameInfo = getNameFromPropertyName(member.name);
-			if (!nameInfo) return;
-			return {
-				callSignature: false,
-				name: nameInfo.name,
-				static: isStatic(member),
-				type: nameInfo.type
-			};
-		}
-	}
-	if (ts.isExportDeclaration(member) || ts.isImportDeclaration(member) || ts.isTypeAliasDeclaration(member) || ts.isInterfaceDeclaration(member) || ts.isClassDeclaration(member) || ts.isEnumDeclaration(member) || ts.isModuleDeclaration(member)) return;
-}
-function getMembers(node) {
-	switch (node.kind) {
-		case SyntaxKind.Block:
-		case SyntaxKind.ModuleBlock:
-		case SyntaxKind.SourceFile: return node.statements;
-		case SyntaxKind.ClassDeclaration:
-		case SyntaxKind.ClassExpression: return node.members;
-		case SyntaxKind.InterfaceDeclaration: return node.members;
-		case SyntaxKind.TypeLiteral: return node.members;
-	}
-}
-function getMethodDisplayName(method) {
-	if (method.static) return `static ${method.name}`;
-	if (method.type === "quoted") return `"${method.name}"`;
-	return method.name;
-}
-function getNameFromPropertyName(name) {
-	switch (name.kind) {
-		case SyntaxKind.ComputedPropertyName:
-			if (ts.isStringLiteral(name.expression)) return {
-				name: name.expression.text,
-				type: "quoted"
-			};
-			return;
-		case SyntaxKind.Identifier:
-		case SyntaxKind.NumericLiteral:
-		case SyntaxKind.PrivateIdentifier: return {
-			name: name.text,
-			type: "normal"
-		};
-		case SyntaxKind.StringLiteral: return {
-			name: name.text,
-			type: "quoted"
-		};
-		default: return;
-	}
-}
-function isSameMethod(method1, method2) {
-	return !!method2 && method1.name === method2.name && method1.static === method2.static && method1.callSignature === method2.callSignature && method1.type === method2.type;
-}
-function isStatic(node) {
-	return ts.canHaveModifiers(node) && !!node.modifiers?.some((mod) => mod.kind === SyntaxKind.StaticKeyword);
-}
-var overloadSignaturesAdjacent_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Require that function overload signatures be consecutive.",
-		id: "overloadSignaturesAdjacent",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { overloadSignatureSeparated: {
-		primary: "All {{ name }} signatures should be adjacent.",
-		secondary: ["Separating overload signatures makes code harder to read and maintain.", "Grouping all overloads for a function together makes it easier to read and understand that function."],
-		suggestions: ["Group all overload signatures for this function together."]
-	} },
-	setup(context) {
-		function checkNode(node, { sourceFile }) {
-			const members = getMembers(node);
-			let lastMethod;
-			const seenMethods = [];
-			for (const member of members) {
-				const method = getMemberMethod(member);
-				if (method == null) {
-					lastMethod = void 0;
-					continue;
-				}
-				const indexOfSameMethod = seenMethods.findIndex((seenMethod) => isSameMethod(method, seenMethod));
-				if (indexOfSameMethod > -1 && !isSameMethod(method, lastMethod)) context.report({
-					data: { name: getMethodDisplayName(method) },
-					message: "overloadSignatureSeparated",
-					range: getTSNodeRange(member, sourceFile)
-				});
-				else if (indexOfSameMethod === -1) seenMethods.push(method);
-				lastMethod = method;
-			}
-		}
-		return { visitors: {
-			Block: checkNode,
-			ClassDeclaration: checkNode,
-			ClassExpression: checkNode,
-			InterfaceDeclaration: checkNode,
-			ModuleBlock: checkNode,
-			SourceFile: checkNode,
-			TypeLiteral: checkNode
-		} };
-	}
-});
-//#endregion
-export { overloadSignaturesAdjacent_default as default };

package/lib/rules/parameterReassignments.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Disallow reassignment of function parameters.";
-    readonly id: "parameterReassignments";
-    readonly presets: readonly ["logical"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "parameterReassignment", undefined>;
-export default _default;

package/lib/rules/parameterReassignments.js

@@ -1,43 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getScopeManager, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-//#region src/rules/parameterReassignments.ts
-var parameterReassignments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Disallow reassignment of function parameters.",
-		id: "parameterReassignments",
-		presets: ["logical"]
-	},
-	messages: { parameterReassignment: {
-		primary: "Reassigning function parameters can make them more difficult to reason about.",
-		secondary: [
-			"Most code treats function parameters as constants.",
-			"Reassigning them inside the function removes that reference to the original value.",
-			"It's generally more understandable to write code that does not modify parameters."
-		],
-		suggestions: ["Use a new variable if you need to modify the value.", "Use a different pattern such as a helper function."]
-	} },
-	setup(context) {
-		function reportParameterReassignments(node, { sourceFile }) {
-			const scopeManager = getScopeManager(sourceFile);
-			const parameterVariables = new Set(node.parameters.flatMap((parameter) => scopeManager.getDeclaredVariables(parameter)));
-			for (const reference of scopeManager.getReferencesInScope(node)) {
-				if (!reference.isWrite || !reference.variable || !parameterVariables.has(reference.variable)) continue;
-				context.report({
-					message: "parameterReassignment",
-					range: getTSNodeRange(reference.identifier, sourceFile)
-				});
-			}
-		}
-		return { visitors: {
-			ArrowFunction: reportParameterReassignments,
-			Constructor: reportParameterReassignments,
-			FunctionDeclaration: reportParameterReassignments,
-			FunctionExpression: reportParameterReassignments,
-			GetAccessor: reportParameterReassignments,
-			MethodDeclaration: reportParameterReassignments,
-			SetAccessor: reportParameterReassignments
-		} };
-	}
-});
-//#endregion
-export { parameterReassignments_default as default };

package/lib/rules/parseIntRadixes.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports parseInt calls that are missing or have an invalid radix parameter.";
-    readonly id: "parseIntRadixes";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "invalidRadix" | "missingRadix", undefined>;
-export default _default;

package/lib/rules/parseIntRadixes.js

@@ -1,57 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getStaticNumberValue, getTSNodeRange, isGlobalDeclarationOfName, typescriptLanguage } from "@flint.fyi/typescript-language";
-import { SyntaxKind, isIdentifier } from "typescript";
-//#region src/rules/parseIntRadixes.ts
-function isParseIntCall(node, typeChecker, program) {
-	switch (node.expression.kind) {
-		case SyntaxKind.Identifier: return isGlobalDeclarationOfName(node.expression, "parseInt", typeChecker, program);
-		case SyntaxKind.PropertyAccessExpression: return isIdentifier(node.expression.name) && node.expression.name.text === "parseInt" && isIdentifier(node.expression.expression) && node.expression.expression.text === "Number" && isGlobalDeclarationOfName(node.expression.expression, "Number", typeChecker, program);
-		default: return false;
-	}
-}
-function isValidRadix(argument) {
-	if (argument.kind === SyntaxKind.Identifier && argument.text === "undefined") return false;
-	const value = getStaticNumberValue(argument);
-	return value === void 0 ? true : isValidRadixValue(value);
-}
-function isValidRadixValue(value) {
-	return value >= 2 && value <= 36;
-}
-var parseIntRadixes_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports parseInt calls that are missing or have an invalid radix parameter.",
-		id: "parseIntRadixes",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: {
-		invalidRadix: {
-			primary: "Invalid radix parameter; must be an integer between 2 and 36.",
-			secondary: ["The radix determines the base of the numeral system used for parsing.", "Valid radix values are integers from 2 (binary) to 36."],
-			suggestions: ["Use a valid radix value, typically 10 for decimal numbers."]
-		},
-		missingRadix: {
-			primary: "This `parseInt` call is missing a radix parameter to specify the numeral system base.",
-			secondary: ["Without a radix, parseInt may interpret the string differently based on its format.", "For example, strings starting with '0' were historically parsed as octal."],
-			suggestions: ["Add an explicit radix parameter."]
-		}
-	},
-	setup(context) {
-		return { visitors: { CallExpression: (node, { program, sourceFile, typeChecker }) => {
-			if (!isParseIntCall(node, typeChecker, program)) return;
-			if (node.arguments.length <= 1) {
-				context.report({
-					message: "missingRadix",
-					range: getTSNodeRange(node, sourceFile)
-				});
-				return;
-			}
-			const radixArgument = node.arguments[1];
-			if (!isValidRadix(radixArgument)) context.report({
-				message: "invalidRadix",
-				range: getTSNodeRange(radixArgument, sourceFile)
-			});
-		} } };
-	}
-});
-//#endregion
-export { parseIntRadixes_default as default };

package/lib/rules/propertyAccessNotation.d.ts

@@ -1,12 +0,0 @@
-import { z } from "zod/v4";
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports bracket notation property access when dot notation can be used.";
-    readonly id: "propertyAccessNotation";
-    readonly presets: readonly ["stylistic", "stylisticStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "preferDotNotation", {
-    allowIndexSignaturePropertyAccess: z.ZodDefault<z.ZodBoolean>;
-}>;
-export default _default;

package/lib/rules/propertyAccessNotation.js

@@ -1,117 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import ts from "typescript";
-import { z as z$1 } from "zod/v4";
-//#region src/rules/propertyAccessNotation.ts
-const javascriptReservedWords = /* @__PURE__ */ new Set([
-	"await",
-	"break",
-	"case",
-	"catch",
-	"class",
-	"const",
-	"continue",
-	"debugger",
-	"default",
-	"delete",
-	"do",
-	"else",
-	"enum",
-	"export",
-	"extends",
-	"false",
-	"finally",
-	"for",
-	"function",
-	"if",
-	"implements",
-	"import",
-	"in",
-	"instanceof",
-	"interface",
-	"let",
-	"new",
-	"null",
-	"package",
-	"private",
-	"protected",
-	"public",
-	"return",
-	"static",
-	"super",
-	"switch",
-	"this",
-	"throw",
-	"true",
-	"try",
-	"typeof",
-	"var",
-	"void",
-	"while",
-	"with",
-	"yield"
-]);
-function getModifiers(node) {
-	return node && ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
-}
-function getPropertyKeyText(node) {
-	switch (node.argumentExpression.kind) {
-		case ts.SyntaxKind.FalseKeyword: return "false";
-		case ts.SyntaxKind.NullKeyword: return "null";
-		case ts.SyntaxKind.StringLiteral: return node.argumentExpression.text;
-		case ts.SyntaxKind.TrueKeyword: return "true";
-		default: return;
-	}
-}
-function keyCannotBeUsedWithDotNotation(key) {
-	return !/^[\p{L}_$][\p{L}\d_$]*$/u.test(key) || javascriptReservedWords.has(key);
-}
-var propertyAccessNotation_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports bracket notation property access when dot notation can be used.",
-		id: "propertyAccessNotation",
-		presets: ["stylistic", "stylisticStrict"]
-	},
-	messages: { preferDotNotation: {
-		primary: "Prefer the cleaner dot notation instead of bracket notation for `{{ key }}`.",
-		secondary: ["Dot notation is more concise and easier to read.", "Bracket notation should only be used when the property name is not a valid identifier or is a reserved word."],
-		suggestions: ["Replace `[\"{{ key }}\"]` with `.{{ key }}`."]
-	} },
-	options: { allowIndexSignaturePropertyAccess: z$1.boolean().default(false).describe("Whether to allow accessing properties matching an index signature with bracket notation.") },
-	setup(context) {
-		function getKeyTypeInformation(node, typeChecker) {
-			const propertySymbol = typeChecker.getSymbolAtLocation(node.argumentExpression) ?? typeChecker.getTypeAtLocation(node.expression).getNonNullableType().getProperties().find((propertySymbol) => ts.isStringLiteral(node.argumentExpression) && propertySymbol.escapedName === node.argumentExpression.text);
-			const modifierKind = getModifiers(propertySymbol?.getDeclarations()?.[0])?.[0]?.kind;
-			return {
-				inaccessible: modifierKind === ts.SyntaxKind.PrivateKeyword || modifierKind === ts.SyntaxKind.ProtectedKeyword,
-				propertySymbol
-			};
-		}
-		return { visitors: { ElementAccessExpression: (node, { options, sourceFile, typeChecker }) => {
-			const key = getPropertyKeyText(node);
-			if (!key || keyCannotBeUsedWithDotNotation(key)) return;
-			const { inaccessible, propertySymbol } = getKeyTypeInformation(node, typeChecker);
-			if (inaccessible) return;
-			if (options.allowIndexSignaturePropertyAccess && !propertySymbol) {
-				const objectType = typeChecker.getTypeAtLocation(node.expression).getNonNullableType();
-				if (typeChecker.getIndexInfosOfType(objectType).some((info) => info.keyType.flags & ts.TypeFlags.StringLike)) return;
-			}
-			const objectText = node.expression.getText(sourceFile);
-			const dotOperator = node.questionDotToken !== void 0 ? "?." : ".";
-			context.report({
-				data: { key },
-				fix: {
-					range: getTSNodeRange(node, sourceFile),
-					text: `${objectText}${dotOperator}${key}`
-				},
-				message: "preferDotNotation",
-				range: {
-					begin: node.argumentExpression.getStart(sourceFile),
-					end: node.argumentExpression.getEnd()
-				}
-			});
-		} } };
-	}
-});
-//#endregion
-export { propertyAccessNotation_default as default };

package/lib/rules/recursionOnlyArguments.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports function parameters that are only used in recursive calls.";
-    readonly id: "recursionOnlyArguments";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "onlyUsedInRecursion", undefined>;
-export default _default;

package/lib/rules/recursionOnlyArguments.js

@@ -1,62 +0,0 @@
-import { ruleCreator } from "./ruleCreator.js";
-import { getFunctionName } from "./utils/getFunctionName.js";
-import { getScopeManager, getTSNodeRange, typescriptLanguage } from "@flint.fyi/typescript-language";
-import * as ts$1 from "typescript";
-import * as tsutils from "ts-api-utils";
-//#region src/rules/recursionOnlyArguments.ts
-function isParameterOnlyUsedInRecursion(parameter, parameterIndex, functionName, functionNode, scopeManager) {
-	if (!ts$1.isIdentifier(parameter.name) || !functionNode.body) return false;
-	const [variable] = scopeManager.getDeclaredVariables(parameter);
-	if (!variable) return false;
-	const { references } = variable;
-	return references.length && references.every((reference) => isReferenceOnlyUsedInRecursion(reference.identifier, parameterIndex, functionName, functionNode));
-}
-function isRecursiveCall(callExpression, functionName, functionNode) {
-	const callee = callExpression.expression;
-	let calleeMatchesFunctionName = false;
-	if (ts$1.isIdentifier(callee)) calleeMatchesFunctionName = callee.text === functionName;
-	else if (ts$1.isPropertyAccessExpression(callee) && callee.expression.kind === ts$1.SyntaxKind.ThisKeyword && ts$1.isIdentifier(callee.name)) calleeMatchesFunctionName = callee.name.text === functionName;
-	if (!calleeMatchesFunctionName) return false;
-	for (let current = callExpression.parent; current; current = current.parent) {
-		if (current === functionNode) return true;
-		if (tsutils.isFunctionScopeBoundary(current)) return false;
-	}
-	return false;
-}
-function isReferenceOnlyUsedInRecursion(reference, parameterIndex, functionName, functionNode) {
-	const parent = reference.parent;
-	if (!ts$1.isCallExpression(parent)) return false;
-	if (!isRecursiveCall(parent, functionName, functionNode)) return false;
-	return parent.arguments.findIndex((argument) => argument === reference) === parameterIndex;
-}
-var recursionOnlyArguments_default = ruleCreator.createRule(typescriptLanguage, {
-	about: {
-		description: "Reports function parameters that are only used in recursive calls.",
-		id: "recursionOnlyArguments",
-		presets: ["logical", "logicalStrict"]
-	},
-	messages: { onlyUsedInRecursion: {
-		primary: "This parameter is only used in recursive calls.",
-		secondary: ["Parameters that are only passed through to recursive calls serve no functional purpose.", "This increases cognitive complexity and may impact performance."],
-		suggestions: ["Remove the parameter if it's not needed.", "Use the parameter in the function body for some computation."]
-	} },
-	setup(context) {
-		function checkFunction(node, { sourceFile }) {
-			const functionName = getFunctionName(node);
-			if (!functionName || !node.body) return;
-			const scopeManager = getScopeManager(sourceFile);
-			for (const [parameterIndex, parameter] of node.parameters.entries()) if (isParameterOnlyUsedInRecursion(parameter, parameterIndex, functionName, node, scopeManager)) context.report({
-				message: "onlyUsedInRecursion",
-				range: getTSNodeRange(parameter.name, sourceFile)
-			});
-		}
-		return { visitors: {
-			ArrowFunction: checkFunction,
-			FunctionDeclaration: checkFunction,
-			FunctionExpression: checkFunction,
-			MethodDeclaration: checkFunction
-		} };
-	}
-});
-//#endregion
-export { recursionOnlyArguments_default as default };

package/lib/rules/redundantTypeConstituents.d.ts

@@ -1,9 +0,0 @@
-declare const _default: import("@flint.fyi/core").Rule<{
-    readonly description: "Reports union and intersection type constituents that are redundant or override other types.";
-    readonly id: "redundantTypeConstituents";
-    readonly presets: readonly ["logical", "logicalStrict"];
-} & {
-    readonly pluginId: string;
-    readonly url: string;
-}, "errorTypeOverrides" | "literalOverridden" | "overridden" | "overrides" | "primitiveOverridden", undefined>;
-export default _default;