[TrimmableTypeMap] Add CoreCLRTrimmable Mono.Android.NET-Tests lane

build-tools/automation/yaml-templates/stage-package-tests.yaml

@@ -203,6 +203,16 @@ stages:
         artifactSource: bin/Test$(XA.Build.Configuration)/$(DotNetTargetFramework)-android/Mono.Android.NET_Tests-Signed.aab
         artifactFolder: $(DotNetTargetFramework)-CoreCLR
 
+    - template: /build-tools/automation/yaml-templates/apk-instrumentation.yaml
+      parameters:
+        configuration: $(XA.Build.Configuration)
+        testName: Mono.Android.NET_Tests-CoreCLRTrimmable
+        project: tests/Mono.Android-Tests/Mono.Android-Tests/Mono.Android.NET-Tests.csproj
+        testResultsFiles: TestResult-Mono.Android.NET_Tests-$(XA.Build.Configuration)CoreCLRTrimmable.xml
+        extraBuildArgs: -p:_AndroidTypeMapImplementation=trimmable -p:UseMonoRuntime=false
+        artifactSource: bin/Test$(XA.Build.Configuration)/$(DotNetTargetFramework)-android/Mono.Android.NET_Tests-Signed.aab
+        artifactFolder: $(DotNetTargetFramework)-CoreCLRTrimmable
+
     - template: /build-tools/automation/yaml-templates/apk-instrumentation.yaml
       parameters:
         configuration: $(XA.Build.Configuration)

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

@@ -132,9 +132,7 @@ static void EmitPeers (TypeMapAssemblyData model, string jniName,
 
 			// Emit TypeMapAssociation for all proxy-backed types so managed → proxy
 			// lookup works even when the final JNI name differs from the type's attributes.
-			// Generic definitions are included — their proxy types derive from the
-			// non-generic `JavaPeerProxy` base so the CLR can load them without
-			// resolving an open generic argument.
+			// Generic definitions are supported via the non-generic `JavaPeerProxy` base.
 			var assocProxy = (i > 0 && primaryProxy != null) ? primaryProxy : proxy;
 			if (assocProxy != null) {
 				model.Associations.Add (new TypeMapAssociationData {

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

@@ -11,6 +11,11 @@ public class TrimmableTypeMapGenerator
 {
 	readonly ITrimmableTypeMapLogger logger;
 
+	static readonly HashSet<string> RequiredFrameworkDeferredRegistrationTypes = new (StringComparer.Ordinal) {
+		"android/app/Application",
+		"android/app/Instrumentation",
+	};
+
 	public TrimmableTypeMapGenerator (ITrimmableTypeMapLogger logger)
 	{
 		this.logger = logger ?? throw new ArgumentNullException (nameof (logger));
@@ -40,6 +45,7 @@ public TrimmableTypeMapResult Execute (
 
 		RootManifestReferencedTypes (allPeers, PrepareManifestForRooting (manifestTemplate, manifestConfig));
 		PropagateDeferredRegistrationToBaseClasses (allPeers);
+		PropagateCannotRegisterToDescendants (allPeers);
 
 		var generatedAssemblies = GenerateTypeMapAssemblies (allPeers, systemRuntimeVersion);
 		var jcwPeers = allPeers.Where (p =>
@@ -48,14 +54,7 @@ public TrimmableTypeMapResult Execute (
 		logger.LogGeneratingJcwFilesInfo (jcwPeers.Count, allPeers.Count);
 		var generatedJavaSources = GenerateJcwJavaSources (jcwPeers);
 
-		// Collect Application/Instrumentation types that need deferred registerNatives
-		var appRegTypes = allPeers
-			// Include all deferred-registration peers here: framework MCWs still need
-			// ApplicationRegistration.java even without generated ACWs, and abstract
-			// base types can own the native methods that derived types invoke.
-			.Where (p => p.CannotRegisterInStaticConstructor)
-			.Select (p => JniSignatureHelper.JniNameToJavaName (p.JavaName))
-			.ToList ();
+		var appRegTypes = CollectApplicationRegistrationTypes (allPeers);
 		if (appRegTypes.Count > 0) {
 			logger.LogDeferredRegistrationTypesInfo (appRegTypes.Count);
 		}
@@ -67,6 +66,33 @@ public TrimmableTypeMapResult Execute (
 		return new TrimmableTypeMapResult (generatedAssemblies, generatedJavaSources, allPeers, manifest, appRegTypes);
 	}
 
+	internal static List<string> CollectApplicationRegistrationTypes (List<JavaPeerInfo> allPeers)
+	{
+		var appRegTypes = new List<string> ();
+		var seen = new HashSet<string> (StringComparer.Ordinal);
+
+		foreach (var peer in allPeers) {
+			if (!peer.CannotRegisterInStaticConstructor) {
+				continue;
+			}
+
+			// ApplicationRegistration.java is compiled against the app's target Android API
+			// surface. Legacy framework descendants such as android.test.* may not exist there,
+			// so keep only the two framework roots plus app/runtime types that participate in
+			// the deferred-registration flow.
+			if (peer.DoNotGenerateAcw && !RequiredFrameworkDeferredRegistrationTypes.Contains (peer.JavaName)) {
+				continue;
+			}
+
+			var javaName = JniSignatureHelper.JniNameToJavaName (peer.JavaName);
+			if (seen.Add (javaName)) {
+				appRegTypes.Add (javaName);
+			}
+		}
+
+		return appRegTypes;
+	}
+
 	GeneratedManifest GenerateManifest (List<JavaPeerInfo> allPeers, AssemblyManifestInfo assemblyManifestInfo,
 		ManifestConfig config, XDocument? manifestTemplate)
 	{
@@ -217,8 +243,7 @@ internal void RootManifestReferencedTypes (List<JavaPeerInfo> allPeers, XDocumen
 	/// TestInstrumentation_1 must also defer — otherwise the base class <c>&lt;clinit&gt;</c> will call
 	/// <c>registerNatives</c> before the managed runtime is ready.
 	/// </summary>
-	internal static void PropagateDeferredRegistrationToBaseClasses (List<JavaPeerInfo> allPeers)
-	{
+	internal static void PropagateDeferredRegistrationToBaseClasses (List<JavaPeerInfo> allPeers)	{
 		// In practice only 1–2 types need propagation (one Application, maybe one
 		// Instrumentation), each with a short base-class chain.  A linear scan per
 		// ancestor is simpler and cheaper than building a Dictionary<JavaName, List<Peer>>
@@ -247,6 +272,43 @@ static void PropagateToAncestors (string? baseJniName, List<JavaPeerInfo> allPee
 		}
 	}
 
+	/// <summary>
+	/// Propagates <see cref="JavaPeerInfo.CannotRegisterInStaticConstructor"/> DOWN
+	/// from Application/Instrumentation types to all their descendants. Any subclass of
+	/// an Instrumentation/Application type can be loaded by Android before the native
+	/// library is ready, so it must also use the lazy __md_registerNatives pattern.
+	/// </summary>
+	internal static void PropagateCannotRegisterToDescendants (List<JavaPeerInfo> allPeers)
+	{
+		// Build a set of JavaNames that have CannotRegisterInStaticConstructor
+		var cannotRegister = new HashSet<string> (StringComparer.Ordinal);
+		foreach (var peer in allPeers) {
+			if (peer.CannotRegisterInStaticConstructor) {
+				cannotRegister.Add (peer.JavaName);
+			}
+		}
+
+		// Also include the framework base types
+		cannotRegister.Add ("android/app/Application");
+		cannotRegister.Add ("android/app/Instrumentation");
+
+		// Propagate to descendants: if your base is in the set, you're in the set too
+		bool changed = true;
+		while (changed) {
+			changed = false;
+			foreach (var peer in allPeers) {
+				if (peer.CannotRegisterInStaticConstructor || peer.BaseJavaName is null) {
+					continue;
+				}
+				if (cannotRegister.Contains (peer.BaseJavaName)) {
+					peer.CannotRegisterInStaticConstructor = true;
+					cannotRegister.Add (peer.JavaName);
+					changed = true;
+				}
+			}
+		}
+	}
+
 	static void AddPeerByDotName (Dictionary<string, List<JavaPeerInfo>> peersByDotName, string dotName, JavaPeerInfo peer)
 	{
 		if (!peersByDotName.TryGetValue (dotName, out var list)) {

src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets

@@ -92,15 +92,35 @@
     </ItemGroup>
   </Target>
 
+  <!--
+    Populates @(_AdditionalNativeConfigResolvedAssemblies) with the trimmable TypeMap DLLs
+    so that GenerateNativeApplicationConfigSources (in _GeneratePackageManagerJava) accounts
+    for them.  This must NOT live inside _GenerateJavaStubs because that target can be
+    skipped on incremental builds, which would leave the item group empty.
+  -->
+  <Target Name="_PrepareTrimmableNativeConfigAssemblies"
+      BeforeTargets="_GeneratePackageManagerJava">
+    <ItemGroup>
+      <_AdditionalNativeConfigResolvedAssemblies Remove="@(_AdditionalNativeConfigResolvedAssemblies)" />
+      <_AdditionalNativeConfigResolvedAssemblies Include="$(_TypeMapOutputDirectory)*.dll" />
+    </ItemGroup>
+  </Target>
+
   <!--
     _GenerateJavaStubs: overrides the legacy target from BuildOrder.targets.
     In the trimmable path, TypeMap generation already happened in _GenerateTrimmableTypeMap,
     so this target only handles JCW file copying, manifest, assembly store setup, and native config.
     We keep the name _GenerateJavaStubs because BuildOrder.targets references it.
+
+    Inputs uses the TypeMap DLL as a focused sentinel — _GenerateTrimmableTypeMap regenerates
+    the DLL whenever any of its own inputs (assemblies, manifest, etc.) change, so the DLL
+    timestamp is a reliable proxy for "something changed that requires re-copying".
+    We keep _GetGenerateJavaStubsInputs in DependsOnTargets so that downstream targets
+    (_GetGeneratePackageManagerJavaInputs) can still read @(_GenerateJavaStubsInputs).
   -->
   <Target Name="_GenerateJavaStubs"
       DependsOnTargets="_SetLatestTargetFrameworkVersion;_CleanIntermediateIfNeeded;_PrepareAssemblies;_GetGenerateJavaStubsInputs;_DefineBuildTargetAbis;_PrepareNativeAssemblySources"
-      Inputs="@(_GenerateJavaStubsInputs)"
+      Inputs="$(_TypeMapOutputDirectory)$(_TypeMapAssemblyName).dll"
       Outputs="$(_AndroidStampDirectory)_GenerateJavaStubs.stamp">
 
     <ItemGroup>
@@ -112,28 +132,6 @@
       <FileWrites Include="@(_TypeMapJavaFiles->'$(IntermediateOutputPath)android/src/%(RecursiveDir)%(Filename)%(Extension)')" />
     </ItemGroup>
 
-    <!-- Set properties for ABI/RID used by CoreCLR _AddTrimmableTypeMapAssembliesToStore fallback -->
-    <PropertyGroup>
-      <_TypeMapFirstAbi Condition=" '$(AndroidSupportedAbis)' != '' ">$([System.String]::Copy('$(AndroidSupportedAbis)').Split(';')[0])</_TypeMapFirstAbi>
-      <_TypeMapFirstAbi Condition=" '$(_TypeMapFirstAbi)' == '' ">arm64-v8a</_TypeMapFirstAbi>
-      <_TypeMapFirstRid Condition=" '$(_TypeMapFirstAbi)' == 'arm64-v8a' ">android-arm64</_TypeMapFirstRid>
-      <_TypeMapFirstRid Condition=" '$(_TypeMapFirstAbi)' == 'armeabi-v7a' ">android-arm</_TypeMapFirstRid>
-      <_TypeMapFirstRid Condition=" '$(_TypeMapFirstAbi)' == 'x86_64' ">android-x64</_TypeMapFirstRid>
-      <_TypeMapFirstRid Condition=" '$(_TypeMapFirstAbi)' == 'x86' ">android-x86</_TypeMapFirstRid>
-    </PropertyGroup>
-
-    <!-- Add TypeMap DLLs to _ResolvedAssemblies so they are counted by
-         GenerateNativeApplicationConfigSources (in _GeneratePackageManagerJava)
-         and included in the assembly store hash table. -->
-    <ItemGroup>
-      <_ResolvedAssemblies Include="$(_TypeMapOutputDirectory)*.dll">
-        <Abi>$(_TypeMapFirstAbi)</Abi>
-        <RuntimeIdentifier>$(_TypeMapFirstRid)</RuntimeIdentifier>
-        <DestinationSubPath>$(_TypeMapFirstAbi)/%(Filename)%(Extension)</DestinationSubPath>
-        <DestinationSubDirectory>$(_TypeMapFirstAbi)/</DestinationSubDirectory>
-      </_ResolvedAssemblies>
-    </ItemGroup>
-
     <!-- Copy generated manifest to expected location -->
     <Copy SourceFiles="$(_TypeMapBaseOutputDir)AndroidManifest.xml"
         DestinationFiles="$(IntermediateOutputPath)AndroidManifest.xml"
@@ -175,5 +173,4 @@
       <FileWrites Include="@(_TypeMapAssemblySource)" />
     </ItemGroup>
   </Target>
-
 </Project>

src/Xamarin.Android.Build.Tasks/Tasks/GenerateNativeApplicationConfigSources.cs

@@ -27,6 +27,8 @@ public class GenerateNativeApplicationConfigSources : AndroidTask
 		[Required]
 		public ITaskItem[] ResolvedAssemblies { get; set; } = [];
 
+		public ITaskItem[]? AdditionalResolvedAssemblies { get; set; }
+
 		public ITaskItem[]? NativeLibraries { get; set; }
 		public ITaskItem[]? NativeLibrariesNoJniPreload { get; set; }
 		public ITaskItem[]? NativeLibrariesAlwaysJniPreload { get; set; }
@@ -202,6 +204,13 @@ public override bool RunTask ()
 				GetRequiredTokens (assembly.ItemSpec, out android_runtime_jnienv_class_token, out jnienv_initialize_method_token, out jnienv_registerjninatives_method_token);
 			}
 
+			if (AdditionalResolvedAssemblies != null) {
+				foreach (ITaskItem assembly in AdditionalResolvedAssemblies) {
+					updateNameWidth (assembly);
+					updateAssemblyCount (assembly);
+				}
+			}
+
 			if (!UseAssemblyStore) {
 				int abiNameLength = 0;
 				foreach (string abi in SupportedAbis) {

src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/Tasks/GenerateTrimmableTypeMapTests.cs

@@ -169,6 +169,8 @@ public void Execute_ManifestPlaceholdersAreResolvedForRooting ()
 			var registrationText = File.ReadAllText (applicationRegistration);
 			StringAssert.Contains ("mono.android.Runtime.registerNatives (android.app.Application.class);", registrationText);
 			StringAssert.Contains ("mono.android.Runtime.registerNatives (android.app.Instrumentation.class);", registrationText);
+			StringAssert.DoesNotContain ("android.test.InstrumentationTestRunner.class", registrationText);
+			StringAssert.DoesNotContain ("android.test.mock.MockApplication.class", registrationText);
 			Assert.IsFalse (warnings.Any (w => w.Code == "XA4250"), "Resolved placeholder-based manifest references should not log XA4250.");
 		}
 

src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs

@@ -1,4 +1,6 @@
 using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
 using NUnit.Framework;
 using Xamarin.Android.Tasks;
 using Xamarin.ProjectTools;
@@ -11,45 +13,101 @@ public class TrimmableTypeMapBuildTests : BaseTest {
 		[Test]
 		public void Build_WithTrimmableTypeMap_Succeeds ()
 		{
-			var proj = new XamarinAndroidApplicationProject ();
+			var proj = new XamarinAndroidApplicationProject {
+				IsRelease = true,
+			};
 			proj.SetRuntime (AndroidRuntime.CoreCLR);
 			proj.SetProperty ("_AndroidTypeMapImplementation", "trimmable");
 
-			// Full Build will fail downstream (manifest generation not yet implemented for trimmable path),
-			// but _GenerateJavaStubs runs and completes before the failure point.
 			using var builder = CreateApkBuilder ();
-			builder.ThrowOnBuildFailure = false;
-			builder.Build (proj);
+			Assert.IsTrue (builder.Build (proj), "Build should have succeeded.");
 
-			// Verify _GenerateJavaStubs ran by checking typemap outputs exist
 			var intermediateDir = builder.Output.GetIntermediaryPath ("typemap");
 			DirectoryAssert.Exists (intermediateDir);
 		}
 
 		[Test]
 		public void Build_WithTrimmableTypeMap_IncrementalBuild ()
 		{
-			var proj = new XamarinAndroidApplicationProject ();
+			var proj = new XamarinAndroidApplicationProject {
+				IsRelease = true,
+			};
 			proj.SetRuntime (AndroidRuntime.CoreCLR);
 			proj.SetProperty ("_AndroidTypeMapImplementation", "trimmable");
 
-			// Full Build will fail downstream (manifest generation not yet implemented for trimmable path),
-			// but _GenerateJavaStubs runs and completes before the failure point.
 			using var builder = CreateApkBuilder ();
-			builder.ThrowOnBuildFailure = false;
-			builder.Build (proj);
+			Assert.IsTrue (builder.Build (proj), "First build should have succeeded.");
 
-			// Verify _GenerateJavaStubs ran on the first build
 			var intermediateDir = builder.Output.GetIntermediaryPath ("typemap");
 			DirectoryAssert.Exists (intermediateDir);
 
-			// Second build with no changes — _GenerateJavaStubs should be skipped
-			builder.Build (proj);
+			Assert.IsTrue (builder.Build (proj), "Second build should have succeeded.");
 			Assert.IsTrue (
 				builder.Output.IsTargetSkipped ("_GenerateJavaStubs"),
 				"_GenerateJavaStubs should be skipped on incremental build.");
 		}
 
+		[Test]
+		public void Build_WithTrimmableTypeMap_DoesNotHitCopyIfChangedMismatch ()
+		{
+			var proj = new XamarinAndroidApplicationProject {
+				IsRelease = true,
+			};
+			proj.SetRuntime (AndroidRuntime.CoreCLR);
+			proj.SetProperty ("_AndroidTypeMapImplementation", "trimmable");
+
+			using var builder = CreateApkBuilder ();
+			Assert.IsTrue (builder.Build (proj), "Build should have succeeded.");
+
+			Assert.IsFalse (
+				StringAssertEx.ContainsText (builder.LastBuildOutput, "source and destination count mismatch"),
+				$"{builder.BuildLogFile} should not fail with XACIC7004.");
+			Assert.IsFalse (
+				StringAssertEx.ContainsText (builder.LastBuildOutput, "Internal error: architecture"),
+				$"{builder.BuildLogFile} should keep trimmable typemap assemblies aligned across ABIs.");
+		}
+
+		[Test]
+		public void Build_WithTrimmableTypeMap_AssemblyStoreMappingsStayInRange ()
+		{
+			var proj = new XamarinAndroidApplicationProject {
+				IsRelease = true,
+			};
+			proj.SetRuntime (AndroidRuntime.CoreCLR);
+			proj.SetProperty ("_AndroidTypeMapImplementation", "trimmable");
+
+			using var builder = CreateApkBuilder ();
+			Assert.IsTrue (builder.Build (proj), "Build should have succeeded.");
+
+			var environmentFiles = Directory.GetFiles (builder.Output.GetIntermediaryPath ("android"), "environment.*.ll");
+			Assert.IsNotEmpty (environmentFiles, "Expected generated environment.<abi>.ll files.");
+
+			foreach (var environmentFile in environmentFiles) {
+				var abi = Path.GetFileNameWithoutExtension (environmentFile).Substring ("environment.".Length);
+				var manifestFile = builder.Output.GetIntermediaryPath (Path.Combine ("app_shared_libraries", abi, "assembly-store.so.manifest"));
+
+				if (!File.Exists (manifestFile)) {
+					continue;
+				}
+
+				var environmentText = File.ReadAllText (environmentFile);
+				var runtimeDataMatch = Regex.Match (environmentText, @"assembly_store_bundled_assemblies.*\[(\d+)\s+x");
+				Assert.IsTrue (runtimeDataMatch.Success, $"{environmentFile} should declare assembly_store_bundled_assemblies.");
+
+				var runtimeDataCount = int.Parse (runtimeDataMatch.Groups [1].Value);
+				var maxMappingIndex = File.ReadLines (manifestFile)
+					.Select (line => Regex.Match (line, @"\bmi:(\d+)\b"))
+					.Where (match => match.Success)
+					.Select (match => int.Parse (match.Groups [1].Value))
+					.Max ();
+
+				Assert.That (
+					runtimeDataCount,
+					Is.GreaterThan (maxMappingIndex),
+					$"{Path.GetFileName (environmentFile)} should allocate enough runtime slots for {Path.GetFileName (manifestFile)}.");
+			}
+		}
+
 		[Test]
 		public void TrimmableTypeMap_PreserveList_IsPackagedInSdk ()
 		{

src/Xamarin.Android.Build.Tasks/Xamarin.Android.Common.targets

@@ -1727,6 +1727,7 @@ because xbuild doesn't support framework reference assemblies.
 
   <GenerateNativeApplicationConfigSources
       ResolvedAssemblies="@(_ResolvedAssemblies)"
+      AdditionalResolvedAssemblies="@(_AdditionalNativeConfigResolvedAssemblies)"
       SatelliteAssemblies="@(_AndroidResolvedSatellitePaths)"
       NativeLibraries="@(_AllNativeLibraries)"
       NativeLibrariesNoJniPreload="@(_AndroidNativeLibraryNeverJniPreload);@(AndroidNativeLibraryNoJniPreload)"