[TrimmableTypeMap] Replace per-T array factory with TypeMap entries

Generator: for every per-peer TypeMap entry, also emit speculative
`[L<jni>;` / `[[L<jni>;` / `[[[L<jni>;` entries pointing at the
corresponding closed managed array type (`T[]`, `T[][]`, `T[][][]`).
Emitted as 3-arg conditional attributes so the trimmer drops entries
whose array target type is not live in the shipped app. Skips open
generics, primitive JNI keyword keys (`Z`, `B`, …), and alias groups
(deferred until a real-world need).

Runtime: new `ITypeMapWithAliasing.TryGetType` raw lookup that bypasses
`JavaPeerProxy` filtering — array entries point directly at the closed
`Type` and have no proxy. New `TrimmableTypeMap.TryGetArrayType(Type
elementType, out Type? arrayType)` walks down `elementType.IsArray` /
`GetElementType()` to find the leaf type and array depth, resolves the
leaf JNI encoding (primitive static dict OR `TryGetJniNameForManagedType`
wrapped as `L<jni>;`), prepends `[` × (depth+1), and looks up the
closed array `Type` via the raw typemap. Caller then uses AOT-safe
`Array.CreateInstanceFromArrayType`.

`JNIEnv.ArrayCreateInstance` swaps to the new flow on hit; throws
`NotSupportedException` on miss under trimmable. Legacy non-trimmable
fallback unchanged.

Cleanup: deletes `JavaPeerContainerFactory<T>.CreateArray` and the
private `CreateHigherRankArray` helper. The base abstract method goes
too. Other (collection) factory methods stay for the follow-up PR.

Tests: 13 new `ArrayEntries` unit tests in `TypeMapModelBuilderTests`
covering ranks 1-3, conditional emission, open-generic skip, alias-group
skip, and primitive-JNI-keyword skip. Existing count-asserting tests
updated via a `NonArrayEntries` helper.

Tracking: #11234 (sub-task — arrays only; collection factory removal
follows in a separate PR).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: simonrozsival

src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/ModelBuilder.cs

@@ -40,6 +40,14 @@ static class ModelBuilder
 	/// <param name="peers">Scanned Java peer types (typically from a single input assembly).</param>
 	/// <param name="outputPath">Output .dll path — used to derive assembly/module names if not specified.</param>
 	/// <param name="assemblyName">Explicit assembly name. If null, derived from <paramref name="outputPath"/>.</param>
+	/// <remarks>
+	/// In addition to the per-peer <c>TypeMap</c> entry, this method also emits speculative
+	/// <c>[L&lt;jni&gt;;</c>, <c>[[L&lt;jni&gt;;</c>, and <c>[[[L&lt;jni&gt;;</c> entries pointing at
+	/// the corresponding closed managed array types (<c>T[]</c>, <c>T[][]</c>, <c>T[][][]</c>).
+	/// They are 3-arg (conditional) attributes, so the trimmer drops entries whose array
+	/// target type is not live in the shipped app. Required for the AOT-safe array creation
+	/// path in <c>JNIEnv.ArrayCreateInstance</c>.
+	/// </remarks>
 	public static TypeMapAssemblyData Build (IReadOnlyList<JavaPeerInfo> peers, string outputPath, string? assemblyName = null)
 	{
 		if (peers is null) {
@@ -89,6 +97,7 @@ public static TypeMapAssemblyData Build (IReadOnlyList<JavaPeerInfo> peers, stri
 			}
 
 			EmitPeers (model, jniName, peersForName, assemblyName, usedProxyNames);
+			EmitArrayEntries (model, jniName, peersForName);
 		}
 
 		// Compute IgnoresAccessChecksTo from cross-assembly references
@@ -198,6 +207,76 @@ static void EmitPeers (TypeMapAssemblyData model, string jniName,
 		});
 	}
 
+	/// <summary>
+	/// Maximum jagged-array rank emitted per peer. Matches the legacy
+	/// <c>JavaPeerContainerFactory&lt;T&gt;.CreateArray</c> switch (ranks 1–3) — higher ranks
+	/// already throw <see cref="NotSupportedException"/> under NativeAOT today.
+	/// </summary>
+	const int MaxArrayRank = 3;
+
+	/// <summary>
+	/// Emits speculative <c>[L&lt;jni&gt;;</c> / <c>[[L&lt;jni&gt;;</c> / <c>[[[L&lt;jni&gt;;</c> TypeMap entries
+	/// for a single peer. Each entry maps a JNI array name to the corresponding closed
+	/// managed array type (e.g. <c>typeof(SomePeer[])</c>) and is emitted as a 3-arg
+	/// (conditional) attribute so the trimmer can drop entries whose array target type is
+	/// not live in the shipped app.
+	/// </summary>
+	/// <remarks>
+	/// Skips:
+	///   <list type="bullet">
+	///     <item>Open-generic peers (<c>JavaPeerInfo.IsGenericDefinition</c>) — <c>typeof(T&lt;&gt;[])</c> is invalid.</item>
+	///     <item>JNI keyword keys (<c>Z</c>, <c>B</c>, …) — primitives are handled by
+	///       <c>JniRuntime.JniTypeManager.GetPrimitiveArrayTypesForSimpleReference</c>; emitting
+	///       array entries here would collide with that built-in path.</item>
+	///     <item>Alias groups — multiple peers sharing a JNI name would produce duplicate
+	///       array-key entries. Array-typemap support for aliases would need its own
+	///       indexed-alias scheme; deferred until a real-world need is identified.</item>
+	///   </list>
+	/// </remarks>
+	static void EmitArrayEntries (TypeMapAssemblyData model, string jniName, List<JavaPeerInfo> peersForName)
+	{
+		// Primitive single-letter JNI keywords are handled by the legacy primitive path.
+		// Skip them so we don't shadow the built-in [Z, [B, etc. array entries.
+		if (jniName.Length == 1 && IsJniPrimitiveKeyword (jniName [0])) {
+			return;
+		}
+
+		// Alias groups would produce duplicate JNI array keys (one per peer). Defer
+		// alias-aware array emission until we have a concrete use case.
+		if (peersForName.Count != 1) {
+			return;
+		}
+
+		var peer = peersForName [0];
+		if (peer.IsGenericDefinition) {
+			return;
+		}
+
+		for (int rank = 1; rank <= MaxArrayRank; rank++) {
+			string arrayJniName = string.Concat (new string ('[', rank), "L", jniName, ";");
+			string arrayTargetRef = AssemblyQualify (peer.ManagedTypeName + Brackets (rank), peer.AssemblyName);
+			model.Entries.Add (new TypeMapAttributeData {
+				JniName = arrayJniName,
+				ProxyTypeReference = arrayTargetRef,
+				TargetTypeReference = arrayTargetRef,
+			});
+		}
+	}
+
+	static string Brackets (int rank)
+	{
+		switch (rank) {
+		case 1: return "[]";
+		case 2: return "[][]";
+		case 3: return "[][][]";
+		default: return new string ('[', rank).Replace ("[", "[]");
+		}
+	}
+
+	static bool IsJniPrimitiveKeyword (char c)
+		=> c == 'Z' || c == 'B' || c == 'C' || c == 'S' || c == 'I'
+			|| c == 'J' || c == 'F' || c == 'D' || c == 'V';
+
 	/// <summary>
 	/// Determines whether a type should use the unconditional (2-arg) TypeMap attribute.
 	/// Unconditional types are always preserved by the trimmer.

src/Mono.Android/Android.Runtime/JNIEnv.cs

@@ -27,9 +27,12 @@ public static partial class JNIEnv {
 		static Array ArrayCreateInstance (Type elementType, int length)
 		{
 			if (RuntimeFeature.TrimmableTypeMap) {
-				var factory = TrimmableTypeMap.Instance?.GetContainerFactory (elementType);
-				if (factory is not null)
-					return factory.CreateArray (length, 1);
+				if (TrimmableTypeMap.Instance.TryGetArrayType (elementType, out var arrayType)) {
+					return Array.CreateInstanceFromArrayType (arrayType, length);
+				}
+				throw new NotSupportedException (
+					$"No TrimmableTypeMap array entry for element type '{elementType}'. " +
+					$"Add an [assembly: TypeMap] entry for the closed array type or report an issue.");
 			}
 
 			#pragma warning disable IL3050 // Array.CreateInstance is not AOT-safe, but this is the legacy fallback path

src/Mono.Android/Java.Interop/JavaPeerContainerFactory.cs

@@ -10,16 +10,17 @@
 namespace Java.Interop
 {
 	/// <summary>
-	/// AOT-safe factory for creating typed containers (arrays, lists, collections, dictionaries)
-	/// without using <c>MakeGenericType()</c> or <c>Array.CreateInstance()</c>.
+	/// AOT-safe factory for creating typed containers (lists, collections, dictionaries)
+	/// without using <c>MakeGenericType()</c>.
 	/// </summary>
+	/// <remarks>
+	/// Array creation has been moved out of this factory: <c>JNIEnv.ArrayCreateInstance</c>
+	/// now resolves closed array types via the trimmable typemap and
+	/// <see cref="Array.CreateInstanceFromArrayType"/> instead of going through a per-T
+	/// factory instantiation.
+	/// </remarks>
 	public abstract class JavaPeerContainerFactory
 	{
-		/// <summary>
-		/// Creates a typed jagged array. Rank 1 = T[], rank 2 = T[][], etc.
-		/// </summary>
-		internal abstract Array CreateArray (int length, int rank);
-
 		/// <summary>
 		/// Creates a typed <c>JavaList&lt;T&gt;</c> from a JNI handle.
 		/// </summary>
@@ -71,31 +72,6 @@ public sealed class JavaPeerContainerFactory<
 
 		JavaPeerContainerFactory () { }
 
-		// TODO (https://github.com/dotnet/android/issues/10794): This might cause unnecessary code bloat for NativeAOT. Revisit
-		// how we use this API and instead use a differnet approach that uses AOT-safe `Array.CreateInstanceFromArrayType`
-		// with statically provided array types based on a statically known array type.
-		internal override Array CreateArray (int length, int rank) => rank switch {
-			1 => new T [length],
-			2 => new T [length][],
-			3 => new T [length][][],
-			_ when rank >= 0 => CreateHigherRankArray (length, rank),
-			_ => throw new ArgumentOutOfRangeException (nameof (rank), rank, "Rank must be non-negative."),
-		};
-
-		static Array CreateHigherRankArray (int length, int rank)
-		{
-			if (!RuntimeFeature.IsDynamicCodeSupported) {
-				throw new NotSupportedException ($"Cannot create array of rank {rank} because dynamic code is not supported.");
-			}
-
-			var arrayType = typeof (T);
-			for (int i = 0; i < rank; i++) {
-				arrayType = arrayType.MakeArrayType ();
-			}
-
-			return Array.CreateInstanceFromArrayType (arrayType, length);
-		}
-
 		internal override IList CreateList (IntPtr handle, JniHandleOwnership transfer)
 			=> new Android.Runtime.JavaList<T> (handle, transfer);
 

src/Mono.Android/Microsoft.Android.Runtime/AggregateTypeMap.cs

@@ -30,6 +30,19 @@ public IEnumerable<Type> GetTypes (string jniName)
 		}
 	}
 
+	public bool TryGetType (string jniName, [NotNullWhen (true)] out Type? type)
+	{
+		// First-wins: each JNI name appears in at most one universe (or is duplicated
+		// across universes with the same target — order-independent).
+		foreach (var universe in _universes) {
+			if (universe.TryGetType (jniName, out type)) {
+				return true;
+			}
+		}
+		type = null;
+		return false;
+	}
+
 	public bool TryGetProxyType (Type managedType, [NotNullWhen (true)] out Type? proxyType)
 	{
 		// First-wins: each managed type exists in exactly one assembly

src/Mono.Android/Microsoft.Android.Runtime/ITypeMapWithAliasing.cs

@@ -26,4 +26,14 @@ interface ITypeMapWithAliasing
 	/// carries the <see cref="JavaPeerProxy"/> attribute).
 	/// </summary>
 	bool TryGetProxyType (Type managedType, [NotNullWhen (true)] out Type? proxyType);
+
+	/// <summary>
+	/// Raw lookup of a managed type by JNI name, without the
+	/// <see cref="JavaPeerProxy"/> attribute filtering applied by
+	/// <see cref="GetTypes"/>. Used by the AOT-safe array creation path,
+	/// where the typemap entry points directly at a closed array
+	/// <see cref="Type"/> (e.g. <c>typeof(byte[][])</c>) that has no
+	/// proxy attribute.
+	/// </summary>
+	bool TryGetType (string jniName, [NotNullWhen (true)] out Type? type);
 }

src/Mono.Android/Microsoft.Android.Runtime/SingleUniverseTypeMap.cs

@@ -53,6 +53,11 @@ public IEnumerable<Type> GetTypes (string jniName)
 		}
 	}
 
+	public bool TryGetType (string jniName, [NotNullWhen (true)] out Type? type)
+	{
+		return _typeMap.TryGetValue (jniName, out type);
+	}
+
 	public bool TryGetProxyType (Type managedType, [NotNullWhen (true)] out Type? proxyType)
 	{
 		if (!_proxyTypeMap.TryGetValue (managedType, out var mappedProxyType)) {

src/Mono.Android/Microsoft.Android.Runtime/TrimmableTypeMap.cs

@@ -318,6 +318,88 @@ internal static bool TargetTypeMatches (Type targetType, Type proxyTargetType)
 		return GetProxyForManagedType (type)?.GetContainerFactory ();
 	}
 
+	/// <summary>
+	/// AOT-safe lookup of the closed array <see cref="Type"/> for the supplied
+	/// <paramref name="elementType"/> via the trimmable typemap. Implements the
+	/// flow:
+	///   <list type="number">
+	///     <item>Walk down <see cref="Type.IsArray"/> / <see cref="Type.GetElementType"/>
+	///       to find the leaf element type and the depth of array nesting.</item>
+	///     <item>Resolve the leaf JNI element encoding — primitive (<c>byte</c> →
+	///       <c>"B"</c>, etc.) or reference (<see cref="TryGetJniNameForManagedType"/>
+	///       wrapped as <c>"L&lt;jni&gt;;"</c>).</item>
+	///     <item>Build the full JNI array name by prepending <c>'['</c> for each
+	///       array level (the outer rank that is being created plus the depth of
+	///       the element type itself).</item>
+	///     <item>Look the array Type up via the raw typemap (<see cref="ITypeMapWithAliasing.TryGetType"/>),
+	///       which bypasses proxy attribute filtering — array entries point directly
+	///       at the closed managed array <see cref="Type"/> and have no
+	///       <see cref="JavaPeerProxy"/>.</item>
+	///   </list>
+	/// Returns false if any step fails (unknown leaf type, no typemap entry).
+	/// </summary>
+	internal bool TryGetArrayType (Type elementType, [NotNullWhen (true)] out Type? arrayType)
+	{
+		if (elementType is null) {
+			arrayType = null;
+			return false;
+		}
+
+		// 1. Walk down to the leaf and count the element's own array depth.
+		var leaf = elementType;
+		int elementDepth = 0;
+		while (leaf.IsArray) {
+			var next = leaf.GetElementType ();
+			if (next is null) {
+				arrayType = null;
+				return false;
+			}
+			leaf = next;
+			elementDepth++;
+		}
+
+		// 2. Resolve the leaf JNI element encoding.
+		string leafEncoding;
+		if (leaf.IsPrimitive) {
+			if (!TryGetPrimitiveJniEncoding (leaf, out var primitive)) {
+				arrayType = null;
+				return false;
+			}
+			leafEncoding = primitive;
+		} else {
+			if (!TryGetJniNameForManagedType (leaf, out var leafJni)) {
+				arrayType = null;
+				return false;
+			}
+			leafEncoding = "L" + leafJni + ";";
+		}
+
+		// 3. Build the full JNI array name. The "+1" accounts for the outer rank
+		//    being created by the caller (ArrayCreateInstance(elementType, length)
+		//    creates new elementType[length]).
+		int totalArrayDepth = elementDepth + 1;
+		string arrayJniName = string.Concat (new string ('[', totalArrayDepth), leafEncoding);
+
+		// 4. Raw typemap lookup — no proxy filtering.
+		return _typeMap.TryGetType (arrayJniName, out arrayType);
+	}
+
+	static bool TryGetPrimitiveJniEncoding (Type primitive, [NotNullWhen (true)] out string? encoding)
+	{
+		// JNI single-letter encodings for primitive types.
+		// Reference: https://docs.oracle.com/javase/8/docs/technotes/guides/jni/spec/types.html
+		if (primitive == typeof (bool))   { encoding = "Z"; return true; }
+		if (primitive == typeof (byte))   { encoding = "B"; return true; }
+		if (primitive == typeof (char))   { encoding = "C"; return true; }
+		if (primitive == typeof (short))  { encoding = "S"; return true; }
+		if (primitive == typeof (int))    { encoding = "I"; return true; }
+		if (primitive == typeof (long))   { encoding = "J"; return true; }
+		if (primitive == typeof (float))  { encoding = "F"; return true; }
+		if (primitive == typeof (double)) { encoding = "D"; return true; }
+		encoding = null;
+		return false;
+	}
+
 	[UnmanagedCallersOnly]
 	static void OnRegisterNatives (IntPtr jnienv, IntPtr klass, IntPtr nativeClassHandle)
 	{