[TrimmableTypeMap] Direct-dispatch interface-implementation proxy methods

Marshal methods collected from an implemented Java interface (e.g. a listener
Implementor) declare their n_* callback as a *private static* method on the
interface type, which lives in the separately ILC-trimmed binding assembly.
Nothing in the trimmable path references that callback within its own assembly,
so ILC trims it away and the generated proxy forwarder 'will always throw' (or,
for generic JavaPeerProxy<TInterface> closed over a bare interface, fails to
load with a TypeLoadException).

Dispatch these methods directly to the managed method instead -- this mirrors
exactly what the static n_* callback does internally (GetObject<TInterface> +
callvirt the interface method) but keeps the generated proxy self-contained and
independent of whether the binding's private n_* survives trimming.

Reproduced with Xamarin.AndroidX.Fragment (IOnBackStackChangedListener et al.):
the ILC 'will always throw' warnings are gone and built-in Mono.Android
listeners (Button.Click/LongClick) still build clean. Fixes the MergeLibraryManifest
and RemovePermissionTest NativeAOT failures.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: simonrozsival

src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs

@@ -1117,7 +1117,7 @@ void AddMarshalMethod (List<MarshalMethodInfo> methods, RegisterInfo registerInf
 		string declaringAssemblyName = "";
 		ParseConnectorDeclaringType (registerInfo.Connector, out declaringTypeName, out declaringAssemblyName);
 
-		bool mayCallManagedMethodDirectly = ShouldCallManagedMethodDirectly (isConstructor, isExport, declaringTypeName);
+		bool mayCallManagedMethodDirectly = ShouldCallManagedMethodDirectly (isConstructor, isExport, declaringTypeName, isInterfaceImplementation);
 
 		// Only decode TypeRefData signatures for methods that need direct dispatch IL
 		// generation; static n_* callback forwarders already encode from the JNI signature.
@@ -1160,7 +1160,7 @@ void AddMarshalMethod (List<MarshalMethodInfo> methods, RegisterInfo registerInf
 		});
 	}
 
-	static bool ShouldCallManagedMethodDirectly (bool isConstructor, bool isExport, string declaringTypeName)
+	static bool ShouldCallManagedMethodDirectly (bool isConstructor, bool isExport, string declaringTypeName, bool isInterfaceImplementation)
 	{
 		if (isExport) {
 			return true;
@@ -1170,6 +1170,17 @@ static bool ShouldCallManagedMethodDirectly (bool isConstructor, bool isExport,
 			return false;
 		}
 
+		// Methods collected from an implemented Java interface (e.g. a listener Implementor)
+		// declare their n_* callback as a *private static* method on the interface type, which
+		// lives in the (separately ILC-trimmed) binding assembly. Nothing in the trimmable path
+		// references that callback within its own assembly, so ILC trims it and the generated
+		// proxy's forwarder "will always throw" (or fails to load). Dispatch directly to the
+		// managed method instead — this mirrors exactly what the static n_* callback does
+		// (GetObject<TInterface> + callvirt the interface method) but keeps the proxy self-contained.
+		if (isInterfaceImplementation) {
+			return true;
+		}
+
 		// Direct [Register] methods have no connector-declared callback owner, so forwarding
 		// through n_* may bind to an inherited callback. If the type hides a base virtual
 		// member with "new virtual" but keeps the same JNI method, that inherited callback

tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Scanner/InterfaceMethodDetectionTests.cs

@@ -21,6 +21,20 @@ public void ImplicitInterfaceImpl_DetectsOnClickWithCorrectSignatureAndConnector
 		Assert.Equal ("Android.Views.IOnClickListenerInvoker", onClick.DeclaringTypeName);
 	}
 
+	[Fact]
+	public void ImplicitInterfaceImpl_UsesDirectManagedDispatch ()
+	{
+		// Interface-implementation marshal methods must dispatch directly to the managed
+		// method rather than forwarding through the interface's private static n_* callback.
+		// That callback lives in the (separately ILC-trimmed) binding assembly and is trimmed
+		// away in the trimmable path, which otherwise makes the generated proxy forwarder
+		// "will always throw" (or fail to load). See JavaPeerScanner.ShouldCallManagedMethodDirectly.
+		var peer = FindFixtureByJavaName ("my/app/ImplicitClickListener");
+		var onClick = peer.MarshalMethods.First (m => m.JniName == "onClick");
+		Assert.True (onClick.IsInterfaceImplementation);
+		Assert.True (onClick.CallManagedMethodDirectly);
+	}
+
 	[Fact]
 	public void ImplicitMultiInterface_BothMethodsDetected ()
 	{