[NativeAOT] Make the trimmable typemap the default

Configuration.OperatingSystem.props

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+    <PropertyGroup>
+        <HostOsName Condition=" '$(HostOsName)' == '' ">macOS</HostOsName>
+        <HostOsFlavor Condition=" '$(HostOsFlavor)' == '' ">macOS</HostOsFlavor>
+        <HostOsRelease Condition=" '$(HostOsRelease)' == '' ">26.5 (25F71)</HostOsRelease>
+        <HostCpuCount Condition=" '$(HostCpuCount)' == '' ">10</HostCpuCount>
+        <HostBits Condition=" '$(HostBits)' == '' ">64</HostBits>
+        <NdkLlvmTag Condition=" '$(NdkLlvmTag)' == '' ">darwin-x86_64</NdkLlvmTag>
+    </PropertyGroup>
+</Project>

external/Java.Interop/tests/Java.Interop-Tests/Java.Interop/JniTypeManagerTests.cs

@@ -161,6 +161,20 @@ static void AssertGetJniTypeInfoForType (Type type, string jniType, bool isKeywo
 			AssertArrayTypesFromSignature<double[]> (manager, "[[D", typeof (JavaObjectArray<JavaPrimitiveArray<double>>));
 			AssertArrayTypesFromSignature<string[]> (manager, "[[Ljava/lang/String;", typeof (JavaObjectArray<JavaObjectArray<string>>));
 
+			// Nullable counterparts of the primitive value types: the boxed reference signatures
+			// java/lang/<Boxed> map to Nullable<T> (see JniBuiltinSimpleReferenceToType /
+			// GetBuiltInTypeForSimpleReference). Unlike the primitive keyword arrays above, these are
+			// non-keyword reference arrays, so the element type is the boxed Nullable<T> and the array
+			// family is T?[] and JavaObjectArray<T?> (no JavaArray<T>/JavaPrimitiveArray<T>).
+			AssertArrayTypesFromSignature<bool?>   (manager, "[Ljava/lang/Boolean;",   typeof (JavaObjectArray<bool?>));
+			AssertArrayTypesFromSignature<sbyte?>  (manager, "[Ljava/lang/Byte;",      typeof (JavaObjectArray<sbyte?>));
+			AssertArrayTypesFromSignature<char?>   (manager, "[Ljava/lang/Character;", typeof (JavaObjectArray<char?>));
+			AssertArrayTypesFromSignature<short?>  (manager, "[Ljava/lang/Short;",     typeof (JavaObjectArray<short?>));
+			AssertArrayTypesFromSignature<int?>    (manager, "[Ljava/lang/Integer;",   typeof (JavaObjectArray<int?>));
+			AssertArrayTypesFromSignature<long?>   (manager, "[Ljava/lang/Long;",      typeof (JavaObjectArray<long?>));
+			AssertArrayTypesFromSignature<float?>  (manager, "[Ljava/lang/Float;",     typeof (JavaObjectArray<float?>));
+			AssertArrayTypesFromSignature<double?> (manager, "[Ljava/lang/Double;",    typeof (JavaObjectArray<double?>));
+
 			// Yes, these look weird...
 			// Assume: class II {}
 			Assert.AreEqual (null, GetType ("II"));

external/Java.Interop/tests/Java.Interop-Tests/Java.Interop/JniTypeTest.cs

@@ -219,6 +219,8 @@ public unsafe void RegisterNativeMethods_JniNativeMethod ()
 		static int NativeAdd (IntPtr jnienv, IntPtr self, int a, int b) => a + b;
 
 		[Test]
+		[Category ("NativeAOTIgnore")]
+		[Category ("TrimmableTypeMapUnsupported")]
 		[UnconditionalSuppressMessage ("AOT", "IL3050", Justification = "Test exercises non-AOT-compatible JniNativeMethodRegistration[] registration path.")]
 		public unsafe void RegisterNativeMethods_JniNativeMethodRegistration ()
 		{
@@ -253,6 +255,8 @@ public unsafe void RegisterNativeMethods_JniNativeMethodRegistration ()
 		static int ManagedAdd (IntPtr jnienv, IntPtr self, int a, int b) => a + b;
 
 		[Test]
+		[Category ("NativeAOTIgnore")]
+		[Category ("TrimmableTypeMapUnsupported")]
 		[UnconditionalSuppressMessage ("AOT", "IL3050", Justification = "Test exercises non-AOT-compatible JniNativeMethodRegistration[] registration path with many methods.")]
 		public unsafe void RegisterNativeMethods_JniNativeMethodRegistration_ManyMethods ()
 		{

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

@@ -515,7 +515,11 @@ internal static void ApplyPlaceholders (XDocument doc, string? placeholders, str
 				var eqIndex = entry.IndexOf ('=');
 				if (eqIndex > 0) {
 					var key = entry.Substring (0, eqIndex).Trim ();
-					var value = entry.Substring (eqIndex + 1).Trim ();
+					// Normalize '\' to the platform directory separator to match the legacy pipeline,
+					// where the substituted manifest is re-encoded by aapt2 (which rewrites backslashes
+					// to '/' on Unix). The trimmable generator writes the merged manifest directly, so we
+					// apply the same normalization here to keep placeholder values byte-for-byte identical.
+					var value = entry.Substring (eqIndex + 1).Trim ().Replace ('\\', Path.DirectorySeparatorChar);
 					replacements ["${" + key + "}"] = value;
 				} else if (eqIndex < 0) {
 					// An entry without '=' is not a valid key=value pair. Mirror the legacy

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",
@@ -55,7 +70,7 @@ static class ModelBuilder
 	/// 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));
@@ -66,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.
@@ -102,20 +124,34 @@ public static TypeMapAssemblyData Build (IReadOnlyList<JavaPeerInfo> peers, stri
 			string jniName = kvp.Key;
 			var peersForName = kvp.Value;
 
-			// Sort aliases by managed type name for deterministic proxy naming
+			// Order aliases to match the java→managed selection the native runtime performs (see
+			// clr_typemap_java_to_managed / monovm_typemap_java_to_managed and NativeTypeMappingData):
+			// the runtime builds its java→managed map by processing the Mono.Android module first and
+			// keeping the first managed type that claims a Java name (first-writer-wins). GetTypeForSimpleReference
+			// returns the first (index [0]) alias, so put the Mono.Android peer first — e.g. java/lang/Object
+			// must resolve to Java.Lang.Object (Mono.Android), not Java.Interop.JavaObject. Remaining peers are
+			// ordered by ordinal managed type name for deterministic proxy naming.
 			if (peersForName.Count > 1) {
-				peersForName.Sort ((a, b) => StringComparer.Ordinal.Compare (a.ManagedTypeName, b.ManagedTypeName));
+				peersForName.Sort ((a, b) => {
+					bool aMonoAndroid = string.Equals (a.AssemblyName, "Mono.Android", StringComparison.Ordinal);
+					bool bMonoAndroid = string.Equals (b.AssemblyName, "Mono.Android", StringComparison.Ordinal);
+					if (aMonoAndroid != bMonoAndroid) {
+						return aMonoAndroid ? -1 : 1;
+					}
+					return StringComparer.Ordinal.Compare (a.ManagedTypeName, b.ManagedTypeName);
+				});
 			}
 
 			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);
@@ -665,7 +701,14 @@ 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 up to maxArrayRank (also a built-in element type, so multidimensional string
+	//     arrays like String[][] stay resolvable),
+	//   * the boxed Nullable<T> value types up to maxArrayRank (also built-in element types mapping to
+	//     java/lang/<Boxed>; a small fixed set, so multidim boxed arrays stay resolvable too).
+	static void EmitPrimitiveArrayEntries (TypeMapAssemblyData model, int maxArrayRank, int maxReferenceArrayRank)
 	{
 		foreach (var primitive in PrimitiveArrayProxies) {
 			for (int rank = 1; rank <= maxArrayRank; rank++) {
@@ -694,6 +737,65 @@ static void EmitPrimitiveArrayEntries (TypeMapAssemblyData model, int maxArrayRa
 				AddArrayProxyAssociations (model, proxy, proxyReference);
 			}
 		}
+
+		// System.String maps to java/lang/String but is a built-in element type injected at runtime by
+		// TrimmableTypeMapTypeManager.GetBuiltInTypeForSimpleReference, so it is neither a scanned Java
+		// peer (EmitArrayEntriesForPeer) nor a keyword 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.
+		// String is a single, fixed built-in element type (not part of the scanned-peer explosion), so —
+		// like the keyword primitives — it goes up to maxArrayRank. This keeps multidimensional string
+		// arrays (String[][], "[[Ljava/lang/String;") resolvable, matching the other type-map backends.
+		for (int rank = 1; rank <= maxArrayRank; rank++) {
+			var proxy = new ArrayProxyData {
+				TypeName = ManagedTypeNameToArrayProxyTypeName ("System.String", rank),
+				ElementType = new TypeRefData {
+					ManagedTypeName = "System.String",
+					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);
+		}
+
+		// Nullable counterparts of the primitive value types map to the boxed java/lang/<Boxed>
+		// references and, like System.String, are built-in element 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>. Like the primitives
+		// and System.String, these are a small fixed set of built-in element types (not the scanned-peer
+		// explosion), so they go up to maxArrayRank and keep multidim boxed arrays resolvable.
+		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/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/PEAssemblyBuilder.cs

@@ -6,6 +6,7 @@
 using System.Reflection.Metadata;
 using System.Reflection.Metadata.Ecma335;
 using System.Reflection.PortableExecutable;
+using System.Security.Cryptography;
 
 namespace Microsoft.Android.Sdk.TrimmableTypeMap;
 
@@ -107,12 +108,28 @@ public void WritePE (Stream stream)
 			new PEHeaderBuilder (imageCharacteristics: Characteristics.Dll),
 			new MetadataRootBuilder (Metadata),
 			ILBuilder,
-			mappedFieldData: _mappedFieldData.Count > 0 ? _mappedFieldData : null);
+			mappedFieldData: _mappedFieldData.Count > 0 ? _mappedFieldData : null,
+			// Derive the PE content id (and thus the header TimeDateStamp/debug id) from a hash of the
+			// image so the bytes are fully deterministic. Without this, ManagedPEBuilder falls back to a
+			// time-based id, so every regeneration produces different bytes even for identical input; that
+			// churns the generated typemap assemblies and breaks incremental packaging (a no-op rebuild
+			// re-touches the .dll, forcing repackage + re-sign). The MVID is already deterministic.
+			deterministicIdProvider: DeterministicContentId);
 		var peBlob = new BlobBuilder ();
 		peBuilder.Serialize (peBlob);
 		peBlob.WriteContentTo (stream);
 	}
 
+	static BlobContentId DeterministicContentId (IEnumerable<Blob> content)
+	{
+		using var hash = IncrementalHash.CreateHash (HashAlgorithmName.SHA256);
+		foreach (var blob in content) {
+			var segment = blob.GetBytes ();
+			hash.AppendData (segment.Array!, segment.Offset, segment.Count);
+		}
+		return BlobContentId.FromHash (hash.GetHashAndReset ());
+	}
+
 	/// <summary>
 	/// Adds (or retrieves from cache) an assembly reference.
 	/// </summary>

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/ITrimmableTypeMapLogger.cs

@@ -12,6 +12,8 @@ public interface ITrimmableTypeMapLogger
 	void LogGeneratedJcwFilesInfo (int sourceCount);
 	void LogRootingManifestReferencedTypeInfo (string javaTypeName, string managedTypeName);
 	void LogManifestReferencedTypeNotFoundWarning (string javaTypeName);
+	void LogInvalidManifestPlaceholderWarning (string placeholders);
+	void LogLibraryManifestMergeWarning (string message);
 	void LogUnresolvableJavaPeerSkippedWarning (
 		string managedTypeName,
 		string assemblyName,

src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/AssemblyIndex.cs

@@ -164,6 +164,7 @@ bool TryGetTypeReferenceAssemblyName (TypeReference typeReference, [NotNullWhen
 		// with the wrong AttributeName.
 		List<IntentFilterInfo>? intentFilters = null;
 		List<MetaDataInfo>? metaData = null;
+		Dictionary<string, object?>? layoutProperties = null;
 
 		foreach (var caHandle in typeDef.GetCustomAttributes ()) {
 			var ca = Reader.GetCustomAttribute (caHandle);
@@ -214,6 +215,8 @@ bool TryGetTypeReferenceAssemblyName (TypeReference typeReference, [NotNullWhen
 				metaData ??= new List<MetaDataInfo> ();
 				var (mdName, mdProps) = ParseNameAndProperties (ca);
 				metaData.Add (CreateMetaDataInfo (mdName, mdProps));
+			} else if (attrName == "LayoutAttribute") {
+				layoutProperties = ParseLayoutAttribute (ca);
 			} else if (attrInfo is null && ImplementsJniNameProviderAttribute (ca)) {
 				// Custom attribute implementing IJniNameProviderAttribute (e.g., user-defined [CustomJniName])
 				var name = TryGetNameProperty (ca);
@@ -232,6 +235,9 @@ bool TryGetTypeReferenceAssemblyName (TypeReference typeReference, [NotNullWhen
 			if (metaData is not null) {
 				attrInfo.MetaData.AddRange (metaData);
 			}
+			if (layoutProperties is not null) {
+				attrInfo.LayoutProperties = layoutProperties;
+			}
 		}
 
 		return (registerInfo, attrInfo);
@@ -425,6 +431,18 @@ RegisterInfo ParseRegisterInfo (CustomAttributeValue<string> value)
 		return null;
 	}
 
+	Dictionary<string, object?> ParseLayoutAttribute (CustomAttribute ca)
+	{
+		var value = DecodeAttribute (ca);
+		var properties = new Dictionary<string, object?> (StringComparer.Ordinal);
+		foreach (var named in value.NamedArguments) {
+			if (named.Name is not null) {
+				properties [named.Name] = named.Value;
+			}
+		}
+		return properties;
+	}
+
 	IntentFilterInfo ParseIntentFilterAttribute (CustomAttribute ca)
 	{
 		var value = DecodeAttribute (ca);
@@ -712,6 +730,12 @@ class TypeAttributeInfo (string attributeName)
 	/// Metadata entries declared on this type via [MetaData] attributes.
 	/// </summary>
 	public List<MetaDataInfo> MetaData { get; } = [];
+
+	/// <summary>
+	/// Named property values from a [Layout] attribute on this type, or null if none.
+	/// Maps to the &lt;layout&gt; child element of the component in the manifest.
+	/// </summary>
+	public Dictionary<string, object?>? LayoutProperties { get; set; }
 }
 
 sealed class ApplicationAttributeInfo () : TypeAttributeInfo ("ApplicationAttribute")