[TrimmableTypeMap] Implement reflection-free TrimmableTypeMapValueManager and TrimmableTypeMapTypeManager

[simonrozsival]

Goal

Integrate the Java.Interop value-manager/type-manager split into dotnet/android while keeping the trimmable typemap runtime path reflection-free, AOT-friendly, and covered by targeted tests.

This PR is about making Android use the new Java.Interop abstractions safely across MonoVM, CoreCLR, trimmable CoreCLR, and NativeAOT. NativeAOT now defaults to the trimmable typemap path; unsupported non-trimmable NativeAOT manager paths are intentionally rejected instead of silently falling back to reflection-backed code.

Contributes significantly to #10794
Contributes significantly to #11012
Contributes to #8724

Change map

Approximate size assigns each changed file to one primary row; the row totals sum to the full PR diff.

Area	Approx. size	Additions are for	Removals are for
Runtime manager selection	+88 -114	JNIEnvInit now selects managers by feature switch: Mono uses existing Android managers, CoreCLR non-trimmable uses CoreClrJavaMarshalValueManager, trimmable uses generated typemap managers, NativeAOT requires trimmable.	Removes the old “maybe use managed typemap / NativeAOT fallback” paths. The PR wants unsupported combinations to fail clearly instead of silently using reflection-backed managers.
Value managers	+621 -435	Adds TrimmableTypeMapValueManager for reflection-free peer creation, value conversion, primitive arrays, opaque object proxying, and local-reference argument creation. Adds CoreClrJavaMarshalValueManager for the reflection-backed CoreCLR path.	Deletes AndroidReflectionJniValueManager and SimpleValueManager. Splits the old monolithic JavaMarshalValueManager into JavaMarshalRegisteredPeers plus the new concrete managers.
Peer registration / GC bridge	+48 -213	JavaMarshalRegisteredPeers keeps the peer table and CoreCLR GC bridge behavior shared between CoreCLR and trimmable managers.	Removes duplicated peer-registration code from the old value manager shape.
Trimmable type manager	+357 -237	TrimmableTypeMapTypeManager now handles built-ins, nullable primitive wrappers, arrays, remapping, generated proxy lookup, and NativeAOT-safe array metadata.	Removes reflection fallback/invoker lookup paths from the trimmable path. Unsupported APIs now throw because generated metadata should cover them.
Java conversion helpers	+202 -113	JavaConvert gains nullable primitive conversions, AOT-safe collection/dictionary factories, JniObjectReference ownership handling, and “known value to local JNI handle” conversion.	Removes trimmable-path MakeGenericType() usage and dependency on Java.Interop value marshalers for cases the generated runtime can handle directly.
Primitive and object arrays	+272 -46	Adds PrimitiveArrayInfo, generated JavaArrayProxy metadata, JNIEnv.ArrayCreateInstance() typemap lookup, and CreateManagedArray() emitted with direct newarr. This avoids Array.CreateInstance()/MakeArrayType() where NativeAOT can’t support it.	Removes assumptions that dynamic array construction is always available. CoreCLR can still use dynamic creation; NativeAOT must use generated proxies.
Generated typemap model	+725 -79	Adds TypeMapAssociation, reverse managed-type/proxy mappings, alias-holder support, per-rank __ArrayMapRankN maps, primitive array proxies, and deterministic PE/MVID hashing.	Removes older ad hoc proxy preservation and timestamp-based “up to date” generated-DLL skipping that could leave stale typemap assemblies.
Scanner	+383 -87	Adds assembly-path-aware AssemblyInput, exported-type tracking, inherited generic base substitution, framework generic peer filtering, and XA4256 warnings for Java peers skipped because stale binding metadata references missing types.	Removes the behavior of blindly rooting unresolvable peers into the typemap, which could make NativeAOT fail on unused stale package metadata.
Build targets	+35 -60	Keeps one pre-trim GenerateTrimmableTypeMap pass, feeds generated typemap DLLs to ILLink, packages linked/R2R typemap DLLs, tracks a typemap stamp, deletes stale generated Java sources, and disables ManagedPeer native registration for trimmable apps.	Removes the second post-ILLink GenerateTrimmableTypeMap pass, typemap/linked-java, JavaSourceInputDirectory, GenerateTypeMapAssemblies=false, CleanJavaSourceOutputDirectory, and XA4254/XA4255.
NativeAOT defaults	+3 -3	NativeAOT now defaults _AndroidTypeMapImplementation to trimmable; JreRuntime delegates value-manager creation to Android runtime wiring.	Removes the non-trimmable NativeAOT managed typemap/value-manager fallback.
Runtime Java artifacts	+1 -1	The trimmable runtime jar excludes Java.Interop ManagedPeer.java; trimmable apps use generated registration/proxy paths instead.	Removes ManagedPeer runtime support from the trimmable Java artifact to match disabled ManagedPeer native registration.
Docs/resources	+42 -79	Adds XA4256 docs/resources for skipped unresolvable peers.	Removes XA4254/XA4255 docs/resources because those only existed for the deleted post-trim Java-copy path.
Attributes/API compatibility	+4 -11	Removes unproven trim annotations from [Export]/[ExportField] and updates API-compat baselines/exclusions accordingly.	Removes broad DAM/suppression noise where the code now either has explicit Requires* annotations or uses generated trimmable code.
Tests and baselines	+765 -270	Adds/updates tests for manager wiring, stale Java cleanup, deterministic typemap generation, array proxies, generic/inherited callback metadata, Export/ExportField codegen, runtime collection/array marshaling, and trimmable category exclusions.	Removes name-based trimmable test exclusions in favor of categories, drops assertions for warnings that no longer exist, and updates APK size baselines for changed runtime/generator output.

The main deletion theme is: remove reflection/post-trim/legacy fallback scaffolding once the generated trimmable typemap becomes the source of truth. The main addition theme is: generate enough metadata and runtime helpers so CoreCLR and especially NativeAOT can marshal peers, arrays, collections, exceptions, and callbacks without falling back to reflection.

Current design notes

Java.Interop integration

• Updates external/Java.Interop to the branch that exposes the minimal object-reference hook needed by JavaObjectArray<T>.SetElementAt():
  • CreateLocalObjectReferenceArgument(Type type, object? value) returns an owned local JniObjectReference; callers dispose the returned reference.
• The trimmable Android value manager implements direct local-reference creation and intentionally does not implement GetValueMarshaler*(); those APIs should not be called on the generated trimmable path.
• Reflection-backed Java.Interop behavior remains a Java.Interop implementation detail for non-trimmable/reflection manager paths.

Runtime manager wiring

• JNIEnvInit.CreateTypeManager():
  • trimmable: TrimmableTypeMapTypeManager
  • MonoVM/CoreCLR non-trimmable: Android reflection type manager
  • NativeAOT without trimmable typemap: unsupported
• JNIEnvInit.CreateValueManager():
  • trimmable: TrimmableTypeMapValueManager
  • MonoVM non-trimmable: existing Android value manager
  • CoreCLR non-trimmable: CoreClrJavaMarshalValueManager
  • NativeAOT without trimmable typemap: unsupported
• Runtime feature switches now carry FeatureGuard annotations where they gate reflection/dynamic-code paths, so trim analysis can understand dead branches.

Trimmable typemap runtime path

• TrimmableTypeMapTypeManager resolves managed ↔ JNI signatures from generated typemap data plus built-in mappings for primitives, nullable primitive wrappers, strings, primitive arrays, and Java array wrappers.
• TrimmableTypeMapValueManager creates peers through generated JavaPeerProxy metadata and handles:
  • existing peer lookup/registration,
  • generated activation,
  • primitive arrays and Java arrays,
  • nullable primitives and strings,
  • opaque managed objects through TrimmableJavaProxyObject, including generated Java overrides for equals, hashCode, and toString,
  • Java proxy throwable unwrapping.
• ManagedPeer native registration is disabled for trimmable apps; the trimmable path relies on generated JCWs and generated native-registration replacements.

Array proxy shape

The trimmable typemap array path generates one JavaArrayProxy type per JNI element name and supported rank. Array entries are stored in rank-scoped typemap groups instead of encoding rank into the JNI key.

Conceptually:

[assembly: TypeMap<__ArrayMapRank1>(
    "android/net/Network",
    typeof(Android_Net_Network_ArrayProxy1),
    typeof(Android_Net_Network_ArrayProxy1))]

[assembly: TypeMapAssociation<__ArrayMapRank1>(
    typeof(Network[]),
    typeof(Android_Net_Network_ArrayProxy1))]

[assembly: TypeMapAssociation<__ArrayMapRank1>(
    typeof(JavaArray<Network>),
    typeof(Android_Net_Network_ArrayProxy1))]

[assembly: TypeMapAssociation<__ArrayMapRank1>(
    typeof(JavaObjectArray<Network>),
    typeof(Android_Net_Network_ArrayProxy1))]

Each generated array proxy is self-applied as a JavaArrayProxy attribute and provides:

• CreateManagedArray(int length), emitted with direct newarr IL for the requested rank.
• GetArrayTypes(), emitted with direct ldtoken entries for every managed representation that should resolve to the same JNI array shape.

At runtime:

• JNIEnv.ArrayCreateInstance() uses generated array proxies on NativeAOT and dynamic Array.CreateInstance() on CoreCLR.
• TrimmableTypeMapTypeManager.GetTypes() uses the same generated array proxy metadata on NativeAOT and dynamic generic/array construction on CoreCLR.
• Primitive array proxies are emitted once from the Java.Interop typemap assembly so shared-universe builds do not duplicate rank-map association source keys.

Normal peer proxy lookup

Normal JNI → managed entries remain in the default typemap universe, and managed-type → generated-proxy lookup uses TypeMapAssociation data. After review/bug fixes, this PR does not use the older __managed_type: reverse-key scheme; that path was removed and proxy associations were restored because the runtime proxy map is populated from TypeMapAssociationAttribute.

Alias groups still use alias holders when multiple managed types share one JNI name. Array proxy associations are scoped to the matching __ArrayMapRankN group so array-only preservation does not pollute the normal Object universe.

Build pipeline

• The trimmable typemap is generated once before trimming.
• Generated typemap assemblies are passed to ILLink as trimmable typemap assemblies.
• Linked/R2R typemap assemblies are added back into the publish pipeline for single-RID CoreCLR builds.
• Stale generated Java sources and their copied android/src counterparts are deleted when _GenerateTrimmableTypeMap reruns.
• Generated typemap assemblies use content-based writes and deterministic PE/MVID hashing so generator option changes do not leave stale DLLs behind and incremental builds are stable.

Scanner and diagnostics

• The scanner now keeps assembly paths and exported type names, substitutes inherited generic base type references, and skips unsupported framework generic peer definitions while preserving supported collection wrappers.
• Java peer types whose base/interface metadata references a missing type in the resolved assembly set are skipped with XA4256 instead of being rooted into the generated typemap. This makes stale binding package metadata actionable without breaking NativeAOT for unused types.
• XA4254/XA4255 were removed because they only supported the deleted post-trim Java-source copy path.

Review notes / intentional non-goals

• Full ManagedPeer removal is not part of this PR. This PR disables ManagedPeer native registration for trimmable apps and excludes ManagedPeer.java from the trimmable runtime jar.
• The trimmable path intentionally does not support Java.Interop value-marshaler APIs; generated managers and direct local-reference creation are the supported paths.
• Non-trimmable NativeAOT is not broadened here. NativeAOT defaults to and requires the trimmable typemap path.
• The built-in Type → JniTypeSignature mapping intentionally keeps Type.GetTypeCode plus explicit nullable typeof(...) checks. Nullable.GetUnderlyingType() allocates and is avoided on this path.

Test strategy

This PR adds/updates coverage in these areas:

• Host generator/scanner tests for deterministic output, array proxy/rank maps, alias/proxy associations, inherited generic base metadata, Export/ExportField codegen, and XA4251/XA4256 behavior.
• Build tests for trimmable runtimeconfig switches, stale generated Java cleanup, generated-Java copy incrementality, single-RID linked/R2R typemap packaging, NativeAOT defaults, and API/package baselines.
• Device/runtime tests for trimmable Java-to-managed callbacks, object/primitive/string marshaling, Java collection wrappers, object arrays, native object arrays, activation/dispose behavior, and category-based trimmable exclusions.

Local validation performed during the PR

Representative local validation from this branch includes:

dotnet build external/Java.Interop/src/Java.Interop/Java.Interop.csproj \
  -p:Configuration=Debug \
  -m:1 \
  -nodeReuse:false \
  --no-restore \
  -v:minimal

dotnet test tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests.csproj \
  -v minimal \
  --no-restore

./dotnet-local.sh build --disable-build-servers src/Xamarin.Android.Build.Tasks/Xamarin.Android.Build.Tasks.csproj -c Release --no-restore
./dotnet-local.sh build --disable-build-servers src/java-runtime/java-runtime.csproj -c Release --no-restore
./dotnet-local.sh build --disable-build-servers src/Mono.Android/Mono.Android.csproj -c Release --no-restore

./dotnet-local.sh test tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests.csproj \
  -c Release --no-restore \
  --filter 'FullyQualifiedName~ModelBuilderTests|FullyQualifiedName~TypeMapAssemblyGeneratorTests|FullyQualifiedName~RootTypeMapAssemblyGeneratorTests|FullyQualifiedName~TrimmableTypeMapGeneratorTests'

./dotnet-local.sh build tests/Mono.Android-Tests/Mono.Android-Tests/Mono.Android.NET-Tests.csproj \
  -c Release -p:_AndroidTypeMapImplementation=trimmable -p:UseMonoRuntime=false --no-restore

Additional manual validation during the array-proxy work:

• Verified mono.android.jar contains net/dot/jni/internal/TrimmableJavaProxyObject.class.
• Verified java_runtime_trimmable.jar does not contain duplicate Java proxy classes after cleaning stale intermediates.
• Ran a NativeAOT HelloWorld sample that calls ConnectivityManager.GetAllNetworks(); the generated Android_Net_Network_ArrayProxy1 path successfully allocated and marshaled Network[] and used the returned Network instance.

[simonrozsival]

/azp run

[azure-pipelines]

Azure Pipelines successfully started running 1 pipeline(s).

[simonrozsival]

Rebased onto #11622 (external/Java.Interop d7dbad5) and revalidated targeted Mono.Android build locally.\n\n/azp run

[simonrozsival]

/azp run

[azure-pipelines]

Azure Pipelines will not run the associated pipelines, because the pull request was updated after the run command was issued. Review the pull request again and issue a new run command.

[simonrozsival]

/azp run

[azure-pipelines]

Azure Pipelines will not run the associated pipelines, because the pull request was updated after the run command was issued. Review the pull request again and issue a new run command.

[simonrozsival]

/azp run

[azure-pipelines]

Azure Pipelines will not run the associated pipelines, because the pull request was updated after the run command was issued. Review the pull request again and issue a new run command.

[simonrozsival]

/azp run

[azure-pipelines]

Azure Pipelines will not run the associated pipelines, because the pull request was updated after the run command was issued. Review the pull request again and issue a new run command.

[simonrozsival]

/azp run

[azure-pipelines]

Azure Pipelines will not run the associated pipelines, because the pull request was updated after the run command was issued. Review the pull request again and issue a new run command.