[TrimmableTypeMap] Improve array handling

[simonrozsival]

Summary

Replaces the per-T JavaPeerContainerFactory<T>.CreateArray factory with a runtime fork that uses the .NET runtime type loader on CoreCLR/Mono and a per-rank trimmable typemap on NativeAOT. Eliminates the per-peer array-creation IL bloat that JavaPeerContainerFactory<T> was contributing — without the trim regressions we evaluated through several alternative designs (see Considered alternatives at the end).

Tracking: #11234 Phase 2 (arrays-only — container types JavaList<T> / JavaCollection<T> / JavaDictionary<K, V> stay untouched and have their own follow-up PR).

Runtime fork

JNIEnv.ArrayCreateInstance branches on RuntimeFeature.IsDynamicCodeSupported:

if (RuntimeFeature.TrimmableTypeMap) {
    if (System.Runtime.CompilerServices.RuntimeFeature.IsDynamicCodeSupported) {
        // CoreCLR / Mono — runtime type loader can construct any T[] dynamically.
        // No typemap roundtrip; supports unlimited array rank.
        return Array.CreateInstance (elementType, length);
    }
    // NativeAOT — resolve via per-rank trimmable typemap +
    // AOT-safe Array.CreateInstanceFromArrayType.
    if (TrimmableTypeMap.Instance.TryGetArrayType (elementType, out var arrayType)) {
        return Array.CreateInstanceFromArrayType (arrayType, length);
    }
    throw new NotSupportedException ("...");
}
// legacy non-trimmable fallback unchanged

Why fork? CoreCLR's runtime type loader can construct any T[] from its element-type metadata at runtime, so going through the typemap is unnecessary work and trim warnings. NativeAOT cannot (value-type arrays each need their own codegen, and our marshaling call sites are opaque to the trimmer), so the typemap is the only AOT-safe route.

Generator changes

For every non-aliased, non-generic peer (excluding JNI primitive-keyword keys), the generator emits three speculative TypeMap entries keyed by the element JNI name and anchored to per-typemap-assembly rank sentinel TypeDefs:

// Inside each per-assembly typemap dll, when $(PublishAot) == true:
internal sealed class __ArrayMapRank1 { }
internal sealed class __ArrayMapRank2 { }
internal sealed class __ArrayMapRank3 { }

[assembly: TypeMap<__ArrayMapRank1>("java/lang/String", typeof(string[]),     typeof(string[]))]
[assembly: TypeMap<__ArrayMapRank2>("java/lang/String", typeof(string[][]),   typeof(string[][]))]
[assembly: TypeMap<__ArrayMapRank3>("java/lang/String", typeof(string[][][]), typeof(string[][][]))]

• Trim target = closed array type so ILC's per-shape conditional drops the entry when the array shape is never constructed (validated at ~/Projects/playground/TestTypeMapArrays with disjoint type sets — works for both ref- and value-type elements).
• Element-only JNI keys — no "[" + "L" + jni + ";" runtime concat.
• Per-rank groups — rank is a switch dispatch at runtime, not part of the key. The __ArrayMapRank{N} sentinels mirror the existing __TypeMapAnchor pattern (per-assembly, like generic anchor types).
• Conditional emission gated on $(PublishAot) == true. Saves attribute metadata on CoreCLR-only builds where the runtime fork bypasses the typemap entirely.
• Skip rules: open-generic peers (typeof(T<>[]) invalid), JNI primitive-keyword keys (handled by the legacy primitive-array path), alias groups (would produce duplicate keys; deferred until alias-aware design).

Runtime API

ITypeMapWithAliasing gains:

bool TryGetArrayType (string jniElementTypeName, int rank, [NotNullWhen (true)] out Type? arrayType);

SingleUniverseTypeMap carries three nullable IReadOnlyDictionary<string, Type>? fields (rank 1, 2, 3); AggregateTypeMap does first-wins iteration. TrimmableTypeMap.Initialize gains 5-arg overloads (single + aggregate) accepting the per-rank dicts; the existing 2-arg overloads stay as wrappers passing null per-rank dicts.

TrimmableTypeMap.TryGetArrayType(Type elementType, out Type? arrayType) walks down elementType.IsArray / GetElementType() to find the leaf type and the element array depth, resolves the leaf JNI element name (primitive static dict OR TryGetJniNameForManagedType wrapped), and delegates the (elementJni, rank=elementDepth+1) lookup to _typeMap.TryGetArrayType.

Generator IL emission

RootTypeMapAssemblyGenerator.EmitTypeMapLoader branches on emitArrayEntries. When true, the generated TypeMapLoader.Initialize IL collects per-rank dicts from each per-assembly typemap (5 IReadOnlyDictionary<...>[] arrays total — typeMaps, proxyMaps, arrayMapsRank1/2/3) and passes them to the 5-arg TrimmableTypeMap.Initialize. The aggregate (Debug) path is fully implemented; the merged-universe (Release) path throws at generation time with a clear message — wiring the shared-universe array sentinels is a small follow-up.

What's deleted

• JavaPeerContainerFactory<T>.CreateArray and CreateHigherRankArray.
• The abstract base method on JavaPeerContainerFactory.

Other factory methods (CreateList, CreateCollection, CreateDictionary*) stay — those will be addressed in the follow-up Phase 2-collections PR.

Files changed

File	Notes
Generator/Model/TypeMapAssemblyData.cs	New TypeMapAttributeData.AnchorRank (1-based per-rank anchor) and TypeMapAssemblyData.RankSentinels (sentinel TypeDef names).
Generator/TypeMapAssemblyEmitter.cs	EmitRankSentinels mirrors EmitAnchorType; per-anchor TypeMap<TGroup> 3-arg ctor caching via GetOrAddTypeMapAttr3ArgCtorRef.
Generator/ModelBuilder.cs	New bool emitArrayEntries parameter on Build; per-rank trio emitted via new EmitArrayEntries (skip rules: generics, primitive keywords, aliases).
Generator/RootTypeMapAssemblyGenerator.cs	New bool emitArrayEntries parameter; aggregate path emits per-rank dict arrays in TypeMapLoader.Initialize; new 5-arg Initialize member refs.
TrimmableTypeMapGenerator.cs	Execute and GenerateTypeMapAssemblies propagate emitArrayEntries.
Generator/TypeMapAssemblyGenerator.cs	Generate propagates emitArrayEntries.
Tasks/GenerateTrimmableTypeMap.cs	New EmitArrayEntries MSBuild task property.
targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets	Sets EmitArrayEntries="$(PublishAot)" on the task invocation.
Microsoft.Android.Runtime/ITypeMapWithAliasing.cs	TryGetArrayType interface method.
Microsoft.Android.Runtime/SingleUniverseTypeMap.cs	Per-rank dict ctor + TryGetArrayType impl.
Microsoft.Android.Runtime/AggregateTypeMap.cs	First-wins TryGetArrayType impl.
Microsoft.Android.Runtime/TrimmableTypeMap.cs	New 5-arg Initialize overloads + TryGetArrayType(Type, out Type?) + TryGetPrimitiveJniName helper.
Android.Runtime/JNIEnv.cs	ArrayCreateInstance runtime fork.
Java.Interop/JavaPeerContainerFactory.cs	CreateArray / CreateHigherRankArray deleted; class doc updated.
tests/.../TypeMapModelBuilderTests.cs	14 new generator unit tests covering default-off behavior, sentinel emission, per-rank trio, element-only key, closed-array trim target, conditional-only entries, skip rules (open generic, alias group, primitive keywords), multi-peer isolation, and PE blob round-trip.

Validation

• Generator unit tests: 445 / 445 pass (425 baseline + 20 new).
• Trimmable + CoreCLR RunTestApp lane on emulator (-p:_AndroidTypeMapImplementation=trimmable -p:UseMonoRuntime=false): 917 total, 0 errors, 3 failures (the 3 are pre-existing TryGetJniNameForManagedType_* from [TrimmableTypeMap] JavaCast/JavaAs + container support #11225, called out as out-of-scope there). No regression.
• NativeAOT path with array TypeMap entries: validated with the standalone repro at ~/Projects/playground/TestTypeMapArrays against .NET 11 nightly 11.0.100-preview.5.26228.123 (which bundles [ILLink/ILCompiler] Fix crash when array types are used as TypeMap trim targets runtime#126380's TypeMapHandler.UnwrapToResolvableType fix). The dotnet/android end-to-end NativeAOT lane needs the SDK to ship a build with #126380 — currently in our SDK we have 11.0.0-preview.4.26215.121 which crashes ILLink before reaching the new code.

SDK gating

The NativeAOT array-emission path requires dotnet/runtime#126380 (TypeMapHandler.UnwrapToResolvableType, merged 2026-04-20, ships in .NET 11 nightly preview.5+). Until dotnet/android picks up an SDK with that fix:

• CoreCLR / Mono — works today. The runtime fork hits Array.CreateInstance directly; the typemap isn't consulted.
• NativeAOT with _AndroidTypeMapImplementation=trimmable — would crash in ILLink's TypeMapHandler.RecordTypeMapEntry on the [assembly: TypeMap<__ArrayMapRank{N}>(...)] array entries. Not in any current dotnet/android CI lane (the typical NativeAOT lanes use Mono runtime or don't enable trimmable typemap), so the PR can land without blocking on the SDK bump. Once the SDK bumps, the path becomes live with no further changes.

Considered alternatives

Documented in detail in #11234. Summary:

• Proxy map (TypeMapAssociation<G>(typeof(T), typeof(T[]))): cleaner Type → Type lookup, but ProxyTypeMapNode.GetConditionalStaticDependencies conditions on MaximallyConstructableType(key) (the element), so T[] survives whenever T is reachable — losing per-shape trimming. Validated on disjoint-set NativeAOT tests.
• Single composite-key external map ("[L<jni>;", "[[L<jni>;"): same trim behavior as per-rank groups but pays a string.Concat at every JNIEnv.ArrayCreateInstance call. Per-rank groups eliminate that cost.
• Scanner-based emission: tighter trim than speculative emission, but requires a metadata signature walker. Layerable on top of this PR as a follow-up if app-size measurement shows speculative emission is too costly.

Out of scope

• Container types (JavaList<T> / JavaCollection<T> / JavaDictionary<K, V>) and the corresponding JavaPeerContainerFactory<T>.Create* methods.
• JavaPeerProxy<T>.GetContainerFactory() virtual / override (deletion follows in the Phase 3 PR).
• TrimmableTypeMap.GetContainerFactory(Type).
• Removing [DAM(Constructors)] annotations ([TrimmableTypeMap] Address all trimming and AOT warnings #10794).
• Alias-aware array emission.
• Merged-universe (Release) array emission — generator throws at generation time today; small follow-up to wire the shared-universe loader.