[TrimmableTypeMap] Add trimmable [Export] and [ExportField] callback support

[simonrozsival]

Summary

Add UCO (UnmanagedCallersOnly) wrapper codegen for [Export] methods and [ExportField] fields in the trimmable typemap pipeline, and extend UCO constructor codegen to invoke user-visible managed ctors (parameterless and object-reference parameterized) so types whose Java-side activation triggers user-defined ctor logic — including all Throwable subclasses with (Throwable cause) ctors and types using [Export] ctors — work correctly under trimming + CoreCLR.

Depends on #11091 (trimmable test plumbing + CoreCLRTrimmable CI lane).

Part of #10788

Changes

Export method dispatch support

• Scanner: Detect [Export] and [ExportField] attributes on Java peer types; resolve JNI signatures for non-primitive Java-bound parameter types; collect Java access modifiers and throws clauses
• Model: MarshalMethodInfo carries IsExport, JavaAccess, ThrownNames, and SuperArgumentsString for export metadata
• JCW Java codegen: Generate Java native methods with correct access modifiers and throws clauses for [Export] methods; generate Java field declarations for [ExportField]
• UCO wrappers + RegisterNatives: Export methods get the same UCO wrapper + JNI native registration as [Register] native callbacks
• ExportMethodDispatchEmitter: New emitter class handling the PE metadata generation for export dispatch, separate from the UCO constructor emitter
• Exclude Mono.Android.Export: Exclude the Mono.Android.Export assembly from trimmable packages — its DynamicMethod-based codegen is incompatible with AOT/trimming; uses [ExportAttribute]/[ExportFieldAttribute] from the user assembly's [Register]-scanned types instead

UCO constructor wrappers — invoke user-visible managed ctors

The legacy UCO constructor codegen always built the managed peer via the JI activation ctor (IntPtr, JniHandleOwnership), which is sufficient for plain [Register] types but skips any user-defined ctor body. That broke types whose Java-side activation must run user code — most notably [Export]-using types (whose Constructed = true / SuperArgumentsString initialization happens in the user ctor) and Throwable subclasses that need to forward the cause argument.

This PR generalizes UCO constructor codegen to mirror Java.Interop.TypeManager.Activate:

• Scanner: JavaPeerScanner.TryFindMatchingManagedCtorParams matches each registered Java ctor signature to a managed ..ctor. The match requires equal arity and (currently) all-object-reference JNI args; primitive args fall through to the legacy activation-ctor path. Match results are recorded on JavaConstructorInfo.ManagedParameterTypes and plumbed through ModelBuilder → UcoConstructorData.
• Emitter: New EmitUserVisibleCtorWrapper helper emits, when a match exists:

  var obj = (T) RuntimeHelpers.GetUninitializedObject (typeof (T));
  ((IJavaPeerable) obj).SetPeerReference (new JniObjectReference (self));
  obj..ctor (
      (TParam0) Java.Lang.Object.GetObject (arg0, JniHandleOwnership.DoNotTransfer, typeof (TParam0)),
      ...);

  The internal Java.Lang.Object.GetObject (IntPtr, JniHandleOwnership, Type) helper is reachable from the generated assembly via the always-on [IgnoresAccessChecksTo("Mono.Android")] attribute that ModelBuilder emits.
• Safe fallback: When no managed ctor matches by arity (e.g. Java.Lang.Thread+RunnableImplementor, which only has parameterized managed ctors but registers a ()V Java ctor via JCW codegen) or when the JNI signature contains a primitive arg, the emitter falls back to the legacy activation-ctor path so we never emit a metadata reference to a non-existent method.

Bug fixes

• Fix missing static keyword in Java codegen for static [Export] methods
• Fix stack corruption in TryEmitExportParameterArgument (wrong local variable index)
• Fix instrumentation targetPackage defaulting to use the passed-in package name parameter
• Propagate deferred registerNatives to base classes so inherited exports are registered correctly
• Fix RunnableImplementor crash (MissingMethodException: Default constructor not found for type Java.Lang.Thread+RunnableImplementor) — see "UCO constructor wrappers" above

Tests

New device tests in Mono.Android-Tests covering the activation contract:

• ActivatedDirectThrowableSubclasses_ThrowableCtor_ShouldForwardArgs — single-arg (Throwable cause) ctor invoked from Java
• ActivatedDirectThrowableSubclasses_MultipleCtors_ShouldDispatchToCorrectCtor — multi-arity dispatch (()V and (Throwable)V)
• Plus the existing ContainsExportedMethods / [Export] test fixtures, which exercise the parameterless user-ctor path

Java.Interop/ExportTests.cs — new fixture exercising [Export] parameter / return marshalling end-to-end via JNIEnv.GetMethodID + Call*Method. Each test runs under both the legacy llvm-ir typemap (which defines the contract) and the trimmable typemap (which must match it). Verified locally: all 11 / 11 Export tests pass on _AndroidTypeMapImplementation=trimmable + UseMonoRuntime=false:

Group	Test	Coverage
A	Export_Method_Primitive_RoundTrip	int -> int
A	Export_Method_Bool_RoundTrip	bool -> bool (byte / bool ABI)
A	Export_Method_String_RoundTrip	string -> string
A	Export_Method_PeerArg_RoundTrip	Java.Lang.Object arg unwrap
A	Export_Method_PeerArg_NullArg_HandledGracefully	null arg → C# null
A	Export_Method_IntArray_RoundTrip_AndCopyBack	int[] arg + copy-back
A	Export_Method_PeerArray_RoundTrip	Java.Lang.Object[] arg/return
B	Export_Method_Throws_PrimitiveReturn_SurfacesAsManagedException	exception preserved through OnUserUnhandledException
B	Export_Method_Throws_ObjectReturn_SurfacesAsManagedException	exception preserved through OnUserUnhandledException

Group B verifies the new [Export] UCO marshal-method wrapper: each exported method body now runs inside BeginMarshalMethod / try / catch (route via JniRuntime.OnUserUnhandledException) / finally (EndMarshalMethod), mirroring the trimmable UCO ctor wrapper. Without this, an unhandled managed exception aborts the CoreCLR process. Note: unlike legacy AndroidEnvironment.UnhandledException (which translated to Java.Lang.Throwable), JniRuntime.OnUserUnhandledException preserves the original managed exception via JniTransition.SetPendingException, so callers see the original C# exception type with the original message.

Also: JavaPeerScanner.TryFindMatchingManagedCtorParams now skips parameterized [Export] ctors with generic / by-ref / pointer parameter types (falling back to the activation-ctor path), fixing a pre-existing build failure on Xamarin.Android.NUnitLite's TestDataAdapter ctor whose JavaList<T> parameter triggered XAGTT7015.

Verified locally on _AndroidTypeMapImplementation=trimmable × UseMonoRuntime=false: 928 passed / 0 failed / 56 ignored, plus the 9 new Export tests.

Scanner integration coverage for [Export] shapes

A dedicated integration test project (Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests) walks the new scanner over a fixture assembly (UserTypesFixture) and asserts JNI signatures / connectors / metadata for every shape the scanner needs to handle. Coverage was expanded over the course of the PR to 27 test cases and surfaced 5 real scanner bugs that the unit suite did not catch:

Area	Cases	Bugs caught & fixed
Advanced [Export] shapes (enum, ICharSequence, non-generic collections, [ExportField], [ExportParameter])	8	[ExportField] returning a user-peer type emitted Ljava/lang/Object; instead of the peer's CRC64 JNI name. Fixed by extending TryResolveJniObjectDescriptor to fall back to ComputeAutoJniNames for types extending a Java peer without [Register].
Phase A — dispatch & declaration shapes (static [Export], Throws, mixed [Register]+[Export], virtual + derived, custom JNI name)	5	(1) [Export(Throws = …)] Type[] was silently dropped — scanner only read the internal ThrownNames (string[]). Fixed by resolving each typeof() arg to its JNI internal name. (2) ExportAttribute is Inherited=false, but FindBaseRegisteredMethodInfo propagated base [Export] registrations to derived overrides. Fixed by restricting propagation to [Register]/[JniConstructorSignature]-direct registrations.
Phase B — edge marshalling (Java.Lang.Object explicit, array of user-peer, protected/private visibility, primitive [ExportField], overloaded names)	5	All green on first run.
Phase C — robustness (generic method, [Export] on [Register]'d-base override)	2	Pass 1 unconditionally added every registered method to the dedup key set, so [Export] on a [Register]'d-base override prevented Pass 3 from also emitting the override entry (only onCreateExport, no onCreate). Fixed by skipping the dedup key for [Export]/[ExportField].

Marshalling parity follow-ups (commits in this PR)

These extend the trimmable typemap's [Export] parameter/return marshalling to mirror legacy Mono.Android.Export/CallbackCode for reference / value types whose JNI ABI requires more than the generic IJavaObject path:

Type	JNI descriptor	Runtime helper	Commit
enum (Int32 / Byte / Int16 / Int64 backed)	underlying primitive (I / B / S / J)	n/a — primitive ABI	"Marshal enum [Export] params/returns via underlying primitive JNI ABI"
Java.Lang.ICharSequence	Ljava/lang/CharSequence;	Android.Runtime.CharSequence.ToLocalJniHandle (ICharSequence)	"Marshal ICharSequence and non-generic collection [Export] returns via dedicated runtime helpers"
System.Collections.IList	Ljava/util/List;	Android.Runtime.JavaList.ToLocalJniHandle (IList)	(same)
System.Collections.IDictionary	Ljava/util/Map;	Android.Runtime.JavaDictionary.ToLocalJniHandle (IDictionary)	(same)
System.Collections.ICollection	Ljava/util/Collection;	Android.Runtime.JavaCollection.ToLocalJniHandle (ICollection)	(same)

Scanner unit tests cover each new descriptor; emitter changes are exercised through the existing JavaPeerScannerTests / TypeMapAssemblyGeneratorTests coverage (468 unit tests passing).

Device-test follow-up: the legacy JCW emitter CecilImporter.GetJniSignature rejects these same types when generating Java callable wrappers (it returns null, which fails the build), so the new marshalling paths are not yet exercised end-to-end through real JCW callbacks. Teaching the JCW emitter to widen these types is filed as a separate item.

[Copilot]

Pull request overview

This PR extends the TrimmableTypeMap pipeline to support legacy [Export] / [ExportField] callbacks (including UCO wrapper + RegisterNatives generation and richer signature/metadata scanning), and adjusts test/build plumbing to stabilize the CoreCLRTrimmable test lane (including excluding Mono.Android.Export from app packaging on the trimmable path).

Changes:

• Add scanner + model support for [Export] / [ExportField], including signature resolution for Java-bound types and [ExportParameter] legacy marshalling shapes.
• Add generator support for direct-dispatch UCO wrappers for [Export] (new ExportMethodDispatchEmitter) and align typemap/manifest generation behavior.
• Stabilize CI/test lanes: introduce CoreCLRTrimmable flavor + categories, defer registerNatives up base class chains, and ensure Mono.Android.Export isn’t packaged on the trimmable path.

Reviewed changes

Copilot reviewed 31 out of 31 changed files in this pull request and generated 3 comments.

Show a summary per file

File	Description
src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerScanner.cs	Detect/export [Export] metadata, compute JNI signatures with legacy marshalling shapes, and record precise managed type/assembly info.
src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ExportMethodDispatchEmitter.cs	New emitter that generates UCO wrappers which dispatch directly to managed [Export] targets (avoids legacy dynamic callback generation).
src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/TypeMapAssemblyEmitter.cs	Integrate export dispatch emitter, refactor RegisterNatives emission, and adjust proxy/UCO emission flow.
src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs	Manifest rooting rewrite + propagation of deferred registration flags to base classes; pass prepared manifest through generation.
src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets	Mark Mono.Android.Export references with AndroidSkipAddToPackage=true for trimmable typemap builds.
src/Xamarin.Android.Build.Tasks/Tasks/GenerateNativeApplicationConfigSources.cs	Skip assemblies marked AndroidSkipAddToPackage when generating native app config sources.
tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/*	New/updated fixtures and assertions covering export scanning, export dispatch generation, manifest rewriting, and instrumentation defaults.
tests/Mono.Android-Tests/Mono.Android-Tests/Mono.Android.NET-Tests.csproj	Add CoreCLRTrimmable configuration defaults (runtime selection, categories, constants).
build-tools/automation/yaml-templates/stage-package-tests.yaml	Add CoreCLRTrimmable instrumentation lane and adjust CoreCLR lane args.

[Copilot]

_baseCtorRef is assigned but never used, and the encoded .ctor signature here doesn’t match JavaPeerProxy<T> (it encodes two System.Type parameters instead of string + Type). This should be removed to avoid dead/incorrect metadata and to prevent future accidental use of a wrong member reference.

Suggested change

	_baseCtorRef = _pe.AddMemberRef (_javaPeerProxyRef, ".ctor",
	sig => sig.MethodSignature (isInstanceMethod: true).Parameters (2,
	rt => rt.Void (),
	p => {
	p.AddParameter ().Type ().Type (_systemTypeRef, false);
	p.AddParameter ().Type ().Type (_systemTypeRef, false);
	}));

[simonrozsival]

🤖 Code Review — PR #11123

Verdict: ⚠️ Needs Changes (1 warning, 2 suggestions; CI still pending)

Summary

Solid implementation of [Export]/[ExportField] for the trimmable typemap pipeline. The static UCO dispatch via [UnmanagedCallersOnly] + RegisterNatives is correct, the IL generation handles all primitive/object/array/stream/XML marshalling shapes, and the test coverage is thorough (162 new test assertions across scanner, model builder, assembly generator, JCW codegen, and build integration). The Mono.Android.Export.dll exclusion from the packaged APK is properly wired.

Positive callouts

• ExportMethodDispatchEmitterContext factory — single-allocation, reused for the entire emit pass. Clean separation from the parent emitter.
• ExportParameterKind support — properly resolves InputStream, OutputStream, XmlPullParser, XmlResourceParser marshalling in both directions (JNI→managed and managed→JNI return).
• Array copy-back with null guards — the Brfalse_s skip pattern correctly avoids null-array copy-back crashes.
• Cross-assembly type resolution — TypeRefSignatureTypeProvider + MetadataTypeNameResolver properly chase ResolutionScope to the correct assembly reference, and the test Generate_ExportProxy_UsesExactCrossAssemblyTypeReferences validates it end-to-end.

CI (Xamarin.Android-PR) is still pending — review is based on code analysis only.

[simonrozsival]

Blocked by #11091

[simonrozsival]

/android-reviewer