[TrimmableTypeMap] Keep user AndroidJavaSource Java under R8 shrinking by simonrozsival · Pull Request #11798 · dotnet/android

simonrozsival · 2026-06-29T07:59:00Z

Problem

When R8 code shrinking is enabled, R8 removes any Java type that nothing keeps. .NET for Android keeps the Java callable wrappers (JCWs) of bound managed types by generating -keep rules from the acw-map (managed peer ↔ Java type). That works for generated JCWs, but user-authored AndroidJavaSource.java files marked Bind != true have no managed peer, so they never appear in the acw-map — and therefore get no keep rule. With shrinking on, R8 silently deletes them, and the app fails at runtime when it references those classes (often as a NoClassDefFoundError that only reproduces in Release/shrunk builds).

Fix

Pass user AndroidJavaSource (Bind != True) to the R8 task and emit -keep class <package>.<Type> { *; } for each, so user Java survives shrinking:

D8.targets — collect @(AndroidJavaSource) items where %(Bind) != 'True' into _R8KeepJavaSource and pass them to R8 via the new JavaSourceFiles property.
R8.cs — append keep rules in the same block that emits acw-map keeps. GetUserJavaTypes() derives the fully-qualified name as <package>.<FileNameWithoutExtension> (Java requires the public top-level type name to match the file name); ReadJavaPackage() parses the package declaration, skipping comments and stopping at the first import/type declaration. Names are de-duplicated.
R8Tests.cs — unit tests covering ReadJavaPackage: package present, trailing space before ;, comment headers, no package, and package after import/type (ignored).

Why split out

This is being carved out of the trimmable typemap mega-PR #11617. Although the bug surfaced while bringing up the NativeAOT trimmable path, it is not trimmable-specific — the acw-map keep logic and R8 shrinking apply equally to legacy/MonoVM and CoreCLR, so user AndroidJavaSource was at risk of being shrunk there too. Landing it independently de-risks #11617 and ships a general correctness fix sooner.

Context / related PRs

[TrimmableTypeMap] Implement reflection-free TrimmableTypeMapValueManager and TrimmableTypeMapTypeManager #11617 — parent mega-PR (reflection-free trimmable typemap) this is sliced from.
[NativeAOT] Remove managed NativeAOT type map in favor of the trimmable type map #11643 — removes the managed NativeAOT typemap in favor of the trimmable one (the path that exposed this gap).
Sibling slices already split out off main: [TrimmableTypeMap] Honor AndroidApplicationJavaClass for the JCW base and manifest #11794 (AndroidApplicationJavaClass/multidex), [TrimmableTypeMap] Complete trimmable manifest generation parity #11796 (manifest generation parity). Other merged groundwork: [TrimmableTypeMap] Fix inherited generic base typemap refs #11749, [TrimmableTypeMap] Skip unresolvable trimmable typemap peers #11751, [TrimmableTypeMap] Fix trimmable manifest generation parity #11752, [TrimmableTypeMap] Add trimmable array proxy mapping #11753, [TrimmableTypeMap] Improve trimmable typemap build incrementality #11764, [TrimmableTypeMap] Use non-generic JavaPeerProxy base for interface proxies (NativeAOT) #11769.

Verification

24/24 R8 unit tests pass (18 existing + 6 new). BuildAfterMultiDexIsNotRequired verified locally on NativeAOT and CoreCLR — user Java is retained after shrinking.

The trimmable NativeAOT path enables R8 with shrinking (AndroidLinkTool=r8 -> _R8EnableShrinking=True). When the application ProGuard config is generated from the acw-map (the default, UseTrimmableNativeAotProguardConfiguration=false), the R8 task only emits -keep rules for managed-mapped Java types. User-authored AndroidJavaSource (Bind != true) has no managed peer and is therefore absent from the acw-map, so R8 shrank it away. This made BuildAfterMultiDexIsNotRequired fail on NativeAOT: the huge ManyMethods.java classes were removed, so multidex was no longer required and classes2.dex was never produced. Pass the user AndroidJavaSource (.java with Bind != true) to the R8 task and emit '-keep class <package>.<Type> { *; }' for each, so user Java survives shrinking. The type name is '<package>.<FileNameWithoutExtension>' (Java requires the public top-level type name to match the file name). Verified locally: BuildAfterMultiDexIsNotRequired(NativeAOT) and (CoreCLR) pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Cover package detection: present, trailing space, comment headers, no package, and package-after-import/type (ignored). Exposes ReadJavaPackage as internal for direct testing, matching the TryGetDisallowedOption pattern. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

Fixes R8 shrinking removing user-authored AndroidJavaSource.java files (those without a managed peer / absent from acw-map) by deriving their Java FQNs and emitting -keep class … { *; } rules when shrinking is enabled.

Changes:

Passes @(AndroidJavaSource) items with Bind != True to the R8 MSBuild task via a new JavaSourceFiles input.
Adds R8.GetUserJavaTypes() + R8.ReadJavaPackage() to derive the fully-qualified class names from .java sources and append -keep rules.
Adds unit tests for ReadJavaPackage parsing behavior across several common source layouts.

Show a summary per file

File	Description
src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets	Collects non-binding `AndroidJavaSource` items and forwards them to `R8` as `JavaSourceFiles`.
src/Xamarin.Android.Build.Tasks/Tasks/R8.cs	Adds Java package parsing + FQN derivation and appends `-keep` rules to the generated R8 app config.
src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/R8Tests.cs	Adds test coverage for `ReadJavaPackage()` parsing rules.

Copilot's findings

Files reviewed: 3/3 changed files
Comments generated: 2

* R8Tests: expected parameter is string? (TestCase passes null). * R8: comment that only the public top-level type is kept, and that ReadJavaPackage is a lightweight scan (package precedes types in practice). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

simonrozsival · 2026-06-29T11:08:57Z

/review

jonathanpeppers · 2026-06-29T13:26:18Z

+ <!-- User-authored AndroidJavaSource (Bind != True) is not in the acw-map; pass it to R8 so it
+ is kept when shrinking is enabled rather than silently removed. -->
+ <_R8KeepJavaSource Include="@(AndroidJavaSource)" Condition=" '%(AndroidJavaSource.Bind)' != 'True' " />


There is not an easy way to turn this off if you don't want it, but I can't think of a case you would need to do that.

…TypeManagers (#11799) ## Summary Bumps **external/Java.Interop** and aligns Mono.Android's reflection-based type and value managers with the new base-class contracts. The Java.Interop bump relaxes the `[DynamicallyAccessedMembers]` (DAM) requirements on the virtual members of `JniRuntime.ReflectionJniTypeManager` / `JniRuntime.ReflectionJniValueManager`, so the Mono.Android overrides no longer need to repeat those annotations and instead rely on targeted trimmer/AOT suppressions. This is a standalone slice of #11617 with no dependency on the trimmable type-map scanner/emitter or array codegen work. ## Changes - `external/Java.Interop` → `8d544738a` (from `70493645c`). - Drop now-redundant `[DynamicallyAccessedMembers]` annotations from the overrides in `AndroidTypeManager`, `ManagedTypeManager`, and `TrimmableTypeMapTypeManager` (`GetInvokerTypeCore`, `GetTypeForSimpleReference`, `RegisterNativeMembers`, `ActivatePeer`), replacing them with `[UnconditionalSuppressMessage]` where the trimmer still needs reassurance. - `JavaMarshalValueManager` now extends `JniRuntime.ReflectionJniValueManager` directly. It is marked `sealed` and carries `[RequiresDynamicCode]` / `[RequiresUnreferencedCode]`, uses the base `EnsureNotDisposed ()` helper, and drops its own dispose tracking and `ActivatePeer` override. - Remove the superseded `AndroidReflectionJniValueManager` and `SimpleValueManager` (and their `Mono.Android.csproj` entries). - `JNIEnvInit.CreateValueManager` creates the value manager through a local helper with the appropriate trimming/AOT suppressions for both the CoreCLR and NativeAOT paths. - No NativeAOT default change; the trimmable type/value managers are **not** part of this PR. ## Tests / baselines - Update the API-compatibility baseline: `Android.Graphics.ColorValueMarshaler.CreateGenericValue`'s `targetType` parameter no longer carries a DAM attribute (inherited from the Java.Interop base-class change). - Refresh `SimpleDotNet` CoreCLR/NativeAOT apkdesc size baselines and the NativeAOT `BuildHasNoWarnings` count, plus `BuildTest2`. ## Context Carved out of #11617. `JavaMarshalRegisteredPeers` extraction already merged via #11750. The trimmable managers, scanner/emitter, manifest, and R8 changes ship in their own PRs (#11749/#11751/#11753/#11769/#11794/#11796/#11798). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…11801) ## Summary This PR adds the two runtime managers that make the **trimmable typemap** a fully functional, reflection-free peer-resolution path: - **`TrimmableTypeMapValueManager`** — creates and tracks Java↔managed peers without reflection or `Activator`. - **`TrimmableTypeMapTypeManager`** — resolves managed↔Java type mappings by delegating to the generated `TrimmableTypeMap`. Both are selected through the existing `RuntimeFeature.TrimmableTypeMap` switch and wired into `JNIEnvInit`. The trimmable path is **opt-in**; the NativeAOT default remains `managed`, and Mono/CoreCLR defaults are unchanged. Also included is the `JavaConvert` collection-factory refactor and a generator fix that the trimmable managers depend on. ## Background The classic Java.Interop runtime resolves the managed `Type` for a Java instance (and vice-versa) using `Type.GetType`, `MakeGenericType`, and `Activator`-style construction. That is incompatible with trimming and NativeAOT: the trimmer can't see which types are reachable, and the types can't be created at runtime under AOT. The **trimmable typemap** replaces those reflection calls with a build-time-generated map of `JavaPeerProxy` objects (produced by `Microsoft.Android.Sdk.TrimmableTypeMap`). Each proxy knows how to construct a specific peer and describes its JNI ↔ managed association statically. Earlier PRs landed the generator, the proxy shapes (array / generic-base / interface / unresolvable peers), and the CoreCLR `JavaMarshal` value-manager split. **This PR adds the runtime managers that consume that generated map.** ## What's in this PR ### 1. `TrimmableTypeMapValueManager` (new) A `JniRuntime.JniValueManager` that performs peer creation with **no reflection**: - **Peer lifetime** (`AddPeer` / `PeekPeer` / `RemovePeer` / `FinalizePeer` / `CollectPeers` / `GetSurfacedPeers`) is delegated to `JavaMarshalRegisteredPeers`, i.e. the CoreCLR `JavaMarshal` GC-bridge machinery. `WaitForGCBridgeProcessing` is intentionally a no-op (documented: the wait can't close the bridge race on CoreCLR, where JNI wrapper threads hold their own `JniObjectReference` copies). - **`CreatePeer`** resolves the requested target type (mapping `object`/`IJavaPeerable` → `Java.Interop.JavaObject`, `Exception` → `JavaException`) and asks `TrimmableTypeMap.Instance.CreateInstance (handle, resolvedType)` to build the peer from a generated proxy. - **`ActivatePeer`** throws `PlatformNotSupportedException` — reflection-based activation is not part of this path. - **`NotFoundFallback`** carefully reproduces the base `JniValueManager.CreatePeer` contract so `JavaCast`/`JavaAs` still surface the correct outcome when no proxy is found: - target type has no Java mapping → `ArgumentException` - Java instance not assignable to the target's Java class → `null` (so `JavaAs` returns null / `JavaCast` throws `InvalidCastException`) - compatible classes but no proxy → `NotSupportedException` (a genuine generator gap, with a message pointing at the missing proxy) The assignability check honors `RuntimeFeature.IsAssignableFromCheck` and mirrors the legacy cast diagnostic when assembly logging is enabled. ### 2. `TrimmableTypeMapTypeManager` (new) A `JniRuntime.JniTypeManager` that has exactly two live responsibilities and throws for everything else it doesn't need: - **Managed → Java** via `GetTypeSignatureCore`, backed by a `ConcurrentDictionary<Type, JniTypeSignature>` cache. - **Java → managed** via `GetTypes` / `GetTypeForSimpleReference`, delegating to `TrimmableTypeMap`. - **Array handling** diverges by runtime: NativeAOT reads a pre-generated array-proxy map (types can't be built at runtime), while CoreCLR builds array/generic types dynamically to save app size (suppressions are scoped to the CoreCLR-only branch). ### 3. `JNIEnvInit` wiring `CreateValueManager` / `CreateTypeManager` now return the trimmable managers when `RuntimeFeature.TrimmableTypeMap` is set. The existing Mono / CoreCLR / managed selection is preserved, and the manager constructions were refactored into small local helpers so trimming suppressions (`IL2026` / `IL3050`) apply only to the exact branch that needs them. `RegisterJniNatives` is likewise gated so the reflection-based JNI registration path isn't emitted for the trimmable typemap. ### 4. `JavaConvert` collection-factory refactor Generic collection marshalling (`IDictionary<,>` → `JavaDictionary<,>`, `IList<>` → `JavaList<>`, `ICollection<>` → `JavaCollection<>`) is split into two branches: a **factory-based converter** on the trimmable path (no `MakeGenericType`) and the classic `MakeGenericType` path elsewhere, with the reflection-requiring code isolated behind narrowly-scoped suppressions. Also adds `Nullable<T>` converter handling (null reference → null value). ### 5. Generator fix (`ModelBuilder`) Emits a managed→Java typemap entry for **self-peer types** (`[JniTypeSignature(GenerateJavaPeer=false)]` or MCW bindings with no activation ctor). These are constructed managed-side with `new`, but their JNI name must still resolve so the correct Java class is instantiated; without the association they fell back to the generic `mono.android.runtime.JavaObject` peer and threw `ArrayStoreException` when placed into a typed Java array. ### 6. Cleanup Removes the dead `TrimmableTypeMap` branch from `JavaMarshalValueManager` (that logic now lives in the dedicated `TrimmableTypeMapValueManager`). ## Behavioral impact - **Opt-in only.** With `RuntimeFeature.TrimmableTypeMap` unset, behavior is unchanged. NativeAOT still defaults to `managed`. - No new user-facing / localized strings; error messages point at the generator when a proxy is genuinely missing. ## Status All earlier prerequisites have **merged into `main`**, and this PR is **rebased on latest `main`**, so it is no longer stacked or blocked — it contains only the value/type-manager implementations (plus the supporting `JavaConvert` and generator changes) on top of them: - #11799 — CoreCLR `JavaMarshal` split + Java.Interop bump - #11753 array proxies · #11749 generic base · #11751 unresolvable peers · #11769 interface proxies - #11794 multidex/manifest base · #11796 manifest parity · #11798 R8 keep ## Testing - `TrimmableTypeMapTypeManagerTests` and `TypeMapModelBuilderTests` updated/extended for the new type resolution and the self-peer generator fix. - Export tests enabled for the trimmable typemap; `TrimmableTypeMapUnsupported` cases excluded. - NativeAOT warning-count and CoreCLR `apkdesc` baselines updated to match.

simonrozsival · 2026-06-29T07:59:00Z

Problem

When R8 code shrinking is enabled, R8 removes any Java type that nothing keeps. .NET for Android keeps the Java callable wrappers (JCWs) of bound managed types by generating -keep rules from the acw-map (managed peer ↔ Java type). That works for generated JCWs, but user-authored AndroidJavaSource.java files marked Bind != true have no managed peer, so they never appear in the acw-map — and therefore get no keep rule. With shrinking on, R8 silently deletes them, and the app fails at runtime when it references those classes (often as a NoClassDefFoundError that only reproduces in Release/shrunk builds).

Fix

Pass user AndroidJavaSource (Bind != True) to the R8 task and emit -keep class <package>.<Type> { *; } for each, so user Java survives shrinking:

D8.targets — collect @(AndroidJavaSource) items where %(Bind) != 'True' into _R8KeepJavaSource and pass them to R8 via the new JavaSourceFiles property.
R8.cs — append keep rules in the same block that emits acw-map keeps. GetUserJavaTypes() derives the fully-qualified name as <package>.<FileNameWithoutExtension> (Java requires the public top-level type name to match the file name); ReadJavaPackage() parses the package declaration, skipping comments and stopping at the first import/type declaration. Names are de-duplicated.
R8Tests.cs — unit tests covering ReadJavaPackage: package present, trailing space before ;, comment headers, no package, and package after import/type (ignored).

Why split out

This is being carved out of the trimmable typemap mega-PR #11617. Although the bug surfaced while bringing up the NativeAOT trimmable path, it is not trimmable-specific — the acw-map keep logic and R8 shrinking apply equally to legacy/MonoVM and CoreCLR, so user AndroidJavaSource was at risk of being shrunk there too. Landing it independently de-risks #11617 and ships a general correctness fix sooner.

Context / related PRs

[TrimmableTypeMap] Implement reflection-free TrimmableTypeMapValueManager and TrimmableTypeMapTypeManager #11617 — parent mega-PR (reflection-free trimmable typemap) this is sliced from.
[NativeAOT] Remove managed NativeAOT type map in favor of the trimmable type map #11643 — removes the managed NativeAOT typemap in favor of the trimmable one (the path that exposed this gap).
Sibling slices already split out off main: [TrimmableTypeMap] Honor AndroidApplicationJavaClass for the JCW base and manifest #11794 (AndroidApplicationJavaClass/multidex), [TrimmableTypeMap] Complete trimmable manifest generation parity #11796 (manifest generation parity). Other merged groundwork: [TrimmableTypeMap] Fix inherited generic base typemap refs #11749, [TrimmableTypeMap] Skip unresolvable trimmable typemap peers #11751, [TrimmableTypeMap] Fix trimmable manifest generation parity #11752, [TrimmableTypeMap] Add trimmable array proxy mapping #11753, [TrimmableTypeMap] Improve trimmable typemap build incrementality #11764, [TrimmableTypeMap] Use non-generic JavaPeerProxy base for interface proxies (NativeAOT) #11769.

Verification

24/24 R8 unit tests pass (18 existing + 6 new). BuildAfterMultiDexIsNotRequired verified locally on NativeAOT and CoreCLR — user Java is retained after shrinking.

The trimmable NativeAOT path enables R8 with shrinking (AndroidLinkTool=r8 -> _R8EnableShrinking=True). When the application ProGuard config is generated from the acw-map (the default, UseTrimmableNativeAotProguardConfiguration=false), the R8 task only emits -keep rules for managed-mapped Java types. User-authored AndroidJavaSource (Bind != true) has no managed peer and is therefore absent from the acw-map, so R8 shrank it away. This made BuildAfterMultiDexIsNotRequired fail on NativeAOT: the huge ManyMethods.java classes were removed, so multidex was no longer required and classes2.dex was never produced. Pass the user AndroidJavaSource (.java with Bind != true) to the R8 task and emit '-keep class <package>.<Type> { *; }' for each, so user Java survives shrinking. The type name is '<package>.<FileNameWithoutExtension>' (Java requires the public top-level type name to match the file name). Verified locally: BuildAfterMultiDexIsNotRequired(NativeAOT) and (CoreCLR) pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Cover package detection: present, trailing space, comment headers, no package, and package-after-import/type (ignored). Exposes ReadJavaPackage as internal for direct testing, matching the TryGetDisallowedOption pattern. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

Fixes R8 shrinking removing user-authored AndroidJavaSource.java files (those without a managed peer / absent from acw-map) by deriving their Java FQNs and emitting -keep class … { *; } rules when shrinking is enabled.

Changes:

Passes @(AndroidJavaSource) items with Bind != True to the R8 MSBuild task via a new JavaSourceFiles input.
Adds R8.GetUserJavaTypes() + R8.ReadJavaPackage() to derive the fully-qualified class names from .java sources and append -keep rules.
Adds unit tests for ReadJavaPackage parsing behavior across several common source layouts.

Show a summary per file

File	Description
src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets	Collects non-binding `AndroidJavaSource` items and forwards them to `R8` as `JavaSourceFiles`.
src/Xamarin.Android.Build.Tasks/Tasks/R8.cs	Adds Java package parsing + FQN derivation and appends `-keep` rules to the generated R8 app config.
src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/R8Tests.cs	Adds test coverage for `ReadJavaPackage()` parsing rules.

Copilot's findings

Files reviewed: 3/3 changed files
Comments generated: 2

* R8Tests: expected parameter is string? (TestCase passes null). * R8: comment that only the public top-level type is kept, and that ReadJavaPackage is a lightweight scan (package precedes types in practice). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

simonrozsival · 2026-06-29T11:08:57Z

/review

jonathanpeppers · 2026-06-29T13:26:18Z

+ <!-- User-authored AndroidJavaSource (Bind != True) is not in the acw-map; pass it to R8 so it
+ is kept when shrinking is enabled rather than silently removed. -->
+ <_R8KeepJavaSource Include="@(AndroidJavaSource)" Condition=" '%(AndroidJavaSource.Bind)' != 'True' " />


There is not an easy way to turn this off if you don't want it, but I can't think of a case you would need to do that.

…TypeManagers (#11799) ## Summary Bumps **external/Java.Interop** and aligns Mono.Android's reflection-based type and value managers with the new base-class contracts. The Java.Interop bump relaxes the `[DynamicallyAccessedMembers]` (DAM) requirements on the virtual members of `JniRuntime.ReflectionJniTypeManager` / `JniRuntime.ReflectionJniValueManager`, so the Mono.Android overrides no longer need to repeat those annotations and instead rely on targeted trimmer/AOT suppressions. This is a standalone slice of #11617 with no dependency on the trimmable type-map scanner/emitter or array codegen work. ## Changes - `external/Java.Interop` → `8d544738a` (from `70493645c`). - Drop now-redundant `[DynamicallyAccessedMembers]` annotations from the overrides in `AndroidTypeManager`, `ManagedTypeManager`, and `TrimmableTypeMapTypeManager` (`GetInvokerTypeCore`, `GetTypeForSimpleReference`, `RegisterNativeMembers`, `ActivatePeer`), replacing them with `[UnconditionalSuppressMessage]` where the trimmer still needs reassurance. - `JavaMarshalValueManager` now extends `JniRuntime.ReflectionJniValueManager` directly. It is marked `sealed` and carries `[RequiresDynamicCode]` / `[RequiresUnreferencedCode]`, uses the base `EnsureNotDisposed ()` helper, and drops its own dispose tracking and `ActivatePeer` override. - Remove the superseded `AndroidReflectionJniValueManager` and `SimpleValueManager` (and their `Mono.Android.csproj` entries). - `JNIEnvInit.CreateValueManager` creates the value manager through a local helper with the appropriate trimming/AOT suppressions for both the CoreCLR and NativeAOT paths. - No NativeAOT default change; the trimmable type/value managers are **not** part of this PR. ## Tests / baselines - Update the API-compatibility baseline: `Android.Graphics.ColorValueMarshaler.CreateGenericValue`'s `targetType` parameter no longer carries a DAM attribute (inherited from the Java.Interop base-class change). - Refresh `SimpleDotNet` CoreCLR/NativeAOT apkdesc size baselines and the NativeAOT `BuildHasNoWarnings` count, plus `BuildTest2`. ## Context Carved out of #11617. `JavaMarshalRegisteredPeers` extraction already merged via #11750. The trimmable managers, scanner/emitter, manifest, and R8 changes ship in their own PRs (#11749/#11751/#11753/#11769/#11794/#11796/#11798). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…11801) ## Summary This PR adds the two runtime managers that make the **trimmable typemap** a fully functional, reflection-free peer-resolution path: - **`TrimmableTypeMapValueManager`** — creates and tracks Java↔managed peers without reflection or `Activator`. - **`TrimmableTypeMapTypeManager`** — resolves managed↔Java type mappings by delegating to the generated `TrimmableTypeMap`. Both are selected through the existing `RuntimeFeature.TrimmableTypeMap` switch and wired into `JNIEnvInit`. The trimmable path is **opt-in**; the NativeAOT default remains `managed`, and Mono/CoreCLR defaults are unchanged. Also included is the `JavaConvert` collection-factory refactor and a generator fix that the trimmable managers depend on. ## Background The classic Java.Interop runtime resolves the managed `Type` for a Java instance (and vice-versa) using `Type.GetType`, `MakeGenericType`, and `Activator`-style construction. That is incompatible with trimming and NativeAOT: the trimmer can't see which types are reachable, and the types can't be created at runtime under AOT. The **trimmable typemap** replaces those reflection calls with a build-time-generated map of `JavaPeerProxy` objects (produced by `Microsoft.Android.Sdk.TrimmableTypeMap`). Each proxy knows how to construct a specific peer and describes its JNI ↔ managed association statically. Earlier PRs landed the generator, the proxy shapes (array / generic-base / interface / unresolvable peers), and the CoreCLR `JavaMarshal` value-manager split. **This PR adds the runtime managers that consume that generated map.** ## What's in this PR ### 1. `TrimmableTypeMapValueManager` (new) A `JniRuntime.JniValueManager` that performs peer creation with **no reflection**: - **Peer lifetime** (`AddPeer` / `PeekPeer` / `RemovePeer` / `FinalizePeer` / `CollectPeers` / `GetSurfacedPeers`) is delegated to `JavaMarshalRegisteredPeers`, i.e. the CoreCLR `JavaMarshal` GC-bridge machinery. `WaitForGCBridgeProcessing` is intentionally a no-op (documented: the wait can't close the bridge race on CoreCLR, where JNI wrapper threads hold their own `JniObjectReference` copies). - **`CreatePeer`** resolves the requested target type (mapping `object`/`IJavaPeerable` → `Java.Interop.JavaObject`, `Exception` → `JavaException`) and asks `TrimmableTypeMap.Instance.CreateInstance (handle, resolvedType)` to build the peer from a generated proxy. - **`ActivatePeer`** throws `PlatformNotSupportedException` — reflection-based activation is not part of this path. - **`NotFoundFallback`** carefully reproduces the base `JniValueManager.CreatePeer` contract so `JavaCast`/`JavaAs` still surface the correct outcome when no proxy is found: - target type has no Java mapping → `ArgumentException` - Java instance not assignable to the target's Java class → `null` (so `JavaAs` returns null / `JavaCast` throws `InvalidCastException`) - compatible classes but no proxy → `NotSupportedException` (a genuine generator gap, with a message pointing at the missing proxy) The assignability check honors `RuntimeFeature.IsAssignableFromCheck` and mirrors the legacy cast diagnostic when assembly logging is enabled. ### 2. `TrimmableTypeMapTypeManager` (new) A `JniRuntime.JniTypeManager` that has exactly two live responsibilities and throws for everything else it doesn't need: - **Managed → Java** via `GetTypeSignatureCore`, backed by a `ConcurrentDictionary<Type, JniTypeSignature>` cache. - **Java → managed** via `GetTypes` / `GetTypeForSimpleReference`, delegating to `TrimmableTypeMap`. - **Array handling** diverges by runtime: NativeAOT reads a pre-generated array-proxy map (types can't be built at runtime), while CoreCLR builds array/generic types dynamically to save app size (suppressions are scoped to the CoreCLR-only branch). ### 3. `JNIEnvInit` wiring `CreateValueManager` / `CreateTypeManager` now return the trimmable managers when `RuntimeFeature.TrimmableTypeMap` is set. The existing Mono / CoreCLR / managed selection is preserved, and the manager constructions were refactored into small local helpers so trimming suppressions (`IL2026` / `IL3050`) apply only to the exact branch that needs them. `RegisterJniNatives` is likewise gated so the reflection-based JNI registration path isn't emitted for the trimmable typemap. ### 4. `JavaConvert` collection-factory refactor Generic collection marshalling (`IDictionary<,>` → `JavaDictionary<,>`, `IList<>` → `JavaList<>`, `ICollection<>` → `JavaCollection<>`) is split into two branches: a **factory-based converter** on the trimmable path (no `MakeGenericType`) and the classic `MakeGenericType` path elsewhere, with the reflection-requiring code isolated behind narrowly-scoped suppressions. Also adds `Nullable<T>` converter handling (null reference → null value). ### 5. Generator fix (`ModelBuilder`) Emits a managed→Java typemap entry for **self-peer types** (`[JniTypeSignature(GenerateJavaPeer=false)]` or MCW bindings with no activation ctor). These are constructed managed-side with `new`, but their JNI name must still resolve so the correct Java class is instantiated; without the association they fell back to the generic `mono.android.runtime.JavaObject` peer and threw `ArrayStoreException` when placed into a typed Java array. ### 6. Cleanup Removes the dead `TrimmableTypeMap` branch from `JavaMarshalValueManager` (that logic now lives in the dedicated `TrimmableTypeMapValueManager`). ## Behavioral impact - **Opt-in only.** With `RuntimeFeature.TrimmableTypeMap` unset, behavior is unchanged. NativeAOT still defaults to `managed`. - No new user-facing / localized strings; error messages point at the generator when a proxy is genuinely missing. ## Status All earlier prerequisites have **merged into `main`**, and this PR is **rebased on latest `main`**, so it is no longer stacked or blocked — it contains only the value/type-manager implementations (plus the supporting `JavaConvert` and generator changes) on top of them: - #11799 — CoreCLR `JavaMarshal` split + Java.Interop bump - #11753 array proxies · #11749 generic base · #11751 unresolvable peers · #11769 interface proxies - #11794 multidex/manifest base · #11796 manifest parity · #11798 R8 keep ## Testing - `TrimmableTypeMapTypeManagerTests` and `TypeMapModelBuilderTests` updated/extended for the new type resolution and the self-peer generator fix. - Export tests enabled for the trimmable typemap; `TrimmableTypeMapUnsupported` cases excluded. - NativeAOT warning-count and CoreCLR `apkdesc` baselines updated to match.

simonrozsival · 2026-06-29T07:59:00Z

Problem

When R8 code shrinking is enabled, R8 removes any Java type that nothing keeps. .NET for Android keeps the Java callable wrappers (JCWs) of bound managed types by generating -keep rules from the acw-map (managed peer ↔ Java type). That works for generated JCWs, but user-authored AndroidJavaSource.java files marked Bind != true have no managed peer, so they never appear in the acw-map — and therefore get no keep rule. With shrinking on, R8 silently deletes them, and the app fails at runtime when it references those classes (often as a NoClassDefFoundError that only reproduces in Release/shrunk builds).

Fix

Pass user AndroidJavaSource (Bind != True) to the R8 task and emit -keep class <package>.<Type> { *; } for each, so user Java survives shrinking:

D8.targets — collect @(AndroidJavaSource) items where %(Bind) != 'True' into _R8KeepJavaSource and pass them to R8 via the new JavaSourceFiles property.
R8.cs — append keep rules in the same block that emits acw-map keeps. GetUserJavaTypes() derives the fully-qualified name as <package>.<FileNameWithoutExtension> (Java requires the public top-level type name to match the file name); ReadJavaPackage() parses the package declaration, skipping comments and stopping at the first import/type declaration. Names are de-duplicated.
R8Tests.cs — unit tests covering ReadJavaPackage: package present, trailing space before ;, comment headers, no package, and package after import/type (ignored).

Why split out

This is being carved out of the trimmable typemap mega-PR #11617. Although the bug surfaced while bringing up the NativeAOT trimmable path, it is not trimmable-specific — the acw-map keep logic and R8 shrinking apply equally to legacy/MonoVM and CoreCLR, so user AndroidJavaSource was at risk of being shrunk there too. Landing it independently de-risks #11617 and ships a general correctness fix sooner.

Context / related PRs

[TrimmableTypeMap] Implement reflection-free TrimmableTypeMapValueManager and TrimmableTypeMapTypeManager #11617 — parent mega-PR (reflection-free trimmable typemap) this is sliced from.
[NativeAOT] Remove managed NativeAOT type map in favor of the trimmable type map #11643 — removes the managed NativeAOT typemap in favor of the trimmable one (the path that exposed this gap).
Sibling slices already split out off main: [TrimmableTypeMap] Honor AndroidApplicationJavaClass for the JCW base and manifest #11794 (AndroidApplicationJavaClass/multidex), [TrimmableTypeMap] Complete trimmable manifest generation parity #11796 (manifest generation parity). Other merged groundwork: [TrimmableTypeMap] Fix inherited generic base typemap refs #11749, [TrimmableTypeMap] Skip unresolvable trimmable typemap peers #11751, [TrimmableTypeMap] Fix trimmable manifest generation parity #11752, [TrimmableTypeMap] Add trimmable array proxy mapping #11753, [TrimmableTypeMap] Improve trimmable typemap build incrementality #11764, [TrimmableTypeMap] Use non-generic JavaPeerProxy base for interface proxies (NativeAOT) #11769.

Verification

24/24 R8 unit tests pass (18 existing + 6 new). BuildAfterMultiDexIsNotRequired verified locally on NativeAOT and CoreCLR — user Java is retained after shrinking.

The trimmable NativeAOT path enables R8 with shrinking (AndroidLinkTool=r8 -> _R8EnableShrinking=True). When the application ProGuard config is generated from the acw-map (the default, UseTrimmableNativeAotProguardConfiguration=false), the R8 task only emits -keep rules for managed-mapped Java types. User-authored AndroidJavaSource (Bind != true) has no managed peer and is therefore absent from the acw-map, so R8 shrank it away. This made BuildAfterMultiDexIsNotRequired fail on NativeAOT: the huge ManyMethods.java classes were removed, so multidex was no longer required and classes2.dex was never produced. Pass the user AndroidJavaSource (.java with Bind != true) to the R8 task and emit '-keep class <package>.<Type> { *; }' for each, so user Java survives shrinking. The type name is '<package>.<FileNameWithoutExtension>' (Java requires the public top-level type name to match the file name). Verified locally: BuildAfterMultiDexIsNotRequired(NativeAOT) and (CoreCLR) pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Cover package detection: present, trailing space, comment headers, no package, and package-after-import/type (ignored). Exposes ReadJavaPackage as internal for direct testing, matching the TryGetDisallowedOption pattern. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

Fixes R8 shrinking removing user-authored AndroidJavaSource.java files (those without a managed peer / absent from acw-map) by deriving their Java FQNs and emitting -keep class … { *; } rules when shrinking is enabled.

Changes:

Passes @(AndroidJavaSource) items with Bind != True to the R8 MSBuild task via a new JavaSourceFiles input.
Adds R8.GetUserJavaTypes() + R8.ReadJavaPackage() to derive the fully-qualified class names from .java sources and append -keep rules.
Adds unit tests for ReadJavaPackage parsing behavior across several common source layouts.

Show a summary per file

File	Description
src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets	Collects non-binding `AndroidJavaSource` items and forwards them to `R8` as `JavaSourceFiles`.
src/Xamarin.Android.Build.Tasks/Tasks/R8.cs	Adds Java package parsing + FQN derivation and appends `-keep` rules to the generated R8 app config.
src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/R8Tests.cs	Adds test coverage for `ReadJavaPackage()` parsing rules.

Copilot's findings

Files reviewed: 3/3 changed files
Comments generated: 2

* R8Tests: expected parameter is string? (TestCase passes null). * R8: comment that only the public top-level type is kept, and that ReadJavaPackage is a lightweight scan (package precedes types in practice). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

simonrozsival · 2026-06-29T11:08:57Z

/review

jonathanpeppers · 2026-06-29T13:26:18Z

+ <!-- User-authored AndroidJavaSource (Bind != True) is not in the acw-map; pass it to R8 so it
+ is kept when shrinking is enabled rather than silently removed. -->
+ <_R8KeepJavaSource Include="@(AndroidJavaSource)" Condition=" '%(AndroidJavaSource.Bind)' != 'True' " />


There is not an easy way to turn this off if you don't want it, but I can't think of a case you would need to do that.

…TypeManagers (#11799) ## Summary Bumps **external/Java.Interop** and aligns Mono.Android's reflection-based type and value managers with the new base-class contracts. The Java.Interop bump relaxes the `[DynamicallyAccessedMembers]` (DAM) requirements on the virtual members of `JniRuntime.ReflectionJniTypeManager` / `JniRuntime.ReflectionJniValueManager`, so the Mono.Android overrides no longer need to repeat those annotations and instead rely on targeted trimmer/AOT suppressions. This is a standalone slice of #11617 with no dependency on the trimmable type-map scanner/emitter or array codegen work. ## Changes - `external/Java.Interop` → `8d544738a` (from `70493645c`). - Drop now-redundant `[DynamicallyAccessedMembers]` annotations from the overrides in `AndroidTypeManager`, `ManagedTypeManager`, and `TrimmableTypeMapTypeManager` (`GetInvokerTypeCore`, `GetTypeForSimpleReference`, `RegisterNativeMembers`, `ActivatePeer`), replacing them with `[UnconditionalSuppressMessage]` where the trimmer still needs reassurance. - `JavaMarshalValueManager` now extends `JniRuntime.ReflectionJniValueManager` directly. It is marked `sealed` and carries `[RequiresDynamicCode]` / `[RequiresUnreferencedCode]`, uses the base `EnsureNotDisposed ()` helper, and drops its own dispose tracking and `ActivatePeer` override. - Remove the superseded `AndroidReflectionJniValueManager` and `SimpleValueManager` (and their `Mono.Android.csproj` entries). - `JNIEnvInit.CreateValueManager` creates the value manager through a local helper with the appropriate trimming/AOT suppressions for both the CoreCLR and NativeAOT paths. - No NativeAOT default change; the trimmable type/value managers are **not** part of this PR. ## Tests / baselines - Update the API-compatibility baseline: `Android.Graphics.ColorValueMarshaler.CreateGenericValue`'s `targetType` parameter no longer carries a DAM attribute (inherited from the Java.Interop base-class change). - Refresh `SimpleDotNet` CoreCLR/NativeAOT apkdesc size baselines and the NativeAOT `BuildHasNoWarnings` count, plus `BuildTest2`. ## Context Carved out of #11617. `JavaMarshalRegisteredPeers` extraction already merged via #11750. The trimmable managers, scanner/emitter, manifest, and R8 changes ship in their own PRs (#11749/#11751/#11753/#11769/#11794/#11796/#11798). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…11801) ## Summary This PR adds the two runtime managers that make the **trimmable typemap** a fully functional, reflection-free peer-resolution path: - **`TrimmableTypeMapValueManager`** — creates and tracks Java↔managed peers without reflection or `Activator`. - **`TrimmableTypeMapTypeManager`** — resolves managed↔Java type mappings by delegating to the generated `TrimmableTypeMap`. Both are selected through the existing `RuntimeFeature.TrimmableTypeMap` switch and wired into `JNIEnvInit`. The trimmable path is **opt-in**; the NativeAOT default remains `managed`, and Mono/CoreCLR defaults are unchanged. Also included is the `JavaConvert` collection-factory refactor and a generator fix that the trimmable managers depend on. ## Background The classic Java.Interop runtime resolves the managed `Type` for a Java instance (and vice-versa) using `Type.GetType`, `MakeGenericType`, and `Activator`-style construction. That is incompatible with trimming and NativeAOT: the trimmer can't see which types are reachable, and the types can't be created at runtime under AOT. The **trimmable typemap** replaces those reflection calls with a build-time-generated map of `JavaPeerProxy` objects (produced by `Microsoft.Android.Sdk.TrimmableTypeMap`). Each proxy knows how to construct a specific peer and describes its JNI ↔ managed association statically. Earlier PRs landed the generator, the proxy shapes (array / generic-base / interface / unresolvable peers), and the CoreCLR `JavaMarshal` value-manager split. **This PR adds the runtime managers that consume that generated map.** ## What's in this PR ### 1. `TrimmableTypeMapValueManager` (new) A `JniRuntime.JniValueManager` that performs peer creation with **no reflection**: - **Peer lifetime** (`AddPeer` / `PeekPeer` / `RemovePeer` / `FinalizePeer` / `CollectPeers` / `GetSurfacedPeers`) is delegated to `JavaMarshalRegisteredPeers`, i.e. the CoreCLR `JavaMarshal` GC-bridge machinery. `WaitForGCBridgeProcessing` is intentionally a no-op (documented: the wait can't close the bridge race on CoreCLR, where JNI wrapper threads hold their own `JniObjectReference` copies). - **`CreatePeer`** resolves the requested target type (mapping `object`/`IJavaPeerable` → `Java.Interop.JavaObject`, `Exception` → `JavaException`) and asks `TrimmableTypeMap.Instance.CreateInstance (handle, resolvedType)` to build the peer from a generated proxy. - **`ActivatePeer`** throws `PlatformNotSupportedException` — reflection-based activation is not part of this path. - **`NotFoundFallback`** carefully reproduces the base `JniValueManager.CreatePeer` contract so `JavaCast`/`JavaAs` still surface the correct outcome when no proxy is found: - target type has no Java mapping → `ArgumentException` - Java instance not assignable to the target's Java class → `null` (so `JavaAs` returns null / `JavaCast` throws `InvalidCastException`) - compatible classes but no proxy → `NotSupportedException` (a genuine generator gap, with a message pointing at the missing proxy) The assignability check honors `RuntimeFeature.IsAssignableFromCheck` and mirrors the legacy cast diagnostic when assembly logging is enabled. ### 2. `TrimmableTypeMapTypeManager` (new) A `JniRuntime.JniTypeManager` that has exactly two live responsibilities and throws for everything else it doesn't need: - **Managed → Java** via `GetTypeSignatureCore`, backed by a `ConcurrentDictionary<Type, JniTypeSignature>` cache. - **Java → managed** via `GetTypes` / `GetTypeForSimpleReference`, delegating to `TrimmableTypeMap`. - **Array handling** diverges by runtime: NativeAOT reads a pre-generated array-proxy map (types can't be built at runtime), while CoreCLR builds array/generic types dynamically to save app size (suppressions are scoped to the CoreCLR-only branch). ### 3. `JNIEnvInit` wiring `CreateValueManager` / `CreateTypeManager` now return the trimmable managers when `RuntimeFeature.TrimmableTypeMap` is set. The existing Mono / CoreCLR / managed selection is preserved, and the manager constructions were refactored into small local helpers so trimming suppressions (`IL2026` / `IL3050`) apply only to the exact branch that needs them. `RegisterJniNatives` is likewise gated so the reflection-based JNI registration path isn't emitted for the trimmable typemap. ### 4. `JavaConvert` collection-factory refactor Generic collection marshalling (`IDictionary<,>` → `JavaDictionary<,>`, `IList<>` → `JavaList<>`, `ICollection<>` → `JavaCollection<>`) is split into two branches: a **factory-based converter** on the trimmable path (no `MakeGenericType`) and the classic `MakeGenericType` path elsewhere, with the reflection-requiring code isolated behind narrowly-scoped suppressions. Also adds `Nullable<T>` converter handling (null reference → null value). ### 5. Generator fix (`ModelBuilder`) Emits a managed→Java typemap entry for **self-peer types** (`[JniTypeSignature(GenerateJavaPeer=false)]` or MCW bindings with no activation ctor). These are constructed managed-side with `new`, but their JNI name must still resolve so the correct Java class is instantiated; without the association they fell back to the generic `mono.android.runtime.JavaObject` peer and threw `ArrayStoreException` when placed into a typed Java array. ### 6. Cleanup Removes the dead `TrimmableTypeMap` branch from `JavaMarshalValueManager` (that logic now lives in the dedicated `TrimmableTypeMapValueManager`). ## Behavioral impact - **Opt-in only.** With `RuntimeFeature.TrimmableTypeMap` unset, behavior is unchanged. NativeAOT still defaults to `managed`. - No new user-facing / localized strings; error messages point at the generator when a proxy is genuinely missing. ## Status All earlier prerequisites have **merged into `main`**, and this PR is **rebased on latest `main`**, so it is no longer stacked or blocked — it contains only the value/type-manager implementations (plus the supporting `JavaConvert` and generator changes) on top of them: - #11799 — CoreCLR `JavaMarshal` split + Java.Interop bump - #11753 array proxies · #11749 generic base · #11751 unresolvable peers · #11769 interface proxies - #11794 multidex/manifest base · #11796 manifest parity · #11798 R8 keep ## Testing - `TrimmableTypeMapTypeManagerTests` and `TypeMapModelBuilderTests` updated/extended for the new type resolution and the self-peer generator fix. - Export tests enabled for the trimmable typemap; `TrimmableTypeMapUnsupported` cases excluded. - NativeAOT warning-count and CoreCLR `apkdesc` baselines updated to match.

simonrozsival · 2026-06-29T07:59:00Z

Problem

When R8 code shrinking is enabled, R8 removes any Java type that nothing keeps. .NET for Android keeps the Java callable wrappers (JCWs) of bound managed types by generating -keep rules from the acw-map (managed peer ↔ Java type). That works for generated JCWs, but user-authored AndroidJavaSource.java files marked Bind != true have no managed peer, so they never appear in the acw-map — and therefore get no keep rule. With shrinking on, R8 silently deletes them, and the app fails at runtime when it references those classes (often as a NoClassDefFoundError that only reproduces in Release/shrunk builds).

Fix

Pass user AndroidJavaSource (Bind != True) to the R8 task and emit -keep class <package>.<Type> { *; } for each, so user Java survives shrinking:

D8.targets — collect @(AndroidJavaSource) items where %(Bind) != 'True' into _R8KeepJavaSource and pass them to R8 via the new JavaSourceFiles property.
R8.cs — append keep rules in the same block that emits acw-map keeps. GetUserJavaTypes() derives the fully-qualified name as <package>.<FileNameWithoutExtension> (Java requires the public top-level type name to match the file name); ReadJavaPackage() parses the package declaration, skipping comments and stopping at the first import/type declaration. Names are de-duplicated.
R8Tests.cs — unit tests covering ReadJavaPackage: package present, trailing space before ;, comment headers, no package, and package after import/type (ignored).

Why split out

This is being carved out of the trimmable typemap mega-PR #11617. Although the bug surfaced while bringing up the NativeAOT trimmable path, it is not trimmable-specific — the acw-map keep logic and R8 shrinking apply equally to legacy/MonoVM and CoreCLR, so user AndroidJavaSource was at risk of being shrunk there too. Landing it independently de-risks #11617 and ships a general correctness fix sooner.

Context / related PRs

[TrimmableTypeMap] Implement reflection-free TrimmableTypeMapValueManager and TrimmableTypeMapTypeManager #11617 — parent mega-PR (reflection-free trimmable typemap) this is sliced from.
[NativeAOT] Remove managed NativeAOT type map in favor of the trimmable type map #11643 — removes the managed NativeAOT typemap in favor of the trimmable one (the path that exposed this gap).
Sibling slices already split out off main: [TrimmableTypeMap] Honor AndroidApplicationJavaClass for the JCW base and manifest #11794 (AndroidApplicationJavaClass/multidex), [TrimmableTypeMap] Complete trimmable manifest generation parity #11796 (manifest generation parity). Other merged groundwork: [TrimmableTypeMap] Fix inherited generic base typemap refs #11749, [TrimmableTypeMap] Skip unresolvable trimmable typemap peers #11751, [TrimmableTypeMap] Fix trimmable manifest generation parity #11752, [TrimmableTypeMap] Add trimmable array proxy mapping #11753, [TrimmableTypeMap] Improve trimmable typemap build incrementality #11764, [TrimmableTypeMap] Use non-generic JavaPeerProxy base for interface proxies (NativeAOT) #11769.

Verification

24/24 R8 unit tests pass (18 existing + 6 new). BuildAfterMultiDexIsNotRequired verified locally on NativeAOT and CoreCLR — user Java is retained after shrinking.

The trimmable NativeAOT path enables R8 with shrinking (AndroidLinkTool=r8 -> _R8EnableShrinking=True). When the application ProGuard config is generated from the acw-map (the default, UseTrimmableNativeAotProguardConfiguration=false), the R8 task only emits -keep rules for managed-mapped Java types. User-authored AndroidJavaSource (Bind != true) has no managed peer and is therefore absent from the acw-map, so R8 shrank it away. This made BuildAfterMultiDexIsNotRequired fail on NativeAOT: the huge ManyMethods.java classes were removed, so multidex was no longer required and classes2.dex was never produced. Pass the user AndroidJavaSource (.java with Bind != true) to the R8 task and emit '-keep class <package>.<Type> { *; }' for each, so user Java survives shrinking. The type name is '<package>.<FileNameWithoutExtension>' (Java requires the public top-level type name to match the file name). Verified locally: BuildAfterMultiDexIsNotRequired(NativeAOT) and (CoreCLR) pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Cover package detection: present, trailing space, comment headers, no package, and package-after-import/type (ignored). Exposes ReadJavaPackage as internal for direct testing, matching the TryGetDisallowedOption pattern. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

Fixes R8 shrinking removing user-authored AndroidJavaSource.java files (those without a managed peer / absent from acw-map) by deriving their Java FQNs and emitting -keep class … { *; } rules when shrinking is enabled.

Changes:

Passes @(AndroidJavaSource) items with Bind != True to the R8 MSBuild task via a new JavaSourceFiles input.
Adds R8.GetUserJavaTypes() + R8.ReadJavaPackage() to derive the fully-qualified class names from .java sources and append -keep rules.
Adds unit tests for ReadJavaPackage parsing behavior across several common source layouts.

Show a summary per file

File	Description
src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets	Collects non-binding `AndroidJavaSource` items and forwards them to `R8` as `JavaSourceFiles`.
src/Xamarin.Android.Build.Tasks/Tasks/R8.cs	Adds Java package parsing + FQN derivation and appends `-keep` rules to the generated R8 app config.
src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/R8Tests.cs	Adds test coverage for `ReadJavaPackage()` parsing rules.

Copilot's findings

Files reviewed: 3/3 changed files
Comments generated: 2

* R8Tests: expected parameter is string? (TestCase passes null). * R8: comment that only the public top-level type is kept, and that ReadJavaPackage is a lightweight scan (package precedes types in practice). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

simonrozsival · 2026-06-29T11:08:57Z

/review

jonathanpeppers · 2026-06-29T13:26:18Z

+ <!-- User-authored AndroidJavaSource (Bind != True) is not in the acw-map; pass it to R8 so it
+ is kept when shrinking is enabled rather than silently removed. -->
+ <_R8KeepJavaSource Include="@(AndroidJavaSource)" Condition=" '%(AndroidJavaSource.Bind)' != 'True' " />


There is not an easy way to turn this off if you don't want it, but I can't think of a case you would need to do that.

…TypeManagers (#11799) ## Summary Bumps **external/Java.Interop** and aligns Mono.Android's reflection-based type and value managers with the new base-class contracts. The Java.Interop bump relaxes the `[DynamicallyAccessedMembers]` (DAM) requirements on the virtual members of `JniRuntime.ReflectionJniTypeManager` / `JniRuntime.ReflectionJniValueManager`, so the Mono.Android overrides no longer need to repeat those annotations and instead rely on targeted trimmer/AOT suppressions. This is a standalone slice of #11617 with no dependency on the trimmable type-map scanner/emitter or array codegen work. ## Changes - `external/Java.Interop` → `8d544738a` (from `70493645c`). - Drop now-redundant `[DynamicallyAccessedMembers]` annotations from the overrides in `AndroidTypeManager`, `ManagedTypeManager`, and `TrimmableTypeMapTypeManager` (`GetInvokerTypeCore`, `GetTypeForSimpleReference`, `RegisterNativeMembers`, `ActivatePeer`), replacing them with `[UnconditionalSuppressMessage]` where the trimmer still needs reassurance. - `JavaMarshalValueManager` now extends `JniRuntime.ReflectionJniValueManager` directly. It is marked `sealed` and carries `[RequiresDynamicCode]` / `[RequiresUnreferencedCode]`, uses the base `EnsureNotDisposed ()` helper, and drops its own dispose tracking and `ActivatePeer` override. - Remove the superseded `AndroidReflectionJniValueManager` and `SimpleValueManager` (and their `Mono.Android.csproj` entries). - `JNIEnvInit.CreateValueManager` creates the value manager through a local helper with the appropriate trimming/AOT suppressions for both the CoreCLR and NativeAOT paths. - No NativeAOT default change; the trimmable type/value managers are **not** part of this PR. ## Tests / baselines - Update the API-compatibility baseline: `Android.Graphics.ColorValueMarshaler.CreateGenericValue`'s `targetType` parameter no longer carries a DAM attribute (inherited from the Java.Interop base-class change). - Refresh `SimpleDotNet` CoreCLR/NativeAOT apkdesc size baselines and the NativeAOT `BuildHasNoWarnings` count, plus `BuildTest2`. ## Context Carved out of #11617. `JavaMarshalRegisteredPeers` extraction already merged via #11750. The trimmable managers, scanner/emitter, manifest, and R8 changes ship in their own PRs (#11749/#11751/#11753/#11769/#11794/#11796/#11798). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…11801) ## Summary This PR adds the two runtime managers that make the **trimmable typemap** a fully functional, reflection-free peer-resolution path: - **`TrimmableTypeMapValueManager`** — creates and tracks Java↔managed peers without reflection or `Activator`. - **`TrimmableTypeMapTypeManager`** — resolves managed↔Java type mappings by delegating to the generated `TrimmableTypeMap`. Both are selected through the existing `RuntimeFeature.TrimmableTypeMap` switch and wired into `JNIEnvInit`. The trimmable path is **opt-in**; the NativeAOT default remains `managed`, and Mono/CoreCLR defaults are unchanged. Also included is the `JavaConvert` collection-factory refactor and a generator fix that the trimmable managers depend on. ## Background The classic Java.Interop runtime resolves the managed `Type` for a Java instance (and vice-versa) using `Type.GetType`, `MakeGenericType`, and `Activator`-style construction. That is incompatible with trimming and NativeAOT: the trimmer can't see which types are reachable, and the types can't be created at runtime under AOT. The **trimmable typemap** replaces those reflection calls with a build-time-generated map of `JavaPeerProxy` objects (produced by `Microsoft.Android.Sdk.TrimmableTypeMap`). Each proxy knows how to construct a specific peer and describes its JNI ↔ managed association statically. Earlier PRs landed the generator, the proxy shapes (array / generic-base / interface / unresolvable peers), and the CoreCLR `JavaMarshal` value-manager split. **This PR adds the runtime managers that consume that generated map.** ## What's in this PR ### 1. `TrimmableTypeMapValueManager` (new) A `JniRuntime.JniValueManager` that performs peer creation with **no reflection**: - **Peer lifetime** (`AddPeer` / `PeekPeer` / `RemovePeer` / `FinalizePeer` / `CollectPeers` / `GetSurfacedPeers`) is delegated to `JavaMarshalRegisteredPeers`, i.e. the CoreCLR `JavaMarshal` GC-bridge machinery. `WaitForGCBridgeProcessing` is intentionally a no-op (documented: the wait can't close the bridge race on CoreCLR, where JNI wrapper threads hold their own `JniObjectReference` copies). - **`CreatePeer`** resolves the requested target type (mapping `object`/`IJavaPeerable` → `Java.Interop.JavaObject`, `Exception` → `JavaException`) and asks `TrimmableTypeMap.Instance.CreateInstance (handle, resolvedType)` to build the peer from a generated proxy. - **`ActivatePeer`** throws `PlatformNotSupportedException` — reflection-based activation is not part of this path. - **`NotFoundFallback`** carefully reproduces the base `JniValueManager.CreatePeer` contract so `JavaCast`/`JavaAs` still surface the correct outcome when no proxy is found: - target type has no Java mapping → `ArgumentException` - Java instance not assignable to the target's Java class → `null` (so `JavaAs` returns null / `JavaCast` throws `InvalidCastException`) - compatible classes but no proxy → `NotSupportedException` (a genuine generator gap, with a message pointing at the missing proxy) The assignability check honors `RuntimeFeature.IsAssignableFromCheck` and mirrors the legacy cast diagnostic when assembly logging is enabled. ### 2. `TrimmableTypeMapTypeManager` (new) A `JniRuntime.JniTypeManager` that has exactly two live responsibilities and throws for everything else it doesn't need: - **Managed → Java** via `GetTypeSignatureCore`, backed by a `ConcurrentDictionary<Type, JniTypeSignature>` cache. - **Java → managed** via `GetTypes` / `GetTypeForSimpleReference`, delegating to `TrimmableTypeMap`. - **Array handling** diverges by runtime: NativeAOT reads a pre-generated array-proxy map (types can't be built at runtime), while CoreCLR builds array/generic types dynamically to save app size (suppressions are scoped to the CoreCLR-only branch). ### 3. `JNIEnvInit` wiring `CreateValueManager` / `CreateTypeManager` now return the trimmable managers when `RuntimeFeature.TrimmableTypeMap` is set. The existing Mono / CoreCLR / managed selection is preserved, and the manager constructions were refactored into small local helpers so trimming suppressions (`IL2026` / `IL3050`) apply only to the exact branch that needs them. `RegisterJniNatives` is likewise gated so the reflection-based JNI registration path isn't emitted for the trimmable typemap. ### 4. `JavaConvert` collection-factory refactor Generic collection marshalling (`IDictionary<,>` → `JavaDictionary<,>`, `IList<>` → `JavaList<>`, `ICollection<>` → `JavaCollection<>`) is split into two branches: a **factory-based converter** on the trimmable path (no `MakeGenericType`) and the classic `MakeGenericType` path elsewhere, with the reflection-requiring code isolated behind narrowly-scoped suppressions. Also adds `Nullable<T>` converter handling (null reference → null value). ### 5. Generator fix (`ModelBuilder`) Emits a managed→Java typemap entry for **self-peer types** (`[JniTypeSignature(GenerateJavaPeer=false)]` or MCW bindings with no activation ctor). These are constructed managed-side with `new`, but their JNI name must still resolve so the correct Java class is instantiated; without the association they fell back to the generic `mono.android.runtime.JavaObject` peer and threw `ArrayStoreException` when placed into a typed Java array. ### 6. Cleanup Removes the dead `TrimmableTypeMap` branch from `JavaMarshalValueManager` (that logic now lives in the dedicated `TrimmableTypeMapValueManager`). ## Behavioral impact - **Opt-in only.** With `RuntimeFeature.TrimmableTypeMap` unset, behavior is unchanged. NativeAOT still defaults to `managed`. - No new user-facing / localized strings; error messages point at the generator when a proxy is genuinely missing. ## Status All earlier prerequisites have **merged into `main`**, and this PR is **rebased on latest `main`**, so it is no longer stacked or blocked — it contains only the value/type-manager implementations (plus the supporting `JavaConvert` and generator changes) on top of them: - #11799 — CoreCLR `JavaMarshal` split + Java.Interop bump - #11753 array proxies · #11749 generic base · #11751 unresolvable peers · #11769 interface proxies - #11794 multidex/manifest base · #11796 manifest parity · #11798 R8 keep ## Testing - `TrimmableTypeMapTypeManagerTests` and `TypeMapModelBuilderTests` updated/extended for the new type resolution and the self-peer generator fix. - Export tests enabled for the trimmable typemap; `TrimmableTypeMapUnsupported` cases excluded. - NativeAOT warning-count and CoreCLR `apkdesc` baselines updated to match.

simonrozsival · 2026-06-29T07:59:00Z

Problem

When R8 code shrinking is enabled, R8 removes any Java type that nothing keeps. .NET for Android keeps the Java callable wrappers (JCWs) of bound managed types by generating -keep rules from the acw-map (managed peer ↔ Java type). That works for generated JCWs, but user-authored AndroidJavaSource.java files marked Bind != true have no managed peer, so they never appear in the acw-map — and therefore get no keep rule. With shrinking on, R8 silently deletes them, and the app fails at runtime when it references those classes (often as a NoClassDefFoundError that only reproduces in Release/shrunk builds).

Fix

Pass user AndroidJavaSource (Bind != True) to the R8 task and emit -keep class <package>.<Type> { *; } for each, so user Java survives shrinking:

D8.targets — collect @(AndroidJavaSource) items where %(Bind) != 'True' into _R8KeepJavaSource and pass them to R8 via the new JavaSourceFiles property.
R8.cs — append keep rules in the same block that emits acw-map keeps. GetUserJavaTypes() derives the fully-qualified name as <package>.<FileNameWithoutExtension> (Java requires the public top-level type name to match the file name); ReadJavaPackage() parses the package declaration, skipping comments and stopping at the first import/type declaration. Names are de-duplicated.
R8Tests.cs — unit tests covering ReadJavaPackage: package present, trailing space before ;, comment headers, no package, and package after import/type (ignored).

Why split out

This is being carved out of the trimmable typemap mega-PR #11617. Although the bug surfaced while bringing up the NativeAOT trimmable path, it is not trimmable-specific — the acw-map keep logic and R8 shrinking apply equally to legacy/MonoVM and CoreCLR, so user AndroidJavaSource was at risk of being shrunk there too. Landing it independently de-risks #11617 and ships a general correctness fix sooner.

Context / related PRs

[TrimmableTypeMap] Implement reflection-free TrimmableTypeMapValueManager and TrimmableTypeMapTypeManager #11617 — parent mega-PR (reflection-free trimmable typemap) this is sliced from.
[NativeAOT] Remove managed NativeAOT type map in favor of the trimmable type map #11643 — removes the managed NativeAOT typemap in favor of the trimmable one (the path that exposed this gap).
Sibling slices already split out off main: [TrimmableTypeMap] Honor AndroidApplicationJavaClass for the JCW base and manifest #11794 (AndroidApplicationJavaClass/multidex), [TrimmableTypeMap] Complete trimmable manifest generation parity #11796 (manifest generation parity). Other merged groundwork: [TrimmableTypeMap] Fix inherited generic base typemap refs #11749, [TrimmableTypeMap] Skip unresolvable trimmable typemap peers #11751, [TrimmableTypeMap] Fix trimmable manifest generation parity #11752, [TrimmableTypeMap] Add trimmable array proxy mapping #11753, [TrimmableTypeMap] Improve trimmable typemap build incrementality #11764, [TrimmableTypeMap] Use non-generic JavaPeerProxy base for interface proxies (NativeAOT) #11769.

Verification

24/24 R8 unit tests pass (18 existing + 6 new). BuildAfterMultiDexIsNotRequired verified locally on NativeAOT and CoreCLR — user Java is retained after shrinking.

The trimmable NativeAOT path enables R8 with shrinking (AndroidLinkTool=r8 -> _R8EnableShrinking=True). When the application ProGuard config is generated from the acw-map (the default, UseTrimmableNativeAotProguardConfiguration=false), the R8 task only emits -keep rules for managed-mapped Java types. User-authored AndroidJavaSource (Bind != true) has no managed peer and is therefore absent from the acw-map, so R8 shrank it away. This made BuildAfterMultiDexIsNotRequired fail on NativeAOT: the huge ManyMethods.java classes were removed, so multidex was no longer required and classes2.dex was never produced. Pass the user AndroidJavaSource (.java with Bind != true) to the R8 task and emit '-keep class <package>.<Type> { *; }' for each, so user Java survives shrinking. The type name is '<package>.<FileNameWithoutExtension>' (Java requires the public top-level type name to match the file name). Verified locally: BuildAfterMultiDexIsNotRequired(NativeAOT) and (CoreCLR) pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Cover package detection: present, trailing space, comment headers, no package, and package-after-import/type (ignored). Exposes ReadJavaPackage as internal for direct testing, matching the TryGetDisallowedOption pattern. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

Fixes R8 shrinking removing user-authored AndroidJavaSource.java files (those without a managed peer / absent from acw-map) by deriving their Java FQNs and emitting -keep class … { *; } rules when shrinking is enabled.

Changes:

Passes @(AndroidJavaSource) items with Bind != True to the R8 MSBuild task via a new JavaSourceFiles input.
Adds R8.GetUserJavaTypes() + R8.ReadJavaPackage() to derive the fully-qualified class names from .java sources and append -keep rules.
Adds unit tests for ReadJavaPackage parsing behavior across several common source layouts.

Show a summary per file

File	Description
src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets	Collects non-binding `AndroidJavaSource` items and forwards them to `R8` as `JavaSourceFiles`.
src/Xamarin.Android.Build.Tasks/Tasks/R8.cs	Adds Java package parsing + FQN derivation and appends `-keep` rules to the generated R8 app config.
src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/R8Tests.cs	Adds test coverage for `ReadJavaPackage()` parsing rules.

Copilot's findings

Files reviewed: 3/3 changed files
Comments generated: 2

* R8Tests: expected parameter is string? (TestCase passes null). * R8: comment that only the public top-level type is kept, and that ReadJavaPackage is a lightweight scan (package precedes types in practice). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

simonrozsival · 2026-06-29T11:08:57Z

/review

jonathanpeppers · 2026-06-29T13:26:18Z

+ <!-- User-authored AndroidJavaSource (Bind != True) is not in the acw-map; pass it to R8 so it
+ is kept when shrinking is enabled rather than silently removed. -->
+ <_R8KeepJavaSource Include="@(AndroidJavaSource)" Condition=" '%(AndroidJavaSource.Bind)' != 'True' " />


There is not an easy way to turn this off if you don't want it, but I can't think of a case you would need to do that.

…TypeManagers (#11799) ## Summary Bumps **external/Java.Interop** and aligns Mono.Android's reflection-based type and value managers with the new base-class contracts. The Java.Interop bump relaxes the `[DynamicallyAccessedMembers]` (DAM) requirements on the virtual members of `JniRuntime.ReflectionJniTypeManager` / `JniRuntime.ReflectionJniValueManager`, so the Mono.Android overrides no longer need to repeat those annotations and instead rely on targeted trimmer/AOT suppressions. This is a standalone slice of #11617 with no dependency on the trimmable type-map scanner/emitter or array codegen work. ## Changes - `external/Java.Interop` → `8d544738a` (from `70493645c`). - Drop now-redundant `[DynamicallyAccessedMembers]` annotations from the overrides in `AndroidTypeManager`, `ManagedTypeManager`, and `TrimmableTypeMapTypeManager` (`GetInvokerTypeCore`, `GetTypeForSimpleReference`, `RegisterNativeMembers`, `ActivatePeer`), replacing them with `[UnconditionalSuppressMessage]` where the trimmer still needs reassurance. - `JavaMarshalValueManager` now extends `JniRuntime.ReflectionJniValueManager` directly. It is marked `sealed` and carries `[RequiresDynamicCode]` / `[RequiresUnreferencedCode]`, uses the base `EnsureNotDisposed ()` helper, and drops its own dispose tracking and `ActivatePeer` override. - Remove the superseded `AndroidReflectionJniValueManager` and `SimpleValueManager` (and their `Mono.Android.csproj` entries). - `JNIEnvInit.CreateValueManager` creates the value manager through a local helper with the appropriate trimming/AOT suppressions for both the CoreCLR and NativeAOT paths. - No NativeAOT default change; the trimmable type/value managers are **not** part of this PR. ## Tests / baselines - Update the API-compatibility baseline: `Android.Graphics.ColorValueMarshaler.CreateGenericValue`'s `targetType` parameter no longer carries a DAM attribute (inherited from the Java.Interop base-class change). - Refresh `SimpleDotNet` CoreCLR/NativeAOT apkdesc size baselines and the NativeAOT `BuildHasNoWarnings` count, plus `BuildTest2`. ## Context Carved out of #11617. `JavaMarshalRegisteredPeers` extraction already merged via #11750. The trimmable managers, scanner/emitter, manifest, and R8 changes ship in their own PRs (#11749/#11751/#11753/#11769/#11794/#11796/#11798). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…11801) ## Summary This PR adds the two runtime managers that make the **trimmable typemap** a fully functional, reflection-free peer-resolution path: - **`TrimmableTypeMapValueManager`** — creates and tracks Java↔managed peers without reflection or `Activator`. - **`TrimmableTypeMapTypeManager`** — resolves managed↔Java type mappings by delegating to the generated `TrimmableTypeMap`. Both are selected through the existing `RuntimeFeature.TrimmableTypeMap` switch and wired into `JNIEnvInit`. The trimmable path is **opt-in**; the NativeAOT default remains `managed`, and Mono/CoreCLR defaults are unchanged. Also included is the `JavaConvert` collection-factory refactor and a generator fix that the trimmable managers depend on. ## Background The classic Java.Interop runtime resolves the managed `Type` for a Java instance (and vice-versa) using `Type.GetType`, `MakeGenericType`, and `Activator`-style construction. That is incompatible with trimming and NativeAOT: the trimmer can't see which types are reachable, and the types can't be created at runtime under AOT. The **trimmable typemap** replaces those reflection calls with a build-time-generated map of `JavaPeerProxy` objects (produced by `Microsoft.Android.Sdk.TrimmableTypeMap`). Each proxy knows how to construct a specific peer and describes its JNI ↔ managed association statically. Earlier PRs landed the generator, the proxy shapes (array / generic-base / interface / unresolvable peers), and the CoreCLR `JavaMarshal` value-manager split. **This PR adds the runtime managers that consume that generated map.** ## What's in this PR ### 1. `TrimmableTypeMapValueManager` (new) A `JniRuntime.JniValueManager` that performs peer creation with **no reflection**: - **Peer lifetime** (`AddPeer` / `PeekPeer` / `RemovePeer` / `FinalizePeer` / `CollectPeers` / `GetSurfacedPeers`) is delegated to `JavaMarshalRegisteredPeers`, i.e. the CoreCLR `JavaMarshal` GC-bridge machinery. `WaitForGCBridgeProcessing` is intentionally a no-op (documented: the wait can't close the bridge race on CoreCLR, where JNI wrapper threads hold their own `JniObjectReference` copies). - **`CreatePeer`** resolves the requested target type (mapping `object`/`IJavaPeerable` → `Java.Interop.JavaObject`, `Exception` → `JavaException`) and asks `TrimmableTypeMap.Instance.CreateInstance (handle, resolvedType)` to build the peer from a generated proxy. - **`ActivatePeer`** throws `PlatformNotSupportedException` — reflection-based activation is not part of this path. - **`NotFoundFallback`** carefully reproduces the base `JniValueManager.CreatePeer` contract so `JavaCast`/`JavaAs` still surface the correct outcome when no proxy is found: - target type has no Java mapping → `ArgumentException` - Java instance not assignable to the target's Java class → `null` (so `JavaAs` returns null / `JavaCast` throws `InvalidCastException`) - compatible classes but no proxy → `NotSupportedException` (a genuine generator gap, with a message pointing at the missing proxy) The assignability check honors `RuntimeFeature.IsAssignableFromCheck` and mirrors the legacy cast diagnostic when assembly logging is enabled. ### 2. `TrimmableTypeMapTypeManager` (new) A `JniRuntime.JniTypeManager` that has exactly two live responsibilities and throws for everything else it doesn't need: - **Managed → Java** via `GetTypeSignatureCore`, backed by a `ConcurrentDictionary<Type, JniTypeSignature>` cache. - **Java → managed** via `GetTypes` / `GetTypeForSimpleReference`, delegating to `TrimmableTypeMap`. - **Array handling** diverges by runtime: NativeAOT reads a pre-generated array-proxy map (types can't be built at runtime), while CoreCLR builds array/generic types dynamically to save app size (suppressions are scoped to the CoreCLR-only branch). ### 3. `JNIEnvInit` wiring `CreateValueManager` / `CreateTypeManager` now return the trimmable managers when `RuntimeFeature.TrimmableTypeMap` is set. The existing Mono / CoreCLR / managed selection is preserved, and the manager constructions were refactored into small local helpers so trimming suppressions (`IL2026` / `IL3050`) apply only to the exact branch that needs them. `RegisterJniNatives` is likewise gated so the reflection-based JNI registration path isn't emitted for the trimmable typemap. ### 4. `JavaConvert` collection-factory refactor Generic collection marshalling (`IDictionary<,>` → `JavaDictionary<,>`, `IList<>` → `JavaList<>`, `ICollection<>` → `JavaCollection<>`) is split into two branches: a **factory-based converter** on the trimmable path (no `MakeGenericType`) and the classic `MakeGenericType` path elsewhere, with the reflection-requiring code isolated behind narrowly-scoped suppressions. Also adds `Nullable<T>` converter handling (null reference → null value). ### 5. Generator fix (`ModelBuilder`) Emits a managed→Java typemap entry for **self-peer types** (`[JniTypeSignature(GenerateJavaPeer=false)]` or MCW bindings with no activation ctor). These are constructed managed-side with `new`, but their JNI name must still resolve so the correct Java class is instantiated; without the association they fell back to the generic `mono.android.runtime.JavaObject` peer and threw `ArrayStoreException` when placed into a typed Java array. ### 6. Cleanup Removes the dead `TrimmableTypeMap` branch from `JavaMarshalValueManager` (that logic now lives in the dedicated `TrimmableTypeMapValueManager`). ## Behavioral impact - **Opt-in only.** With `RuntimeFeature.TrimmableTypeMap` unset, behavior is unchanged. NativeAOT still defaults to `managed`. - No new user-facing / localized strings; error messages point at the generator when a proxy is genuinely missing. ## Status All earlier prerequisites have **merged into `main`**, and this PR is **rebased on latest `main`**, so it is no longer stacked or blocked — it contains only the value/type-manager implementations (plus the supporting `JavaConvert` and generator changes) on top of them: - #11799 — CoreCLR `JavaMarshal` split + Java.Interop bump - #11753 array proxies · #11749 generic base · #11751 unresolvable peers · #11769 interface proxies - #11794 multidex/manifest base · #11796 manifest parity · #11798 R8 keep ## Testing - `TrimmableTypeMapTypeManagerTests` and `TypeMapModelBuilderTests` updated/extended for the new type resolution and the self-peer generator fix. - Export tests enabled for the trimmable typemap; `TrimmableTypeMapUnsupported` cases excluded. - NativeAOT warning-count and CoreCLR `apkdesc` baselines updated to match.

simonrozsival · 2026-06-29T07:59:00Z

Problem

When R8 code shrinking is enabled, R8 removes any Java type that nothing keeps. .NET for Android keeps the Java callable wrappers (JCWs) of bound managed types by generating -keep rules from the acw-map (managed peer ↔ Java type). That works for generated JCWs, but user-authored AndroidJavaSource.java files marked Bind != true have no managed peer, so they never appear in the acw-map — and therefore get no keep rule. With shrinking on, R8 silently deletes them, and the app fails at runtime when it references those classes (often as a NoClassDefFoundError that only reproduces in Release/shrunk builds).

Fix

Pass user AndroidJavaSource (Bind != True) to the R8 task and emit -keep class <package>.<Type> { *; } for each, so user Java survives shrinking:

D8.targets — collect @(AndroidJavaSource) items where %(Bind) != 'True' into _R8KeepJavaSource and pass them to R8 via the new JavaSourceFiles property.
R8.cs — append keep rules in the same block that emits acw-map keeps. GetUserJavaTypes() derives the fully-qualified name as <package>.<FileNameWithoutExtension> (Java requires the public top-level type name to match the file name); ReadJavaPackage() parses the package declaration, skipping comments and stopping at the first import/type declaration. Names are de-duplicated.
R8Tests.cs — unit tests covering ReadJavaPackage: package present, trailing space before ;, comment headers, no package, and package after import/type (ignored).

Why split out

This is being carved out of the trimmable typemap mega-PR #11617. Although the bug surfaced while bringing up the NativeAOT trimmable path, it is not trimmable-specific — the acw-map keep logic and R8 shrinking apply equally to legacy/MonoVM and CoreCLR, so user AndroidJavaSource was at risk of being shrunk there too. Landing it independently de-risks #11617 and ships a general correctness fix sooner.

Context / related PRs

[TrimmableTypeMap] Implement reflection-free TrimmableTypeMapValueManager and TrimmableTypeMapTypeManager #11617 — parent mega-PR (reflection-free trimmable typemap) this is sliced from.
[NativeAOT] Remove managed NativeAOT type map in favor of the trimmable type map #11643 — removes the managed NativeAOT typemap in favor of the trimmable one (the path that exposed this gap).
Sibling slices already split out off main: [TrimmableTypeMap] Honor AndroidApplicationJavaClass for the JCW base and manifest #11794 (AndroidApplicationJavaClass/multidex), [TrimmableTypeMap] Complete trimmable manifest generation parity #11796 (manifest generation parity). Other merged groundwork: [TrimmableTypeMap] Fix inherited generic base typemap refs #11749, [TrimmableTypeMap] Skip unresolvable trimmable typemap peers #11751, [TrimmableTypeMap] Fix trimmable manifest generation parity #11752, [TrimmableTypeMap] Add trimmable array proxy mapping #11753, [TrimmableTypeMap] Improve trimmable typemap build incrementality #11764, [TrimmableTypeMap] Use non-generic JavaPeerProxy base for interface proxies (NativeAOT) #11769.

Verification

24/24 R8 unit tests pass (18 existing + 6 new). BuildAfterMultiDexIsNotRequired verified locally on NativeAOT and CoreCLR — user Java is retained after shrinking.

The trimmable NativeAOT path enables R8 with shrinking (AndroidLinkTool=r8 -> _R8EnableShrinking=True). When the application ProGuard config is generated from the acw-map (the default, UseTrimmableNativeAotProguardConfiguration=false), the R8 task only emits -keep rules for managed-mapped Java types. User-authored AndroidJavaSource (Bind != true) has no managed peer and is therefore absent from the acw-map, so R8 shrank it away. This made BuildAfterMultiDexIsNotRequired fail on NativeAOT: the huge ManyMethods.java classes were removed, so multidex was no longer required and classes2.dex was never produced. Pass the user AndroidJavaSource (.java with Bind != true) to the R8 task and emit '-keep class <package>.<Type> { *; }' for each, so user Java survives shrinking. The type name is '<package>.<FileNameWithoutExtension>' (Java requires the public top-level type name to match the file name). Verified locally: BuildAfterMultiDexIsNotRequired(NativeAOT) and (CoreCLR) pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Cover package detection: present, trailing space, comment headers, no package, and package-after-import/type (ignored). Exposes ReadJavaPackage as internal for direct testing, matching the TryGetDisallowedOption pattern. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

Fixes R8 shrinking removing user-authored AndroidJavaSource.java files (those without a managed peer / absent from acw-map) by deriving their Java FQNs and emitting -keep class … { *; } rules when shrinking is enabled.

Changes:

Passes @(AndroidJavaSource) items with Bind != True to the R8 MSBuild task via a new JavaSourceFiles input.
Adds R8.GetUserJavaTypes() + R8.ReadJavaPackage() to derive the fully-qualified class names from .java sources and append -keep rules.
Adds unit tests for ReadJavaPackage parsing behavior across several common source layouts.

Show a summary per file

File	Description
src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets	Collects non-binding `AndroidJavaSource` items and forwards them to `R8` as `JavaSourceFiles`.
src/Xamarin.Android.Build.Tasks/Tasks/R8.cs	Adds Java package parsing + FQN derivation and appends `-keep` rules to the generated R8 app config.
src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/R8Tests.cs	Adds test coverage for `ReadJavaPackage()` parsing rules.

Copilot's findings

Files reviewed: 3/3 changed files
Comments generated: 2

* R8Tests: expected parameter is string? (TestCase passes null). * R8: comment that only the public top-level type is kept, and that ReadJavaPackage is a lightweight scan (package precedes types in practice). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

simonrozsival · 2026-06-29T11:08:57Z

/review

jonathanpeppers · 2026-06-29T13:26:18Z

+ <!-- User-authored AndroidJavaSource (Bind != True) is not in the acw-map; pass it to R8 so it
+ is kept when shrinking is enabled rather than silently removed. -->
+ <_R8KeepJavaSource Include="@(AndroidJavaSource)" Condition=" '%(AndroidJavaSource.Bind)' != 'True' " />


There is not an easy way to turn this off if you don't want it, but I can't think of a case you would need to do that.

…TypeManagers (#11799) ## Summary Bumps **external/Java.Interop** and aligns Mono.Android's reflection-based type and value managers with the new base-class contracts. The Java.Interop bump relaxes the `[DynamicallyAccessedMembers]` (DAM) requirements on the virtual members of `JniRuntime.ReflectionJniTypeManager` / `JniRuntime.ReflectionJniValueManager`, so the Mono.Android overrides no longer need to repeat those annotations and instead rely on targeted trimmer/AOT suppressions. This is a standalone slice of #11617 with no dependency on the trimmable type-map scanner/emitter or array codegen work. ## Changes - `external/Java.Interop` → `8d544738a` (from `70493645c`). - Drop now-redundant `[DynamicallyAccessedMembers]` annotations from the overrides in `AndroidTypeManager`, `ManagedTypeManager`, and `TrimmableTypeMapTypeManager` (`GetInvokerTypeCore`, `GetTypeForSimpleReference`, `RegisterNativeMembers`, `ActivatePeer`), replacing them with `[UnconditionalSuppressMessage]` where the trimmer still needs reassurance. - `JavaMarshalValueManager` now extends `JniRuntime.ReflectionJniValueManager` directly. It is marked `sealed` and carries `[RequiresDynamicCode]` / `[RequiresUnreferencedCode]`, uses the base `EnsureNotDisposed ()` helper, and drops its own dispose tracking and `ActivatePeer` override. - Remove the superseded `AndroidReflectionJniValueManager` and `SimpleValueManager` (and their `Mono.Android.csproj` entries). - `JNIEnvInit.CreateValueManager` creates the value manager through a local helper with the appropriate trimming/AOT suppressions for both the CoreCLR and NativeAOT paths. - No NativeAOT default change; the trimmable type/value managers are **not** part of this PR. ## Tests / baselines - Update the API-compatibility baseline: `Android.Graphics.ColorValueMarshaler.CreateGenericValue`'s `targetType` parameter no longer carries a DAM attribute (inherited from the Java.Interop base-class change). - Refresh `SimpleDotNet` CoreCLR/NativeAOT apkdesc size baselines and the NativeAOT `BuildHasNoWarnings` count, plus `BuildTest2`. ## Context Carved out of #11617. `JavaMarshalRegisteredPeers` extraction already merged via #11750. The trimmable managers, scanner/emitter, manifest, and R8 changes ship in their own PRs (#11749/#11751/#11753/#11769/#11794/#11796/#11798). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…11801) ## Summary This PR adds the two runtime managers that make the **trimmable typemap** a fully functional, reflection-free peer-resolution path: - **`TrimmableTypeMapValueManager`** — creates and tracks Java↔managed peers without reflection or `Activator`. - **`TrimmableTypeMapTypeManager`** — resolves managed↔Java type mappings by delegating to the generated `TrimmableTypeMap`. Both are selected through the existing `RuntimeFeature.TrimmableTypeMap` switch and wired into `JNIEnvInit`. The trimmable path is **opt-in**; the NativeAOT default remains `managed`, and Mono/CoreCLR defaults are unchanged. Also included is the `JavaConvert` collection-factory refactor and a generator fix that the trimmable managers depend on. ## Background The classic Java.Interop runtime resolves the managed `Type` for a Java instance (and vice-versa) using `Type.GetType`, `MakeGenericType`, and `Activator`-style construction. That is incompatible with trimming and NativeAOT: the trimmer can't see which types are reachable, and the types can't be created at runtime under AOT. The **trimmable typemap** replaces those reflection calls with a build-time-generated map of `JavaPeerProxy` objects (produced by `Microsoft.Android.Sdk.TrimmableTypeMap`). Each proxy knows how to construct a specific peer and describes its JNI ↔ managed association statically. Earlier PRs landed the generator, the proxy shapes (array / generic-base / interface / unresolvable peers), and the CoreCLR `JavaMarshal` value-manager split. **This PR adds the runtime managers that consume that generated map.** ## What's in this PR ### 1. `TrimmableTypeMapValueManager` (new) A `JniRuntime.JniValueManager` that performs peer creation with **no reflection**: - **Peer lifetime** (`AddPeer` / `PeekPeer` / `RemovePeer` / `FinalizePeer` / `CollectPeers` / `GetSurfacedPeers`) is delegated to `JavaMarshalRegisteredPeers`, i.e. the CoreCLR `JavaMarshal` GC-bridge machinery. `WaitForGCBridgeProcessing` is intentionally a no-op (documented: the wait can't close the bridge race on CoreCLR, where JNI wrapper threads hold their own `JniObjectReference` copies). - **`CreatePeer`** resolves the requested target type (mapping `object`/`IJavaPeerable` → `Java.Interop.JavaObject`, `Exception` → `JavaException`) and asks `TrimmableTypeMap.Instance.CreateInstance (handle, resolvedType)` to build the peer from a generated proxy. - **`ActivatePeer`** throws `PlatformNotSupportedException` — reflection-based activation is not part of this path. - **`NotFoundFallback`** carefully reproduces the base `JniValueManager.CreatePeer` contract so `JavaCast`/`JavaAs` still surface the correct outcome when no proxy is found: - target type has no Java mapping → `ArgumentException` - Java instance not assignable to the target's Java class → `null` (so `JavaAs` returns null / `JavaCast` throws `InvalidCastException`) - compatible classes but no proxy → `NotSupportedException` (a genuine generator gap, with a message pointing at the missing proxy) The assignability check honors `RuntimeFeature.IsAssignableFromCheck` and mirrors the legacy cast diagnostic when assembly logging is enabled. ### 2. `TrimmableTypeMapTypeManager` (new) A `JniRuntime.JniTypeManager` that has exactly two live responsibilities and throws for everything else it doesn't need: - **Managed → Java** via `GetTypeSignatureCore`, backed by a `ConcurrentDictionary<Type, JniTypeSignature>` cache. - **Java → managed** via `GetTypes` / `GetTypeForSimpleReference`, delegating to `TrimmableTypeMap`. - **Array handling** diverges by runtime: NativeAOT reads a pre-generated array-proxy map (types can't be built at runtime), while CoreCLR builds array/generic types dynamically to save app size (suppressions are scoped to the CoreCLR-only branch). ### 3. `JNIEnvInit` wiring `CreateValueManager` / `CreateTypeManager` now return the trimmable managers when `RuntimeFeature.TrimmableTypeMap` is set. The existing Mono / CoreCLR / managed selection is preserved, and the manager constructions were refactored into small local helpers so trimming suppressions (`IL2026` / `IL3050`) apply only to the exact branch that needs them. `RegisterJniNatives` is likewise gated so the reflection-based JNI registration path isn't emitted for the trimmable typemap. ### 4. `JavaConvert` collection-factory refactor Generic collection marshalling (`IDictionary<,>` → `JavaDictionary<,>`, `IList<>` → `JavaList<>`, `ICollection<>` → `JavaCollection<>`) is split into two branches: a **factory-based converter** on the trimmable path (no `MakeGenericType`) and the classic `MakeGenericType` path elsewhere, with the reflection-requiring code isolated behind narrowly-scoped suppressions. Also adds `Nullable<T>` converter handling (null reference → null value). ### 5. Generator fix (`ModelBuilder`) Emits a managed→Java typemap entry for **self-peer types** (`[JniTypeSignature(GenerateJavaPeer=false)]` or MCW bindings with no activation ctor). These are constructed managed-side with `new`, but their JNI name must still resolve so the correct Java class is instantiated; without the association they fell back to the generic `mono.android.runtime.JavaObject` peer and threw `ArrayStoreException` when placed into a typed Java array. ### 6. Cleanup Removes the dead `TrimmableTypeMap` branch from `JavaMarshalValueManager` (that logic now lives in the dedicated `TrimmableTypeMapValueManager`). ## Behavioral impact - **Opt-in only.** With `RuntimeFeature.TrimmableTypeMap` unset, behavior is unchanged. NativeAOT still defaults to `managed`. - No new user-facing / localized strings; error messages point at the generator when a proxy is genuinely missing. ## Status All earlier prerequisites have **merged into `main`**, and this PR is **rebased on latest `main`**, so it is no longer stacked or blocked — it contains only the value/type-manager implementations (plus the supporting `JavaConvert` and generator changes) on top of them: - #11799 — CoreCLR `JavaMarshal` split + Java.Interop bump - #11753 array proxies · #11749 generic base · #11751 unresolvable peers · #11769 interface proxies - #11794 multidex/manifest base · #11796 manifest parity · #11798 R8 keep ## Testing - `TrimmableTypeMapTypeManagerTests` and `TypeMapModelBuilderTests` updated/extended for the new type resolution and the self-peer generator fix. - Export tests enabled for the trimmable typemap; `TrimmableTypeMapUnsupported` cases excluded. - NativeAOT warning-count and CoreCLR `apkdesc` baselines updated to match.

simonrozsival · 2026-06-29T07:59:00Z

Problem

When R8 code shrinking is enabled, R8 removes any Java type that nothing keeps. .NET for Android keeps the Java callable wrappers (JCWs) of bound managed types by generating -keep rules from the acw-map (managed peer ↔ Java type). That works for generated JCWs, but user-authored AndroidJavaSource.java files marked Bind != true have no managed peer, so they never appear in the acw-map — and therefore get no keep rule. With shrinking on, R8 silently deletes them, and the app fails at runtime when it references those classes (often as a NoClassDefFoundError that only reproduces in Release/shrunk builds).

Fix

Pass user AndroidJavaSource (Bind != True) to the R8 task and emit -keep class <package>.<Type> { *; } for each, so user Java survives shrinking:

D8.targets — collect @(AndroidJavaSource) items where %(Bind) != 'True' into _R8KeepJavaSource and pass them to R8 via the new JavaSourceFiles property.
R8.cs — append keep rules in the same block that emits acw-map keeps. GetUserJavaTypes() derives the fully-qualified name as <package>.<FileNameWithoutExtension> (Java requires the public top-level type name to match the file name); ReadJavaPackage() parses the package declaration, skipping comments and stopping at the first import/type declaration. Names are de-duplicated.
R8Tests.cs — unit tests covering ReadJavaPackage: package present, trailing space before ;, comment headers, no package, and package after import/type (ignored).

Why split out

This is being carved out of the trimmable typemap mega-PR #11617. Although the bug surfaced while bringing up the NativeAOT trimmable path, it is not trimmable-specific — the acw-map keep logic and R8 shrinking apply equally to legacy/MonoVM and CoreCLR, so user AndroidJavaSource was at risk of being shrunk there too. Landing it independently de-risks #11617 and ships a general correctness fix sooner.

Context / related PRs

[TrimmableTypeMap] Implement reflection-free TrimmableTypeMapValueManager and TrimmableTypeMapTypeManager #11617 — parent mega-PR (reflection-free trimmable typemap) this is sliced from.
[NativeAOT] Remove managed NativeAOT type map in favor of the trimmable type map #11643 — removes the managed NativeAOT typemap in favor of the trimmable one (the path that exposed this gap).
Sibling slices already split out off main: [TrimmableTypeMap] Honor AndroidApplicationJavaClass for the JCW base and manifest #11794 (AndroidApplicationJavaClass/multidex), [TrimmableTypeMap] Complete trimmable manifest generation parity #11796 (manifest generation parity). Other merged groundwork: [TrimmableTypeMap] Fix inherited generic base typemap refs #11749, [TrimmableTypeMap] Skip unresolvable trimmable typemap peers #11751, [TrimmableTypeMap] Fix trimmable manifest generation parity #11752, [TrimmableTypeMap] Add trimmable array proxy mapping #11753, [TrimmableTypeMap] Improve trimmable typemap build incrementality #11764, [TrimmableTypeMap] Use non-generic JavaPeerProxy base for interface proxies (NativeAOT) #11769.

Verification

24/24 R8 unit tests pass (18 existing + 6 new). BuildAfterMultiDexIsNotRequired verified locally on NativeAOT and CoreCLR — user Java is retained after shrinking.

The trimmable NativeAOT path enables R8 with shrinking (AndroidLinkTool=r8 -> _R8EnableShrinking=True). When the application ProGuard config is generated from the acw-map (the default, UseTrimmableNativeAotProguardConfiguration=false), the R8 task only emits -keep rules for managed-mapped Java types. User-authored AndroidJavaSource (Bind != true) has no managed peer and is therefore absent from the acw-map, so R8 shrank it away. This made BuildAfterMultiDexIsNotRequired fail on NativeAOT: the huge ManyMethods.java classes were removed, so multidex was no longer required and classes2.dex was never produced. Pass the user AndroidJavaSource (.java with Bind != true) to the R8 task and emit '-keep class <package>.<Type> { *; }' for each, so user Java survives shrinking. The type name is '<package>.<FileNameWithoutExtension>' (Java requires the public top-level type name to match the file name). Verified locally: BuildAfterMultiDexIsNotRequired(NativeAOT) and (CoreCLR) pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Cover package detection: present, trailing space, comment headers, no package, and package-after-import/type (ignored). Exposes ReadJavaPackage as internal for direct testing, matching the TryGetDisallowedOption pattern. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

Fixes R8 shrinking removing user-authored AndroidJavaSource.java files (those without a managed peer / absent from acw-map) by deriving their Java FQNs and emitting -keep class … { *; } rules when shrinking is enabled.

Changes:

Passes @(AndroidJavaSource) items with Bind != True to the R8 MSBuild task via a new JavaSourceFiles input.
Adds R8.GetUserJavaTypes() + R8.ReadJavaPackage() to derive the fully-qualified class names from .java sources and append -keep rules.
Adds unit tests for ReadJavaPackage parsing behavior across several common source layouts.

Show a summary per file

File	Description
src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets	Collects non-binding `AndroidJavaSource` items and forwards them to `R8` as `JavaSourceFiles`.
src/Xamarin.Android.Build.Tasks/Tasks/R8.cs	Adds Java package parsing + FQN derivation and appends `-keep` rules to the generated R8 app config.
src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/R8Tests.cs	Adds test coverage for `ReadJavaPackage()` parsing rules.

Copilot's findings

Files reviewed: 3/3 changed files
Comments generated: 2

* R8Tests: expected parameter is string? (TestCase passes null). * R8: comment that only the public top-level type is kept, and that ReadJavaPackage is a lightweight scan (package precedes types in practice). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

simonrozsival · 2026-06-29T11:08:57Z

/review

jonathanpeppers · 2026-06-29T13:26:18Z

+ <!-- User-authored AndroidJavaSource (Bind != True) is not in the acw-map; pass it to R8 so it
+ is kept when shrinking is enabled rather than silently removed. -->
+ <_R8KeepJavaSource Include="@(AndroidJavaSource)" Condition=" '%(AndroidJavaSource.Bind)' != 'True' " />


There is not an easy way to turn this off if you don't want it, but I can't think of a case you would need to do that.

…TypeManagers (#11799) ## Summary Bumps **external/Java.Interop** and aligns Mono.Android's reflection-based type and value managers with the new base-class contracts. The Java.Interop bump relaxes the `[DynamicallyAccessedMembers]` (DAM) requirements on the virtual members of `JniRuntime.ReflectionJniTypeManager` / `JniRuntime.ReflectionJniValueManager`, so the Mono.Android overrides no longer need to repeat those annotations and instead rely on targeted trimmer/AOT suppressions. This is a standalone slice of #11617 with no dependency on the trimmable type-map scanner/emitter or array codegen work. ## Changes - `external/Java.Interop` → `8d544738a` (from `70493645c`). - Drop now-redundant `[DynamicallyAccessedMembers]` annotations from the overrides in `AndroidTypeManager`, `ManagedTypeManager`, and `TrimmableTypeMapTypeManager` (`GetInvokerTypeCore`, `GetTypeForSimpleReference`, `RegisterNativeMembers`, `ActivatePeer`), replacing them with `[UnconditionalSuppressMessage]` where the trimmer still needs reassurance. - `JavaMarshalValueManager` now extends `JniRuntime.ReflectionJniValueManager` directly. It is marked `sealed` and carries `[RequiresDynamicCode]` / `[RequiresUnreferencedCode]`, uses the base `EnsureNotDisposed ()` helper, and drops its own dispose tracking and `ActivatePeer` override. - Remove the superseded `AndroidReflectionJniValueManager` and `SimpleValueManager` (and their `Mono.Android.csproj` entries). - `JNIEnvInit.CreateValueManager` creates the value manager through a local helper with the appropriate trimming/AOT suppressions for both the CoreCLR and NativeAOT paths. - No NativeAOT default change; the trimmable type/value managers are **not** part of this PR. ## Tests / baselines - Update the API-compatibility baseline: `Android.Graphics.ColorValueMarshaler.CreateGenericValue`'s `targetType` parameter no longer carries a DAM attribute (inherited from the Java.Interop base-class change). - Refresh `SimpleDotNet` CoreCLR/NativeAOT apkdesc size baselines and the NativeAOT `BuildHasNoWarnings` count, plus `BuildTest2`. ## Context Carved out of #11617. `JavaMarshalRegisteredPeers` extraction already merged via #11750. The trimmable managers, scanner/emitter, manifest, and R8 changes ship in their own PRs (#11749/#11751/#11753/#11769/#11794/#11796/#11798). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…11801) ## Summary This PR adds the two runtime managers that make the **trimmable typemap** a fully functional, reflection-free peer-resolution path: - **`TrimmableTypeMapValueManager`** — creates and tracks Java↔managed peers without reflection or `Activator`. - **`TrimmableTypeMapTypeManager`** — resolves managed↔Java type mappings by delegating to the generated `TrimmableTypeMap`. Both are selected through the existing `RuntimeFeature.TrimmableTypeMap` switch and wired into `JNIEnvInit`. The trimmable path is **opt-in**; the NativeAOT default remains `managed`, and Mono/CoreCLR defaults are unchanged. Also included is the `JavaConvert` collection-factory refactor and a generator fix that the trimmable managers depend on. ## Background The classic Java.Interop runtime resolves the managed `Type` for a Java instance (and vice-versa) using `Type.GetType`, `MakeGenericType`, and `Activator`-style construction. That is incompatible with trimming and NativeAOT: the trimmer can't see which types are reachable, and the types can't be created at runtime under AOT. The **trimmable typemap** replaces those reflection calls with a build-time-generated map of `JavaPeerProxy` objects (produced by `Microsoft.Android.Sdk.TrimmableTypeMap`). Each proxy knows how to construct a specific peer and describes its JNI ↔ managed association statically. Earlier PRs landed the generator, the proxy shapes (array / generic-base / interface / unresolvable peers), and the CoreCLR `JavaMarshal` value-manager split. **This PR adds the runtime managers that consume that generated map.** ## What's in this PR ### 1. `TrimmableTypeMapValueManager` (new) A `JniRuntime.JniValueManager` that performs peer creation with **no reflection**: - **Peer lifetime** (`AddPeer` / `PeekPeer` / `RemovePeer` / `FinalizePeer` / `CollectPeers` / `GetSurfacedPeers`) is delegated to `JavaMarshalRegisteredPeers`, i.e. the CoreCLR `JavaMarshal` GC-bridge machinery. `WaitForGCBridgeProcessing` is intentionally a no-op (documented: the wait can't close the bridge race on CoreCLR, where JNI wrapper threads hold their own `JniObjectReference` copies). - **`CreatePeer`** resolves the requested target type (mapping `object`/`IJavaPeerable` → `Java.Interop.JavaObject`, `Exception` → `JavaException`) and asks `TrimmableTypeMap.Instance.CreateInstance (handle, resolvedType)` to build the peer from a generated proxy. - **`ActivatePeer`** throws `PlatformNotSupportedException` — reflection-based activation is not part of this path. - **`NotFoundFallback`** carefully reproduces the base `JniValueManager.CreatePeer` contract so `JavaCast`/`JavaAs` still surface the correct outcome when no proxy is found: - target type has no Java mapping → `ArgumentException` - Java instance not assignable to the target's Java class → `null` (so `JavaAs` returns null / `JavaCast` throws `InvalidCastException`) - compatible classes but no proxy → `NotSupportedException` (a genuine generator gap, with a message pointing at the missing proxy) The assignability check honors `RuntimeFeature.IsAssignableFromCheck` and mirrors the legacy cast diagnostic when assembly logging is enabled. ### 2. `TrimmableTypeMapTypeManager` (new) A `JniRuntime.JniTypeManager` that has exactly two live responsibilities and throws for everything else it doesn't need: - **Managed → Java** via `GetTypeSignatureCore`, backed by a `ConcurrentDictionary<Type, JniTypeSignature>` cache. - **Java → managed** via `GetTypes` / `GetTypeForSimpleReference`, delegating to `TrimmableTypeMap`. - **Array handling** diverges by runtime: NativeAOT reads a pre-generated array-proxy map (types can't be built at runtime), while CoreCLR builds array/generic types dynamically to save app size (suppressions are scoped to the CoreCLR-only branch). ### 3. `JNIEnvInit` wiring `CreateValueManager` / `CreateTypeManager` now return the trimmable managers when `RuntimeFeature.TrimmableTypeMap` is set. The existing Mono / CoreCLR / managed selection is preserved, and the manager constructions were refactored into small local helpers so trimming suppressions (`IL2026` / `IL3050`) apply only to the exact branch that needs them. `RegisterJniNatives` is likewise gated so the reflection-based JNI registration path isn't emitted for the trimmable typemap. ### 4. `JavaConvert` collection-factory refactor Generic collection marshalling (`IDictionary<,>` → `JavaDictionary<,>`, `IList<>` → `JavaList<>`, `ICollection<>` → `JavaCollection<>`) is split into two branches: a **factory-based converter** on the trimmable path (no `MakeGenericType`) and the classic `MakeGenericType` path elsewhere, with the reflection-requiring code isolated behind narrowly-scoped suppressions. Also adds `Nullable<T>` converter handling (null reference → null value). ### 5. Generator fix (`ModelBuilder`) Emits a managed→Java typemap entry for **self-peer types** (`[JniTypeSignature(GenerateJavaPeer=false)]` or MCW bindings with no activation ctor). These are constructed managed-side with `new`, but their JNI name must still resolve so the correct Java class is instantiated; without the association they fell back to the generic `mono.android.runtime.JavaObject` peer and threw `ArrayStoreException` when placed into a typed Java array. ### 6. Cleanup Removes the dead `TrimmableTypeMap` branch from `JavaMarshalValueManager` (that logic now lives in the dedicated `TrimmableTypeMapValueManager`). ## Behavioral impact - **Opt-in only.** With `RuntimeFeature.TrimmableTypeMap` unset, behavior is unchanged. NativeAOT still defaults to `managed`. - No new user-facing / localized strings; error messages point at the generator when a proxy is genuinely missing. ## Status All earlier prerequisites have **merged into `main`**, and this PR is **rebased on latest `main`**, so it is no longer stacked or blocked — it contains only the value/type-manager implementations (plus the supporting `JavaConvert` and generator changes) on top of them: - #11799 — CoreCLR `JavaMarshal` split + Java.Interop bump - #11753 array proxies · #11749 generic base · #11751 unresolvable peers · #11769 interface proxies - #11794 multidex/manifest base · #11796 manifest parity · #11798 R8 keep ## Testing - `TrimmableTypeMapTypeManagerTests` and `TypeMapModelBuilderTests` updated/extended for the new type resolution and the self-peer generator fix. - Export tests enabled for the trimmable typemap; `TrimmableTypeMapUnsupported` cases excluded. - NativeAOT warning-count and CoreCLR `apkdesc` baselines updated to match.

simonrozsival · 2026-06-29T07:59:00Z

Problem

When R8 code shrinking is enabled, R8 removes any Java type that nothing keeps. .NET for Android keeps the Java callable wrappers (JCWs) of bound managed types by generating -keep rules from the acw-map (managed peer ↔ Java type). That works for generated JCWs, but user-authored AndroidJavaSource.java files marked Bind != true have no managed peer, so they never appear in the acw-map — and therefore get no keep rule. With shrinking on, R8 silently deletes them, and the app fails at runtime when it references those classes (often as a NoClassDefFoundError that only reproduces in Release/shrunk builds).

Fix

Pass user AndroidJavaSource (Bind != True) to the R8 task and emit -keep class <package>.<Type> { *; } for each, so user Java survives shrinking:

D8.targets — collect @(AndroidJavaSource) items where %(Bind) != 'True' into _R8KeepJavaSource and pass them to R8 via the new JavaSourceFiles property.
R8.cs — append keep rules in the same block that emits acw-map keeps. GetUserJavaTypes() derives the fully-qualified name as <package>.<FileNameWithoutExtension> (Java requires the public top-level type name to match the file name); ReadJavaPackage() parses the package declaration, skipping comments and stopping at the first import/type declaration. Names are de-duplicated.
R8Tests.cs — unit tests covering ReadJavaPackage: package present, trailing space before ;, comment headers, no package, and package after import/type (ignored).

Why split out

This is being carved out of the trimmable typemap mega-PR #11617. Although the bug surfaced while bringing up the NativeAOT trimmable path, it is not trimmable-specific — the acw-map keep logic and R8 shrinking apply equally to legacy/MonoVM and CoreCLR, so user AndroidJavaSource was at risk of being shrunk there too. Landing it independently de-risks #11617 and ships a general correctness fix sooner.

Context / related PRs

[TrimmableTypeMap] Implement reflection-free TrimmableTypeMapValueManager and TrimmableTypeMapTypeManager #11617 — parent mega-PR (reflection-free trimmable typemap) this is sliced from.
[NativeAOT] Remove managed NativeAOT type map in favor of the trimmable type map #11643 — removes the managed NativeAOT typemap in favor of the trimmable one (the path that exposed this gap).
Sibling slices already split out off main: [TrimmableTypeMap] Honor AndroidApplicationJavaClass for the JCW base and manifest #11794 (AndroidApplicationJavaClass/multidex), [TrimmableTypeMap] Complete trimmable manifest generation parity #11796 (manifest generation parity). Other merged groundwork: [TrimmableTypeMap] Fix inherited generic base typemap refs #11749, [TrimmableTypeMap] Skip unresolvable trimmable typemap peers #11751, [TrimmableTypeMap] Fix trimmable manifest generation parity #11752, [TrimmableTypeMap] Add trimmable array proxy mapping #11753, [TrimmableTypeMap] Improve trimmable typemap build incrementality #11764, [TrimmableTypeMap] Use non-generic JavaPeerProxy base for interface proxies (NativeAOT) #11769.

Verification

24/24 R8 unit tests pass (18 existing + 6 new). BuildAfterMultiDexIsNotRequired verified locally on NativeAOT and CoreCLR — user Java is retained after shrinking.

The trimmable NativeAOT path enables R8 with shrinking (AndroidLinkTool=r8 -> _R8EnableShrinking=True). When the application ProGuard config is generated from the acw-map (the default, UseTrimmableNativeAotProguardConfiguration=false), the R8 task only emits -keep rules for managed-mapped Java types. User-authored AndroidJavaSource (Bind != true) has no managed peer and is therefore absent from the acw-map, so R8 shrank it away. This made BuildAfterMultiDexIsNotRequired fail on NativeAOT: the huge ManyMethods.java classes were removed, so multidex was no longer required and classes2.dex was never produced. Pass the user AndroidJavaSource (.java with Bind != true) to the R8 task and emit '-keep class <package>.<Type> { *; }' for each, so user Java survives shrinking. The type name is '<package>.<FileNameWithoutExtension>' (Java requires the public top-level type name to match the file name). Verified locally: BuildAfterMultiDexIsNotRequired(NativeAOT) and (CoreCLR) pass. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Cover package detection: present, trailing space, comment headers, no package, and package-after-import/type (ignored). Exposes ReadJavaPackage as internal for direct testing, matching the TryGetDisallowedOption pattern. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot

Pull request overview

Fixes R8 shrinking removing user-authored AndroidJavaSource.java files (those without a managed peer / absent from acw-map) by deriving their Java FQNs and emitting -keep class … { *; } rules when shrinking is enabled.

Changes:

Passes @(AndroidJavaSource) items with Bind != True to the R8 MSBuild task via a new JavaSourceFiles input.
Adds R8.GetUserJavaTypes() + R8.ReadJavaPackage() to derive the fully-qualified class names from .java sources and append -keep rules.
Adds unit tests for ReadJavaPackage parsing behavior across several common source layouts.

Show a summary per file

File	Description
src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets	Collects non-binding `AndroidJavaSource` items and forwards them to `R8` as `JavaSourceFiles`.
src/Xamarin.Android.Build.Tasks/Tasks/R8.cs	Adds Java package parsing + FQN derivation and appends `-keep` rules to the generated R8 app config.
src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/R8Tests.cs	Adds test coverage for `ReadJavaPackage()` parsing rules.

Copilot's findings

Files reviewed: 3/3 changed files
Comments generated: 2

* R8Tests: expected parameter is string? (TestCase passes null). * R8: comment that only the public top-level type is kept, and that ReadJavaPackage is a lightweight scan (package precedes types in practice). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

simonrozsival · 2026-06-29T11:08:57Z

/review

jonathanpeppers · 2026-06-29T13:26:18Z

+ <!-- User-authored AndroidJavaSource (Bind != True) is not in the acw-map; pass it to R8 so it
+ is kept when shrinking is enabled rather than silently removed. -->
+ <_R8KeepJavaSource Include="@(AndroidJavaSource)" Condition=" '%(AndroidJavaSource.Bind)' != 'True' " />


There is not an easy way to turn this off if you don't want it, but I can't think of a case you would need to do that.

…TypeManagers (#11799) ## Summary Bumps **external/Java.Interop** and aligns Mono.Android's reflection-based type and value managers with the new base-class contracts. The Java.Interop bump relaxes the `[DynamicallyAccessedMembers]` (DAM) requirements on the virtual members of `JniRuntime.ReflectionJniTypeManager` / `JniRuntime.ReflectionJniValueManager`, so the Mono.Android overrides no longer need to repeat those annotations and instead rely on targeted trimmer/AOT suppressions. This is a standalone slice of #11617 with no dependency on the trimmable type-map scanner/emitter or array codegen work. ## Changes - `external/Java.Interop` → `8d544738a` (from `70493645c`). - Drop now-redundant `[DynamicallyAccessedMembers]` annotations from the overrides in `AndroidTypeManager`, `ManagedTypeManager`, and `TrimmableTypeMapTypeManager` (`GetInvokerTypeCore`, `GetTypeForSimpleReference`, `RegisterNativeMembers`, `ActivatePeer`), replacing them with `[UnconditionalSuppressMessage]` where the trimmer still needs reassurance. - `JavaMarshalValueManager` now extends `JniRuntime.ReflectionJniValueManager` directly. It is marked `sealed` and carries `[RequiresDynamicCode]` / `[RequiresUnreferencedCode]`, uses the base `EnsureNotDisposed ()` helper, and drops its own dispose tracking and `ActivatePeer` override. - Remove the superseded `AndroidReflectionJniValueManager` and `SimpleValueManager` (and their `Mono.Android.csproj` entries). - `JNIEnvInit.CreateValueManager` creates the value manager through a local helper with the appropriate trimming/AOT suppressions for both the CoreCLR and NativeAOT paths. - No NativeAOT default change; the trimmable type/value managers are **not** part of this PR. ## Tests / baselines - Update the API-compatibility baseline: `Android.Graphics.ColorValueMarshaler.CreateGenericValue`'s `targetType` parameter no longer carries a DAM attribute (inherited from the Java.Interop base-class change). - Refresh `SimpleDotNet` CoreCLR/NativeAOT apkdesc size baselines and the NativeAOT `BuildHasNoWarnings` count, plus `BuildTest2`. ## Context Carved out of #11617. `JavaMarshalRegisteredPeers` extraction already merged via #11750. The trimmable managers, scanner/emitter, manifest, and R8 changes ship in their own PRs (#11749/#11751/#11753/#11769/#11794/#11796/#11798). Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

…11801) ## Summary This PR adds the two runtime managers that make the **trimmable typemap** a fully functional, reflection-free peer-resolution path: - **`TrimmableTypeMapValueManager`** — creates and tracks Java↔managed peers without reflection or `Activator`. - **`TrimmableTypeMapTypeManager`** — resolves managed↔Java type mappings by delegating to the generated `TrimmableTypeMap`. Both are selected through the existing `RuntimeFeature.TrimmableTypeMap` switch and wired into `JNIEnvInit`. The trimmable path is **opt-in**; the NativeAOT default remains `managed`, and Mono/CoreCLR defaults are unchanged. Also included is the `JavaConvert` collection-factory refactor and a generator fix that the trimmable managers depend on. ## Background The classic Java.Interop runtime resolves the managed `Type` for a Java instance (and vice-versa) using `Type.GetType`, `MakeGenericType`, and `Activator`-style construction. That is incompatible with trimming and NativeAOT: the trimmer can't see which types are reachable, and the types can't be created at runtime under AOT. The **trimmable typemap** replaces those reflection calls with a build-time-generated map of `JavaPeerProxy` objects (produced by `Microsoft.Android.Sdk.TrimmableTypeMap`). Each proxy knows how to construct a specific peer and describes its JNI ↔ managed association statically. Earlier PRs landed the generator, the proxy shapes (array / generic-base / interface / unresolvable peers), and the CoreCLR `JavaMarshal` value-manager split. **This PR adds the runtime managers that consume that generated map.** ## What's in this PR ### 1. `TrimmableTypeMapValueManager` (new) A `JniRuntime.JniValueManager` that performs peer creation with **no reflection**: - **Peer lifetime** (`AddPeer` / `PeekPeer` / `RemovePeer` / `FinalizePeer` / `CollectPeers` / `GetSurfacedPeers`) is delegated to `JavaMarshalRegisteredPeers`, i.e. the CoreCLR `JavaMarshal` GC-bridge machinery. `WaitForGCBridgeProcessing` is intentionally a no-op (documented: the wait can't close the bridge race on CoreCLR, where JNI wrapper threads hold their own `JniObjectReference` copies). - **`CreatePeer`** resolves the requested target type (mapping `object`/`IJavaPeerable` → `Java.Interop.JavaObject`, `Exception` → `JavaException`) and asks `TrimmableTypeMap.Instance.CreateInstance (handle, resolvedType)` to build the peer from a generated proxy. - **`ActivatePeer`** throws `PlatformNotSupportedException` — reflection-based activation is not part of this path. - **`NotFoundFallback`** carefully reproduces the base `JniValueManager.CreatePeer` contract so `JavaCast`/`JavaAs` still surface the correct outcome when no proxy is found: - target type has no Java mapping → `ArgumentException` - Java instance not assignable to the target's Java class → `null` (so `JavaAs` returns null / `JavaCast` throws `InvalidCastException`) - compatible classes but no proxy → `NotSupportedException` (a genuine generator gap, with a message pointing at the missing proxy) The assignability check honors `RuntimeFeature.IsAssignableFromCheck` and mirrors the legacy cast diagnostic when assembly logging is enabled. ### 2. `TrimmableTypeMapTypeManager` (new) A `JniRuntime.JniTypeManager` that has exactly two live responsibilities and throws for everything else it doesn't need: - **Managed → Java** via `GetTypeSignatureCore`, backed by a `ConcurrentDictionary<Type, JniTypeSignature>` cache. - **Java → managed** via `GetTypes` / `GetTypeForSimpleReference`, delegating to `TrimmableTypeMap`. - **Array handling** diverges by runtime: NativeAOT reads a pre-generated array-proxy map (types can't be built at runtime), while CoreCLR builds array/generic types dynamically to save app size (suppressions are scoped to the CoreCLR-only branch). ### 3. `JNIEnvInit` wiring `CreateValueManager` / `CreateTypeManager` now return the trimmable managers when `RuntimeFeature.TrimmableTypeMap` is set. The existing Mono / CoreCLR / managed selection is preserved, and the manager constructions were refactored into small local helpers so trimming suppressions (`IL2026` / `IL3050`) apply only to the exact branch that needs them. `RegisterJniNatives` is likewise gated so the reflection-based JNI registration path isn't emitted for the trimmable typemap. ### 4. `JavaConvert` collection-factory refactor Generic collection marshalling (`IDictionary<,>` → `JavaDictionary<,>`, `IList<>` → `JavaList<>`, `ICollection<>` → `JavaCollection<>`) is split into two branches: a **factory-based converter** on the trimmable path (no `MakeGenericType`) and the classic `MakeGenericType` path elsewhere, with the reflection-requiring code isolated behind narrowly-scoped suppressions. Also adds `Nullable<T>` converter handling (null reference → null value). ### 5. Generator fix (`ModelBuilder`) Emits a managed→Java typemap entry for **self-peer types** (`[JniTypeSignature(GenerateJavaPeer=false)]` or MCW bindings with no activation ctor). These are constructed managed-side with `new`, but their JNI name must still resolve so the correct Java class is instantiated; without the association they fell back to the generic `mono.android.runtime.JavaObject` peer and threw `ArrayStoreException` when placed into a typed Java array. ### 6. Cleanup Removes the dead `TrimmableTypeMap` branch from `JavaMarshalValueManager` (that logic now lives in the dedicated `TrimmableTypeMapValueManager`). ## Behavioral impact - **Opt-in only.** With `RuntimeFeature.TrimmableTypeMap` unset, behavior is unchanged. NativeAOT still defaults to `managed`. - No new user-facing / localized strings; error messages point at the generator when a proxy is genuinely missing. ## Status All earlier prerequisites have **merged into `main`**, and this PR is **rebased on latest `main`**, so it is no longer stacked or blocked — it contains only the value/type-manager implementations (plus the supporting `JavaConvert` and generator changes) on top of them: - #11799 — CoreCLR `JavaMarshal` split + Java.Interop bump - #11753 array proxies · #11749 generic base · #11751 unresolvable peers · #11769 interface proxies - #11794 multidex/manifest base · #11796 manifest parity · #11798 R8 keep ## Testing - `TrimmableTypeMapTypeManagerTests` and `TypeMapModelBuilderTests` updated/extended for the new type resolution and the self-peer generator fix. - Export tests enabled for the trimmable typemap; `TrimmableTypeMapUnsupported` cases excluded. - NativeAOT warning-count and CoreCLR `apkdesc` baselines updated to match.

simonrozsivaland others added 2 commits June 29, 2026 09:54

CopilotAI review requested due to automatic review settings June 29, 2026 07:59

simonrozsival requested a review from jonathanpeppers as a code owner June 29, 2026 07:59

simonrozsival added copilot `copilot-cli` or other AIs were used to author this trimmable-type-map labels Jun 29, 2026

Copilotstarted reviewing on behalf of simonrozsival June 29, 2026 07:59 View session

CopilotAI reviewed Jun 29, 2026
View reviewed changes

Comment threadsrc/Xamarin.Android.Build.Tasks/Tasks/R8.cs
Comment threadsrc/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/R8Tests.cs Outdated

simonrozsival mentioned this pull request Jun 29, 2026
[TrimmableTypeMap] Java.Interop bump and update to ValueManagers and TypeManagers #11799
Merged

simonrozsival added the ready-to-review This PR is ready to review/merge, I think any CI failures are just flaky (ignorable). label Jun 29, 2026

simonrozsival mentioned this pull request Jun 29, 2026
[TrimmableTypeMap] Reflection-free TrimmableTypeMapType/ValueManager #11801
Merged

jonathanpeppers approved these changes Jun 29, 2026
View reviewed changes

jonathanpeppers merged commit e86f075 into mainJun 29, 2026
40 checks passed

jonathanpeppers deleted the dev/simonrozsival/r8-keep-user-java branch June 29, 2026 13:27

jonathanpeppers mentioned this pull request Jun 29, 2026
[TrimmableTypeMap] Keep user AndroidJavaSource Java under R8 shrinking #11790
Closed

simonrozsival mentioned this pull request Jul 7, 2026
[NativeAOT] Make the trimmable typemap the default #11822
Closed

github-actionsBot locked and limited conversation to collaborators Jul 30, 2026