[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,35 @@ 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 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/ModelBuilder.cs

@@ -505,14 +505,10 @@ static string AssemblyQualify (string typeName, string assemblyName)
 	/// <summary>
 	/// Emits per-rank array TypeMap entries for one peer, anchored to the per-assembly
 	/// <c>__ArrayMapRank{N}</c> sentinels. Keys are bare element JNI names (rank is encoded
-	/// by the sentinel anchor, not by JNI array prefixes). Skips open generics, primitive JNI
-	/// keyword keys (handled by the legacy primitive-array path), and alias groups.
+	/// by the sentinel anchor, not by JNI array prefixes). Skips open generics and alias groups.
 	/// </summary>
 	static void EmitArrayEntries (TypeMapAssemblyData model, string jniName, List<JavaPeerInfo> peersForName, int maxArrayRank)
 	{
-		if (jniName.Length == 1 && IsJniPrimitiveKeyword (jniName [0])) {
-			return;
-		}
 		if (peersForName.Count != 1) {
 			return;
 		}
@@ -526,6 +522,9 @@ static void EmitArrayEntries (TypeMapAssemblyData model, string jniName, List<Ja
 		}
 
 		for (int rank = 1; rank <= maxArrayRank; rank++) {
+			// TODO: we should also map elements to `JavaObjectArray<JavaObjectArray<...<T>...>>`
+			// so we migth want to generate a `ProxyTypeReference` which would return `JavaObjectArray<JavaObjectArray<...<T>...>>` AND `T[]`
+
 			string arrayTypeRef = AssemblyQualify (peer.ManagedTypeName + Brackets (rank), peer.AssemblyName);
 			model.Entries.Add (new TypeMapAttributeData {
 				JniName = jniName,

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

@@ -5,6 +5,7 @@
 using System.Reflection.Metadata;
 using System.Reflection.Metadata.Ecma335;
 using System.Reflection.PortableExecutable;
+using System.Security.Cryptography;
 
 namespace Microsoft.Android.Sdk.TrimmableTypeMap;
 
@@ -106,12 +107,31 @@ 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,
+			deterministicIdProvider: CreateDeterministicContentId);
 		var peBlob = new BlobBuilder ();
 		peBuilder.Serialize (peBlob);
 		peBlob.WriteContentTo (stream);
 	}
 
+	static BlobContentId CreateDeterministicContentId (IEnumerable<Blob> blobs)
+	{
+		using var sha = SHA256.Create ();
+		foreach (var blob in blobs) {
+			var bytes = blob.GetBytes ();
+			if (bytes.Array is null) {
+				continue;
+			}
+			sha.TransformBlock (bytes.Array, bytes.Offset, bytes.Count, null, 0);
+		}
+		sha.TransformFinalBlock ([], 0, 0);
+		var hash = sha.Hash;
+		if (hash is null) {
+			throw new InvalidOperationException ("SHA256 did not produce a hash.");
+		}
+		return BlobContentId.FromHash (hash);
+	}
+
 	/// <summary>
 	/// Adds (or retrieves from cache) an assembly reference.
 	/// </summary>

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

@@ -93,7 +93,7 @@ public void Generate (IReadOnlyList<string> perAssemblyTypeMapNames, bool useSha
 		moduleName ??= assemblyName + ".dll";
 
 		var pe = new PEAssemblyBuilder (_systemRuntimeVersion);
-		pe.EmitPreamble (assemblyName, moduleName);
+		pe.EmitPreamble (assemblyName, moduleName, MetadataHelper.ComputeRootContentFingerprint (_systemRuntimeVersion, perAssemblyTypeMapNames, useSharedTypemapUniverse, maxArrayRank));
 
 		EntityHandle anchorTypeHandle;
 		if (useSharedTypemapUniverse) {

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

@@ -210,13 +210,16 @@ void ScanAssembly (AssemblyIndex index, Dictionary<(string ManagedName, string A
 
 			var fullName = MetadataTypeNameResolver.GetFullName (typeDef, index.Reader);
 
-			// Temporarily allow [JniAddNativeMethodRegistrationAttribute] while we investigate
-			// which scenarios fail later in the trimmable typemap pipeline.
-			// if (index.MayUseJniAddNativeMethodRegistrationAttribute &&
-			//     !IsBuiltInJniAddNativeMethodRegistrationType (fullName, index) &&
-			//     HasJniAddNativeMethodRegistrationAttribute (typeDef, index)) {
-			// 	logger?.LogJniAddNativeMethodRegistrationAttributeError (fullName);
-			// }
+			// Framework/runtime assemblies contain internal [JniAddNativeMethodRegistration]
+			// users such as Java.Interop.JavaProxyObject and Java.Interop.ManagedPeer.
+			// The diagnostic is for user assemblies because the trimmable runtime either
+			// has generated replacements for framework registration or intentionally
+			// disables unsupported runtime paths.
+			if (!frameworkAssemblyNames.Contains (index.AssemblyName) &&
+			    index.MayUseJniAddNativeMethodRegistrationAttribute &&
+			    HasJniAddNativeMethodRegistrationAttribute (typeDef, index)) {
+				logger?.LogJniAddNativeMethodRegistrationAttributeError (fullName);
+			}
 
 			// Determine the JNI name and whether this is a known Java peer.
 			// Priority:
@@ -413,12 +416,6 @@ static bool HasJniAddNativeMethodRegistrationAttribute (TypeDefinition typeDef,
 		return false;
 	}
 
-	static bool IsBuiltInJniAddNativeMethodRegistrationType (string fullName, AssemblyIndex index)
-	{
-		return string.Equals (index.AssemblyName, "Java.Interop", StringComparison.Ordinal) &&
-			string.Equals (fullName, "Java.Interop.JavaProxyObject", StringComparison.Ordinal);
-	}
-
 	/// <summary>
 	/// For each virtual override method on <paramref name="typeDef"/> that wasn't already
 	/// collected (no direct [Register]), walks up the base type hierarchy to find a