[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 enabled device test runs under both the legacy llvm-ir typemap (which defines the contract) and the trimmable typemap (which must match it). Verified locally after rebase: all 9 / 9 currently enabled ExportTests 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: device tests for enum, ICharSequence, non-generic collection, and [ExportField] shapes are intentionally deferred. The legacy JCW emitter CecilImporter.GetJniSignature rejects some of these types when generating Java callable wrappers (it returns null, which fails the build), and [ExportField] currently needs separate JCW field-initializer work before runtime coverage is possible. The scanner/emitter paths are covered by host tests in this PR; end-to-end device coverage is tracked by #11289.

Related issues

• Reference [Epic] Trimmable Type Map for Native AOT and CoreCLR #10788
• Reference [TrimmableTypeMap] Run full on-device test suite with trimmable type map #11054
• Reference [TrimmableTypeMap] Resolve all TrimmableIgnore, SSL, and Java.Interop-Tests exclusions #11099
• Reference [TrimmableTypeMap] Trimmable typemap test exclusions inventory #11170
• Reference [TrimmableTypeMap] Enable deferred Export device coverage for JCW-only shapes #11289

Rebase validation (2026-05-05)

Rebased onto current main and resolved the test-project trimmable root conflict. Additional rebase fallout fixed in 16382c25d:

• Use InvokerActivationCtorStyle when generating interface invoker activation so Java.Interop-style invokers use the by-ref JniObjectReference constructor path.
• Retarget the export UCO exception-region test to an actual [Export] wrapper and assert the catch/finally wrapper shape emitted by export dispatch.

Validation after the rebase:

• git diff --check
• make prepare CONFIGURATION=Release
• ./bin/Release/dotnet/dotnet test tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests.csproj -v minimal --no-restore — 476 passed
• ./bin/Release/dotnet/dotnet test tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests.csproj -c Release -v minimal --no-restore — 27 passed
• make all CONFIGURATION=Release
• MSBUILDDISABLENODEREUSE=1 ANDROID_SERIAL=emulator-5554 ./dotnet-local.sh build -t:RunTestApp tests/Mono.Android-Tests/Mono.Android-Tests/Mono.Android.NET-Tests.csproj -c Release -p:_AndroidTypeMapImplementation=trimmable -p:UseMonoRuntime=false -p:AdbTarget="-s emulator-5554" -nr:false — Passed: 878, Failed: 0, Skipped: 56, Total: 934. Confirmed ExportTests and the activated direct throwable subclass tests executed successfully.

Rebase + follow-ups (current branch)

The branch has been rebased onto current main (replacing the merge-driven catch-up commits). The NUnitInstrumentation.cs rebase conflict in tests/Mono.Android-Tests/Mono.Android-Tests/Xamarin.Android.RuntimeTests/ was resolved by taking main's 4-entry exclusion list verbatim; no new trimmable test exclusions are introduced (#11270 and #11271, now in main, fix the JavaProxyObject / JavaProxyThrowable / JNI-method-replacement tests that this PR had previously excluded).

Six follow-up commits address production-readiness gaps identified after the rebase:

1. Surface diagnostic for silent user-ctor fallback in trimmable typemap — adds CtorFallbackReason on JavaConstructorInfo plus ITrimmableTypeMapLogger.LogUserCtorFallbackInfo, so silent fallback from a registered Java ctor to the legacy (IntPtr, JniHandleOwnership) activation path is visible in MSBuild -bl output. No new logger dependency inside the scanner.
2. Scanner regression tests for HasMatchingManagedCtor + CtorFallbackReason — guards the RunnableImplementor-style activation-ctor fallback fixed earlier in this PR.
3. Phase D integration: [Export] on a [Register]'d interface implementor — adds two scanner integration cases (onClick and renamed-JNI-name variant on an IOnClickListener impl).
4. Build-task coverage: Build_WithExportAndExportField_GeneratesJcwAndTypeMap end-to-end test, Build_WithExport_ProducesNoTrimWarningsTargetingExportCodegen trim-warning baseline, and TrimmableTypeMap_ExcludedTestNames_DoesNotGrow tripwire guarding the exclusion count from creeping up.
5. Device tests for nested + re-entrant exception routing — adds Export_Method_Throws_FollowedBySecondCall_DoesNotLeakPendingException and Export_Method_NestedJniCall_PreservesExceptionFromInnerExport to Group B of ExportTests.
6. Release notes — Documentation/release-notes/11123-trimmable-typemap-export-attribute.md documents [Export] / [ExportField] support, the Mono.Android.Export exclusion, user-visible ctor invocation, and the new exception-routing behaviour.

Host validation (current commits)

• ./bin/Release/dotnet/dotnet test tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests.csproj -c Release — 508 passed (was 476; +5 ctor scanner tests in this PR's follow-ups, plus +27 from earlier PR commits).
• ./bin/Release/dotnet/dotnet test tests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests/Microsoft.Android.Sdk.TrimmableTypeMap.IntegrationTests.csproj -c Release — 29 passed (was 27; +2 Phase D cases).
• ./bin/Release/dotnet/dotnet test src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Xamarin.Android.Build.Tests.csproj -c Release --filter "FullyQualifiedName~TrimmableTypeMap_ExcludedTestNames" — passed (the exclusion-growth tripwire).

Device validation

Device validation for the new commits is delegated to CI (the local rebuild was blocked by a pre-existing BG4304 XPath / path-separator issue in src/Mono.Android/metadata that is unrelated to this PR and also reproduces on origin/main). The Group B device tests in ExportTests exercise the existing exception-routing wrapper plus the two new re-entrancy cases; the [Export]-bearing fixtures used today (ExportPrimitives, ExportThrowing) gain a new ExportReentrant peer.

[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.

[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

[simonrozsival]

@copilot resolve the merge conflicts in this pull request

[Copilot]

@copilot resolve the merge conflicts in this pull request

Resolved in a730499. Three files had conflicts:

• TypeMapAssemblyEmitter.cs: kept ExportMethodDispatchEmitter field from our branch alongside the new array-handling fields (_rankAnchorHandles, _typeMapAttr3ArgCtorRefByAnchor, _typeMapAttrOpenRef) from main's [TrimmableTypeMap] Improve array handling #11238.
• FixtureTestBase.cs: took main's refactored ILContainsOpcodeToken helper (single shared method replacing the duplicate inline byte-scanning in ILContainsCallToken and ILContainsNewobjToken).
• NUnitInstrumentation.cs: removed stale test exclusions that main's [TrimmableTypeMap] Improve array handling #11238 and [TrimmableTypeMap] Reject open generic JNI construction #11273 already fixed (CannotCreateGenericHolderFromJava, GetType, DisposeAccessesThis, JavaCast_*, NewOpenGenericTypeThrows); updated comments to match main's approved text.

500 unit tests + 27 integration tests pass after the merge.