[TrimmableTypeMap] Add reflection-free TrimmableTypeMapType/ValueManager

Adds TrimmableTypeMapValueManager + reflection-free TrimmableTypeMapTypeManager and
wires opt-in selection (RuntimeFeature.TrimmableTypeMap) in JNIEnvInit. Builds on the
CoreCLR JavaMarshal split. Default stays managed; depends on array-codegen (#11753)
and other slices to be fully functional at runtime.

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

Author: simonrozsival

src/Mono.Android/Android.App/IntentFilterAttribute.Partial.cs

@@ -1,4 +1,4 @@
-#nullable enable
+#nullable disable
 
 using System;
 

src/Mono.Android/Android.Graphics/Color.cs

@@ -440,7 +440,10 @@ public override Type MarshalType {
 			get { return typeof (int); }
 		}
 
-		public override Color CreateGenericValue (ref JniObjectReference reference, JniObjectReferenceOptions options, Type targetType)
+		public override Color CreateGenericValue (
+				ref JniObjectReference reference,
+				JniObjectReferenceOptions options,
+				Type targetType)
 		{
 			throw new NotImplementedException ();
 		}

src/Mono.Android/Android.Runtime/AndroidRuntime.cs

@@ -58,6 +58,10 @@ public override string GetCurrentManagedThreadStackTrace (int skipFrames, bool f
 			if (!reference.IsValid)
 				return null;
 			var peeked      = JniEnvironment.Runtime.ValueManager.PeekPeer (reference);
+			if (peeked is JavaProxyThrowable proxyThrowable) {
+				JniObjectReference.Dispose (ref reference, options);
+				return proxyThrowable.InnerException;
+			}
 			var peekedExc   = peeked as Exception;
 			if (peekedExc == null) {
 				var throwable = Java.Lang.Object.GetObject<Java.Lang.Throwable> (reference.Handle, JniHandleOwnership.DoNotTransfer);
@@ -310,10 +314,13 @@ public override void DeleteWeakGlobalReference (ref JniObjectReference value)
 		}
 	}
 
-	[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Temporary suppression for Java.Interop reflection manager base.")]
+	[RequiresDynamicCode ("This type manager is reflection-backed and is not compatible with Native AOT.")]
+	[RequiresUnreferencedCode ("This type manager is reflection-backed and is not trimming-compatible.")]
 	class AndroidTypeManager : JniRuntime.ReflectionJniTypeManager {
 		bool jniAddNativeMethodRegistrationAttributePresent;
 
+		const DynamicallyAccessedMemberTypes Constructors = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors;
+
 		public AndroidTypeManager (bool jniAddNativeMethodRegistrationAttributePresent)
 		{
 			this.jniAddNativeMethodRegistrationAttributePresent = jniAddNativeMethodRegistrationAttributePresent;
@@ -329,7 +336,6 @@ protected override IEnumerable<Type> GetTypesForSimpleReference (string jniSimpl
 				yield return t;
 		}
 
-		[UnconditionalSuppressMessage ("Trimming", "IL2073", Justification = "Temporary suppression until legacy typemap entries carry DAM annotations.")]
 		protected override Type? GetTypeForSimpleReference (string jniSimpleReference)
 		{
 			var type = base.GetTypeForSimpleReference (jniSimpleReference);
@@ -346,29 +352,30 @@ protected override IEnumerable<Type> GetTypesForSimpleReference (string jniSimpl
 			if (j != null) {
 				return GetReplacementTypeCore (j) ?? j;
 			}
-			return base.GetSimpleReference (type);
+			// Intentionally don't call base.GetSimpleReference(type): Android's
+			// non-trimmable runtime uses the generated/registered typemap, not
+			// Java.Interop's JniTypeSignatureAttribute fallback.
+			return null;
 		}
 
 		protected override IEnumerable<string> GetSimpleReferences (Type type)
 		{
 			string? j = JNIEnv.TypemapManagedToJava (type);
-			j   = GetReplacementTypeCore (j) ?? j;
+			j	   = GetReplacementTypeCore (j) ?? j;
 
 			if (j != null) {
-				yield return j;
-				yield break;
-			}
-			foreach (var r in base.GetSimpleReferences (type)) {
-				yield return r;
+				return [j];
 			}
+			// Keep this in sync with GetSimpleReference(): no base fallback.
+			return [];
 		}
 
 		protected override IReadOnlyList<string>? GetStaticMethodFallbackTypesCore (string jniSimpleReference)
 		{
 			return JniRemappingLookup.GetStaticMethodFallbackTypes (jniSimpleReference, useReplacementTypes: true);
 		}
 
-		protected override string? GetReplacementTypeCore (string jniSimpleReference)
+		protected override string? GetReplacementTypeCore (string? jniSimpleReference)
 		{
 			return JniRemappingLookup.GetReplacementType (jniSimpleReference);
 		}
@@ -393,8 +400,6 @@ protected override IEnumerable<string> GetSimpleReferences (Type type)
 		static MethodInfo? dynamic_callback_gen;
 
 		// See ExportAttribute.cs
-		[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Mono.Android.Export.dll is preserved when [Export] is used via [DynamicDependency].")]
-		[UnconditionalSuppressMessage ("Trimming", "IL2075", Justification = "Mono.Android.Export.dll is preserved when [Export] is used via [DynamicDependency].")]
 		static Delegate CreateDynamicCallback (MethodInfo method)
 		{
 			if (dynamic_callback_gen == null) {
@@ -489,20 +494,10 @@ static bool CallRegisterMethodByIndex (JniNativeMethodRegistrationArguments argu
 		}
 
 		[Obsolete ("Use RegisterNativeMembers(JniType, Type, ReadOnlySpan<char>) instead.")]
-		public override void RegisterNativeMembers (
-				JniType nativeClass,
-				Type type,
-				string? methods) =>
+		public override void RegisterNativeMembers (JniType nativeClass, Type type, string? methods) =>
 			RegisterNativeMembers (nativeClass, type, methods.AsSpan ());
 
-		[UnconditionalSuppressMessage ("Trimming", "IL2057", Justification = "Type.GetType() can never statically know the string value parsed from parameter 'methods'.")]
-		[UnconditionalSuppressMessage ("Trimming", "IL2067", Justification = "Delegate.CreateDelegate() can never statically know the string value parsed from parameter 'methods'.")]
-		[UnconditionalSuppressMessage ("Trimming", "IL2070", Justification = "GetMethods can never statically know the string value parsed from parameter 'methods'.")]
-		[UnconditionalSuppressMessage ("Trimming", "IL2072", Justification = "Delegate.CreateDelegate() can never statically know the string value parsed from parameter 'methods'.")]
-		public override void RegisterNativeMembers (
-				JniType nativeClass,
-				Type type,
-				ReadOnlySpan<char> methods)
+		public override void RegisterNativeMembers (JniType nativeClass, Type type, ReadOnlySpan<char> methods)
 		{
 			try {
 				if (methods.IsEmpty) {
@@ -586,15 +581,6 @@ public override void RegisterNativeMembers (
 			} catch (Exception e) {
 				JniEnvironment.Runtime.RaisePendingException (e);
 			}
-
-			bool ShouldRegisterDynamically (string callbackTypeName, string callbackString, string typeName, string callbackName)
-			{
-				if (String.Compare (typeName, callbackTypeName, StringComparison.Ordinal) != 0) {
-					return false;
-				}
-
-				return String.Compare (callbackName, callbackString, StringComparison.Ordinal) == 0;
-			}
 		}
 
 		static int CountMethods (ReadOnlySpan<char> methodsSpan)
@@ -631,7 +617,8 @@ static void SplitMethodLine (
 		}
 	}
 
-	[UnconditionalSuppressMessage ("Trimming", "IL2026", Justification = "Temporary suppression for Java.Interop reflection manager base.")]
+	[RequiresDynamicCode ("This value manager is reflection-backed and is not compatible with Native AOT.")]
+	[RequiresUnreferencedCode ("This value manager is reflection-backed and is not trimming-compatible.")]
 	class AndroidValueManager : JniRuntime.ReflectionJniValueManager {
 
 		Dictionary<IntPtr, IdentityHashTargets>         instances       = new Dictionary<IntPtr, IdentityHashTargets> ();
@@ -841,11 +828,7 @@ internal void RemovePeer (IJavaPeerable value, IntPtr hash)
 			return null;
 		}
 
-		public override void ActivatePeer (
-			JniObjectReference reference,
-			Type type,
-			ConstructorInfo cinfo,
-			object?[]? argumentValues)
+		public override void ActivatePeer (JniObjectReference reference, Type type, ConstructorInfo cinfo, object?[]? argumentValues)
 		{
 			Java.Interop.TypeManager.Activate (reference.Handle, cinfo, argumentValues);
 		}

src/Mono.Android/Android.Runtime/IJavaObjectValueMarshaler.cs

@@ -46,6 +46,8 @@ public override Expression CreateReturnValueFromManagedExpression (JniValueMarsh
 		[RequiresUnreferencedCode (ExpressionRequiresUnreferencedCode)]
 		public override Expression CreateParameterToManagedExpression (JniValueMarshalerContext context, ParameterExpression sourceValue, ParameterAttributes synchronize, Type? targetType)
 		{
+			ArgumentNullException.ThrowIfNull (targetType);
+
 			var r   = Expression.Variable (targetType, sourceValue.Name + "_val");
 			context.LocalVariables.Add (r);
 			context.CreationStatements.Add (

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

@@ -27,20 +27,22 @@ public static partial class JNIEnv {
 		static Array ArrayCreateInstance (Type elementType, int length)
 		{
 			if (RuntimeFeature.TrimmableTypeMap) {
-				if (System.Runtime.CompilerServices.RuntimeFeature.IsDynamicCodeSupported) {
+				if (RuntimeFeature.IsCoreClrRuntime) {
 					// CoreCLR runtime type loader can construct any T[] dynamically.
 					// IsDynamicCodeSupported is a [FeatureGuard] so this branch is
 					// dead-coded under PublishAot.
 					return Array.CreateInstance (elementType, length);
 				}
 
-				// NativeAOT: resolve via per-rank typemap + Array.CreateInstanceFromArrayType.
-				if (TrimmableTypeMap.Instance.TryGetArrayType (elementType, out var arrayType)) {
-					return Array.CreateInstanceFromArrayType (arrayType, length);
+				if (RuntimeFeature.IsNativeAotRuntime) {
+					// NativeAOT: resolve via per-rank typemap + generated array proxy.
+					if (TrimmableTypeMap.Instance.TryGetArrayProxy (elementType, additionalRank: 1, out var arrayProxy)) {
+						return arrayProxy.CreateManagedArray (length);
+					}
 				}
 
 				throw new NotSupportedException (
-					$"No TrimmableTypeMap array entry for element type '{elementType}'. " +
+					$"No TrimmableTypeMap array proxy entry for element type '{elementType}'. " +
 					$"Array lookups use the element type within the per-rank __ArrayMapRank{GetArrayRank (elementType)} typemap group; " +
 					$"ensure the mapping is emitted for that rank (for example by increasing _AndroidTrimmableTypeMapMaxArrayRank) or report an issue.");
 			}
@@ -64,13 +66,6 @@ static int GetArrayRank (Type elementType)
 			return rank;
 		}
 
-		static Type MakeArrayType (Type type) =>
-			// FIXME: https://github.com/xamarin/xamarin-android/issues/8724
-			// IL3050 disabled in source: if someone uses NativeAOT, they will get the warning.
-			#pragma warning disable IL3050
-			type.MakeArrayType ();
-			#pragma warning restore IL3050
-
 		internal static IntPtr IdentityHash (IntPtr v)
 		{
 			return JniEnvironment.References.GetIdentityHashCode (new JniObjectReference (v));
@@ -309,10 +304,7 @@ public static IntPtr FindClass (System.Type type)
 				}
 				sig = sig.AddArrayRank (rank);
 
-				JniObjectReference local_ref = JniEnvironment.Types.FindClass (sig.Name);
-				IntPtr global_ref = local_ref.NewGlobalRef ().Handle;
-				JniObjectReference.Dispose (ref local_ref);
-				return global_ref;
+				return FindClass (sig.Name);
 			} catch (Java.Lang.Throwable e) {
 				if (!((e is Java.Lang.NoClassDefFoundError) || (e is Java.Lang.ClassNotFoundException)))
 					throw;
@@ -577,9 +569,9 @@ public static unsafe IntPtr NewString (char[]? text, int length)
 				return JniEnvironment.Strings.NewString (s, length).Handle;
 		}
 
-		static void AssertCompatibleArrayTypes (Type sourceType, IntPtr destArray)
+		static void AssertCompatibleArrayTypes (Type srcElementType, IntPtr destArray)
 		{
-			IntPtr grefSource = FindClass (sourceType);
+			IntPtr grefSource = FindArrayClassByElementType (srcElementType);
 			IntPtr lrefDest   = GetObjectClass (destArray);
 			try {
 				if (!IsAssignableFrom (grefSource, lrefDest)) {
@@ -592,9 +584,9 @@ static void AssertCompatibleArrayTypes (Type sourceType, IntPtr destArray)
 			}
 		}
 
-		static void AssertCompatibleArrayTypes (IntPtr sourceArray, Type destType)
+		static void AssertCompatibleArrayTypes (IntPtr sourceArray, Type destElementType)
 		{
-			IntPtr grefDest   = FindClass (destType);
+			IntPtr grefDest   = FindArrayClassByElementType (destElementType);
 			IntPtr lrefSource = GetObjectClass (sourceArray);
 			try {
 				if (!IsAssignableFrom (lrefSource, grefDest)) {
@@ -607,12 +599,19 @@ static void AssertCompatibleArrayTypes (IntPtr sourceArray, Type destType)
 			}
 		}
 
+		static IntPtr FindArrayClassByElementType (Type elementType)
+		{
+			int rank = JavaNativeTypeManager.GetArrayInfo (elementType, out elementType) + 1;
+			var typeSignature = JniRuntime.CurrentRuntime.TypeManager.GetTypeSignature (elementType).AddArrayRank (rank);
+			return FindClass (typeSignature.Name);
+		}
+
 		public static void CopyArray (IntPtr src, bool[] dest)
 		{
 			if (dest == null)
 				throw new ArgumentNullException ("dest");
 
-			AssertCompatibleArrayTypes (src, typeof (bool[]));
+			AssertCompatibleArrayTypes (src, destElementType: typeof (bool));
 
 			_GetBooleanArrayRegion (src, 0, dest.Length, dest);
 		}
@@ -804,7 +803,7 @@ public static void CopyArray (IntPtr src, Array dest, Type? elementType = null)
 				throw new ArgumentNullException ("dest");
 
 			if (elementType != null && elementType.IsValueType)
-				AssertCompatibleArrayTypes (src, MakeArrayType (elementType));
+				AssertCompatibleArrayTypes (src, destElementType: elementType);
 
 			if (elementType != null && elementType.IsArray) {
 				for (int i = 0; i < dest.Length; ++i) {
@@ -840,7 +839,7 @@ public static void CopyArray<T> (IntPtr src, T[] dest)
 				throw new ArgumentNullException ("dest");
 
 			if (typeof (T).IsValueType)
-				AssertCompatibleArrayTypes (src, typeof (T[]));
+				AssertCompatibleArrayTypes (src, destElementType: typeof (T));
 
 			if (typeof (T).IsArray) {
 				CopyArray (src, dest, typeof (T));
@@ -858,7 +857,7 @@ public static unsafe void CopyArray (bool[] src, IntPtr dest)
 			if (src == null)
 				throw new ArgumentNullException ("src");
 
-			AssertCompatibleArrayTypes (typeof (bool[]), dest);
+			AssertCompatibleArrayTypes (srcElementType: typeof (bool), dest);
 
 			fixed (bool* p = src)
 				JniEnvironment.Arrays.SetBooleanArrayRegion (new JniObjectReference (dest), 0, src.Length, p);
@@ -947,7 +946,7 @@ public static void CopyArray (Array source, Type elementType, IntPtr dest)
 				throw new ArgumentNullException ("elementType");
 
 			if (elementType.IsValueType)
-				AssertCompatibleArrayTypes (MakeArrayType (elementType), dest);
+				AssertCompatibleArrayTypes (srcElementType: elementType, dest);
 
 			Action<Array, IntPtr> converter = GetConverter (CopyManagedToNativeArray, elementType, dest);
 
@@ -1072,7 +1071,7 @@ public static void CopyArray<T> (T[] src, IntPtr dest)
 				return null;
 
 			if (element_type != null && element_type.IsValueType)
-				AssertCompatibleArrayTypes (array_ptr, MakeArrayType (element_type));
+				AssertCompatibleArrayTypes (array_ptr, destElementType: element_type);
 
 			int cnt = _GetArrayLength (array_ptr);
 
@@ -1119,7 +1118,7 @@ static int _GetArrayLength (IntPtr array_ptr)
 				return null;
 
 			if (typeof (T).IsValueType)
-				AssertCompatibleArrayTypes (array_ptr, typeof (T[]));
+				AssertCompatibleArrayTypes (array_ptr, destElementType: typeof (T));
 
 			int cnt = _GetArrayLength (array_ptr);
 			T[] ret = new T [cnt];