[TrimmableTypeMap] Split array-proxy rank: reference-1, primitive-3

The trimmable typemap generates array-proxy types (JavaObjectArray<T>,
T[], nested closures) up to a configurable rank so that array types can
be resolved without Array.CreateInstance under NativeAOT. Emitting these
uniformly at rank 3 caused a NativeAOT ILC type explosion: on an AppCompat
app ILC compiled/preinitialized ~129,320 types and IlcCompile took 333s,
which pushed the heaviest CI apps past the 30-min DefaultBuildTimeOut.

Reference-type array proxies (scanned Java peers, System.String, boxed
Nullable<T>) are now capped at a separate, lower rank
(_AndroidTrimmableTypeMapMaxReferenceArrayRank, default 1 for NativeAOT)
while primitive arrays keep the higher rank (default 3). Jagged reference
arrays (Foo[][]) are rare, and each nesting level multiplies the
JavaObjectArray<T> closure ILC must process, so this trims the bulk of the
cost while preserving the common Foo[] and int[][][] cases.

The anchor matrix (model.MaxArrayRank) stays uniform at max(primitive,
reference) across all typemap assemblies so RootTypeMapAssemblyGenerator's
rectangular [assembly][rank] sentinel layout is unchanged; only the emitted
entries per rank differ.

Measured on the same AppCompat NativeAOT app:
  ILC types    129,320 -> 22,673   (5.7x fewer)
  IlcCompile   333s -> 91s         (3.65x faster)
  TypeMap DLLs 19.7MB -> 9.7MB     (~2x smaller)

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

Author: simonrozsival

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

@@ -70,7 +70,7 @@ static readonly (string Name, string ManagedTypeName) [] NullableArrayProxies =
 	/// Emit per-rank array <c>TypeMap</c> entries + <c>__ArrayMapRank{N}</c> sentinels
 	/// for ranks 1..<paramref name="maxArrayRank"/>. 0 disables array entry emission.
 	/// </param>
-	public static TypeMapAssemblyData Build (IReadOnlyList<JavaPeerInfo> peers, string outputPath, string? assemblyName = null, int maxArrayRank = 0)
+	public static TypeMapAssemblyData Build (IReadOnlyList<JavaPeerInfo> peers, string outputPath, string? assemblyName = null, int maxArrayRank = 0, int maxReferenceArrayRank = 0)
 	{
 		if (peers is null) {
 			throw new ArgumentNullException (nameof (peers));
@@ -81,13 +81,20 @@ public static TypeMapAssemblyData Build (IReadOnlyList<JavaPeerInfo> peers, stri
 		if (maxArrayRank < 0) {
 			throw new ArgumentOutOfRangeException (nameof (maxArrayRank), maxArrayRank, "Must be >= 0.");
 		}
+		if (maxReferenceArrayRank < 0) {
+			throw new ArgumentOutOfRangeException (nameof (maxReferenceArrayRank), maxReferenceArrayRank, "Must be >= 0.");
+		}
 
 		assemblyName ??= Path.GetFileNameWithoutExtension (outputPath);
 
 		var model = new TypeMapAssemblyData {
 			AssemblyName = assemblyName,
 			ModuleName = Path.GetFileName (outputPath),
-			MaxArrayRank = maxArrayRank,
+			// The per-assembly __ArrayMapRank{N} anchor count must be uniform across every typemap
+			// assembly (the root generator builds a rectangular [assembly][rank] matrix), so the model
+			// always carries the overall maximum rank. Primitive and reference element types may
+			// populate different rank ranges within that shared anchor set.
+			MaxArrayRank = Math.Max (maxArrayRank, maxReferenceArrayRank),
 		};
 
 		// Invoker types are NOT emitted as separate proxies or TypeMap entries.
@@ -137,13 +144,14 @@ public static TypeMapAssemblyData Build (IReadOnlyList<JavaPeerInfo> peers, stri
 
 			EmitPeers (model, jniName, peersForName, assemblyName, usedProxyNames);
 
-			if (maxArrayRank > 0) {
-				EmitArrayEntries (model, jniName, peersForName, maxArrayRank);
+			// Java peer types are reference types: emit array proxies only up to the reference rank.
+			if (maxReferenceArrayRank > 0) {
+				EmitArrayEntries (model, jniName, peersForName, maxReferenceArrayRank);
 			}
 		}
 
-		if (maxArrayRank > 0 && string.Equals (assemblyName, "_Java.Interop.TypeMap", StringComparison.Ordinal)) {
-			EmitPrimitiveArrayEntries (model, maxArrayRank);
+		if (string.Equals (assemblyName, "_Java.Interop.TypeMap", StringComparison.Ordinal)) {
+			EmitPrimitiveArrayEntries (model, maxArrayRank, maxReferenceArrayRank);
 		}
 
 		BuildNativeRegistrations (model);
@@ -693,7 +701,12 @@ static void EmitArrayEntriesForPeer (TypeMapAssemblyData model, JavaPeerInfo pee
 		}
 	}
 
-	static void EmitPrimitiveArrayEntries (TypeMapAssemblyData model, int maxArrayRank)
+	// Emits array proxies for the built-in element types that are not scanned Java peers:
+	//   * the keyword primitives (int/bool/...) up to maxArrayRank (jagged/multidim primitive arrays
+	//     like int[][][] are cheap — a small fixed set of element types),
+	//   * System.String and the boxed Nullable<T> value types up to maxReferenceArrayRank (these map to
+	//     java/lang/String and java/lang/<Boxed>, i.e. Java reference arrays).
+	static void EmitPrimitiveArrayEntries (TypeMapAssemblyData model, int maxArrayRank, int maxReferenceArrayRank)
 	{
 		foreach (var primitive in PrimitiveArrayProxies) {
 			for (int rank = 1; rank <= maxArrayRank; rank++) {
@@ -728,7 +741,8 @@ static void EmitPrimitiveArrayEntries (TypeMapAssemblyData model, int maxArrayRa
 		// Java peer (EmitArrayEntriesForPeer) nor a primitive. Emit its array proxies here (Primitive is
 		// null, so it gets the reference-array family) so GetTypes ("[Ljava/lang/String;") yields
 		// System.String[] / JavaObjectArray<string> / JavaArray<string> on NativeAOT, matching CoreCLR.
-		for (int rank = 1; rank <= maxArrayRank; rank++) {
+		// It is a reference type, so it only goes up to maxReferenceArrayRank.
+		for (int rank = 1; rank <= maxReferenceArrayRank; rank++) {
 			var proxy = new ArrayProxyData {
 				TypeName = ManagedTypeNameToArrayProxyTypeName ("System.String", rank),
 				ElementType = new TypeRefData {
@@ -753,10 +767,11 @@ static void EmitPrimitiveArrayEntries (TypeMapAssemblyData model, int maxArrayRa
 		// primitive proxy). Emit reference-array proxies (Primitive is null) so GetTypes
 		// ("[Ljava/lang/Boolean;") yields bool?[] / JavaObjectArray<bool?> on NativeAOT. The element
 		// key uses the normalized generic form (simple assembly names) that
-		// TrimmableTypeMap.BuildManagedTypeKey produces at runtime for Nullable<T>.
+		// TrimmableTypeMap.BuildManagedTypeKey produces at runtime for Nullable<T>. The boxed values are
+		// Java reference types, so they only go up to maxReferenceArrayRank.
 		foreach (var nullablePrimitive in NullableArrayProxies) {
 			var elementTypeName = $"System.Nullable`1[[{nullablePrimitive.ManagedTypeName}, System.Runtime]]";
-			for (int rank = 1; rank <= maxArrayRank; rank++) {
+			for (int rank = 1; rank <= maxReferenceArrayRank; rank++) {
 				var proxy = new ArrayProxyData {
 					TypeName = $"Nullable_{nullablePrimitive.Name}_ArrayProxy{rank}",
 					ElementType = new TypeRefData {

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

@@ -27,10 +27,11 @@ public TypeMapAssemblyGenerator (Version systemRuntimeVersion)
 	/// <param name="useSharedTypemapUniverse">
 	/// When true, uses <c>Java.Lang.Object</c> as the shared anchor type. When false, emits a per-assembly anchor.
 	/// </param>
-	/// <param name="maxArrayRank">Max rank for per-rank array <c>TypeMap</c> entries. 0 disables.</param>
-	public void Generate (IReadOnlyList<JavaPeerInfo> peers, Stream stream, string assemblyName, bool useSharedTypemapUniverse = false, int maxArrayRank = 0)
+	/// <param name="maxArrayRank">Max rank for per-rank primitive array <c>TypeMap</c> entries. 0 disables.</param>
+	/// <param name="maxReferenceArrayRank">Max rank for per-rank reference-type (Java peer, String, boxed Nullable) array <c>TypeMap</c> entries. 0 disables.</param>
+	public void Generate (IReadOnlyList<JavaPeerInfo> peers, Stream stream, string assemblyName, bool useSharedTypemapUniverse = false, int maxArrayRank = 0, int maxReferenceArrayRank = 0)
 	{
-		var model = ModelBuilder.Build (peers, assemblyName + ".dll", assemblyName, maxArrayRank);
+		var model = ModelBuilder.Build (peers, assemblyName + ".dll", assemblyName, maxArrayRank, maxReferenceArrayRank);
 		var emitter = new TypeMapAssemblyEmitter (_systemRuntimeVersion);
 		emitter.Emit (model, stream, useSharedTypemapUniverse);
 	}

src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs

@@ -35,6 +35,7 @@ public TrimmableTypeMapResult Execute (
 		XDocument? manifestTemplate = null,
 		string? packageNamingPolicy = null,
 		int maxArrayRank = 0,
+		int maxReferenceArrayRank = 0,
 		bool generateTypeMapAssemblies = true)
 	{
 		_ = assemblies ?? throw new ArgumentNullException (nameof (assemblies));
@@ -43,6 +44,9 @@ public TrimmableTypeMapResult Execute (
 		if (maxArrayRank < 0) {
 			throw new ArgumentOutOfRangeException (nameof (maxArrayRank), maxArrayRank, "Must be >= 0.");
 		}
+		if (maxReferenceArrayRank < 0) {
+			throw new ArgumentOutOfRangeException (nameof (maxReferenceArrayRank), maxReferenceArrayRank, "Must be >= 0.");
+		}
 
 		var (allPeers, assemblyManifestInfo) = ScanAssemblies (assemblies, packageNamingPolicy, frameworkAssemblyNames);
 		if (allPeers.Count == 0) {
@@ -56,7 +60,7 @@ public TrimmableTypeMapResult Execute (
 		PropagateCannotRegisterToDescendants (allPeers);
 
 		var generatedAssemblies = generateTypeMapAssemblies
-			? GenerateTypeMapAssemblies (allPeers, systemRuntimeVersion, useSharedTypemapUniverse, maxArrayRank)
+			? GenerateTypeMapAssemblies (allPeers, systemRuntimeVersion, useSharedTypemapUniverse, maxArrayRank, maxReferenceArrayRank)
 			: [];
 		var jcwPeers = allPeers.Where (ShouldGenerateJcw).ToList ();
 		logger.LogGeneratingJcwFilesInfo (jcwPeers.Count, allPeers.Count);
@@ -174,7 +178,8 @@ List<GeneratedAssembly> GenerateTypeMapAssemblies (
 		List<JavaPeerInfo> allPeers,
 		Version systemRuntimeVersion,
 		bool useSharedTypemapUniverse,
-		int maxArrayRank)
+		int maxArrayRank,
+		int maxReferenceArrayRank)
 	{
 		List<(string AssemblyName, List<JavaPeerInfo> Peers)> peersByAssembly;
 
@@ -203,14 +208,16 @@ List<GeneratedAssembly> GenerateTypeMapAssemblies (
 			string typeMapAssemblyName = $"_{assemblyName}.TypeMap";
 			perAssemblyNames.Add (typeMapAssemblyName);
 			var stream = new MemoryStream ();
-			generator.Generate (peers, stream, typeMapAssemblyName, useSharedTypemapUniverse, maxArrayRank);
+			generator.Generate (peers, stream, typeMapAssemblyName, useSharedTypemapUniverse, maxArrayRank, maxReferenceArrayRank);
 			stream.Position = 0;
 			generatedAssemblies.Add (new GeneratedAssembly (typeMapAssemblyName, stream));
 			logger.LogGeneratedTypeMapAssemblyInfo (typeMapAssemblyName, peers.Count);
 		}
 		var rootStream = new MemoryStream ();
 		var rootGenerator = new RootTypeMapAssemblyGenerator (systemRuntimeVersion);
-		rootGenerator.Generate (perAssemblyNames, useSharedTypemapUniverse, rootStream, maxArrayRank: maxArrayRank);
+		// The root generator builds the [assembly][rank] anchor matrix, so it needs the overall maximum
+		// rank across primitive and reference element types.
+		rootGenerator.Generate (perAssemblyNames, useSharedTypemapUniverse, rootStream, maxArrayRank: Math.Max (maxArrayRank, maxReferenceArrayRank));
 		rootStream.Position = 0;
 		generatedAssemblies.Add (new GeneratedAssembly ("_Microsoft.Android.TypeMaps", rootStream));
 		logger.LogGeneratedRootTypeMapInfo (perAssemblyNames.Count);

src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets

@@ -80,6 +80,7 @@
         TargetFrameworkVersion="$(TargetFrameworkVersion)"
         PackageNamingPolicy="$(_TrimmableTypeMapPackageNamingPolicy)"
         MaxArrayRank="$(_AndroidTrimmableTypeMapMaxArrayRank)"
+        MaxReferenceArrayRank="$(_AndroidTrimmableTypeMapMaxReferenceArrayRank)"
         GenerateTypeMapAssemblies="false"
         CleanJavaSourceOutputDirectory="true"
         AcwMapOutputFile="$(IntermediateOutputPath)acw-map.txt"

src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets

@@ -55,6 +55,12 @@
          defaults to 0 otherwise, where dynamic code can use Array.CreateInstance directly. -->
     <_AndroidTrimmableTypeMapMaxArrayRank Condition=" '$(_AndroidTrimmableTypeMapMaxArrayRank)' == '' and ('$(PublishAot)' == 'true' or '$(DynamicCodeSupport)' == 'false') ">3</_AndroidTrimmableTypeMapMaxArrayRank>
     <_AndroidTrimmableTypeMapMaxArrayRank Condition=" '$(_AndroidTrimmableTypeMapMaxArrayRank)' == '' ">0</_AndroidTrimmableTypeMapMaxArrayRank>
+    <!-- Reference-type array rank (scanned Java peers, System.String, boxed Nullable<T>). Kept at 1
+         because jagged reference arrays are rare and each nesting level multiplies the generated
+         JavaObjectArray<T> closure that ILC must compile/preinitialize (the dominant NativeAOT
+         build-time and binary-size cost). Primitive arrays keep the higher _AndroidTrimmableTypeMapMaxArrayRank. -->
+    <_AndroidTrimmableTypeMapMaxReferenceArrayRank Condition=" '$(_AndroidTrimmableTypeMapMaxReferenceArrayRank)' == '' and ('$(PublishAot)' == 'true' or '$(DynamicCodeSupport)' == 'false') ">1</_AndroidTrimmableTypeMapMaxReferenceArrayRank>
+    <_AndroidTrimmableTypeMapMaxReferenceArrayRank Condition=" '$(_AndroidTrimmableTypeMapMaxReferenceArrayRank)' == '' ">0</_AndroidTrimmableTypeMapMaxReferenceArrayRank>
     <IncrementalCleanDependsOn>
       _RecordTrimmableTypeMapFileWrites;
       $(IncrementalCleanDependsOn);
@@ -153,6 +159,7 @@
         EmbedAssemblies="$(EmbedAssembliesIntoApk)"
         PackageNamingPolicy="$(_TrimmableTypeMapPackageNamingPolicy)"
         MaxArrayRank="$(_AndroidTrimmableTypeMapMaxArrayRank)"
+        MaxReferenceArrayRank="$(_AndroidTrimmableTypeMapMaxReferenceArrayRank)"
         ManifestPlaceholders="$(AndroidManifestPlaceholders)"
         CheckedBuild="$(_AndroidCheckedBuild)"
         ApplicationJavaClass="$(AndroidApplicationJavaClass)"

src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs

@@ -104,11 +104,20 @@ public void LogJniAddNativeMethodRegistrationAttributeError (string managedTypeN
 
 	/// <summary>
 	/// Maximum array rank for which the generator emits per-rank <c>__ArrayMapRank{N}</c>
-	/// sentinels and <c>TypeMap</c> entries. 0 disables. Set via
-	/// <c>$(_AndroidTrimmableTypeMapMaxArrayRank)</c>.
+	/// sentinels and primitive-element <c>TypeMap</c> entries (e.g. <c>int[][][]</c>). 0 disables.
+	/// Set via <c>$(_AndroidTrimmableTypeMapMaxArrayRank)</c>.
 	/// </summary>
 	public int MaxArrayRank { get; set; }
 
+	/// <summary>
+	/// Maximum array rank for reference-type element <c>TypeMap</c> entries — scanned Java peers,
+	/// <c>System.String</c>, and boxed <c>Nullable&lt;T&gt;</c> (which map to Java reference arrays).
+	/// Kept lower than <see cref="MaxArrayRank"/> because jagged reference arrays are rare and each
+	/// nesting level multiplies the generated <c>JavaObjectArray&lt;T&gt;</c> closure. 0 disables. Set
+	/// via <c>$(_AndroidTrimmableTypeMapMaxReferenceArrayRank)</c>.
+	/// </summary>
+	public int MaxReferenceArrayRank { get; set; }
+
 	public string? ManifestPlaceholders { get; set; }
 	public string? CheckedBuild { get; set; }
 	public string? ApplicationJavaClass { get; set; }
@@ -215,6 +224,7 @@ public override bool RunTask ()
 				manifestTemplate: manifestTemplate,
 				packageNamingPolicy: PackageNamingPolicy,
 				maxArrayRank: MaxArrayRank,
+				maxReferenceArrayRank: MaxReferenceArrayRank,
 				generateTypeMapAssemblies: GenerateTypeMapAssemblies);
 
 			if (GenerateTypeMapAssemblies) {

tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs

@@ -16,10 +16,10 @@ static TypeMapAssemblyData BuildModel (IReadOnlyList<JavaPeerInfo> peers, string
 		return ModelBuilder.Build (peers, outputPath, assemblyName);
 	}
 
-	static TypeMapAssemblyData BuildModelWithArrays (IReadOnlyList<JavaPeerInfo> peers, string? assemblyName = null, int maxArrayRank = 3)
+	static TypeMapAssemblyData BuildModelWithArrays (IReadOnlyList<JavaPeerInfo> peers, string? assemblyName = null, int maxArrayRank = 3, int? maxReferenceArrayRank = null)
 	{
 		var outputPath = Path.Combine (Path.GetTempPath (), (assemblyName ?? "TestTypeMap") + ".dll");
-		return ModelBuilder.Build (peers, outputPath, assemblyName, maxArrayRank);
+		return ModelBuilder.Build (peers, outputPath, assemblyName, maxArrayRank, maxReferenceArrayRank ?? maxArrayRank);
 	}
 
 	public class BasicStructure
@@ -1274,6 +1274,45 @@ public void Build_EmitArrayEntries_PrimitiveEntries_SynthesizedForJavaInteropAss
 				a.AliasProxyTypeReference == nullableBoolRank1.ProxyTypeReference);
 		}
 
+		[Fact]
+		public void Build_ReferenceRankLowerThanPrimitiveRank_PeersGetReferenceRankOnly ()
+		{
+			// Split ranks: reference types (Java peers) capped at rank 1, primitives at rank 3.
+			var peer = MakeMcwPeer ("com/example/Foo", "Com.Example.Foo", "App");
+			var model = BuildModelWithArrays (new [] { peer }, maxArrayRank: 3, maxReferenceArrayRank: 1);
+
+			// The peer (a reference type) gets exactly one array entry, at rank 1.
+			var peerEntries = model.Entries.Where (e => e.MapKey == "Com.Example.Foo, App" && e.AnchorRank is not null).ToList ();
+			Assert.Single (peerEntries);
+			Assert.Equal (1, peerEntries [0].AnchorRank);
+
+			// The anchor set is still rank 3 (uniform across assemblies for the root matrix).
+			Assert.Equal (3, model.MaxArrayRank);
+		}
+
+		[Fact]
+		public void Build_ReferenceRankLowerThanPrimitiveRank_PrimitivesRank3ReferencesRank1 ()
+		{
+			var peer = MakeMcwPeer ("java/lang/Object", "Java.Lang.Object", "Java.Interop");
+			var model = BuildModelWithArrays (new [] { peer }, assemblyName: "_Java.Interop.TypeMap", maxArrayRank: 3, maxReferenceArrayRank: 1);
+
+			// Primitives keep ranks 1..3: 12 primitives × 3.
+			var primitiveInt = model.Entries.Where (e => e.MapKey == "System.Int32, System.Runtime" && e.AnchorRank is not null).Select (e => e.AnchorRank).OrderBy (r => r).ToList ();
+			Assert.Equal (new int? [] { 1, 2, 3 }, primitiveInt);
+
+			// System.String (reference) only rank 1.
+			var stringRanks = model.Entries.Where (e => e.MapKey == "System.String, System.Runtime" && e.AnchorRank is not null).Select (e => e.AnchorRank).ToList ();
+			Assert.Equal (new int? [] { 1 }, stringRanks);
+
+			// Nullable<bool> (boxed reference) only rank 1.
+			var nullableRanks = model.Entries.Where (e => e.MapKey == "System.Nullable`1[[System.Boolean, System.Runtime]], System.Runtime" && e.AnchorRank is not null).Select (e => e.AnchorRank).ToList ();
+			Assert.Equal (new int? [] { 1 }, nullableRanks);
+
+			// Totals: 12 primitives × 3 + (String + 8 nullables) × 1 = 36 + 9 = 45.
+			var builtinEntries = model.Entries.Count (e => e.MapKey.StartsWith ("System.", StringComparison.Ordinal) && e.AnchorRank is not null);
+			Assert.Equal (45, builtinEntries);
+		}
+
 		[Fact]
 		public void Build_EmitArrayEntries_PrimitiveEntries_NotDuplicatedInOtherAssemblies ()
 		{
@@ -1397,7 +1436,7 @@ public void FullPipeline_ArrayEntries_AttributeBlobsRoundTrip ()
 		{
 			var peer = MakeMcwPeer ("foo/Bar", "Foo.Bar", "App");
 			var outputPath = Path.Combine (Path.GetTempPath (), "ArrBlobs.dll");
-			var model = ModelBuilder.Build (new [] { peer }, outputPath, "ArrBlobs", maxArrayRank: 3);
+			var model = ModelBuilder.Build (new [] { peer }, outputPath, "ArrBlobs", maxArrayRank: 3, maxReferenceArrayRank: 3);
 
 			EmitAndVerify (model, "ArrBlobs", (pe, reader) => {
 				var arrayAttrs = ReadAllTypeMapAttributeBlobs (reader)