[TrimmableTypeMap][NativeAOT] Inline resource designer constants (CI validation draft)

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/Model/TypeMapAssemblyData.cs

@@ -119,7 +119,7 @@ sealed record ArrayProxyData
 /// </summary>
 sealed record PrimitiveArrayProxyData
 {
-	public required TypeRefData ConcreteArrayType { get; init; }
+	public IReadOnlyList<TypeRefData> ConcreteArrayTypes { get; init; } = [];
 }
 
 /// <summary>

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

@@ -17,14 +17,18 @@ static class ModelBuilder
 	const string ProxyTypeSuffix = "_Proxy";
 
 	static readonly PrimitiveArrayProxyInfo [] PrimitiveArrayProxies = [
-		new ("Z", "Boolean", "System.Boolean", "Java.Interop.JavaBooleanArray"),
-		new ("B", "SByte", "System.SByte", "Java.Interop.JavaSByteArray"),
-		new ("C", "Char", "System.Char", "Java.Interop.JavaCharArray"),
-		new ("S", "Int16", "System.Int16", "Java.Interop.JavaInt16Array"),
-		new ("I", "Int32", "System.Int32", "Java.Interop.JavaInt32Array"),
-		new ("J", "Int64", "System.Int64", "Java.Interop.JavaInt64Array"),
-		new ("F", "Single", "System.Single", "Java.Interop.JavaSingleArray"),
-		new ("D", "Double", "System.Double", "Java.Interop.JavaDoubleArray"),
+		new ("Z", "Boolean", "System.Boolean", ["Java.Interop.JavaBooleanArray"]),
+		new ("B", "SByte", "System.SByte", ["Java.Interop.JavaSByteArray"]),
+		new ("B", "Byte", "System.Byte", []),
+		new ("C", "Char", "System.Char", ["Java.Interop.JavaCharArray"]),
+		new ("S", "Int16", "System.Int16", ["Java.Interop.JavaInt16Array"]),
+		new ("S", "UInt16", "System.UInt16", []),
+		new ("I", "Int32", "System.Int32", ["Java.Interop.JavaInt32Array"]),
+		new ("I", "UInt32", "System.UInt32", []),
+		new ("J", "Int64", "System.Int64", ["Java.Interop.JavaInt64Array"]),
+		new ("J", "UInt64", "System.UInt64", []),
+		new ("F", "Single", "System.Single", ["Java.Interop.JavaSingleArray"]),
+		new ("D", "Double", "System.Double", ["Java.Interop.JavaDoubleArray"]),
 	];
 
 	static readonly HashSet<string> EssentialRuntimeTypes = new (StringComparer.Ordinal) {
@@ -98,9 +102,22 @@ 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);
@@ -575,12 +592,14 @@ static IReadOnlyList<string> GetArrayTypeReferences (ArrayProxyData proxy)
 			return ExpandRankOneTypes (rankOneTypes, proxy.Rank);
 		}
 
-		var rankOnePrimitiveTypes = new [] {
+		List<string> rankOnePrimitiveTypes = [
 			AddArrayRank (elementType, 1),
 			MakeGenericTypeReference ("Java.Interop.JavaArray`1", "Java.Interop", elementType),
 			MakeGenericTypeReference ("Java.Interop.JavaPrimitiveArray`1", "Java.Interop", elementType),
-			AssemblyQualify (proxy.Primitive.ConcreteArrayType.ManagedTypeName, proxy.Primitive.ConcreteArrayType.AssemblyName),
-		};
+		];
+		foreach (var concreteArrayType in proxy.Primitive.ConcreteArrayTypes) {
+			rankOnePrimitiveTypes.Add (AssemblyQualify (concreteArrayType.ManagedTypeName, concreteArrayType.AssemblyName));
+		}
 		return ExpandRankOneTypes (rankOnePrimitiveTypes, proxy.Rank);
 	}
 
@@ -615,24 +634,27 @@ static string GetArrayProxyMapKey (TypeRefData elementType)
 	/// <summary>
 	/// Emits per-rank array TypeMap entries for one peer, anchored to the per-assembly
 	/// <c>__ArrayMapRank{N}</c> sentinels. Keys are managed element type names (rank is encoded
-	/// by the sentinel anchor, not by JNI array prefixes). Skips open generics and alias groups.
+	/// by the sentinel anchor, not by JNI array prefixes). Skips open generics.
 	/// </summary>
 	static void EmitArrayEntries (TypeMapAssemblyData model, string jniName, List<JavaPeerInfo> peersForName, int maxArrayRank)
 	{
-		if (peersForName.Count != 1) {
+		if (jniName.Length == 1 && IsJniPrimitiveKeyword (jniName [0])) {
 			return;
 		}
 
-		var peer = peersForName [0];
+		foreach (var peer in peersForName) {
+			EmitArrayEntriesForPeer (model, peer, maxArrayRank);
+		}
+	}
+
+	static void EmitArrayEntriesForPeer (TypeMapAssemblyData model, JavaPeerInfo peer, int maxArrayRank)
+	{
 		if (!peer.GenerateArrayEntries) {
 			return;
 		}
 		if (peer.IsGenericDefinition) {
 			return;
 		}
-		if (jniName.Length == 1 && IsJniPrimitiveKeyword (jniName [0])) {
-			return;
-		}
 
 		for (int rank = 1; rank <= maxArrayRank; rank++) {
 			var proxy = new ArrayProxyData {
@@ -668,10 +690,10 @@ static void EmitPrimitiveArrayEntries (TypeMapAssemblyData model, int maxArrayRa
 					},
 					Rank = rank,
 					Primitive = new PrimitiveArrayProxyData {
-						ConcreteArrayType = new TypeRefData {
-							ManagedTypeName = primitive.ConcreteArrayTypeName,
+						ConcreteArrayTypes = primitive.ConcreteArrayTypeNames.Select (name => new TypeRefData {
+							ManagedTypeName = name,
 							AssemblyName = "Java.Interop",
-						},
+						}).ToList (),
 					},
 				};
 				model.ArrayProxyTypes.Add (proxy);
@@ -711,5 +733,5 @@ readonly record struct PrimitiveArrayProxyInfo (
 		string JniName,
 		string Name,
 		string ManagedTypeName,
-		string ConcreteArrayTypeName);
+		IReadOnlyList<string> ConcreteArrayTypeNames);
 }

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

@@ -1636,12 +1636,14 @@ IReadOnlyList<RuntimeTypeSpec> GetArrayProxyTypes (ArrayProxyData proxy)
 			return ExpandRankOneTypes (rankOneObjectTypes, proxy.Rank);
 		}
 
-		var rankOneTypes = new RuntimeTypeSpec [] {
+		List<RuntimeTypeSpec> rankOneTypes = [
 			AddSzArrayRank (elementType, 1),
 			new GenericRuntimeTypeSpec (_javaArrayOpenRef, elementType),
 			new GenericRuntimeTypeSpec (_javaPrimitiveArrayOpenRef, elementType),
-			new NamedRuntimeTypeSpec (proxy.Primitive.ConcreteArrayType),
-		};
+		];
+		foreach (var concreteArrayType in proxy.Primitive.ConcreteArrayTypes) {
+			rankOneTypes.Add (new NamedRuntimeTypeSpec (concreteArrayType));
+		}
 
 		return ExpandRankOneTypes (rankOneTypes, proxy.Rank);
 	}

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

@@ -12,6 +12,7 @@ public interface ITrimmableTypeMapLogger
 	void LogGeneratedJcwFilesInfo (int sourceCount);
 	void LogRootingManifestReferencedTypeInfo (string javaTypeName, string managedTypeName);
 	void LogManifestReferencedTypeNotFoundWarning (string javaTypeName);
+	void LogInvalidManifestPlaceholderWarning (string placeholders);
 	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")

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

@@ -274,6 +274,13 @@ static void ForceUnconditionalIfPresent (Dictionary<(string ManagedName, string
 		}
 	}
 
+	// Managed types that must never be emitted into the trimmable type map, keyed by
+	// (managed full name, assembly simple name). These are reflection-based ([RequiresUnreferencedCode])
+	// helpers that the trimmable runtime never activates via the type map; emitting proxies for them
+	// only produces IL2026 trim warnings.
+	static bool IsUnsupportedByTrimmableTypeMap (string managedFullName, string assemblyName) =>
+		managedFullName == "Java.Interop.ManagedPeer" && assemblyName == "Java.Interop";
+
 	void ScanAssembly (AssemblyIndex index, Dictionary<(string ManagedName, string AssemblyName), JavaPeerInfo> results)
 	{
 		foreach (var typeHandle in index.Reader.TypeDefinitions) {
@@ -286,6 +293,16 @@ void ScanAssembly (AssemblyIndex index, Dictionary<(string ManagedName, string A
 
 			var fullName = MetadataTypeNameResolver.GetFullName (typeDef, index.Reader);
 
+			// Java.Interop.ManagedPeer is a reflection-based helper (marked
+			// [RequiresUnreferencedCode]) that is not supported by the trimmable type map: on the
+			// trimmable path native registration goes through IAndroidCallableWrapper.RegisterNatives
+			// and ManagedPeerNativeRegistration is disabled, so ManagedPeer is never activated via the
+			// type map. Emitting a proxy for it only produces IL2026 trim warnings (its constructors
+			// use reflection), so exclude it here.
+			if (IsUnsupportedByTrimmableTypeMap (fullName, index.AssemblyName)) {
+				continue;
+			}
+
 			// Temporarily allow [JniAddNativeMethodRegistrationAttribute] while we investigate
 			// which scenarios fail later in the trimmable typemap pipeline.
 			// if (index.MayUseJniAddNativeMethodRegistrationAttribute &&
@@ -2528,6 +2545,7 @@ void CollectExportField (MethodDefinition methodDef, AssemblyIndex index, List<J
 			Properties = attrInfo.Properties,
 			IntentFilters = attrInfo.IntentFilters,
 			MetaData = attrInfo.MetaData,
+			LayoutProperties = attrInfo.LayoutProperties,
 		};
 	}
 }

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

@@ -149,6 +149,7 @@ GeneratedManifest GenerateManifest (List<JavaPeerInfo> allPeers, AssemblyManifes
 			ForceExtractNativeLibs = forceDebuggable,
 			ManifestPlaceholders = config.ManifestPlaceholders,
 			ApplicationJavaClass = config.ApplicationJavaClass,
+			WarnInvalidPlaceholder = placeholders => logger.LogInvalidManifestPlaceholderWarning (placeholders),
 		};
 
 		var (doc, providerNames) = generator.Generate (manifestTemplate, allPeers, assemblyManifestInfo);

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

@@ -41,9 +41,11 @@ static Array ArrayCreateInstance (Type elementType, int length)
 					}
 				}
 
+				int arrayRank = GetArrayRank (elementType, out var leafElementType);
 				throw new NotSupportedException (
-					$"No TrimmableTypeMap array proxy entry for element type '{elementType}'. " +
-					$"Array lookups use the element type within the per-rank __ArrayMapRank{GetArrayRank (elementType)} typemap group; " +
+					$"No TrimmableTypeMap array proxy entry for element type '{elementType}' " +
+					$"(leaf element type '{leafElementType}', rank {arrayRank}). " +
+					$"Array lookups use the leaf element type within the per-rank __ArrayMapRank{arrayRank} typemap group; " +
 					$"ensure the mapping is emitted for that rank (for example by increasing _AndroidTrimmableTypeMapMaxArrayRank) or report an issue.");
 			}
 
@@ -52,7 +54,7 @@ static Array ArrayCreateInstance (Type elementType, int length)
 			#pragma warning restore IL3050
 		}
 
-		static int GetArrayRank (Type elementType)
+		static int GetArrayRank (Type elementType, out Type leafElementType)
 		{
 			int rank = 1;
 			while (elementType.IsSZArray) {
@@ -63,6 +65,7 @@ static int GetArrayRank (Type elementType)
 				}
 				elementType = nestedElementType;
 			}
+			leafElementType = elementType;
 			return rank;
 		}