[TrimmableTypeMap] Implement reflection-free TrimmableTypeMapValueManager and TrimmableTypeMapTypeManager

Documentation/docs-mobile/messages/index.md

@@ -221,8 +221,6 @@ Either change the value in the AndroidManifest.xml to match the $(SupportedOSPla
 + [XA4250](xa4250.md): Manifest-referenced type '{type}' was not found in any scanned assembly. It may be a framework type.
 + [XA4252](xa4252.md): Insecure HTTP Maven repository URL '{url}' is not allowed. Use an HTTPS URL, or set AllowInsecureHttp="true" metadata on the item to override this check.
 + [XA4253](xa4253.md): Generated Java callable wrapper code changed: '{path}'
-+ [XA4254](xa4254.md): Trimmable type map Java source input directory '{input}' and output directory '{output}' must be different.
-+ [XA4255](xa4255.md): Generated trimmable type map Java source '{path}' was not found.
 + XA4300: Native library '{library}' will not be bundled because it has an unsupported ABI.
 + [XA4301](xa4301.md): Apk already contains the item `xxx`.
 + [XA4302](xa4302.md): Unhandled exception merging \`AndroidManifest.xml\`: {ex}

src/Microsoft.Android.Runtime.NativeAOT/Java.Interop/JreRuntime.cs

@@ -61,7 +61,7 @@ static NativeAotRuntimeOptions CreateJreVM (NativeAotRuntimeOptions builder)
 			builder.TypeManager     ??= CreateDefaultTypeManager ();
 #endif  // NET
 
-			builder.ValueManager            ??= new JavaMarshalValueManager ();
+			builder.ValueManager            ??= Android.Runtime.JNIEnvInit.CreateValueManager ();
 			builder.ObjectReferenceManager  ??= new Android.Runtime.AndroidObjectReferenceManager ();
 
 			if (builder.InvocationPointer != IntPtr.Zero || builder.EnvironmentPointer != IntPtr.Zero)
@@ -81,7 +81,7 @@ static JniRuntime.JniTypeManager CreateDefaultTypeManager ()
 				return new TrimmableTypeMapTypeManager ();
 			}
 
-			return new ManagedTypeManager ();
+			throw new NotImplementedException ();
 		}
 
 		public override string? GetCurrentManagedThreadName ()

src/Microsoft.Android.Sdk.ILLink/PreserveLists/Mono.Android.xml

@@ -27,6 +27,7 @@
 		<type fullname="Android.Runtime.RaiseThrowableEventArgs" />
 		<type fullname="Android.Runtime.RegisterAttribute" />
 		<type fullname="Android.Runtime.TypeManager" />
+		<type fullname="Microsoft.Android.Runtime.ManagedTypeMapping" preserve="all" />
 		<!--
 		<type fullname="Android.Runtime.XmlResourceParserReader" />
 		<type fullname="Android.Runtime.XmlPullParserReader" />

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

@@ -0,0 +1,96 @@
+using System;
+using System.Buffers;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace Microsoft.Android.Sdk.TrimmableTypeMap;
+
+sealed class DeterministicHashBuilder : IDisposable
+{
+	readonly HashAlgorithm hash = SHA256.Create ();
+	readonly byte [] intBuffer = new byte [4];
+	readonly byte [] byteBuffer = new byte [1];
+	bool finished;
+
+	public void AddString (string value)
+	{
+		var bytes = Encoding.UTF8.GetBytes (value);
+		AddInt32 (bytes.Length);
+		AddBytes (bytes);
+	}
+
+	public void AddVersion (Version version)
+	{
+		AddInt32 (version.Major);
+		AddInt32 (version.Minor);
+		AddInt32 (version.Build);
+		AddInt32 (version.Revision);
+	}
+
+	public void AddInt32 (int value)
+	{
+		intBuffer [0] = (byte) value;
+		intBuffer [1] = (byte) (value >> 8);
+		intBuffer [2] = (byte) (value >> 16);
+		intBuffer [3] = (byte) (value >> 24);
+		AddBytes (intBuffer);
+	}
+
+	public void AddByte (byte value)
+	{
+		byteBuffer [0] = value;
+		AddBytes (byteBuffer);
+	}
+
+	public void AddBytes (byte [] bytes)
+	{
+		EnsureNotFinished ();
+		if (bytes.Length != 0) {
+			hash.TransformBlock (bytes, 0, bytes.Length, null, 0);
+		}
+	}
+
+	public void AddBytes (ReadOnlySpan<byte> bytes)
+	{
+		EnsureNotFinished ();
+		if (bytes.IsEmpty) {
+			return;
+		}
+
+		var buffer = ArrayPool<byte>.Shared.Rent (Math.Min (bytes.Length, 4096));
+		try {
+			while (!bytes.IsEmpty) {
+				var count = Math.Min (bytes.Length, buffer.Length);
+				bytes.Slice (0, count).CopyTo (buffer);
+				hash.TransformBlock (buffer, 0, count, null, 0);
+				bytes = bytes.Slice (count);
+			}
+		} finally {
+			ArrayPool<byte>.Shared.Return (buffer);
+		}
+	}
+
+	public byte [] ToHash ()
+	{
+		if (!finished) {
+			hash.TransformFinalBlock ([], 0, 0);
+			finished = true;
+		}
+		if (hash.Hash is not null) {
+			return hash.Hash;
+		}
+		throw new InvalidOperationException ("SHA256 did not produce a hash.");
+	}
+
+	void EnsureNotFinished ()
+	{
+		if (finished) {
+			throw new InvalidOperationException ("Cannot add data after finalizing the hash.");
+		}
+	}
+
+	public void Dispose ()
+	{
+		hash.Dispose ();
+	}
+}

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

@@ -1,6 +1,5 @@
 using System;
-using System.Security.Cryptography;
-using System.Text;
+using System.Collections.Generic;
 
 namespace Microsoft.Android.Sdk.TrimmableTypeMap;
 
@@ -12,12 +11,12 @@ static class MetadataHelper
 	/// </summary>
 	public static Guid DeterministicMvid (string moduleName, ReadOnlySpan<byte> contentBytes = default)
 	{
-		using var sha = SHA256.Create ();
-		byte [] nameBytes = Encoding.UTF8.GetBytes (moduleName);
-		byte [] input = new byte [nameBytes.Length + contentBytes.Length];
-		nameBytes.CopyTo (input, 0);
-		contentBytes.CopyTo (input.AsSpan (nameBytes.Length));
-		byte [] hash = sha.ComputeHash (input);
+		using var hashBuilder = new DeterministicHashBuilder ();
+		hashBuilder.AddString (moduleName);
+		if (!contentBytes.IsEmpty) {
+			hashBuilder.AddBytes (contentBytes);
+		}
+		byte [] hash = hashBuilder.ToHash ();
 		byte [] guidBytes = new byte [16];
 		Array.Copy (hash, guidBytes, 16);
 		return new Guid (guidBytes);
@@ -28,26 +27,44 @@ public static Guid DeterministicMvid (string moduleName, ReadOnlySpan<byte> cont
 	/// </summary>
 	public static byte [] ComputeContentFingerprint (TypeMapAssemblyData data)
 	{
-		using var sha = SHA256.Create ();
-		using var stream = new System.IO.MemoryStream ();
-		using var writer = new System.IO.BinaryWriter (stream, Encoding.UTF8);
+		using var hash = new DeterministicHashBuilder ();
 		foreach (var entry in data.Entries) {
-			writer.Write (entry.JniName);
-			writer.Write (entry.ProxyTypeReference);
-			writer.Write (entry.TargetTypeReference ?? "");
+			hash.AddString (entry.JniName);
+			hash.AddString (entry.ProxyTypeReference);
+			hash.AddString (entry.TargetTypeReference ?? "");
 		}
 		foreach (var proxy in data.ProxyTypes) {
-			writer.Write (proxy.TypeName);
-			writer.Write (proxy.TargetType.ManagedTypeName);
-			writer.Write (proxy.TargetType.AssemblyName);
-			writer.Write ((byte)(proxy.ActivationCtor?.Style ?? 0));
-			writer.Write ((byte)(proxy.InvokerActivationCtorStyle ?? 0));
+			hash.AddString (proxy.TypeName);
+			hash.AddString (proxy.TargetType.ManagedTypeName);
+			hash.AddString (proxy.TargetType.AssemblyName);
+			hash.AddByte ((byte)(proxy.ActivationCtor?.Style ?? 0));
+			hash.AddByte ((byte)(proxy.InvokerActivationCtorStyle ?? 0));
+		}
+		foreach (var proxy in data.ArrayProxyTypes) {
+			hash.AddString (proxy.TypeName);
+			hash.AddString (proxy.JniName);
+			hash.AddString (proxy.ElementType.ManagedTypeName);
+			hash.AddString (proxy.ElementType.AssemblyName);
+			hash.AddInt32 (proxy.Rank);
+			hash.AddString (proxy.Primitive?.ConcreteArrayType.ManagedTypeName ?? "");
+			hash.AddString (proxy.Primitive?.ConcreteArrayType.AssemblyName ?? "");
 		}
 		foreach (var assoc in data.Associations) {
-			writer.Write (assoc.SourceTypeReference);
-			writer.Write (assoc.AliasProxyTypeReference);
+			hash.AddString (assoc.SourceTypeReference);
+			hash.AddString (assoc.AliasProxyTypeReference);
+		}
+		return hash.ToHash ();
+	}
+
+	public static byte [] ComputeRootContentFingerprint (Version systemRuntimeVersion, IReadOnlyList<string> perAssemblyTypeMapNames, bool useSharedTypemapUniverse, int maxArrayRank)
+	{
+		using var hash = new DeterministicHashBuilder ();
+		hash.AddVersion (systemRuntimeVersion);
+		hash.AddByte (useSharedTypemapUniverse ? (byte) 1 : (byte) 0);
+		hash.AddInt32 (maxArrayRank);
+		foreach (var name in perAssemblyTypeMapNames) {
+			hash.AddString (name);
 		}
-		writer.Flush ();
-		return sha.ComputeHash (stream.ToArray ());
+		return hash.ToHash ();
 	}
 }

src/Microsoft.Android.Sdk.TrimmableTypeMap/Generator/Model/TypeMapAssemblyData.cs

@@ -40,6 +40,11 @@ sealed class TypeMapAssemblyData
 	/// </summary>
 	public List<AliasHolderData> AliasHolders { get; } = new ();
 
+	/// <summary>
+	/// Array proxy types to emit — one per JNI element name and rank.
+	/// </summary>
+	public List<ArrayProxyData> ArrayProxyTypes { get; } = new ();
+
 	/// <summary>
 	/// Maximum array rank for which the generator emits per-rank <c>__ArrayMapRank{N}</c>
 	/// sentinel TypeDefs and <c>TypeMap</c> entries. 0 disables.
@@ -91,6 +96,32 @@ sealed record TypeMapAttributeData
 	public int? AnchorRank { get; init; }
 }
 
+/// <summary>
+/// A generated array proxy type used by per-rank array TypeMap entries.
+/// </summary>
+sealed record ArrayProxyData
+{
+	public required string TypeName { get; init; }
+
+	public string Namespace { get; init; } = "_TypeMap.ArrayProxies";
+
+	public required string JniName { get; init; }
+
+	public required TypeRefData ElementType { get; init; }
+
+	public required int Rank { get; init; }
+
+	public PrimitiveArrayProxyData? Primitive { get; init; }
+}
+
+/// <summary>
+/// Additional primitive array metadata for <see cref="ArrayProxyData"/>.
+/// </summary>
+sealed record PrimitiveArrayProxyData
+{
+	public required TypeRefData ConcreteArrayType { get; init; }
+}
+
 /// <summary>
 /// A proxy type to generate in the TypeMap assembly (subclass of JavaPeerProxy).
 /// </summary>
@@ -390,7 +421,7 @@ sealed record ActivationCtorData
 
 /// <summary>
 /// One [assembly: TypeMapAssociation(typeof(Source), typeof(AliasProxy))] entry.
-/// Links a managed type to the alias holder that owns the alias group.
+/// Links a managed type to an alias holder, generated proxy, or generated array proxy.
 /// </summary>
 sealed record TypeMapAssociationData
 {
@@ -403,6 +434,12 @@ sealed record TypeMapAssociationData
 	/// Assembly-qualified proxy type reference (the alias holder).
 	/// </summary>
 	public required string AliasProxyTypeReference { get; init; }
+
+	/// <summary>
+	/// 1-based array rank when this association should use a <c>__ArrayMapRank{value}</c>
+	/// sentinel as its <c>TGroup</c> instead of the default model anchor.
+	/// </summary>
+	public int? AnchorRank { get; init; }
 }
 
 /// <summary>