[TrimmableTypeMap] Emit array proxies for boxed nullable value types

GetTypes ("[Ljava/lang/Boolean;") and the other boxed value-type array
signatures dropped the Nullable<T> array family (bool?[], JavaObjectArray<bool?>)
on NativeAOT. Like System.String, Nullable<T> is a built-in reference mapping
injected at runtime by GetBuiltInTypeForSimpleReference, so it is neither a
scanned Java peer nor a primitive and had no pre-generated array proxy.

Unlike String, the proxy map key is the tricky part: at runtime
TryGetManagedTypeKey (typeof (bool?)) keyed on Type.FullName, whose type
argument carries the full versioned assembly-qualified name
(System.Nullable`1[[System.Boolean, System.Private.CoreLib, Version=...]]),
which the generator can't stably reproduce.

Normalize the generic key on both sides:
  * Runtime (BuildManagedTypeKey): build closed-generic keys from the open
    definition's FullName plus each type argument's normalized key (simple
    assembly name, no Version/Culture/PublicKeyToken), and treat Nullable<T> as
    a System.Runtime type. typeof (bool?) -> "System.Nullable`1[[System.Boolean,
    System.Runtime]], System.Runtime".
  * Generator (ModelBuilder): emit reference-array proxies for the eight
    Nullable<primitive> types that have a boxed java/lang mapping, keyed with
    the same normalized string.

Normalizing (rather than emitting version-qualified duplicates) keeps a single
canonical proxy per logical type.

Fixes the boxed-nullable portion of JniTypeManagerTests.GetType on trimmable
NativeAOT (added in the preceding test-coverage commit).

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

Author: simonrozsival

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

@@ -31,6 +31,21 @@ static class ModelBuilder
 		new ("D", "Double", "System.Double", ["Java.Interop.JavaDoubleArray"]),
 	];
 
+	// Nullable value types map to the boxed java/lang/<Boxed> references (java/lang/Boolean etc.) via
+	// TrimmableTypeMapTypeManager.GetBuiltInTypeForSimpleReference. Like System.String they are neither
+	// scanned Java peers nor primitives, so their array proxies are emitted explicitly. Only the eight
+	// types with a boxed java/lang mapping are included (java/lang/Byte -> sbyte?, not byte?, etc.).
+	static readonly (string Name, string ManagedTypeName) [] NullableArrayProxies = [
+		("Boolean", "System.Boolean"),
+		("SByte",   "System.SByte"),
+		("Char",    "System.Char"),
+		("Int16",   "System.Int16"),
+		("Int32",   "System.Int32"),
+		("Int64",   "System.Int64"),
+		("Single",  "System.Single"),
+		("Double",  "System.Double"),
+	];
+
 	static readonly HashSet<string> EssentialRuntimeTypes = new (StringComparer.Ordinal) {
 		"java/lang/Object",
 		"java/lang/Class",
@@ -732,6 +747,35 @@ static void EmitPrimitiveArrayEntries (TypeMapAssemblyData model, int maxArrayRa
 			});
 			AddArrayProxyAssociations (model, proxy, proxyReference);
 		}
+
+		// Nullable counterparts of the primitive value types map to the boxed java/lang/<Boxed>
+		// references and, like System.String, are built-in reference mappings (no scanned peer, no
+		// 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>.
+		foreach (var nullablePrimitive in NullableArrayProxies) {
+			var elementTypeName = $"System.Nullable`1[[{nullablePrimitive.ManagedTypeName}, System.Runtime]]";
+			for (int rank = 1; rank <= maxArrayRank; rank++) {
+				var proxy = new ArrayProxyData {
+					TypeName = $"Nullable_{nullablePrimitive.Name}_ArrayProxy{rank}",
+					ElementType = new TypeRefData {
+						ManagedTypeName = elementTypeName,
+						AssemblyName = "System.Runtime",
+					},
+					Rank = rank,
+				};
+				model.ArrayProxyTypes.Add (proxy);
+				var proxyReference = AssemblyQualify ($"{proxy.Namespace}.{proxy.TypeName}", model.AssemblyName);
+				model.Entries.Add (new TypeMapAttributeData {
+					MapKey = GetArrayProxyMapKey (proxy.ElementType),
+					ProxyTypeReference = proxyReference,
+					TargetTypeReference = proxyReference,
+					AnchorRank = rank,
+				});
+				AddArrayProxyAssociations (model, proxy, proxyReference);
+			}
+		}
 	}
 
 	static string Brackets (int rank) => rank switch {

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

@@ -6,6 +6,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Text;
 using System.Threading;
 using Android.Runtime;
 using Java.Interop;
@@ -543,25 +544,58 @@ internal bool TryGetArrayProxy (Type elementType, int additionalRank, [NotNullWh
 
 	static bool TryGetManagedTypeKey (Type type, [NotNullWhen (true)] out string? key)
 	{
-		var fullName = type.FullName;
-		if (fullName is null) {
-			key = null;
-			return false;
-		}
+		key = BuildManagedTypeKey (type);
+		return key is not null;
+	}
 
+	// Builds the array-proxy map key for a managed type. Closed generic types use a normalized,
+	// version-independent form so the key matches the one emitted by the trimmable typemap generator,
+	// which references types by simple assembly name (no Version/Culture/PublicKeyToken). Without
+	// normalization a closed generic like Nullable<bool> would key on Type.FullName, whose type
+	// arguments carry the full versioned assembly-qualified name and would never match.
+	static string? BuildManagedTypeKey (Type type)
+	{
 		var assemblyName = GetAssemblyNameForManagedTypeKey (type);
 		if (assemblyName is null) {
-			key = null;
-			return false;
+			return null;
 		}
 
-		key = $"{fullName}, {assemblyName}";
-		return true;
+		if (type.IsGenericType && !type.IsGenericTypeDefinition) {
+			var definitionName = type.GetGenericTypeDefinition ().FullName;
+			if (definitionName is null) {
+				return null;
+			}
+			var arguments = type.GetGenericArguments ();
+			var builder = new StringBuilder (definitionName);
+			builder.Append ("[[");
+			for (int i = 0; i < arguments.Length; i++) {
+				if (i > 0) {
+					builder.Append ("],[");
+				}
+				var argumentKey = BuildManagedTypeKey (arguments [i]);
+				if (argumentKey is null) {
+					return null;
+				}
+				builder.Append (argumentKey);
+			}
+			builder.Append ("]], ");
+			builder.Append (assemblyName);
+			return builder.ToString ();
+		}
+
+		var fullName = type.FullName;
+		if (fullName is null) {
+			return null;
+		}
+		return $"{fullName}, {assemblyName}";
 	}
 
 	static string? GetAssemblyNameForManagedTypeKey (Type type)
 	{
-		if (type.IsPrimitive || type == typeof (string)) {
+		// Primitives, string, and Nullable<T> are surfaced through the System.Runtime reference
+		// assembly; the trimmable typemap generator emits their keys with "System.Runtime", so
+		// normalize to it here (the runtime implementation assembly is System.Private.CoreLib).
+		if (type.IsPrimitive || type == typeof (string) || Nullable.GetUnderlyingType (type) is not null) {
 			return "System.Runtime";
 		}
 

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

@@ -1203,8 +1203,8 @@ public void Build_EmitArrayEntries_PrimitiveEntries_SynthesizedForJavaInteropAss
 			var primitiveEntries = model.Entries
 				.Where (e => e.MapKey.StartsWith ("System.", StringComparison.Ordinal) && e.AnchorRank is not null)
 				.ToList ();
-			// 12 primitives × 3 ranks + System.String × 3 ranks.
-			Assert.Equal (39, primitiveEntries.Count);
+			// 12 primitives × 3 ranks + System.String × 3 ranks + 8 Nullable<primitive> × 3 ranks.
+			Assert.Equal (63, primitiveEntries.Count);
 
 			var sbyteRank1 = primitiveEntries.Single (e => e.MapKey == "System.SByte, System.Runtime" && e.AnchorRank == 1);
 			Assert.Equal ("_TypeMap.ArrayProxies.Primitive_SByte_ArrayProxy1, _Java.Interop.TypeMap", sbyteRank1.ProxyTypeReference);
@@ -1259,6 +1259,19 @@ public void Build_EmitArrayEntries_PrimitiveEntries_SynthesizedForJavaInteropAss
 			Assert.DoesNotContain (model.Associations, a =>
 				a.SourceTypeReference == "Java.Interop.JavaPrimitiveArray`1[[System.String, System.Runtime]], Java.Interop" &&
 				a.AliasProxyTypeReference == stringRank1.ProxyTypeReference);
+
+			// Nullable<T> boxed mappings (java/lang/Boolean etc.) use the normalized generic key
+			// (simple assembly names) that TrimmableTypeMap.BuildManagedTypeKey produces at runtime, and
+			// get the reference-array family.
+			var nullableBoolRank1 = primitiveEntries.Single (e =>
+				e.MapKey == "System.Nullable`1[[System.Boolean, System.Runtime]], System.Runtime" && e.AnchorRank == 1);
+			Assert.Equal ("_TypeMap.ArrayProxies.Nullable_Boolean_ArrayProxy1, _Java.Interop.TypeMap", nullableBoolRank1.ProxyTypeReference);
+			Assert.Contains (model.Associations, a =>
+				a.SourceTypeReference == "System.Nullable`1[[System.Boolean, System.Runtime]][], System.Runtime" &&
+				a.AliasProxyTypeReference == nullableBoolRank1.ProxyTypeReference);
+			Assert.Contains (model.Associations, a =>
+				a.SourceTypeReference == "Java.Interop.JavaObjectArray`1[[System.Nullable`1[[System.Boolean, System.Runtime]], System.Runtime]], Java.Interop" &&
+				a.AliasProxyTypeReference == nullableBoolRank1.ProxyTypeReference);
 		}
 
 		[Fact]