@ts-for-gir/lib 4.0.0-beta.34 → 4.0.0-beta.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-for-gir/lib",
-  "version": "4.0.0-beta.34",
+  "version": "4.0.0-beta.35",
   "description": "Typescript .d.ts generator from GIR for gjs",
   "main": "src/index.ts",
   "module": "src/index.ts",
@@ -48,9 +48,9 @@
     "typescript": "^5.9.2"
   },
   "dependencies": {
-    "@gi.ts/parser": "^4.0.0-beta.34",
-    "@ts-for-gir/reporter": "^4.0.0-beta.34",
-    "@ts-for-gir/templates": "^4.0.0-beta.34",
+    "@gi.ts/parser": "^4.0.0-beta.35",
+    "@ts-for-gir/reporter": "^4.0.0-beta.35",
+    "@ts-for-gir/templates": "^4.0.0-beta.35",
     "colorette": "^2.0.20",
     "ejs": "^3.1.10",
     "glob": "^11.0.3",

package/src/gir-module.ts

@@ -469,18 +469,39 @@ export class GirModule implements IGirModule {
 		const clazzes = Array.from(this.members.values()).filter(
 			(m): m is IntrospectedBaseClass => m instanceof IntrospectedBaseClass,
 		);
-		const res = clazzes
+
+		// First, try to handle compound names like "ResultFlatMapFunc" -> "Result.FlatMapFunc"
+		// This is the main fix for the Gpseq namespace collision issue
+		for (const clazz of clazzes) {
+			// Check if the name starts with the class name (compound name pattern)
+			if (name.startsWith(clazz.name)) {
+				const potentialCallbackName = name.slice(clazz.name.length);
+				const callback = clazz.callbacks.find((c) => c.name === potentialCallbackName);
+				if (callback) {
+					return [clazz.name, callback.name];
+				}
+			}
+		}
+
+		// Find all matches using the original logic
+		const allMatches = clazzes
 			.map<[IntrospectedBaseClass, IntrospectedClassCallback | undefined]>((m) => [
 				m,
 				m.callbacks.find((c) => c.name === name || c.resolve_names.includes(name)),
 			])
-			.find((r): r is [IntrospectedBaseClass, IntrospectedClassCallback] => r[1] != null);
+			.filter((r): r is [IntrospectedBaseClass, IntrospectedClassCallback] => r[1] != null);
 
-		if (res) {
-			return [res[0].name, res[1].name];
-		} else {
+		if (allMatches.length === 0) {
 			return [null, name];
 		}
+
+		// If there are multiple matches, prefer more specific ones
+		if (allMatches.length > 1) {
+			this.log.warn(`Found multiple matches for ${name}: ${allMatches.map((m) => m[0].name).join(", ")}`);
+		}
+
+		const res = allMatches[0];
+		return [res[0].name, res[1].name];
 	}
 
 	/**

package/src/gir.ts

@@ -18,6 +18,7 @@ export enum ConflictType {
 	FUNCTION_NAME_CONFLICT,
 	ACCESSOR_PROPERTY_CONFLICT,
 	PROPERTY_ACCESSOR_CONFLICT,
+	VFUNC_SIGNATURE_CONFLICT,
 }
 
 import { ConsoleReporter, ReporterService } from "@ts-for-gir/reporter";

package/src/injections/inject.ts

@@ -34,6 +34,7 @@ export function inject(registry: NSRegistry) {
 
 	const $_ = injectDefinitions(registry, false);
 
+	// Optional injections
 	$_(tracker1);
 	$_(gee08);
 	$_(gee1);

package/src/utils/conflicts.ts

@@ -8,6 +8,7 @@ import type { IntrospectedBaseClass } from "../gir/introspected-classes.ts";
 import {
 	IntrospectedClass,
 	IntrospectedClassFunction,
+	IntrospectedInterface,
 	IntrospectedStaticClassFunction,
 	IntrospectedVirtualClassFunction,
 } from "../gir/introspected-classes.ts";
@@ -391,6 +392,12 @@ function detectConflictType<T extends IntrospectedClassMember | IntrospectedClas
 	const propertyConflict = checkPropertyConflicts(ns, c, element, thisType);
 	if (propertyConflict) return propertyConflict;
 
+	// Check virtual function signature conflicts (for interfaces)
+	if (element instanceof IntrospectedVirtualClassFunction) {
+		const vfuncConflict = checkVfuncSignatureConflicts(ns, c, element, thisType);
+		if (vfuncConflict) return vfuncConflict;
+	}
+
 	// Check function conflicts
 	return checkFunctionNameConflicts(ns, c, element, thisType);
 }
@@ -476,6 +483,51 @@ function checkFunctionNameConflicts<
 	);
 }
 
+function checkVfuncSignatureConflicts(
+	ns: IntrospectedNamespace,
+	c: IntrospectedBaseClass,
+	element: IntrospectedVirtualClassFunction,
+	thisType: TypeIdentifier,
+): ConflictType | undefined {
+	// Only check for vfunc conflicts on interfaces
+	if (!(c instanceof IntrospectedInterface)) {
+		return undefined;
+	}
+
+	// Check if this virtual method conflicts with parent class or interface methods
+	return c.findParentMap((resolved_parent) => {
+		// Look for virtual methods with the same name in parent classes/interfaces
+		const parentVirtualMethods = resolved_parent.members.filter(
+			(m) => m instanceof IntrospectedVirtualClassFunction && m.name === element.name,
+		);
+
+		for (const parentMethod of parentVirtualMethods) {
+			// Check if signatures conflict
+			if (isConflictingFunction(ns, thisType, element, resolved_parent.getType(), parentMethod)) {
+				return ConflictType.VFUNC_SIGNATURE_CONFLICT;
+			}
+		}
+
+		// Also check if the parent is an interface that might have virtual methods from its Interface namespace
+		// This is important for cases like List extends Collection where both have vfunc_get_read_only_view
+		if (resolved_parent instanceof IntrospectedInterface) {
+			// Get the virtual methods from the parent interface
+			const parentInterfaceVirtualMethods = resolved_parent.members.filter(
+				(m) => m instanceof IntrospectedVirtualClassFunction && m.name === element.name,
+			);
+
+			for (const parentMethod of parentInterfaceVirtualMethods) {
+				// Check if signatures conflict between the interfaces
+				if (isConflictingFunction(ns, thisType, element, resolved_parent.getType(), parentMethod)) {
+					return ConflictType.VFUNC_SIGNATURE_CONFLICT;
+				}
+			}
+		}
+
+		return undefined;
+	});
+}
+
 function createConflictElement<T extends IntrospectedClassMember | IntrospectedClassFunction | IntrospectedProperty>(
 	element: T,
 	conflictType: ConflictType,
@@ -486,5 +538,90 @@ function createConflictElement<T extends IntrospectedClassMember | IntrospectedC
 		}) as T;
 	}
 
+	// For VFUNC_SIGNATURE_CONFLICT, we'll handle it differently in the generator
+	// Just mark the element so the generator knows to create overloads
+	if (conflictType === ConflictType.VFUNC_SIGNATURE_CONFLICT && element instanceof IntrospectedVirtualClassFunction) {
+		// Return the element with a marker that will be handled in the generator
+		// We don't use TypeConflict here as that causes resolution errors
+		return element;
+	}
+
 	return null;
 }
+
+/**
+ * Check if an interface has virtual methods that conflict with parent class or interface methods.
+ * This is used to determine whether to inherit from Interface namespace or generate method overloads.
+ */
+export function hasVfuncSignatureConflicts(ns: IntrospectedNamespace, interfaceClass: IntrospectedInterface): boolean {
+	const thisType = interfaceClass.getType();
+	const virtualMethods = interfaceClass.members.filter(
+		(m) => m instanceof IntrospectedVirtualClassFunction,
+	) as IntrospectedVirtualClassFunction[];
+
+	// If we don't have any virtual methods, no conflicts possible
+	if (virtualMethods.length === 0) {
+		return false;
+	}
+
+	// Check each virtual method for conflicts with parent classes/interfaces
+	for (const vmethod of virtualMethods) {
+		const conflictType = checkVfuncSignatureConflicts(ns, interfaceClass, vmethod, thisType);
+		if (conflictType === ConflictType.VFUNC_SIGNATURE_CONFLICT) {
+			return true;
+		}
+	}
+
+	// Check if any parent interface already inherits from its own .Interface namespace
+	// If it does, and we have virtual methods with the same name but different signatures,
+	// we have a conflict (e.g., List extends Collection, List.Interface and BidirList extends List, BidirList.Interface)
+	const hasParentWithVirtualMethods = interfaceClass.someParent((parent) => {
+		// Only check parent interfaces (not classes)
+		if (!(parent instanceof IntrospectedInterface)) {
+			return false;
+		}
+
+		// Check if the parent interface has virtual methods (which means it probably inherits from its .Interface namespace)
+		const parentHasVirtualMethods = parent.members.some((m) => m instanceof IntrospectedVirtualClassFunction);
+
+		if (!parentHasVirtualMethods) {
+			return false; // Parent has no virtual methods, no conflict
+		}
+
+		// Check if any of our virtual methods have the same name as parent's virtual methods
+		// but with different signatures (especially return types)
+		for (const vmethod of virtualMethods) {
+			// Find virtual methods with the same name in the parent
+			const parentVirtualMethods = parent.members.filter(
+				(m) => m instanceof IntrospectedVirtualClassFunction && m.name === vmethod.name,
+			) as IntrospectedVirtualClassFunction[];
+
+			for (const parentMethod of parentVirtualMethods) {
+				// For interfaces, even if the return type is a subtype, TypeScript won't allow
+				// multiple inheritance from interfaces with the same method but different return types
+				// So we need to check if there's any difference in signatures
+				// Note: We can't just use isConflictingFunction because it allows subtype relationships
+				// but TypeScript doesn't allow that for interface multiple inheritance
+
+				// Check if return types are different (even if one is a subtype of the other)
+				const ourReturn = vmethod.return();
+				const parentReturn = parentMethod.return();
+
+				// Check if return types are not exactly the same
+				// For interface inheritance, even subtype relationships cause conflicts
+				if (!ourReturn.equals(parentReturn)) {
+					return true; // Different return types = conflict
+				}
+
+				// Also check parameters using the existing conflict detection
+				if (isConflictingFunction(ns, thisType, vmethod, parent.getType(), parentMethod)) {
+					return true;
+				}
+			}
+		}
+
+		return false;
+	});
+
+	return hasParentWithVirtualMethods;
+}