Disable speculative array TypeMap emission (ILLink crash)

Reverts the runtime swap and factory-method removal from the previous
commit. Keeps the new `ITypeMapWithAliasing.TryGetType` raw lookup and
`TrimmableTypeMap.TryGetArrayType` helper as scaffolding for the
eventual ILLink-fixed approach.

The speculative `[L<jni>;` / `[[L<jni>;` / `[[[L<jni>;` TypeMap entries
crash ILLink with:

  System.NotSupportedException: TypeDefinition cannot be resolved from
    'Mono.Cecil.ArrayType' type
     at Mono.Linker.LinkContext.Resolve(TypeReference typeReference)
     at Mono.Linker.TypeMapHandler.RecordTypeMapEntry(...)         (3-arg form)
     at Mono.Linker.TypeMapHandler.MarkTypeMapAttribute(...)        (2-arg form)
     at Mono.Linker.TypeMapHandler.ProcessExternalTypeMapGroupSeen(...)

Both 2-arg and 3-arg TypeMap forms are affected — `MarkTypeMapAttribute`
calls `LinkContext.Resolve` on the `TargetType` slot (constructor arg
index 1) for any TypeMap, and Cecil's `ArrayType` is not a
`TypeDefinition`. There is no shape of `TypeMapAttribute` today that
accepts a closed array `Type`.

`EmitArrayEntries` is now a documented no-op.
`JavaPeerContainerFactory<T>.CreateArray` and
`CreateHigherRankArray` are restored.
`JNIEnv.ArrayCreateInstance` falls back to the legacy per-T factory
under trimmable.

Trimmable + CoreCLR lane after revert: 917 total, 0 errors, 3 failures
(pre-existing `TryGetJniNameForManagedType_*`, out of scope — same
baseline as #11225).

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

Author: simonrozsival

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

@@ -215,52 +215,24 @@ static void EmitPeers (TypeMapAssemblyData model, string jniName,
 	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.
+	/// (Disabled — see remarks.) Would emit speculative <c>[L&lt;jni&gt;;</c> /
+	/// <c>[[L&lt;jni&gt;;</c> / <c>[[[L&lt;jni&gt;;</c> TypeMap entries pointing at closed
+	/// managed array types so <c>JNIEnv.ArrayCreateInstance</c> could resolve arrays
+	/// via <see cref="Array.CreateInstanceFromArrayType"/> instead of through
+	/// <c>JavaPeerContainerFactory&lt;T&gt;</c>.
 	/// </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>
+	/// Currently a no-op. Speculative emission is blocked by an ILLink limitation:
+	/// <c>Mono.Linker.TypeMapHandler</c> calls <c>LinkContext.Resolve</c> on the
+	/// <c>TargetType</c> slot of every <c>TypeMapAttribute</c>, which throws
+	/// <c>NotSupportedException ("TypeDefinition cannot be resolved from
+	/// 'Mono.Cecil.ArrayType' type")</c> for closed array types. This affects both
+	/// 2-arg and 3-arg forms — there is no <c>TypeMapAttribute</c> shape that
+	/// accepts an array <see cref="Type"/> today.
 	/// </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,
-			});
-		}
+		// Intentionally empty. See remarks above.
 	}
 
 	static string Brackets (int rank)

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

@@ -26,13 +26,16 @@ public static partial class JNIEnv {
 
 		static Array ArrayCreateInstance (Type elementType, int length)
 		{
+			// TODO: when the ILLink limitation around array types in TypeMap
+			// attributes is resolved, switch this to use
+			// TrimmableTypeMap.TryGetArrayType + Array.CreateInstanceFromArrayType
+			// (the helpers are already in place) and remove
+			// JavaPeerContainerFactory<T>.CreateArray. Today the speculative array
+			// TypeMap emission crashes ILLink, so we keep using the per-T factory.
 			if (RuntimeFeature.TrimmableTypeMap) {
-				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.");
+				var factory = TrimmableTypeMap.Instance?.GetContainerFactory (elementType);
+				if (factory is not null)
+					return factory.CreateArray (length, 1);
 			}
 
 			#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,17 +10,25 @@
 namespace Java.Interop
 {
 	/// <summary>
-	/// AOT-safe factory for creating typed containers (lists, collections, dictionaries)
-	/// without using <c>MakeGenericType()</c>.
+	/// AOT-safe factory for creating typed containers (arrays, lists, collections, dictionaries)
+	/// without using <c>MakeGenericType()</c> or <c>Array.CreateInstance()</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.
+	/// Array creation is still routed through this factory because the planned
+	/// <c>JNIEnv.ArrayCreateInstance</c> + <c>Array.CreateInstanceFromArrayType</c>
+	/// path requires speculative <c>[L&lt;jni&gt;;</c> <c>TypeMap</c> attribute
+	/// entries that ILLink's <c>TypeMapHandler</c> currently cannot process
+	/// (<c>NotSupportedException</c> on <c>Mono.Cecil.ArrayType</c>).
+	/// <see cref="Microsoft.Android.Runtime.TrimmableTypeMap.TryGetArrayType"/> is
+	/// in place for the future swap once the ILLink limitation is resolved.
 	/// </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>
@@ -72,6 +80,35 @@ 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.
+		// (See PR #11238 and the ILLink limitation it documents — the planned typemap-based
+		// approach is already wired in via `TrimmableTypeMap.TryGetArrayType` but cannot
+		// be activated until ILLink learns to handle `Mono.Cecil.ArrayType` in
+		// `TypeMapAttribute`.)
+		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);
 

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

@@ -778,20 +778,16 @@ public class PeBlobValidation
 		[Fact]
 		public void FullPipeline_Mixed2ArgAnd3Arg_BothSurviveRoundTrip ()
 		{
-			// With ForceUnconditionalEntries, both peer entries are emitted as 2-arg unconditional.
-			// In addition, ModelBuilder emits speculative 3-arg conditional array entries (ranks 1-3)
-			// per non-aliased peer, which also round-trip through the PE blob.
+			// With ForceUnconditionalEntries, both are emitted as 2-arg unconditional
 			var objectPeer = FindFixtureByJavaName ("java/lang/Object");
 			var activityPeer = FindFixtureByJavaName ("android/app/Activity");
 
 			var model = BuildModel (new [] { objectPeer, activityPeer }, "MixedBlob");
-			Assert.Equal (2, NonArrayEntries (model).Count);
-			// 2 peers × 3 array ranks = 6 speculative array entries; total 2 + 6 = 8.
-			Assert.Equal (8, model.Entries.Count);
+			Assert.Equal (2, model.Entries.Count);
 
 			EmitAndVerify (model, "MixedBlob", (pe, reader) => {
 				var attrs = ReadAllTypeMapAttributeBlobs (reader);
-				Assert.Equal (8, attrs.Count);
+				Assert.Equal (2, attrs.Count);
 
 				var objectEntry = attrs.FirstOrDefault (a => a.jniName == "java/lang/Object");
 				Assert.NotNull (objectEntry.jniName);
@@ -800,11 +796,6 @@ public void FullPipeline_Mixed2ArgAnd3Arg_BothSurviveRoundTrip ()
 				var activityEntry = attrs.FirstOrDefault (a => a.jniName == "android/app/Activity");
 				Assert.NotNull (activityEntry.jniName);
 				Assert.Null (activityEntry.targetRef); // unconditional due to ForceUnconditionalEntries
-
-				// Spot-check that array entries also survive the round trip.
-				Assert.Contains (attrs, a => a.jniName == "[Landroid/app/Activity;");
-				Assert.Contains (attrs, a => a.jniName == "[[Landroid/app/Activity;");
-				Assert.Contains (attrs, a => a.jniName == "[[[Landroid/app/Activity;");
 			});
 		}
 
@@ -857,92 +848,17 @@ public void FullPipeline_McwBinding_Emits2ArgAttribute_WithWorkaround ()
 
 	public class ArrayEntries
 	{
-		[Fact]
-		public void Build_SinglePeer_EmitsRanks1Through3 ()
-		{
-			var peer = MakeMcwPeer ("foo/Bar", "Foo.Bar", "App");
-			var model = BuildModel (new [] { peer });
-
-			Assert.Equal ("[Lfoo/Bar;",   model.Entries.Single (e => e.JniName == "[Lfoo/Bar;").JniName);
-			Assert.Equal ("[[Lfoo/Bar;",  model.Entries.Single (e => e.JniName == "[[Lfoo/Bar;").JniName);
-			Assert.Equal ("[[[Lfoo/Bar;", model.Entries.Single (e => e.JniName == "[[[Lfoo/Bar;").JniName);
-		}
+		// EmitArrayEntries is currently a no-op (see ModelBuilder.EmitArrayEntries
+		// remarks — blocked by an ILLink TypeMapHandler limitation around
+		// Mono.Cecil.ArrayType). These tests pin that behavior so we know if it
+		// changes back.
 
 		[Fact]
-		public void Build_ArrayEntries_PointAtClosedManagedArrayTypes ()
+		public void Build_DoesNotEmitArrayEntries_PendingILLinkFix ()
 		{
 			var peer = MakeMcwPeer ("foo/Bar", "Foo.Bar", "App");
 			var model = BuildModel (new [] { peer });
 
-			var rank1 = model.Entries.Single (e => e.JniName == "[Lfoo/Bar;");
-			Assert.Equal ("Foo.Bar[], App", rank1.ProxyTypeReference);
-			Assert.Equal ("Foo.Bar[], App", rank1.TargetTypeReference);
-
-			var rank2 = model.Entries.Single (e => e.JniName == "[[Lfoo/Bar;");
-			Assert.Equal ("Foo.Bar[][], App", rank2.ProxyTypeReference);
-			Assert.Equal ("Foo.Bar[][], App", rank2.TargetTypeReference);
-
-			var rank3 = model.Entries.Single (e => e.JniName == "[[[Lfoo/Bar;");
-			Assert.Equal ("Foo.Bar[][][], App", rank3.ProxyTypeReference);
-			Assert.Equal ("Foo.Bar[][][], App", rank3.TargetTypeReference);
-		}
-
-		[Fact]
-		public void Build_ArrayEntries_AreConditional ()
-		{
-			// Array entries must be conditional (3-arg) so the trimmer can drop
-			// entries whose target array type is not live in the shipped app.
-			var peer = MakeMcwPeer ("foo/Bar", "Foo.Bar", "App");
-			var model = BuildModel (new [] { peer });
-
-			foreach (var arrayEntry in model.Entries.Where (e => e.JniName.StartsWith ("[", StringComparison.Ordinal))) {
-				Assert.False (arrayEntry.IsUnconditional, $"Array entry {arrayEntry.JniName} must be conditional (3-arg)");
-				Assert.NotNull (arrayEntry.TargetTypeReference);
-			}
-		}
-
-		[Fact]
-		public void Build_OpenGenericPeer_DoesNotEmitArrayEntries ()
-		{
-			// typeof(JavaList<>[]) is invalid, so open generics must be skipped.
-			var openGeneric = MakeMcwPeer ("java/util/ArrayList", "Android.Runtime.JavaList`1", "Mono.Android")
-				with { IsGenericDefinition = true };
-			var model = BuildModel (new [] { openGeneric });
-
-			Assert.DoesNotContain (model.Entries, e => e.JniName.StartsWith ("[", StringComparison.Ordinal));
-		}
-
-		[Fact]
-		public void Build_AliasGroup_DoesNotEmitArrayEntries ()
-		{
-			// Alias groups (multiple peers sharing one JNI name) would produce duplicate
-			// JNI array keys; they're skipped pending an alias-aware design.
-			var peers = new List<JavaPeerInfo> {
-				MakeMcwPeer ("test/Dup", "Test.First", "App"),
-				MakeMcwPeer ("test/Dup", "Test.Second", "App"),
-			};
-			var model = BuildModel (peers);
-
-			Assert.DoesNotContain (model.Entries, e => e.JniName.StartsWith ("[", StringComparison.Ordinal));
-		}
-
-		[Theory]
-		[InlineData ("Z")]
-		[InlineData ("B")]
-		[InlineData ("C")]
-		[InlineData ("S")]
-		[InlineData ("I")]
-		[InlineData ("J")]
-		[InlineData ("F")]
-		[InlineData ("D")]
-		public void Build_PrimitiveJniKeyword_DoesNotEmitArrayEntries (string jniKeyword)
-		{
-			// Primitive JNI keyword keys (Z, B, C, S, I, J, F, D) are handled by the legacy
-			// JniRuntime.JniTypeManager.GetPrimitiveArrayTypesForSimpleReference path. Emitting
-			// array entries here would shadow that built-in handling.
-			var peer = MakeMcwPeer (jniKeyword, "FakePrimitive.Wrapper", "App");
-			var model = BuildModel (new [] { peer });
-
 			Assert.DoesNotContain (model.Entries, e => e.JniName.StartsWith ("[", StringComparison.Ordinal));
 		}
 	}