From 9686fb6b5d0b569bb99d67b15be59a4768830162 Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Thu, 14 May 2026 13:54:02 +0200
Subject: [PATCH 1/9] Compare trimmable typemap APK contents

Add a Release CoreCLR HelloWorld comparison test that builds llvm-ir and trimmable typemap APKs, prints managed and dex diagnostics, and asserts the trimmable typemap does not retain extra typemap-eligible managed or Java entries.

Pass all generated typemap assemblies to ILLink as typemap entry assemblies and mark them trimmable so conditional typemap entries are honored.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ...roid.Sdk.TypeMap.Trimmable.CoreCLR.targets |   9 +-
 .../TrimmableTypeMapBuildTests.cs             | 727 +++++++++++++++++-
 2 files changed, 734 insertions(+), 2 deletions(-)

diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
index d0ca9742e30..c27922166c1 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
@@ -12,6 +12,7 @@
     <ItemGroup>
       <ManagedAssemblyToLink Include="$(_TypeMapOutputDirectory)*.dll">
         <DestinationSubPath>%(Filename)%(Extension)</DestinationSubPath>
+        <IsTrimmable>true</IsTrimmable>
       </ManagedAssemblyToLink>
     </ItemGroup>
   </Target>
@@ -20,9 +21,15 @@
   <Target Name="_ConfigureTrimmableTypeMapForLinker"
       BeforeTargets="PrepareForILLink;_RunILLink"
       DependsOnTargets="_GenerateTrimmableTypeMap">
+    <ItemGroup>
+      <_TrimmableTypeMapEntryAssemblies Include="$(_TypeMapOutputDirectory)*.dll" />
+    </ItemGroup>
     <PropertyGroup>
-      <_ExtraTrimmerArgs>--typemap-entry-assembly $(_TypeMapAssemblyName) $(_ExtraTrimmerArgs)</_ExtraTrimmerArgs>
+      <_ExtraTrimmerArgs>@(_TrimmableTypeMapEntryAssemblies->'--typemap-entry-assembly %(Filename)', ' ') $(_ExtraTrimmerArgs)</_ExtraTrimmerArgs>
     </PropertyGroup>
+    <ItemGroup>
+      <_TrimmableTypeMapEntryAssemblies Remove="@(_TrimmableTypeMapEntryAssemblies)" />
+    </ItemGroup>
   </Target>
 
   <!-- Add TypeMap DLLs to assembly store with per-ABI metadata.
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
index 48cb40876d6..2a1fb3f718c 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
@@ -1,16 +1,24 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.IO.Compression;
+using System.Globalization;
 using System.Linq;
+using System.Text;
 using System.Text.RegularExpressions;
+using K4os.Compression.LZ4;
+using Mono.Cecil;
 using NUnit.Framework;
+using Xamarin.Android.AssemblyStore;
 using Xamarin.Android.Tasks;
+using Xamarin.Android.Tools;
 using Xamarin.ProjectTools;
 
 namespace Xamarin.Android.Build.Tests {
 	[TestFixture]
 	[Category ("Node-2")]
 	public class TrimmableTypeMapBuildTests : BaseTest {
+		const uint CompressedAssemblyMagic = 0x5A4C4158; // 'XALZ', little-endian
 
 		[Test]
 		public void Build_WithTrimmableTypeMap_Succeeds ([Values] bool isRelease, [Values (AndroidRuntime.CoreCLR, AndroidRuntime.NativeAOT)] AndroidRuntime runtime)
@@ -197,6 +205,26 @@ public void CoreClrTrimmableTypeMap_PackagesJavaProxyThrowable ()
 				$"`{dexFile}` should include `android.runtime.JavaProxyThrowable`.");
 		}
 
+		[Test]
+		public void ReleaseCoreClrTrimmableTypeMap_DoesNotKeepMoreTypemapPeersThanLlvmIr ()
+		{
+			if (IgnoreUnsupportedConfiguration (AndroidRuntime.CoreCLR, release: true)) {
+				return;
+			}
+
+			var llvmIr = BuildTypemapComparisonApk ("llvm-ir");
+			var trimmable = BuildTypemapComparisonApk ("trimmable");
+
+			WriteComparisonDiagnostics (llvmIr, trimmable);
+
+			Assert.IsEmpty (
+				trimmable.ManagedTypemapEntries.Except (llvmIr.ManagedTypemapEntries, StringComparer.Ordinal).OrderBy (x => x, StringComparer.Ordinal).ToArray (),
+				"Trimmable typemap should not keep additional managed typemap-eligible types or methods compared to llvm-ir.");
+			Assert.IsEmpty (
+				trimmable.JavaTypemapEntries.Except (llvmIr.JavaTypemapEntries, StringComparer.Ordinal).OrderBy (x => x, StringComparer.Ordinal).ToArray (),
+				"Trimmable typemap should not keep additional Java typemap-eligible classes or methods compared to llvm-ir.");
+		}
+
 		[Test]
 		public void TrimmableTypeMap_PreserveLists_ArePackagedInSdk ()
 		{
@@ -228,7 +256,7 @@ public void TrimmableTypeMap_RuntimeArtifacts_ArePackagedInSdk ()
 			}) {
 				FileAssert.Exists (Path.Combine (toolsDir, file), $"{file} should exist in the SDK pack.");
 			}
-
+		}
 		}
 
 		// T1: end-to-end build coverage for [Export] and [ExportField] under trimmable.
@@ -394,5 +422,702 @@ class ExportShapes : Java.Lang.Object {
 				"assembly or the user's [Export] source. Offending warning lines:\n  " +
 				string.Join ("\n  ", offending));
 		}
+
+		ApkComparisonProfile BuildTypemapComparisonApk (string typemapImplementation)
+		{
+			var proj = new XamarinAndroidApplicationProject {
+				IsRelease = true,
+				PackageName = "com.xamarin.typemapcomparison",
+				ProjectName = "TypemapComparison",
+			};
+			proj.SetRuntime (AndroidRuntime.CoreCLR);
+			proj.SetProperty ("AndroidSupportedAbis", "arm64-v8a");
+			proj.SetProperty ("AndroidPackageFormat", "apk");
+			proj.SetProperty ("TrimMode", "full");
+			proj.SetProperty ("_AndroidTypeMapImplementation", typemapImplementation);
+
+			using var builder = CreateApkBuilder (Path.Combine ("temp", $"TypemapComparison_{typemapImplementation}_{Guid.NewGuid ():N}"));
+			Assert.IsTrue (builder.Build (proj), $"{typemapImplementation} build should have succeeded.");
+
+			if (typemapImplementation != "trimmable") {
+				FileAssert.Exists (builder.Output.GetIntermediaryPath (Path.Combine ("android", "typemaps.arm64-v8a.ll")), "llvm-ir build should generate the native typemap.");
+				FileAssert.Exists (builder.Output.GetIntermediaryPath (Path.Combine ("android", "typemaps.arm64-v8a.o")), "llvm-ir build should compile the native typemap.");
+			}
+
+			var apkDirectory = Path.Combine (Root, builder.ProjectDirectory, proj.OutputPath);
+			var apkPath = Directory.GetFiles (apkDirectory, "*-Signed.apk", SearchOption.AllDirectories).Single ();
+			var acwMapPath = builder.Output.GetIntermediaryPath ("acw-map.txt");
+			var javaSourceDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android", "src"));
+
+			var profile = ReadApkProfile (typemapImplementation, apkPath, acwMapPath, javaSourceDirectory);
+			if (typemapImplementation == "trimmable") {
+				Assert.IsTrue (profile.ManagedAssemblyNames.Contains ("_Microsoft.Android.TypeMaps.dll"), "trimmable build should package the root managed typemap assembly.");
+			} else {
+				Assert.IsFalse (profile.ManagedAssemblyNames.Contains ("_Microsoft.Android.TypeMaps.dll"), "llvm-ir build should not package the trimmable root managed typemap assembly.");
+			}
+			return profile;
+		}
+
+		ApkComparisonProfile ReadApkProfile (string name, string apkPath, string acwMapPath, string javaSourceDirectory)
+		{
+			var profile = new ApkComparisonProfile {
+				Name = name,
+				ApkPath = apkPath,
+				ApkSize = new FileInfo (apkPath).Length,
+			};
+
+			LoadAcwMap (acwMapPath, profile);
+			ReadGeneratedJavaProfile (javaSourceDirectory, profile);
+			ReadAssemblyStoreProfile (profile);
+			ReadDexProfile (profile);
+
+			return profile;
+		}
+
+		void ReadGeneratedJavaProfile (string javaSourceDirectory, ApkComparisonProfile profile)
+		{
+			if (!Directory.Exists (javaSourceDirectory)) {
+				return;
+			}
+
+			foreach (var file in Directory.EnumerateFiles (javaSourceDirectory, "*.java", SearchOption.AllDirectories)) {
+				profile.GeneratedJavaSourceCount++;
+				var text = File.ReadAllText (file);
+				if (text.IndexOf ("__md_methods", StringComparison.Ordinal) >= 0) {
+					profile.GeneratedJavaWithMdMethodsCount++;
+				}
+				if (text.IndexOf ("Runtime.register (", StringComparison.Ordinal) >= 0) {
+					profile.GeneratedJavaWithRuntimeRegisterCount++;
+				}
+				if (text.IndexOf ("Runtime.registerNatives", StringComparison.Ordinal) >= 0) {
+					profile.GeneratedJavaWithRegisterNativesCount++;
+				}
+			}
+		}
+
+		void LoadAcwMap (string acwMapPath, ApkComparisonProfile profile)
+		{
+			FileAssert.Exists (acwMapPath, $"{profile.Name} build should produce acw-map.txt.");
+
+			foreach (var line in File.ReadLines (acwMapPath)) {
+				if (line.Length == 0 || line [0] == '#') {
+					continue;
+				}
+
+				var fields = line.Split (new [] { ';' }, 2);
+				if (fields.Length != 2) {
+					continue;
+				}
+
+				var javaName = fields [1].Trim ();
+				if (!IsTypemapHelperJavaType (javaName)) {
+					profile.CandidateJavaNames.Add (javaName);
+				}
+
+				var managedType = GetManagedTypeFromAcwMapKey (fields [0]);
+				if (managedType != null && !IsTypemapHelperManagedType (managedType)) {
+					profile.CandidateManagedTypes.Add (managedType);
+				}
+			}
+		}
+
+		string GetManagedTypeFromAcwMapKey (string key)
+		{
+			var comma = key.IndexOf (',');
+			if (comma < 0) {
+				return null;
+			}
+
+			var typeName = key.Substring (0, comma).Trim ();
+			if (typeName.Length == 0 || typeName.IndexOf ('/') >= 0) {
+				return null;
+			}
+
+			return typeName.Replace ('+', '/');
+		}
+
+		void ReadAssemblyStoreProfile (ApkComparisonProfile profile)
+		{
+			(var explorers, var errorMessage) = AssemblyStoreExplorer.Open (profile.ApkPath);
+			Assert.IsNull (errorMessage, $"{profile.ApkPath} should contain readable assembly stores.");
+			Assert.IsNotNull (explorers, $"{profile.ApkPath} should contain assembly stores.");
+
+			var explorer = explorers.FirstOrDefault (e => e.TargetArch == AndroidTargetArch.Arm64);
+			Assert.IsNotNull (explorer, $"{profile.ApkPath} should contain an arm64-v8a assembly store.");
+
+			profile.AssemblyStoreCount = explorers.Count;
+			foreach (var store in explorers) {
+				var storeSize = store.Assemblies?.Where (a => !a.Ignore).Sum (a => (long)a.DataSize) ?? 0;
+				profile.AssemblyStores.Add ($"{store.TargetArch}: assemblies={store.AssemblyCount}, indexed={store.IndexEntryCount}, size={storeSize}");
+				profile.AssemblyStoreSize += storeSize;
+			}
+
+			foreach (var item in explorer.Assemblies.Where (a => !a.Ignore && a.Name.EndsWith (".dll", StringComparison.OrdinalIgnoreCase) && !a.Name.EndsWith (".ni.dll", StringComparison.OrdinalIgnoreCase))) {
+				profile.ManagedAssemblyNames.Add (item.Name);
+				using var stream = explorer.ReadImageData (item);
+				if (stream == null) {
+					continue;
+				}
+
+				using var assemblyStream = GetManagedAssemblyStream (stream, item.Name);
+				AssemblyDefinition assembly;
+				try {
+					assembly = AssemblyDefinition.ReadAssembly (assemblyStream);
+				} catch (BadImageFormatException ex) {
+					Assert.Fail ($"Assembly store entry '{item.Name}' should contain a readable managed assembly: {ex.Message}. First bytes: {ReadFirstBytes (assemblyStream)}");
+					throw;
+				}
+				using (assembly) {
+					profile.ManagedAssemblyCount++;
+					foreach (var type in assembly.Modules.SelectMany (m => m.Types).SelectMany (FlattenType)) {
+						if (IsTypemapHelperManagedType (type.FullName)) {
+							continue;
+						}
+
+						profile.RawManagedTypeCount++;
+						profile.RawManagedMethodCount += type.Methods.Count;
+
+						if (!IsManagedTypemapEligible (type, profile)) {
+							continue;
+						}
+
+						profile.FilteredManagedTypeCount++;
+						profile.FilteredManagedMethodCount += type.Methods.Count;
+						profile.ManagedTypemapEntries.Add ($"type {type.FullName}");
+						foreach (var method in type.Methods) {
+							profile.ManagedTypemapEntries.Add ($"method {type.FullName}::{GetManagedMethodSignature (method)}");
+						}
+					}
+				}
+			}
+		}
+
+		bool IsManagedTypemapEligible (TypeDefinition type, ApkComparisonProfile profile)
+		{
+			if (profile.CandidateManagedTypes.Contains (type.FullName)) {
+				return true;
+			}
+
+			var isTypemapEligible = false;
+			foreach (var attribute in type.CustomAttributes) {
+				var attributeName = attribute.AttributeType.FullName;
+				if (attributeName != "Android.Runtime.RegisterAttribute" && attributeName != "Java.Interop.JniTypeSignatureAttribute") {
+					continue;
+				}
+
+				isTypemapEligible = true;
+				if (attribute.ConstructorArguments.Count > 0 && attribute.ConstructorArguments [0].Value is string jniName) {
+					jniName = NormalizeJniName (jniName);
+					if (!IsTypemapHelperJavaType (jniName)) {
+						profile.CandidateJavaNames.Add (jniName);
+					}
+				}
+			}
+
+			return isTypemapEligible;
+		}
+
+		string GetManagedMethodSignature (MethodDefinition method)
+		{
+			var parameters = String.Join (",", method.Parameters.Select (p => p.ParameterType.FullName));
+			return $"{method.Name}({parameters}):{method.ReturnType.FullName}";
+		}
+
+		string NormalizeJniName (string jniName)
+		{
+			if (jniName.Length >= 2 && jniName [0] == 'L' && jniName [jniName.Length - 1] == ';') {
+				return jniName.Substring (1, jniName.Length - 2);
+			}
+
+			return jniName;
+		}
+
+		string ReadFirstBytes (Stream stream)
+		{
+			var position = stream.Position;
+			stream.Seek (0, SeekOrigin.Begin);
+			var bytes = new byte [Math.Min (16, stream.Length)];
+			stream.ReadExactly (bytes, 0, bytes.Length);
+			stream.Seek (position, SeekOrigin.Begin);
+			return BitConverter.ToString (bytes);
+		}
+
+		Stream GetManagedAssemblyStream (Stream stream, string name)
+		{
+			(ulong elfPayloadOffset, ulong elfPayloadSize, var error) = Xamarin.Android.AssemblyStore.Utils.FindELFPayloadSectionOffsetAndSize (stream);
+			Assert.IsTrue (
+				error == ELFPayloadError.None || error == ELFPayloadError.NotELF,
+				$"{name} should be a managed assembly or an ELF image containing one. ELF payload error: {error}");
+
+			if (elfPayloadOffset == 0) {
+				stream.Seek (0, SeekOrigin.Begin);
+				var copy = new MemoryStream ();
+				stream.CopyTo (copy);
+				copy.Seek (0, SeekOrigin.Begin);
+				return DecompressAssemblyIfNeeded (copy);
+			}
+
+			var payload = new MemoryStream ();
+			var buffer = new byte [16 * 1024];
+			var remaining = elfPayloadSize;
+			stream.Seek ((long)elfPayloadOffset, SeekOrigin.Begin);
+			while (remaining > 0) {
+				var read = stream.Read (buffer, 0, (int)Math.Min ((ulong)buffer.Length, remaining));
+				if (read == 0) {
+					break;
+				}
+				payload.Write (buffer, 0, read);
+				remaining -= (ulong)read;
+			}
+			payload.Seek (0, SeekOrigin.Begin);
+			return DecompressAssemblyIfNeeded (payload);
+		}
+
+		Stream DecompressAssemblyIfNeeded (Stream stream)
+		{
+			using var reader = new BinaryReader (stream, Encoding.UTF8, leaveOpen: true);
+			var magic = reader.ReadUInt32 ();
+			if (magic != CompressedAssemblyMagic) {
+				stream.Seek (0, SeekOrigin.Begin);
+				return stream;
+			}
+
+			reader.ReadUInt32 ();
+			var decompressedLength = reader.ReadUInt32 ();
+			var compressedLength = (int)(stream.Length - stream.Position);
+			var compressed = new byte [compressedLength];
+			stream.ReadExactly (compressed, 0, compressed.Length);
+
+			var decompressed = new byte [decompressedLength];
+			var decoded = LZ4Codec.Decode (compressed, 0, compressed.Length, decompressed, 0, decompressed.Length);
+			Assert.AreEqual ((int)decompressedLength, decoded, "Compressed assembly should decompress to the expected size.");
+			stream.Dispose ();
+			return new MemoryStream (decompressed, 0, decoded, writable: false);
+		}
+
+		IEnumerable<TypeDefinition> FlattenType (TypeDefinition type)
+		{
+			yield return type;
+			foreach (var nested in type.NestedTypes) {
+				foreach (var nestedType in FlattenType (nested)) {
+					yield return nestedType;
+				}
+			}
+		}
+
+		void ReadDexProfile (ApkComparisonProfile profile)
+		{
+			using var zip = ZipFile.OpenRead (profile.ApkPath);
+			foreach (var entry in zip.Entries.Where (e => Regex.IsMatch (e.FullName, @"^classes(\d*)\.dex$", RegexOptions.CultureInvariant))) {
+				using var stream = entry.Open ();
+				using var memory = new MemoryStream ();
+				stream.CopyTo (memory);
+				var bytes = memory.ToArray ();
+
+				profile.DexSize += bytes.Length;
+
+				var dex = DexProfileReader.Read (bytes);
+				profile.DexFiles.Add ($"{entry.FullName}: size={bytes.Length}, classes={dex.Classes.Count}");
+				profile.DexStringIdCount += dex.StringIdCount;
+				profile.DexTypeIdCount += dex.TypeIdCount;
+				profile.DexProtoIdCount += dex.ProtoIdCount;
+				profile.DexFieldIdCount += dex.FieldIdCount;
+				profile.DexMethodIdCount += dex.MethodIdCount;
+				profile.DexDataSize += dex.DataSize;
+				profile.RawJavaClassCount += dex.Classes.Count;
+				profile.RawJavaMethodCount += dex.Classes.Sum (c => c.Methods.Count);
+
+				foreach (var javaClass in dex.Classes) {
+					profile.JavaClassNames.Add (javaClass.Name);
+					if (IsTypemapHelperJavaType (javaClass.Name) || !profile.CandidateJavaNames.Contains (javaClass.Name)) {
+						continue;
+					}
+
+					profile.FilteredJavaClassCount++;
+					profile.FilteredJavaMethodCount += javaClass.Methods.Count;
+					profile.JavaTypemapEntries.Add ($"class {javaClass.Name}");
+					foreach (var method in javaClass.Methods) {
+						profile.JavaTypemapEntries.Add ($"method {javaClass.Name}->{method}");
+					}
+				}
+			}
+		}
+
+		bool IsTypemapHelperManagedType (string typeName)
+		{
+			return typeName.StartsWith ("_TypeMap.", StringComparison.Ordinal) ||
+				typeName.StartsWith ("_Microsoft.Android.TypeMaps", StringComparison.Ordinal) ||
+				typeName.EndsWith ("/__TypeMapAnchor", StringComparison.Ordinal) ||
+				typeName == "Android.Runtime.JavaProxyThrowable" ||
+				typeName.IndexOf ("JavaPeerProxy", StringComparison.Ordinal) >= 0 ||
+				typeName.IndexOf ("TypeMapProvider", StringComparison.Ordinal) >= 0 ||
+				typeName.IndexOf ("TypeMapping", StringComparison.Ordinal) >= 0;
+		}
+
+		bool IsTypemapHelperJavaType (string jniName)
+		{
+			return jniName.StartsWith ("net/dot/android/", StringComparison.Ordinal) ||
+				jniName.StartsWith ("mono/android/", StringComparison.Ordinal) ||
+				jniName.IndexOf ("JavaPeerProxy", StringComparison.Ordinal) >= 0 ||
+				jniName.IndexOf ("TypeMap", StringComparison.Ordinal) >= 0;
+		}
+
+		void WriteComparisonDiagnostics (ApkComparisonProfile llvmIr, ApkComparisonProfile trimmable)
+		{
+			var managedDiff = GetEntryDiff (llvmIr.ManagedTypemapEntries, trimmable.ManagedTypemapEntries);
+			var javaDiff = GetEntryDiff (llvmIr.JavaTypemapEntries, trimmable.JavaTypemapEntries);
+			var javaClassDiff = GetEntryDiff (llvmIr.JavaClassNames, trimmable.JavaClassNames);
+
+			TestContext.Out.WriteLine ("APK contents comparison: llvm-ir vs trimmable typemap");
+			WriteComparisonTable (llvmIr, trimmable, managedDiff, javaDiff);
+			WriteSize ("APK", llvmIr.ApkSize, trimmable.ApkSize);
+			WriteSize ("assembly stores", llvmIr.AssemblyStoreSize, trimmable.AssemblyStoreSize);
+			WriteSize ("classes*.dex", llvmIr.DexSize, trimmable.DexSize);
+			WriteProfile (llvmIr);
+			WriteProfile (trimmable);
+			WriteEntryDiff ("managed typemap entries", managedDiff);
+			WriteEntryDiff ("Java typemap entries", javaDiff);
+			WriteEntryDiff ("Java classes", javaClassDiff);
+		}
+
+		void WriteComparisonTable (ApkComparisonProfile llvmIr, ApkComparisonProfile trimmable, EntryDiff managedDiff, EntryDiff javaDiff)
+		{
+			TestContext.Out.WriteLine ("| Metric | llvm-ir | trimmable |");
+			TestContext.Out.WriteLine ("|---|---:|---:|");
+			TestContext.Out.WriteLine ($"| APK size | {FormatNumber (llvmIr.ApkSize)} | {FormatNumber (trimmable.ApkSize)} |");
+			TestContext.Out.WriteLine ($"| Assembly-store payload | {FormatNumber (llvmIr.AssemblyStoreSize)} | {FormatNumber (trimmable.AssemblyStoreSize)} |");
+			TestContext.Out.WriteLine ($"| classes*.dex | {FormatNumber (llvmIr.DexSize)} | {FormatNumber (trimmable.DexSize)} |");
+			TestContext.Out.WriteLine ($"| Filtered managed types / methods | {FormatNumber (llvmIr.FilteredManagedTypeCount)} / {FormatNumber (llvmIr.FilteredManagedMethodCount)} | {FormatNumber (trimmable.FilteredManagedTypeCount)} / {FormatNumber (trimmable.FilteredManagedMethodCount)} |");
+			TestContext.Out.WriteLine ($"| Managed diff | {FormatNumber (managedDiff.LlvmIrOnly.Length)} llvm-ir-only | {FormatNumber (managedDiff.TrimmableOnly.Length)} trimmable-only |");
+			TestContext.Out.WriteLine ($"| Java diff | {FormatNumber (javaDiff.LlvmIrOnly.Length)} llvm-ir-only | {FormatNumber (javaDiff.TrimmableOnly.Length)} trimmable-only |");
+		}
+
+		string FormatNumber (long value) => value.ToString ("N0", CultureInfo.InvariantCulture);
+
+		void WriteProfile (ApkComparisonProfile profile)
+		{
+			TestContext.Out.WriteLine ($"{profile.Name}: apk={profile.ApkSize} bytes, stores={profile.AssemblyStoreCount}, store-bytes={profile.AssemblyStoreSize}, dex-bytes={profile.DexSize}");
+			TestContext.Out.WriteLine ($"{profile.Name}: managed assemblies={profile.ManagedAssemblyCount}, raw types={profile.RawManagedTypeCount}, raw methods={profile.RawManagedMethodCount}, filtered types={profile.FilteredManagedTypeCount}, filtered methods={profile.FilteredManagedMethodCount}");
+			TestContext.Out.WriteLine ($"{profile.Name}: raw Java classes={profile.RawJavaClassCount}, raw Java methods={profile.RawJavaMethodCount}, filtered classes={profile.FilteredJavaClassCount}, filtered methods={profile.FilteredJavaMethodCount}");
+			TestContext.Out.WriteLine ($"{profile.Name}: dex ids: strings={profile.DexStringIdCount}, types={profile.DexTypeIdCount}, protos={profile.DexProtoIdCount}, fields={profile.DexFieldIdCount}, methods={profile.DexMethodIdCount}, data-size={profile.DexDataSize}");
+			TestContext.Out.WriteLine ($"{profile.Name}: generated Java sources={profile.GeneratedJavaSourceCount}, __md_methods files={profile.GeneratedJavaWithMdMethodsCount}, Runtime.register files={profile.GeneratedJavaWithRuntimeRegisterCount}, Runtime.registerNatives files={profile.GeneratedJavaWithRegisterNativesCount}");
+			TestContext.Out.WriteLine ($"{profile.Name}: assembly stores: {String.Join ("; ", profile.AssemblyStores)}");
+			TestContext.Out.WriteLine ($"{profile.Name}: dex files: {String.Join ("; ", profile.DexFiles)}");
+		}
+
+		void WriteSize (string label, long llvmIr, long trimmable)
+		{
+			var ratio = llvmIr == 0 ? 0 : (double)trimmable / llvmIr;
+			TestContext.Out.WriteLine ($"{label}: llvm-ir={llvmIr}, trimmable={trimmable}, delta={trimmable - llvmIr}, ratio={ratio:0.000}");
+		}
+
+		EntryDiff GetEntryDiff (ISet<string> llvmIr, ISet<string> trimmable)
+		{
+			var llvmOnly = llvmIr.Except (trimmable, StringComparer.Ordinal).OrderBy (x => x, StringComparer.Ordinal).ToArray ();
+			var trimmableOnly = trimmable.Except (llvmIr, StringComparer.Ordinal).OrderBy (x => x, StringComparer.Ordinal).ToArray ();
+			var common = llvmIr.Intersect (trimmable, StringComparer.Ordinal).Count ();
+
+			return new EntryDiff (llvmOnly, trimmableOnly, common);
+		}
+
+		void WriteEntryDiff (string label, EntryDiff diff)
+		{
+			TestContext.Out.WriteLine ($"{label}: llvm-ir only={diff.LlvmIrOnly.Length}, trimmable only={diff.TrimmableOnly.Length}, common={diff.Common}");
+			WriteSample ($"{label} llvm-ir only", diff.LlvmIrOnly);
+			WriteSample ($"{label} trimmable only", diff.TrimmableOnly);
+		}
+
+		void WriteSample (string label, string [] entries)
+		{
+			if (entries.Length == 0) {
+				return;
+			}
+
+			TestContext.Out.WriteLine ($"{label}:");
+			foreach (var entry in entries.Take (50)) {
+				TestContext.Out.WriteLine ($"  {entry}");
+			}
+			if (entries.Length > 50) {
+				TestContext.Out.WriteLine ($"  ... {entries.Length - 50} more");
+			}
+		}
+
+		class ApkComparisonProfile
+		{
+			public string Name;
+			public string ApkPath;
+			public long ApkSize;
+			public int AssemblyStoreCount;
+			public long AssemblyStoreSize;
+			public long DexSize;
+			public int ManagedAssemblyCount;
+			public int RawManagedTypeCount;
+			public int RawManagedMethodCount;
+			public int FilteredManagedTypeCount;
+			public int FilteredManagedMethodCount;
+			public int RawJavaClassCount;
+			public int RawJavaMethodCount;
+			public int FilteredJavaClassCount;
+			public int FilteredJavaMethodCount;
+			public int DexStringIdCount;
+			public int DexTypeIdCount;
+			public int DexProtoIdCount;
+			public int DexFieldIdCount;
+			public int DexMethodIdCount;
+			public int DexDataSize;
+			public int GeneratedJavaSourceCount;
+			public int GeneratedJavaWithMdMethodsCount;
+			public int GeneratedJavaWithRuntimeRegisterCount;
+			public int GeneratedJavaWithRegisterNativesCount;
+			public readonly List<string> AssemblyStores = new List<string> ();
+			public readonly List<string> DexFiles = new List<string> ();
+			public readonly HashSet<string> ManagedAssemblyNames = new HashSet<string> (StringComparer.Ordinal);
+			public readonly HashSet<string> CandidateManagedTypes = new HashSet<string> (StringComparer.Ordinal);
+			public readonly HashSet<string> CandidateJavaNames = new HashSet<string> (StringComparer.Ordinal);
+			public readonly HashSet<string> ManagedTypemapEntries = new HashSet<string> (StringComparer.Ordinal);
+			public readonly HashSet<string> JavaTypemapEntries = new HashSet<string> (StringComparer.Ordinal);
+			public readonly HashSet<string> JavaClassNames = new HashSet<string> (StringComparer.Ordinal);
+		}
+
+		class EntryDiff
+		{
+			public EntryDiff (string [] llvmIrOnly, string [] trimmableOnly, int common)
+			{
+				LlvmIrOnly = llvmIrOnly;
+				TrimmableOnly = trimmableOnly;
+				Common = common;
+			}
+
+			public string [] LlvmIrOnly { get; }
+			public string [] TrimmableOnly { get; }
+			public int Common { get; }
+		}
+
+		class DexClass
+		{
+			public string Name;
+			public readonly List<string> Methods = new List<string> ();
+		}
+
+		class DexProfile
+		{
+			public readonly List<DexClass> Classes = new List<DexClass> ();
+			public int StringIdCount { get; set; }
+			public int TypeIdCount { get; set; }
+			public int ProtoIdCount { get; set; }
+			public int FieldIdCount { get; set; }
+			public int MethodIdCount { get; set; }
+			public int DataSize { get; set; }
+		}
+
+		class DexProfileReader
+		{
+			readonly byte [] data;
+
+			DexProfileReader (byte [] data)
+			{
+				this.data = data;
+			}
+
+			public static DexProfile Read (byte [] data) => new DexProfileReader (data).ReadProfile ();
+
+			DexProfile ReadProfile ()
+			{
+				Assert.AreEqual ((byte)'d', data [0], "classes.dex magic should start with dex.");
+				Assert.AreEqual ((byte)'e', data [1], "classes.dex magic should start with dex.");
+				Assert.AreEqual ((byte)'x', data [2], "classes.dex magic should start with dex.");
+
+				var strings = ReadStrings ();
+				var typeIds = ReadTypeIds (strings);
+				var protoIds = ReadProtoIds (typeIds);
+				var methodIds = ReadMethodIds (strings, protoIds);
+				var profile = new DexProfile {
+					StringIdCount = strings.Length,
+					TypeIdCount = typeIds.Length,
+					ProtoIdCount = protoIds.Length,
+					FieldIdCount = ReadInt32 (80),
+					MethodIdCount = methodIds.Length,
+					DataSize = ReadInt32 (104),
+				};
+
+				var classDefsSize = ReadInt32 (96);
+				var classDefsOffset = ReadInt32 (100);
+				for (int i = 0; i < classDefsSize; i++) {
+					var classDefOffset = classDefsOffset + i * 32;
+					var classIdx = ReadInt32 (classDefOffset);
+					var classDataOffset = ReadInt32 (classDefOffset + 24);
+					var dexClass = new DexClass {
+						Name = DescriptorToJniName (GetItem (typeIds, classIdx, "class type")),
+					};
+
+					if (classDataOffset != 0) {
+						ReadClassData (classDataOffset, methodIds, dexClass);
+					}
+
+					profile.Classes.Add (dexClass);
+				}
+
+				return profile;
+			}
+
+			string [] ReadStrings ()
+			{
+				var stringsSize = ReadInt32 (56);
+				var stringsOffset = ReadInt32 (60);
+				var strings = new string [stringsSize];
+				for (int i = 0; i < stringsSize; i++) {
+					var offset = ReadInt32 (stringsOffset + i * 4);
+					ReadUleb128 (ref offset);
+					var start = offset;
+					while (true) {
+						EnsureAvailable (offset, 1, "string data");
+						if (data [offset] == 0) {
+							break;
+						}
+						offset++;
+					}
+					strings [i] = Encoding.UTF8.GetString (data, start, offset - start);
+				}
+
+				return strings;
+			}
+
+			string [] ReadTypeIds (string [] strings)
+			{
+				var typeIdsSize = ReadInt32 (64);
+				var typeIdsOffset = ReadInt32 (68);
+				var typeIds = new string [typeIdsSize];
+				for (int i = 0; i < typeIdsSize; i++) {
+					typeIds [i] = GetItem (strings, ReadInt32 (typeIdsOffset + i * 4), "type descriptor string");
+				}
+
+				return typeIds;
+			}
+
+			string [] ReadProtoIds (string [] typeIds)
+			{
+				var protoIdsSize = ReadInt32 (72);
+				var protoIdsOffset = ReadInt32 (76);
+				var protoIds = new string [protoIdsSize];
+				for (int i = 0; i < protoIdsSize; i++) {
+					var returnType = GetItem (typeIds, ReadInt32 (protoIdsOffset + i * 12 + 4), "proto return type");
+					var parametersOffset = ReadInt32 (protoIdsOffset + i * 12 + 8);
+					protoIds [i] = $"({ReadTypeList (parametersOffset, typeIds)}){returnType}";
+				}
+
+				return protoIds;
+			}
+
+			string ReadTypeList (int offset, string [] typeIds)
+			{
+				if (offset == 0) {
+					return "";
+				}
+
+				var count = ReadInt32 (offset);
+				var builder = new StringBuilder ();
+				offset += 4;
+				for (int i = 0; i < count; i++) {
+					builder.Append (GetItem (typeIds, ReadUInt16 (offset + i * 2), "proto parameter type"));
+				}
+				return builder.ToString ();
+			}
+
+			string [] ReadMethodIds (string [] strings, string [] protoIds)
+			{
+				var methodIdsSize = ReadInt32 (88);
+				var methodIdsOffset = ReadInt32 (92);
+				var methodIds = new string [methodIdsSize];
+				for (int i = 0; i < methodIdsSize; i++) {
+					var protoIdx = ReadUInt16 (methodIdsOffset + i * 8 + 2);
+					methodIds [i] = GetItem (strings, ReadInt32 (methodIdsOffset + i * 8 + 4), "method name string") + GetItem (protoIds, protoIdx, "method prototype");
+				}
+
+				return methodIds;
+			}
+
+			void ReadClassData (int offset, string [] methodIds, DexClass dexClass)
+			{
+				var staticFieldsSize = ReadUleb128 (ref offset);
+				var instanceFieldsSize = ReadUleb128 (ref offset);
+				var directMethodsSize = ReadUleb128 (ref offset);
+				var virtualMethodsSize = ReadUleb128 (ref offset);
+
+				SkipEncodedFields (staticFieldsSize, ref offset);
+				SkipEncodedFields (instanceFieldsSize, ref offset);
+				ReadEncodedMethods (directMethodsSize, methodIds, dexClass, ref offset);
+				ReadEncodedMethods (virtualMethodsSize, methodIds, dexClass, ref offset);
+			}
+
+			void SkipEncodedFields (int count, ref int offset)
+			{
+				for (int i = 0; i < count; i++) {
+					ReadUleb128 (ref offset);
+					ReadUleb128 (ref offset);
+				}
+			}
+
+			void ReadEncodedMethods (int count, string [] methodIds, DexClass dexClass, ref int offset)
+			{
+				var methodIndex = 0;
+				for (int i = 0; i < count; i++) {
+					methodIndex += ReadUleb128 (ref offset);
+					ReadUleb128 (ref offset);
+					ReadUleb128 (ref offset);
+					dexClass.Methods.Add (GetItem (methodIds, methodIndex, "encoded method"));
+				}
+			}
+
+			int ReadInt32 (int offset)
+			{
+				EnsureAvailable (offset, 4, "uint");
+				return data [offset] |
+					(data [offset + 1] << 8) |
+					(data [offset + 2] << 16) |
+					(data [offset + 3] << 24);
+			}
+
+			int ReadUInt16 (int offset)
+			{
+				EnsureAvailable (offset, 2, "ushort");
+				return data [offset] |
+					(data [offset + 1] << 8);
+			}
+
+			int ReadUleb128 (ref int offset)
+			{
+				var result = 0;
+				var shift = 0;
+				int value;
+				do {
+					EnsureAvailable (offset, 1, "ULEB128");
+					value = data [offset++];
+					result |= (value & 0x7f) << shift;
+					shift += 7;
+				} while ((value & 0x80) != 0);
+
+				return result;
+			}
+
+			T GetItem<T> (T [] items, int index, string description)
+			{
+				Assert.IsTrue (index >= 0 && index < items.Length, $"Invalid {description} index {index}; table has {items.Length} entries.");
+				return items [index];
+			}
+
+			void EnsureAvailable (int offset, int count, string description)
+			{
+				Assert.IsTrue (offset >= 0 && count >= 0 && offset <= data.Length - count, $"DEX {description} read at offset {offset} with size {count} exceeds file size {data.Length}.");
+			}
+
+			string DescriptorToJniName (string descriptor)
+			{
+				if (descriptor.Length >= 2 && descriptor [0] == 'L' && descriptor [descriptor.Length - 1] == ';') {
+					return descriptor.Substring (1, descriptor.Length - 2);
+				}
+
+				return descriptor;
+			}
+		}
 	}
 }

From 2aace47147be8021c0a57bfab2d37af3dd727a5f Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Thu, 14 May 2026 13:58:22 +0200
Subject: [PATCH 2/9] Enable R8 shrinking for trimmable typemap comparison

Generate proguard keep rules for the CoreCLR trimmable typemap path from the linked assemblies, matching the llvm-ir path, and make the APK comparison test use R8 so dex contents are actually shrunk.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ...roid.Sdk.TypeMap.Trimmable.CoreCLR.targets | 22 +++++++++++++++++++
 ...soft.Android.Sdk.TypeMap.Trimmable.targets |  1 +
 .../TrimmableTypeMapBuildTests.cs             |  1 +
 3 files changed, 24 insertions(+)

diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
index c27922166c1..43406ea56be 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
@@ -5,6 +5,10 @@
     <_TrimmableRuntimeProviderJavaName Condition=" '$(_TrimmableRuntimeProviderJavaName)' == '' ">mono.MonoRuntimeProvider</_TrimmableRuntimeProviderJavaName>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <_GenerateProguardAfterTargets Condition=" '$(_GenerateProguardAfterTargets)' == '' ">ILLink</_GenerateProguardAfterTargets>
+  </PropertyGroup>
+
   <!-- Add TypeMap DLLs to ILLink input. ILLink natively understands TypeMapAttribute<T>. -->
   <Target Name="_AddTrimmableTypeMapToLinker"
       BeforeTargets="PrepareForILLink;_RunILLink"
@@ -32,6 +36,24 @@
     </ItemGroup>
   </Target>
 
+  <Target Name="_PrepareLinkedAssembliesForProguard"
+      AfterTargets="$(_GenerateProguardAfterTargets)"
+      Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' ">
+    <ItemGroup>
+      <_LinkedAssemblyForProguard Include="@(ResolvedFileToPublish)" Condition=" '%(Extension)' == '.dll' " />
+    </ItemGroup>
+  </Target>
+
+  <Target Name="_GenerateProguardConfiguration"
+      AfterTargets="_PrepareLinkedAssembliesForProguard"
+      Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' "
+      Inputs="@(_LinkedAssemblyForProguard)"
+      Outputs="$(_ProguardProjectConfiguration)">
+    <GenerateProguardConfiguration
+        LinkedAssemblies="@(_LinkedAssemblyForProguard)"
+        OutputFile="$(_ProguardProjectConfiguration)" />
+  </Target>
+
   <!-- Add TypeMap DLLs to assembly store with per-ABI metadata.
        TypeMap DLLs are ABI-agnostic (pure IL), so the same DLLs are added for every ABI.
        This target batches over @(_BuildTargetAbis) to add items per-ABI. -->
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
index b040052577f..ea8b052f828 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
@@ -4,6 +4,7 @@
   <UsingTask TaskName="Xamarin.Android.Tasks.GenerateTrimmableTypeMap" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
   <UsingTask TaskName="Xamarin.Android.Tasks.GenerateEmptyTypemapStub" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
   <UsingTask TaskName="Xamarin.Android.Tasks.GenerateNativeAotBootstrapSources" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
+  <UsingTask TaskName="Xamarin.Android.Tasks.GenerateProguardConfiguration" AssemblyFile="$(_XamarinAndroidBuildTasksAssembly)" />
 
   <Import Project="$(MSBuildThisFileDirectory)Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets"
       Condition=" '$(_AndroidRuntime)' == 'CoreCLR' " />
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
index 2a1fb3f718c..446eb045193 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
@@ -433,6 +433,7 @@ ApkComparisonProfile BuildTypemapComparisonApk (string typemapImplementation)
 			proj.SetRuntime (AndroidRuntime.CoreCLR);
 			proj.SetProperty ("AndroidSupportedAbis", "arm64-v8a");
 			proj.SetProperty ("AndroidPackageFormat", "apk");
+			proj.SetProperty (KnownProperties.AndroidLinkTool, "r8");
 			proj.SetProperty ("TrimMode", "full");
 			proj.SetProperty ("_AndroidTypeMapImplementation", typemapImplementation);
 

From 345390f1b95e2937e4050f2d916dd5c176aecf1d Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Thu, 14 May 2026 14:08:13 +0200
Subject: [PATCH 3/9] Pass per-assembly typemap entries to ILLink

Limit --typemap-entry-assembly arguments to generated per-assembly *.TypeMap.dll assemblies that contain TypeMapAttribute entries, instead of treating the root typemap loader assembly as an entry assembly.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
index 43406ea56be..4d3b1470ee2 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
@@ -26,7 +26,7 @@
       BeforeTargets="PrepareForILLink;_RunILLink"
       DependsOnTargets="_GenerateTrimmableTypeMap">
     <ItemGroup>
-      <_TrimmableTypeMapEntryAssemblies Include="$(_TypeMapOutputDirectory)*.dll" />
+      <_TrimmableTypeMapEntryAssemblies Include="$(_TypeMapOutputDirectory)*.TypeMap.dll" />
     </ItemGroup>
     <PropertyGroup>
       <_ExtraTrimmerArgs>@(_TrimmableTypeMapEntryAssemblies->'--typemap-entry-assembly %(Filename)', ' ') $(_ExtraTrimmerArgs)</_ExtraTrimmerArgs>

From c442af3fcf8168e3954de868ada34a721e127e6b Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Thu, 14 May 2026 16:23:53 +0200
Subject: [PATCH 4/9] Refine trimmable typemap framework roots

Keep SDK framework ACWs conditional unless they are explicitly rooted, and pass framework assembly names through trimmable typemap generation. This allows Mono.Android implementor entries to be trimmed while preserving app ACWs and scanner-rooted components.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../Scanner/JavaPeerInfo.cs                   |   6 +-
 .../TrimmableTypeMapGenerator.cs              |  10 ++
 ...soft.Android.Sdk.TypeMap.Trimmable.targets |   1 +
 .../Tasks/GenerateTrimmableTypeMap.cs         |  12 +-
 .../TrimmableTypeMapBuildTests.cs             | 122 +++++++++++++++++-
 .../Generator/TypeMapModelBuilderTests.cs     |  26 ++++
 6 files changed, 171 insertions(+), 6 deletions(-)

diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs
index 2005799d1c3..62a9f55128a 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/Scanner/JavaPeerInfo.cs
@@ -44,9 +44,11 @@ public sealed record JavaPeerInfo
 	public required string AssemblyName { get; init; }
 
 	/// <summary>
-	/// True when the type belongs to a framework assembly.
+	/// True when the type belongs to a framework assembly supplied by the Android SDK.
+	/// Framework ACWs are generated by the SDK and can be trimmed like bindings unless
+	/// another rule explicitly roots them.
 	/// </summary>
-	public bool IsFrameworkAssembly { get; init; }
+	public bool IsFrameworkAssembly { get; set; }
 
 	/// <summary>
 	/// True when per-rank array typemap entries should be generated for this peer.
diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
index 5a391f520b6..652c4fb3a5b 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
@@ -48,6 +48,7 @@ public TrimmableTypeMapResult Execute (
 			logger.LogNoJavaPeerTypesFound ();
 			return new TrimmableTypeMapResult ([], [], allPeers);
 		}
+		MarkFrameworkAssemblyPeers (allPeers, frameworkAssemblyNames);
 
 		RootManifestReferencedTypes (allPeers, PrepareManifestForRooting (manifestTemplate, manifestConfig));
 		PropagateDeferredRegistrationToBaseClasses (allPeers);
@@ -212,6 +213,15 @@ List<GeneratedAssembly> GenerateTypeMapAssemblies (
 		return generatedAssemblies;
 	}
 
+	static void MarkFrameworkAssemblyPeers (List<JavaPeerInfo> allPeers, HashSet<string> frameworkAssemblyNames)
+	{
+		foreach (var peer in allPeers) {
+			if (frameworkAssemblyNames.Contains (peer.AssemblyName)) {
+				peer.IsFrameworkAssembly = true;
+			}
+		}
+	}
+
 	/// <summary>
 	/// Groups peers by assembly, merging cross-assembly aliases into a single group.
 	/// When the same JNI name appears in multiple assemblies (e.g. <c>Java.Lang.Object</c>
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
index ea8b052f828..69da896b24f 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
@@ -85,6 +85,7 @@
     <GenerateTrimmableTypeMap
         ResolvedAssemblies="@(_TypeMapInputAssemblies)"
         ResolvedFrameworkAssemblies="@(ResolvedFrameworkAssemblies)"
+        FrameworkAssemblyNames="@(ResolvedFrameworkAssemblies->'%(Filename)')"
         OutputDirectory="$(_TypeMapOutputDirectory)"
         JavaSourceOutputDirectory="$(_TypeMapJavaOutputDirectory)"
         TargetFrameworkVersion="$(TargetFrameworkVersion)"
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
index ae5fbcfd791..6184f36b467 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
@@ -15,6 +15,12 @@ namespace Xamarin.Android.Tasks;
 
 public class GenerateTrimmableTypeMap : AndroidTask
 {
+	static readonly string [] DefaultFrameworkAssemblyNames = [
+		"Java.Interop",
+		"Mono.Android",
+		"Mono.Android.Runtime",
+	];
+
 	sealed class MSBuildTrimmableTypeMapLogger (TaskLoggingHelper log) : ITrimmableTypeMapLogger
 	{
 		public void LogNoJavaPeerTypesFound () =>
@@ -46,6 +52,7 @@ public void LogJniAddNativeMethodRegistrationAttributeError (string managedTypeN
 	[Required]
 	public ITaskItem [] ResolvedAssemblies { get; set; } = [];
 	public ITaskItem [] ResolvedFrameworkAssemblies { get; set; } = [];
+	public string [] FrameworkAssemblyNames { get; set; } = [];
 	[Required]
 	public string OutputDirectory { get; set; } = "";
 	[Required]
@@ -105,7 +112,10 @@ public override bool RunTask ()
 				Path: g.Key,
 				IsFrameworkAssembly: frameworkAssemblyPaths.Contains (g.Key) || g.Any (IsFrameworkAssemblyItem)))
 			.ToList ();
-		var frameworkAssemblyNames = new HashSet<string> (StringComparer.OrdinalIgnoreCase);
+		var frameworkAssemblyNames = new HashSet<string> (DefaultFrameworkAssemblyNames, StringComparer.OrdinalIgnoreCase);
+		foreach (var assemblyName in FrameworkAssemblyNames) {
+			frameworkAssemblyNames.Add (assemblyName);
+		}
 
 		Directory.CreateDirectory (OutputDirectory);
 		Directory.CreateDirectory (JavaSourceOutputDirectory);
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
index 446eb045193..4e99e9932be 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
@@ -449,8 +449,10 @@ ApkComparisonProfile BuildTypemapComparisonApk (string typemapImplementation)
 			var apkPath = Directory.GetFiles (apkDirectory, "*-Signed.apk", SearchOption.AllDirectories).Single ();
 			var acwMapPath = builder.Output.GetIntermediaryPath ("acw-map.txt");
 			var javaSourceDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android", "src"));
+			var typeMapDirectory = builder.Output.GetIntermediaryPath ("typemap");
+			var linkedAssemblyDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "linked"));
 
-			var profile = ReadApkProfile (typemapImplementation, apkPath, acwMapPath, javaSourceDirectory);
+			var profile = ReadApkProfile (typemapImplementation, apkPath, acwMapPath, javaSourceDirectory, typeMapDirectory, linkedAssemblyDirectory);
 			if (typemapImplementation == "trimmable") {
 				Assert.IsTrue (profile.ManagedAssemblyNames.Contains ("_Microsoft.Android.TypeMaps.dll"), "trimmable build should package the root managed typemap assembly.");
 			} else {
@@ -459,7 +461,7 @@ ApkComparisonProfile BuildTypemapComparisonApk (string typemapImplementation)
 			return profile;
 		}
 
-		ApkComparisonProfile ReadApkProfile (string name, string apkPath, string acwMapPath, string javaSourceDirectory)
+		ApkComparisonProfile ReadApkProfile (string name, string apkPath, string acwMapPath, string javaSourceDirectory, string typeMapDirectory, string linkedAssemblyDirectory)
 		{
 			var profile = new ApkComparisonProfile {
 				Name = name,
@@ -469,6 +471,8 @@ ApkComparisonProfile ReadApkProfile (string name, string apkPath, string acwMapP
 
 			LoadAcwMap (acwMapPath, profile);
 			ReadGeneratedJavaProfile (javaSourceDirectory, profile);
+			ReadTypeMapAssemblyProfile (profile, "generated", typeMapDirectory);
+			ReadTypeMapAssemblyProfile (profile, "linked", linkedAssemblyDirectory);
 			ReadAssemblyStoreProfile (profile);
 			ReadDexProfile (profile);
 
@@ -570,6 +574,9 @@ void ReadAssemblyStoreProfile (ApkComparisonProfile profile)
 				}
 				using (assembly) {
 					profile.ManagedAssemblyCount++;
+					if (item.Name.EndsWith (".TypeMap.dll", StringComparison.Ordinal) || item.Name == "_Microsoft.Android.TypeMaps.dll") {
+						ReadTypeMapAssemblyProfile (profile, "packaged", assembly, item.Name);
+					}
 					foreach (var type in assembly.Modules.SelectMany (m => m.Types).SelectMany (FlattenType)) {
 						if (IsTypemapHelperManagedType (type.FullName)) {
 							continue;
@@ -593,6 +600,66 @@ void ReadAssemblyStoreProfile (ApkComparisonProfile profile)
 			}
 		}
 
+		void ReadTypeMapAssemblyProfile (ApkComparisonProfile profile, string stage, string directory)
+		{
+			if (!Directory.Exists (directory)) {
+				return;
+			}
+
+			foreach (var file in Directory.EnumerateFiles (directory, "*.dll", SearchOption.TopDirectoryOnly).Where (IsTypeMapAssemblyPath)) {
+				using var assembly = AssemblyDefinition.ReadAssembly (file);
+				ReadTypeMapAssemblyProfile (profile, stage, assembly, Path.GetFileName (file));
+			}
+		}
+
+		bool IsTypeMapAssemblyPath (string file)
+		{
+			var name = Path.GetFileName (file);
+			return name.EndsWith (".TypeMap.dll", StringComparison.Ordinal) || name == "_Microsoft.Android.TypeMaps.dll";
+		}
+
+		void ReadTypeMapAssemblyProfile (ApkComparisonProfile profile, string stage, AssemblyDefinition assembly, string assemblyName)
+		{
+			var metrics = new TypeMapAssemblyMetrics {
+				Stage = stage,
+				AssemblyName = assemblyName,
+			};
+
+			foreach (var attribute in assembly.CustomAttributes) {
+				var attributeName = attribute.AttributeType.FullName;
+				if (attributeName.StartsWith ("System.Runtime.InteropServices.TypeMapAttribute`1", StringComparison.Ordinal)) {
+					ReadTypeMapAttribute (attribute, metrics);
+				} else if (attributeName.StartsWith ("System.Runtime.InteropServices.TypeMapAssociationAttribute", StringComparison.Ordinal)) {
+					metrics.AssociationAttributeCount++;
+				} else if (attributeName.StartsWith ("System.Runtime.InteropServices.TypeMapAssemblyTargetAttribute`1", StringComparison.Ordinal)) {
+					metrics.AssemblyTargetAttributeCount++;
+				}
+			}
+
+			if (metrics.TypeMapAttributeCount != 0 || metrics.AssociationAttributeCount != 0 || metrics.AssemblyTargetAttributeCount != 0) {
+				profile.TypeMapAssemblies.Add (metrics);
+			}
+		}
+
+		void ReadTypeMapAttribute (CustomAttribute attribute, TypeMapAssemblyMetrics metrics)
+		{
+			metrics.TypeMapAttributeCount++;
+			if (attribute.ConstructorArguments.Count == 2) {
+				metrics.UnconditionalTypeMapAttributeCount++;
+			} else if (attribute.ConstructorArguments.Count == 3) {
+				metrics.ConditionalTypeMapAttributeCount++;
+			}
+
+			var jniName = attribute.ConstructorArguments.Count > 0 ? attribute.ConstructorArguments [0].Value as string : null;
+			var proxyType = attribute.ConstructorArguments.Count > 1 ? attribute.ConstructorArguments [1].Value as string : null;
+			var targetType = attribute.ConstructorArguments.Count > 2 ? attribute.ConstructorArguments [2].Value as string : null;
+			var key = $"{jniName}\t{proxyType}\t{targetType}";
+			metrics.TypeMapAttributeKeys.Add (key);
+			if (jniName != null) {
+				metrics.IncrementPrefixBucket (jniName);
+			}
+		}
+
 		bool IsManagedTypemapEligible (TypeDefinition type, ApkComparisonProfile profile)
 		{
 			if (profile.CandidateManagedTypes.Contains (type.FullName)) {
@@ -788,7 +855,7 @@ void WriteComparisonTable (ApkComparisonProfile llvmIr, ApkComparisonProfile tri
 			TestContext.Out.WriteLine ($"| APK size | {FormatNumber (llvmIr.ApkSize)} | {FormatNumber (trimmable.ApkSize)} |");
 			TestContext.Out.WriteLine ($"| Assembly-store payload | {FormatNumber (llvmIr.AssemblyStoreSize)} | {FormatNumber (trimmable.AssemblyStoreSize)} |");
 			TestContext.Out.WriteLine ($"| classes*.dex | {FormatNumber (llvmIr.DexSize)} | {FormatNumber (trimmable.DexSize)} |");
-			TestContext.Out.WriteLine ($"| Filtered managed types / methods | {FormatNumber (llvmIr.FilteredManagedTypeCount)} / {FormatNumber (llvmIr.FilteredManagedMethodCount)} | {FormatNumber (trimmable.FilteredManagedTypeCount)} / {FormatNumber (trimmable.FilteredManagedMethodCount)} |");
+			TestContext.Out.WriteLine ($"| Registered managed types / methods | {FormatNumber (llvmIr.FilteredManagedTypeCount)} / {FormatNumber (llvmIr.FilteredManagedMethodCount)} | {FormatNumber (trimmable.FilteredManagedTypeCount)} / {FormatNumber (trimmable.FilteredManagedMethodCount)} |");
 			TestContext.Out.WriteLine ($"| Managed diff | {FormatNumber (managedDiff.LlvmIrOnly.Length)} llvm-ir-only | {FormatNumber (managedDiff.TrimmableOnly.Length)} trimmable-only |");
 			TestContext.Out.WriteLine ($"| Java diff | {FormatNumber (javaDiff.LlvmIrOnly.Length)} llvm-ir-only | {FormatNumber (javaDiff.TrimmableOnly.Length)} trimmable-only |");
 		}
@@ -804,6 +871,9 @@ void WriteProfile (ApkComparisonProfile profile)
 			TestContext.Out.WriteLine ($"{profile.Name}: generated Java sources={profile.GeneratedJavaSourceCount}, __md_methods files={profile.GeneratedJavaWithMdMethodsCount}, Runtime.register files={profile.GeneratedJavaWithRuntimeRegisterCount}, Runtime.registerNatives files={profile.GeneratedJavaWithRegisterNativesCount}");
 			TestContext.Out.WriteLine ($"{profile.Name}: assembly stores: {String.Join ("; ", profile.AssemblyStores)}");
 			TestContext.Out.WriteLine ($"{profile.Name}: dex files: {String.Join ("; ", profile.DexFiles)}");
+			foreach (var metrics in profile.TypeMapAssemblies) {
+				TestContext.Out.WriteLine ($"{profile.Name}: typemap {metrics.Stage}/{metrics.AssemblyName}: typemap={metrics.TypeMapAttributeCount}, unique={metrics.UniqueTypeMapAttributeCount}, duplicates={metrics.DuplicateTypeMapAttributeCount}, unconditional={metrics.UnconditionalTypeMapAttributeCount}, conditional={metrics.ConditionalTypeMapAttributeCount}, associations={metrics.AssociationAttributeCount}, assembly-targets={metrics.AssemblyTargetAttributeCount}, prefixes={metrics.FormatPrefixBuckets ()}");
+			}
 		}
 
 		void WriteSize (string label, long llvmIr, long trimmable)
@@ -878,6 +948,52 @@ class ApkComparisonProfile
 			public readonly HashSet<string> ManagedTypemapEntries = new HashSet<string> (StringComparer.Ordinal);
 			public readonly HashSet<string> JavaTypemapEntries = new HashSet<string> (StringComparer.Ordinal);
 			public readonly HashSet<string> JavaClassNames = new HashSet<string> (StringComparer.Ordinal);
+			public readonly List<TypeMapAssemblyMetrics> TypeMapAssemblies = new List<TypeMapAssemblyMetrics> ();
+		}
+
+		class TypeMapAssemblyMetrics
+		{
+			public string Stage;
+			public string AssemblyName;
+			public int TypeMapAttributeCount;
+			public int UnconditionalTypeMapAttributeCount;
+			public int ConditionalTypeMapAttributeCount;
+			public int AssociationAttributeCount;
+			public int AssemblyTargetAttributeCount;
+			public readonly List<string> TypeMapAttributeKeys = new List<string> ();
+			readonly SortedDictionary<string, int> prefixBuckets = new SortedDictionary<string, int> (StringComparer.Ordinal);
+
+			public int UniqueTypeMapAttributeCount => TypeMapAttributeKeys.Distinct (StringComparer.Ordinal).Count ();
+			public int DuplicateTypeMapAttributeCount => TypeMapAttributeCount - UniqueTypeMapAttributeCount;
+
+			public void IncrementPrefixBucket (string jniName)
+			{
+				var bucket = GetPrefixBucket (jniName);
+				prefixBuckets.TryGetValue (bucket, out int count);
+				prefixBuckets [bucket] = count + 1;
+			}
+
+			public string FormatPrefixBuckets ()
+			{
+				return String.Join (", ", prefixBuckets.Select (p => $"{p.Key}={p.Value}"));
+			}
+
+			static string GetPrefixBucket (string jniName)
+			{
+				if (jniName.StartsWith ("mono/android/", StringComparison.Ordinal)) {
+					return "mono/android";
+				}
+				if (jniName.StartsWith ("android/", StringComparison.Ordinal)) {
+					return "android";
+				}
+				if (jniName.StartsWith ("java/", StringComparison.Ordinal)) {
+					return "java";
+				}
+				if (jniName.StartsWith ("com/xamarin/", StringComparison.Ordinal)) {
+					return "app";
+				}
+				return "other";
+			}
 		}
 
 		class EntryDiff
diff --git a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs
index 06498daa478..33cdea9a84b 100644
--- a/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs
+++ b/tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TypeMapModelBuilderTests.cs
@@ -216,6 +216,32 @@ public void Build_UserAcwType_IsUnconditional ()
 			Assert.Null (mainEntry.TargetTypeReference);
 		}
 
+		[Fact]
+		public void Build_FrameworkAcwType_IsTrimmable ()
+		{
+			var peer = MakeAcwPeer ("mono/android/view/View_OnClickListenerImplementor", "Android.Views.View+IOnClickListenerImplementor", "Mono.Android") with {
+				IsFrameworkAssembly = true,
+			};
+			var model = BuildModel (new [] { peer });
+
+			var entry = model.Entries.First (e => e.JniName == "mono/android/view/View_OnClickListenerImplementor");
+			Assert.False (entry.IsUnconditional);
+			Assert.Equal ("Android.Views.View+IOnClickListenerImplementor, Mono.Android", entry.TargetTypeReference);
+		}
+
+		[Fact]
+		public void Build_FrameworkAcwType_MarkedUnconditional_IsUnconditional ()
+		{
+			var peer = MakeAcwPeer ("mono/android/app/ApplicationRegistration", "Android.App.ApplicationRegistration", "Mono.Android") with {
+				IsFrameworkAssembly = true,
+				IsUnconditional = true,
+			};
+			var model = BuildModel (new [] { peer });
+
+			Assert.True (model.Entries [0].IsUnconditional);
+			Assert.Null (model.Entries [0].TargetTypeReference);
+		}
+
 		[Fact]
 		public void Build_McwBinding_IsTrimmable ()
 		{

From a8af5b16859bb0cfe0d8de325da4afbaf5a3a39a Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Thu, 14 May 2026 20:45:59 +0200
Subject: [PATCH 5/9] Reduce trimmable typemap R8 keep rules

Generate R8 keep rules for trimmable typemap builds from linked assemblies instead of the pre-link acw-map, and use a minimal Xamarin runtime keep list for this path.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ...roid.Sdk.TypeMap.Trimmable.CoreCLR.targets | 20 +++++------
 src/Xamarin.Android.Build.Tasks/Tasks/R8.cs   | 34 +++++++++++++++++--
 .../Xamarin.Android.D8.targets                |  4 +++
 3 files changed, 46 insertions(+), 12 deletions(-)

diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
index 4d3b1470ee2..714ff9ae8aa 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
@@ -7,6 +7,8 @@
 
   <PropertyGroup>
     <_GenerateProguardAfterTargets Condition=" '$(_GenerateProguardAfterTargets)' == '' ">ILLink</_GenerateProguardAfterTargets>
+    <_R8GenerateApplicationProguardConfigurationFromAcwMap>false</_R8GenerateApplicationProguardConfigurationFromAcwMap>
+    <_R8UseMinimalXamarinProguardConfiguration>true</_R8UseMinimalXamarinProguardConfiguration>
   </PropertyGroup>
 
   <!-- Add TypeMap DLLs to ILLink input. ILLink natively understands TypeMapAttribute<T>. -->
@@ -36,22 +38,20 @@
     </ItemGroup>
   </Target>
 
-  <Target Name="_PrepareLinkedAssembliesForProguard"
-      AfterTargets="$(_GenerateProguardAfterTargets)"
-      Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' ">
-    <ItemGroup>
-      <_LinkedAssemblyForProguard Include="@(ResolvedFileToPublish)" Condition=" '%(Extension)' == '.dll' " />
-    </ItemGroup>
-  </Target>
-
   <Target Name="_GenerateProguardConfiguration"
-      AfterTargets="_PrepareLinkedAssembliesForProguard"
+      BeforeTargets="_CompileToDalvik"
       Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' "
-      Inputs="@(_LinkedAssemblyForProguard)"
+      Inputs="$(IntermediateOutputPath)*/linked/*.dll"
       Outputs="$(_ProguardProjectConfiguration)">
+    <ItemGroup>
+      <_LinkedAssemblyForProguard Include="$(IntermediateOutputPath)*/linked/*.dll" />
+    </ItemGroup>
     <GenerateProguardConfiguration
         LinkedAssemblies="@(_LinkedAssemblyForProguard)"
         OutputFile="$(_ProguardProjectConfiguration)" />
+    <ItemGroup>
+      <_LinkedAssemblyForProguard Remove="@(_LinkedAssemblyForProguard)" />
+    </ItemGroup>
   </Target>
 
   <!-- Add TypeMap DLLs to assembly store with per-ABI metadata.
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs b/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
index fbf66e7bf48..59c4cd4ba0c 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
@@ -33,6 +33,8 @@ public class R8 : D8
 		public string? ProguardGeneratedReferenceConfiguration { get; set; }
 		public string? ProguardGeneratedApplicationConfiguration { get; set; }
 		public string? ProguardCommonXamarinConfiguration { get; set; }
+		public bool GenerateApplicationProguardConfigurationFromAcwMap { get; set; } = true;
+		public bool UseMinimalXamarinProguardConfiguration { get; set; }
 		public string? ProguardMappingFileOutput { get; set; }
 		public string []? ProguardConfigurationFiles { get; set; }
 
@@ -95,7 +97,7 @@ protected override string CreateResponseFile ()
 			}
 
 			if (EnableShrinking) {
-				if (!AcwMapFile.IsNullOrEmpty ()) {
+				if (GenerateApplicationProguardConfigurationFromAcwMap && !AcwMapFile.IsNullOrEmpty ()) {
 					var acwMap      = MonoAndroidHelper.LoadMapFile (BuildEngine4, Path.GetFullPath (AcwMapFile), StringComparer.OrdinalIgnoreCase);
 					var javaTypes   = new List<string> (acwMap.Values.Count);
 					foreach (var v in acwMap.Values) {
@@ -107,10 +109,16 @@ protected override string CreateResponseFile ()
 							appcfg.WriteLine ($"-keep class {java} {{ *; }}");
 						}
 					}
+				} else if (!ProguardGeneratedApplicationConfiguration.IsNullOrEmpty ()) {
+					File.WriteAllText (ProguardGeneratedApplicationConfiguration, "");
 				}
 				if (!ProguardCommonXamarinConfiguration.IsNullOrWhiteSpace ()) {
 					using (var xamcfg = File.CreateText (ProguardCommonXamarinConfiguration)) {
-						GetType ().Assembly.GetManifestResourceStream ("proguard_xamarin.cfg").CopyTo (xamcfg.BaseStream);
+						if (UseMinimalXamarinProguardConfiguration) {
+							WriteMinimalXamarinProguardConfiguration (xamcfg);
+						} else {
+							GetType ().Assembly.GetManifestResourceStream ("proguard_xamarin.cfg").CopyTo (xamcfg.BaseStream);
+						}
 						if (IgnoreWarnings) {
 							xamcfg.WriteLine ("-ignorewarnings");
 						}
@@ -159,6 +167,28 @@ protected override string CreateResponseFile ()
 			return responseFile;
 		}
 
+		static void WriteMinimalXamarinProguardConfiguration (TextWriter writer)
+		{
+			writer.WriteLine ("# Minimal Xamarin configuration for trimmable typemap builds.");
+			writer.WriteLine ("-dontobfuscate");
+			writer.WriteLine ();
+			writer.WriteLine ("-keep class android.support.multidex.MultiDexApplication { <init>(); }");
+			writer.WriteLine ("-keep class mono.MonoRuntimeProvider* { *; <init>(...); }");
+			writer.WriteLine ("-keep class mono.MonoPackageManager { *; <init>(...); }");
+			writer.WriteLine ("-keep class mono.MonoPackageManager_Resources { *; <init>(...); }");
+			writer.WriteLine ("-keep class net.dot.jni.** { *; <init>(); }");
+			writer.WriteLine ("-keep class net.dot.android.crypto.** { *; <init>(...); }");
+			writer.WriteLine ();
+			writer.WriteLine ("-keepclassmembers class * extends android.view.View {");
+			writer.WriteLine ("   *** set*(...);");
+			writer.WriteLine ("}");
+			writer.WriteLine ();
+			writer.WriteLine ("-keepclassmembers class * extends android.view.View {");
+			writer.WriteLine ("   <init>(android.content.Context,android.util.AttributeSet);");
+			writer.WriteLine ("   <init>(android.content.Context,android.util.AttributeSet,int);");
+			writer.WriteLine ("}");
+		}
+
 		// Note: We do not want to call the base.LogEventsFromTextOutput as it will incorrectly identify
 		// Warnings and Info messages as errors.
 		protected override void LogEventsFromTextOutput (string singleLine, MessageImportance messageImportance)
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
index 0796e933155..a196142b01a 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
@@ -30,6 +30,8 @@ Copyright (C) 2018 Xamarin. All rights reserved.
       <!--Flag indicating if r8 should have EnableShrinking-->
       <_R8EnableShrinking Condition=" '$(AndroidLinkTool)' == 'r8' ">True</_R8EnableShrinking>
       <_R8EnableShrinking Condition=" '$(_R8EnableShrinking)' == '' ">False</_R8EnableShrinking>
+      <_R8GenerateApplicationProguardConfigurationFromAcwMap Condition=" '$(_R8GenerateApplicationProguardConfigurationFromAcwMap)' == '' ">True</_R8GenerateApplicationProguardConfigurationFromAcwMap>
+      <_R8UseMinimalXamarinProguardConfiguration Condition=" '$(_R8UseMinimalXamarinProguardConfiguration)' == '' ">False</_R8UseMinimalXamarinProguardConfiguration>
     </PropertyGroup>
 
     <Error
@@ -72,6 +74,8 @@ Copyright (C) 2018 Xamarin. All rights reserved.
         ProguardCommonXamarinConfiguration="$(IntermediateOutputPath)proguard\proguard_xamarin.cfg"
         ProguardGeneratedReferenceConfiguration="$(_ProguardProjectConfiguration)"
         ProguardGeneratedApplicationConfiguration="$(IntermediateOutputPath)proguard\proguard_project_primary.cfg"
+        GenerateApplicationProguardConfigurationFromAcwMap="$(_R8GenerateApplicationProguardConfigurationFromAcwMap)"
+        UseMinimalXamarinProguardConfiguration="$(_R8UseMinimalXamarinProguardConfiguration)"
         ProguardMappingFileOutput="$(AndroidProguardMappingFile)"
         ProguardConfigurationFiles="@(_ProguardConfiguration)"
         EnableShrinking="$(_R8EnableShrinking)"

From 0bec5ded1df8a4372ba3d469f67fc8f1263d3be2 Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Thu, 14 May 2026 21:24:34 +0200
Subject: [PATCH 6/9] Revert "Reduce trimmable typemap R8 keep rules"

This reverts commit 44d8c10d429dfc2e691f06bd12f74d4675d9aea5.
---
 ...roid.Sdk.TypeMap.Trimmable.CoreCLR.targets | 20 +++++------
 src/Xamarin.Android.Build.Tasks/Tasks/R8.cs   | 34 ++-----------------
 .../Xamarin.Android.D8.targets                |  4 ---
 3 files changed, 12 insertions(+), 46 deletions(-)

diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
index 714ff9ae8aa..4d3b1470ee2 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
@@ -7,8 +7,6 @@
 
   <PropertyGroup>
     <_GenerateProguardAfterTargets Condition=" '$(_GenerateProguardAfterTargets)' == '' ">ILLink</_GenerateProguardAfterTargets>
-    <_R8GenerateApplicationProguardConfigurationFromAcwMap>false</_R8GenerateApplicationProguardConfigurationFromAcwMap>
-    <_R8UseMinimalXamarinProguardConfiguration>true</_R8UseMinimalXamarinProguardConfiguration>
   </PropertyGroup>
 
   <!-- Add TypeMap DLLs to ILLink input. ILLink natively understands TypeMapAttribute<T>. -->
@@ -38,20 +36,22 @@
     </ItemGroup>
   </Target>
 
+  <Target Name="_PrepareLinkedAssembliesForProguard"
+      AfterTargets="$(_GenerateProguardAfterTargets)"
+      Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' ">
+    <ItemGroup>
+      <_LinkedAssemblyForProguard Include="@(ResolvedFileToPublish)" Condition=" '%(Extension)' == '.dll' " />
+    </ItemGroup>
+  </Target>
+
   <Target Name="_GenerateProguardConfiguration"
-      BeforeTargets="_CompileToDalvik"
+      AfterTargets="_PrepareLinkedAssembliesForProguard"
       Condition=" '$(PublishTrimmed)' == 'true' and '$(_ProguardProjectConfiguration)' != '' "
-      Inputs="$(IntermediateOutputPath)*/linked/*.dll"
+      Inputs="@(_LinkedAssemblyForProguard)"
       Outputs="$(_ProguardProjectConfiguration)">
-    <ItemGroup>
-      <_LinkedAssemblyForProguard Include="$(IntermediateOutputPath)*/linked/*.dll" />
-    </ItemGroup>
     <GenerateProguardConfiguration
         LinkedAssemblies="@(_LinkedAssemblyForProguard)"
         OutputFile="$(_ProguardProjectConfiguration)" />
-    <ItemGroup>
-      <_LinkedAssemblyForProguard Remove="@(_LinkedAssemblyForProguard)" />
-    </ItemGroup>
   </Target>
 
   <!-- Add TypeMap DLLs to assembly store with per-ABI metadata.
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs b/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
index 59c4cd4ba0c..fbf66e7bf48 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/R8.cs
@@ -33,8 +33,6 @@ public class R8 : D8
 		public string? ProguardGeneratedReferenceConfiguration { get; set; }
 		public string? ProguardGeneratedApplicationConfiguration { get; set; }
 		public string? ProguardCommonXamarinConfiguration { get; set; }
-		public bool GenerateApplicationProguardConfigurationFromAcwMap { get; set; } = true;
-		public bool UseMinimalXamarinProguardConfiguration { get; set; }
 		public string? ProguardMappingFileOutput { get; set; }
 		public string []? ProguardConfigurationFiles { get; set; }
 
@@ -97,7 +95,7 @@ protected override string CreateResponseFile ()
 			}
 
 			if (EnableShrinking) {
-				if (GenerateApplicationProguardConfigurationFromAcwMap && !AcwMapFile.IsNullOrEmpty ()) {
+				if (!AcwMapFile.IsNullOrEmpty ()) {
 					var acwMap      = MonoAndroidHelper.LoadMapFile (BuildEngine4, Path.GetFullPath (AcwMapFile), StringComparer.OrdinalIgnoreCase);
 					var javaTypes   = new List<string> (acwMap.Values.Count);
 					foreach (var v in acwMap.Values) {
@@ -109,16 +107,10 @@ protected override string CreateResponseFile ()
 							appcfg.WriteLine ($"-keep class {java} {{ *; }}");
 						}
 					}
-				} else if (!ProguardGeneratedApplicationConfiguration.IsNullOrEmpty ()) {
-					File.WriteAllText (ProguardGeneratedApplicationConfiguration, "");
 				}
 				if (!ProguardCommonXamarinConfiguration.IsNullOrWhiteSpace ()) {
 					using (var xamcfg = File.CreateText (ProguardCommonXamarinConfiguration)) {
-						if (UseMinimalXamarinProguardConfiguration) {
-							WriteMinimalXamarinProguardConfiguration (xamcfg);
-						} else {
-							GetType ().Assembly.GetManifestResourceStream ("proguard_xamarin.cfg").CopyTo (xamcfg.BaseStream);
-						}
+						GetType ().Assembly.GetManifestResourceStream ("proguard_xamarin.cfg").CopyTo (xamcfg.BaseStream);
 						if (IgnoreWarnings) {
 							xamcfg.WriteLine ("-ignorewarnings");
 						}
@@ -167,28 +159,6 @@ protected override string CreateResponseFile ()
 			return responseFile;
 		}
 
-		static void WriteMinimalXamarinProguardConfiguration (TextWriter writer)
-		{
-			writer.WriteLine ("# Minimal Xamarin configuration for trimmable typemap builds.");
-			writer.WriteLine ("-dontobfuscate");
-			writer.WriteLine ();
-			writer.WriteLine ("-keep class android.support.multidex.MultiDexApplication { <init>(); }");
-			writer.WriteLine ("-keep class mono.MonoRuntimeProvider* { *; <init>(...); }");
-			writer.WriteLine ("-keep class mono.MonoPackageManager { *; <init>(...); }");
-			writer.WriteLine ("-keep class mono.MonoPackageManager_Resources { *; <init>(...); }");
-			writer.WriteLine ("-keep class net.dot.jni.** { *; <init>(); }");
-			writer.WriteLine ("-keep class net.dot.android.crypto.** { *; <init>(...); }");
-			writer.WriteLine ();
-			writer.WriteLine ("-keepclassmembers class * extends android.view.View {");
-			writer.WriteLine ("   *** set*(...);");
-			writer.WriteLine ("}");
-			writer.WriteLine ();
-			writer.WriteLine ("-keepclassmembers class * extends android.view.View {");
-			writer.WriteLine ("   <init>(android.content.Context,android.util.AttributeSet);");
-			writer.WriteLine ("   <init>(android.content.Context,android.util.AttributeSet,int);");
-			writer.WriteLine ("}");
-		}
-
 		// Note: We do not want to call the base.LogEventsFromTextOutput as it will incorrectly identify
 		// Warnings and Info messages as errors.
 		protected override void LogEventsFromTextOutput (string singleLine, MessageImportance messageImportance)
diff --git a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
index a196142b01a..0796e933155 100644
--- a/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
+++ b/src/Xamarin.Android.Build.Tasks/Xamarin.Android.D8.targets
@@ -30,8 +30,6 @@ Copyright (C) 2018 Xamarin. All rights reserved.
       <!--Flag indicating if r8 should have EnableShrinking-->
       <_R8EnableShrinking Condition=" '$(AndroidLinkTool)' == 'r8' ">True</_R8EnableShrinking>
       <_R8EnableShrinking Condition=" '$(_R8EnableShrinking)' == '' ">False</_R8EnableShrinking>
-      <_R8GenerateApplicationProguardConfigurationFromAcwMap Condition=" '$(_R8GenerateApplicationProguardConfigurationFromAcwMap)' == '' ">True</_R8GenerateApplicationProguardConfigurationFromAcwMap>
-      <_R8UseMinimalXamarinProguardConfiguration Condition=" '$(_R8UseMinimalXamarinProguardConfiguration)' == '' ">False</_R8UseMinimalXamarinProguardConfiguration>
     </PropertyGroup>
 
     <Error
@@ -74,8 +72,6 @@ Copyright (C) 2018 Xamarin. All rights reserved.
         ProguardCommonXamarinConfiguration="$(IntermediateOutputPath)proguard\proguard_xamarin.cfg"
         ProguardGeneratedReferenceConfiguration="$(_ProguardProjectConfiguration)"
         ProguardGeneratedApplicationConfiguration="$(IntermediateOutputPath)proguard\proguard_project_primary.cfg"
-        GenerateApplicationProguardConfigurationFromAcwMap="$(_R8GenerateApplicationProguardConfigurationFromAcwMap)"
-        UseMinimalXamarinProguardConfiguration="$(_R8UseMinimalXamarinProguardConfiguration)"
         ProguardMappingFileOutput="$(AndroidProguardMappingFile)"
         ProguardConfigurationFiles="@(_ProguardConfiguration)"
         EnableShrinking="$(_R8EnableShrinking)"

From 8ae3b330bbf574d5798e4356deb4ef37b51523f0 Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Wed, 20 May 2026 12:40:46 +0200
Subject: [PATCH 7/9] Fix post-trim trimmable typemap R8 inputs

Scan linked assemblies after ILLink to filter generated Java wrappers and acw-map inputs before R8, while packaging only linked typemap assemblies for single-RID builds.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../TrimmableTypeMapGenerator.cs              |  11 +-
 ...roid.Sdk.TypeMap.Trimmable.CoreCLR.targets |  45 +++++++-
 ...soft.Android.Sdk.TypeMap.Trimmable.targets |  22 +++-
 .../Tasks/GenerateTrimmableTypeMap.cs         |  51 ++++++++-
 .../TrimmableTypeMapBuildTests.cs             | 107 ++++++++++++++++++
 5 files changed, 220 insertions(+), 16 deletions(-)

diff --git a/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs b/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
index 652c4fb3a5b..95d0446b205 100644
--- a/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
+++ b/src/Microsoft.Android.Sdk.TrimmableTypeMap/TrimmableTypeMapGenerator.cs
@@ -34,7 +34,8 @@ public TrimmableTypeMapResult Execute (
 		ManifestConfig? manifestConfig = null,
 		XDocument? manifestTemplate = null,
 		string? packageNamingPolicy = null,
-		int maxArrayRank = 0)
+		int maxArrayRank = 0,
+		bool generateTypeMapAssemblies = true)
 	{
 		_ = assemblies ?? throw new ArgumentNullException (nameof (assemblies));
 		_ = systemRuntimeVersion ?? throw new ArgumentNullException (nameof (systemRuntimeVersion));
@@ -54,11 +55,9 @@ public TrimmableTypeMapResult Execute (
 		PropagateDeferredRegistrationToBaseClasses (allPeers);
 		PropagateCannotRegisterToDescendants (allPeers);
 
-		var generatedAssemblies = GenerateTypeMapAssemblies (
-			allPeers,
-			systemRuntimeVersion,
-			useSharedTypemapUniverse,
-			maxArrayRank);
+		var generatedAssemblies = generateTypeMapAssemblies
+			? GenerateTypeMapAssemblies (allPeers, systemRuntimeVersion, useSharedTypemapUniverse, maxArrayRank)
+			: [];
 		var jcwPeers = allPeers.Where (ShouldGenerateJcw).ToList ();
 		logger.LogGeneratingJcwFilesInfo (jcwPeers.Count, allPeers.Count);
 		var generatedJavaSources = GenerateJcwJavaSources (jcwPeers);
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
index 4d3b1470ee2..e3a43a9d87f 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.CoreCLR.targets
@@ -54,6 +54,46 @@
         OutputFile="$(_ProguardProjectConfiguration)" />
   </Target>
 
+  <Target Name="_GeneratePostTrimTrimmableTypeMapJavaSources"
+      Condition=" '$(_AndroidTypeMapImplementation)' == 'trimmable' and '$(PublishTrimmed)' == 'true' and Exists('$(IntermediateOutputPath)linked/Link.semaphore') "
+      AfterTargets="ILLink"
+      BeforeTargets="_GenerateJavaStubs;_CompileJava;_CompileToDalvik"
+      Inputs="$(IntermediateOutputPath)linked/Link.semaphore"
+      Outputs="$(_PostTrimTrimmableTypeMapJavaStamp)">
+    <ItemGroup>
+      <_PostTrimTrimmableTypeMapInputAssemblies Include="@(ResolvedFileToPublish)"
+          Condition=" '%(Extension)' == '.dll' " />
+    </ItemGroup>
+
+    <GenerateTrimmableTypeMap
+        ResolvedAssemblies="@(_PostTrimTrimmableTypeMapInputAssemblies)"
+        FrameworkAssemblyNames="@(ResolvedFrameworkAssemblies->'%(Filename)')"
+        OutputDirectory="$(_TypeMapOutputDirectory)"
+        JavaSourceOutputDirectory="$(_PostTrimTypeMapJavaOutputDirectory)"
+        JavaSourceInputDirectory="$(_TypeMapJavaOutputDirectory)"
+        TargetFrameworkVersion="$(TargetFrameworkVersion)"
+        PackageNamingPolicy="$(_TrimmableTypeMapPackageNamingPolicy)"
+        MaxArrayRank="$(_AndroidTrimmableTypeMapMaxArrayRank)"
+        GenerateTypeMapAssemblies="false"
+        CleanJavaSourceOutputDirectory="true"
+        AcwMapOutputFile="$(IntermediateOutputPath)acw-map.txt"
+        ApplicationRegistrationOutputFile="$(IntermediateOutputPath)android/src/net/dot/android/ApplicationRegistration.java">
+      <Output TaskParameter="GeneratedJavaFiles" ItemName="_PostTrimGeneratedJavaFiles" />
+    </GenerateTrimmableTypeMap>
+
+    <MakeDir Directories="$([System.IO.Path]::GetDirectoryName('$(_PostTrimTrimmableTypeMapJavaStamp)'))" />
+    <Touch Files="$(_PostTrimTrimmableTypeMapJavaStamp)" AlwaysCreate="true" />
+
+    <ItemGroup>
+      <FileWrites Include="@(_PostTrimGeneratedJavaFiles)" />
+      <FileWrites Include="$(IntermediateOutputPath)acw-map.txt" />
+      <FileWrites Include="$(IntermediateOutputPath)android/src/net/dot/android/ApplicationRegistration.java" />
+      <FileWrites Include="$(_PostTrimTrimmableTypeMapJavaStamp)" />
+      <_PostTrimTrimmableTypeMapInputAssemblies Remove="@(_PostTrimTrimmableTypeMapInputAssemblies)" />
+      <_PostTrimGeneratedJavaFiles Remove="@(_PostTrimGeneratedJavaFiles)" />
+    </ItemGroup>
+  </Target>
+
   <!-- Add TypeMap DLLs to assembly store with per-ABI metadata.
        TypeMap DLLs are ABI-agnostic (pure IL), so the same DLLs are added for every ABI.
        This target batches over @(_BuildTargetAbis) to add items per-ABI. -->
@@ -76,9 +116,10 @@
       </_TrimmableTypeMapAbi>
     </ItemGroup>
 
-    <!-- Try linked/ first (trimmed by ILLink in inner builds) -->
+    <!-- Try linked/ first (trimmed by ILLink).  Single-RID builds put linked output directly
+         under $(IntermediateOutputPath); plural-RID builds put it under the per-RID directory. -->
     <ItemGroup>
-      <_LinkedTypeMapDlls Include="$(IntermediateOutputPath)%(_TrimmableTypeMapAbi.RuntimeIdentifier)/linked/_*.TypeMap.dll;$(IntermediateOutputPath)%(_TrimmableTypeMapAbi.RuntimeIdentifier)/linked/_Microsoft.Android.TypeMap*.dll">
+      <_LinkedTypeMapDlls Include="$(IntermediateOutputPath)linked/_*.TypeMap.dll;$(IntermediateOutputPath)linked/_Microsoft.Android.TypeMap*.dll;$(IntermediateOutputPath)%(_TrimmableTypeMapAbi.RuntimeIdentifier)/linked/_*.TypeMap.dll;$(IntermediateOutputPath)%(_TrimmableTypeMapAbi.RuntimeIdentifier)/linked/_Microsoft.Android.TypeMap*.dll">
         <Abi>%(_TrimmableTypeMapAbi.Identity)</Abi>
         <RuntimeIdentifier>%(_TrimmableTypeMapAbi.RuntimeIdentifier)</RuntimeIdentifier>
         <DestinationSubPath>%(_TrimmableTypeMapAbi.Identity)/%(_LinkedTypeMapDlls.Filename)%(_LinkedTypeMapDlls.Extension)</DestinationSubPath>
diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
index 69da896b24f..1955c4c2580 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
@@ -24,6 +24,13 @@
     <_TypeMapOutputDirectory>$(_TypeMapBaseOutputDir)typemap/</_TypeMapOutputDirectory>
     <_TypeMapJavaOutputDirectory>$(_TypeMapBaseOutputDir)typemap/java</_TypeMapJavaOutputDirectory>
     <_TypeMapAssembliesListFile>$(_TypeMapOutputDirectory)typemap-assemblies.txt</_TypeMapAssembliesListFile>
+    <_PostTrimTypeMapJavaOutputDirectory>$(_TypeMapBaseOutputDir)typemap/linked-java</_PostTrimTypeMapJavaOutputDirectory>
+    <_TypeMapJavaStubsSourceDirectory Condition=" '$(_TypeMapJavaStubsSourceDirectory)' == '' and '$(_AndroidRuntime)' == 'CoreCLR' and '$(PublishTrimmed)' == 'true' ">$(_PostTrimTypeMapJavaOutputDirectory)</_TypeMapJavaStubsSourceDirectory>
+    <_TypeMapJavaStubsSourceDirectory Condition=" '$(_TypeMapJavaStubsSourceDirectory)' == '' ">$(_TypeMapJavaOutputDirectory)</_TypeMapJavaStubsSourceDirectory>
+    <_PostTrimTrimmableTypeMapJavaStamp>$(_TypeMapBaseOutputDir)stamp/_GeneratePostTrimTrimmableTypeMapJavaSources.stamp</_PostTrimTrimmableTypeMapJavaStamp>
+    <_TrimmableJavaSourceStamp Condition=" '$(_TrimmableJavaSourceStamp)' == '' and '$(_AndroidRuntime)' == 'CoreCLR' and '$(PublishTrimmed)' == 'true' ">$(_PostTrimTrimmableTypeMapJavaStamp)</_TrimmableJavaSourceStamp>
+    <_TrimmableJavaSourceStamp Condition=" '$(_TrimmableJavaSourceStamp)' == '' ">$(_TypeMapOutputDirectory)$(_TypeMapAssemblyName).dll</_TrimmableJavaSourceStamp>
+
     <!-- Max array rank for __ArrayMapRank{N} sentinel emission. Defaults to 3 for NativeAOT
          (PublishAot=true, dynamic code is unavailable, so array creation uses the typemap path);
          defaults to 0 otherwise, where dynamic code can use Array.CreateInstance directly. -->
@@ -207,16 +214,23 @@
   -->
   <Target Name="_GenerateJavaStubs"
       DependsOnTargets="_SetLatestTargetFrameworkVersion;_CleanIntermediateIfNeeded;_PrepareAssemblies;_GetGenerateJavaStubsInputs;_DefineBuildTargetAbis;_PrepareNativeAssemblySources"
-      Inputs="$(_TypeMapOutputDirectory)$(_TypeMapAssemblyName).dll;@(_EnvironmentFiles)"
+      Inputs="$(_TrimmableJavaSourceStamp);@(_EnvironmentFiles)"
       Outputs="$(_AndroidStampDirectory)_GenerateJavaStubs.stamp">
 
     <ItemGroup>
-      <_TypeMapJavaFiles Include="$(_TypeMapJavaOutputDirectory)/**/*.java" />
+      <_TypeMapJavaFiles Include="$(_TypeMapJavaStubsSourceDirectory)/**/*.java" />
+      <_TypeMapJavaDestinationFiles Include="@(_TypeMapJavaFiles->'$(IntermediateOutputPath)android/src/%(RecursiveDir)%(Filename)%(Extension)')" />
+      <_ExistingTypeMapJavaDestinationFiles Include="$(IntermediateOutputPath)android/src/mono/**/*.java;$(IntermediateOutputPath)android/src/android/runtime/**/*.java" />
+      <_StaleTypeMapJavaDestinationFiles Include="@(_ExistingTypeMapJavaDestinationFiles)" Exclude="@(_TypeMapJavaDestinationFiles)" />
     </ItemGroup>
-    <Copy SourceFiles="@(_TypeMapJavaFiles)" DestinationFolder="$(IntermediateOutputPath)android/src/%(RecursiveDir)" />
+    <Delete Files="@(_StaleTypeMapJavaDestinationFiles)" />
+    <Copy
+        SourceFiles="@(_TypeMapJavaFiles)"
+        DestinationFiles="@(_TypeMapJavaDestinationFiles)"
+        SkipUnchangedFiles="true" />
 
     <ItemGroup>
-      <FileWrites Include="@(_TypeMapJavaFiles->'$(IntermediateOutputPath)android/src/%(RecursiveDir)%(Filename)%(Extension)')" />
+      <FileWrites Include="@(_TypeMapJavaDestinationFiles)" />
     </ItemGroup>
 
     <!-- NativeAOT bootstrap Java sources depend on environment files, so include them as inputs -->
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
index 6184f36b467..2dd34547a16 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
@@ -57,6 +57,7 @@ public void LogJniAddNativeMethodRegistrationAttributeError (string managedTypeN
 	public string OutputDirectory { get; set; } = "";
 	[Required]
 	public string JavaSourceOutputDirectory { get; set; } = "";
+	public string? JavaSourceInputDirectory { get; set; }
 	[Required]
 	public string TargetFrameworkVersion { get; set; } = "";
 
@@ -92,6 +93,8 @@ public void LogJniAddNativeMethodRegistrationAttributeError (string managedTypeN
 	public string? ManifestPlaceholders { get; set; }
 	public string? CheckedBuild { get; set; }
 	public string? ApplicationJavaClass { get; set; }
+	public bool GenerateTypeMapAssemblies { get; set; } = true;
+	public bool CleanJavaSourceOutputDirectory { get; set; }
 
 	[Output]
 	public ITaskItem [] GeneratedAssemblies { get; set; } = [];
@@ -117,7 +120,19 @@ public override bool RunTask ()
 			frameworkAssemblyNames.Add (assemblyName);
 		}
 
+		if (CleanJavaSourceOutputDirectory && !JavaSourceInputDirectory.IsNullOrEmpty ()) {
+			var inputDirectory = Path.GetFullPath (JavaSourceInputDirectory);
+			var outputDirectory = Path.GetFullPath (JavaSourceOutputDirectory);
+			if (string.Equals (inputDirectory, outputDirectory, StringComparison.OrdinalIgnoreCase)) {
+				Log.LogError ($"{nameof (JavaSourceInputDirectory)} and {nameof (JavaSourceOutputDirectory)} must be different when {nameof (CleanJavaSourceOutputDirectory)} is true.");
+				return false;
+			}
+		}
+
 		Directory.CreateDirectory (OutputDirectory);
+		if (CleanJavaSourceOutputDirectory && Directory.Exists (JavaSourceOutputDirectory)) {
+			Directory.Delete (JavaSourceOutputDirectory, recursive: true);
+		}
 		Directory.CreateDirectory (JavaSourceOutputDirectory);
 
 		var peReaders = new List<PEReader> ();
@@ -168,11 +183,16 @@ public override bool RunTask ()
 				manifestConfig: manifestConfig,
 				manifestTemplate: manifestTemplate,
 				packageNamingPolicy: PackageNamingPolicy,
-				maxArrayRank: MaxArrayRank);
+				maxArrayRank: MaxArrayRank,
+				generateTypeMapAssemblies: GenerateTypeMapAssemblies);
 
-			GeneratedAssemblies = WriteAssembliesToDisk (result.GeneratedAssemblies, assemblyInputs.Select (i => i.Path).ToList ());
-			WriteGeneratedAssembliesListFile (GeneratedAssemblies);
-			GeneratedJavaFiles = WriteJavaSourcesToDisk (result.GeneratedJavaSources);
+			if (GenerateTypeMapAssemblies) {
+				GeneratedAssemblies = WriteAssembliesToDisk (result.GeneratedAssemblies, assemblyInputs.Select (i => i.Path).ToList ());
+				WriteGeneratedAssembliesListFile (GeneratedAssemblies);
+			}
+			GeneratedJavaFiles = JavaSourceInputDirectory.IsNullOrEmpty ()
+				? WriteJavaSourcesToDisk (result.GeneratedJavaSources)
+				: CopyJavaSourcesFromInputDirectory (result.GeneratedJavaSources);
 
 			// Write manifest to disk if generated
 			if (result.Manifest is not null && !MergedAndroidManifestOutput.IsNullOrEmpty ()) {
@@ -247,6 +267,29 @@ void WriteGeneratedAssembliesListFile (IReadOnlyList<ITaskItem> assemblies)
 		Files.CopyIfStringChanged (text, GeneratedAssembliesListFile);
 	}
 
+	ITaskItem [] CopyJavaSourcesFromInputDirectory (IReadOnlyList<GeneratedJavaSource> javaSources)
+	{
+		var items = new List<ITaskItem> ();
+		foreach (var source in javaSources) {
+			string inputPath = Path.Combine (JavaSourceInputDirectory ?? "", source.RelativePath);
+			if (!File.Exists (inputPath)) {
+				Log.LogError ($"Generated Java source '{inputPath}' was not found.");
+				continue;
+			}
+
+			string outputPath = Path.Combine (JavaSourceOutputDirectory, source.RelativePath);
+			string? dir = Path.GetDirectoryName (outputPath);
+			if (!string.IsNullOrEmpty (dir)) {
+				Directory.CreateDirectory (dir);
+			}
+			using (var stream = File.OpenRead (inputPath)) {
+				Files.CopyIfStreamChanged (stream, outputPath);
+			}
+			items.Add (new TaskItem (outputPath));
+		}
+		return items.ToArray ();
+	}
+
 	ITaskItem [] WriteAssembliesToDisk (IReadOnlyList<GeneratedAssembly> assemblies, IReadOnlyList<string> assemblyPaths)
 	{
 		// Build a map from assembly name -> source path for timestamp comparison
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
index 4e99e9932be..0ec9a91085d 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
@@ -205,6 +205,55 @@ public void CoreClrTrimmableTypeMap_PackagesJavaProxyThrowable ()
 				$"`{dexFile}` should include `android.runtime.JavaProxyThrowable`.");
 		}
 
+		[Test]
+		public void ReleaseCoreClrTrimmableTypeMap_SingleRuntimeIdentifier_DoesNotPackageUnlinkedTypeMapAssemblies ()
+		{
+			if (IgnoreUnsupportedConfiguration (AndroidRuntime.CoreCLR, release: true)) {
+				return;
+			}
+
+			var proj = new XamarinAndroidApplicationProject {
+				IsRelease = true,
+				PackageName = "com.xamarin.typemapcomparison",
+				ProjectName = "TypemapComparison",
+			};
+			proj.SetRuntime (AndroidRuntime.CoreCLR);
+			proj.SetProperty (KnownProperties.RuntimeIdentifier, "android-arm64");
+			proj.SetProperty ("AndroidPackageFormat", "apk");
+			proj.SetProperty (KnownProperties.AndroidLinkTool, "r8");
+			proj.SetProperty ("TrimMode", "full");
+			proj.SetProperty ("_AndroidTypeMapImplementation", "trimmable");
+
+			using var builder = CreateApkBuilder (Path.Combine ("temp", $"TypemapComparison_trimmable_single_rid_{Guid.NewGuid ():N}"));
+			Assert.IsTrue (builder.Build (proj), "trimmable single-RID build should have succeeded.");
+
+			var apkDirectory = Path.Combine (Root, builder.ProjectDirectory, proj.OutputPath);
+			var apkPath = Directory.GetFiles (apkDirectory, "*-Signed.apk", SearchOption.AllDirectories).Single ();
+			var typeMapDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "typemap"));
+			var linkedAssemblyDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "linked"));
+			var javaSourceDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "android", "src"));
+			var acwMapPath = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "acw-map.txt"));
+			var proguardPrimaryPath = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "proguard", "proguard_project_primary.cfg"));
+
+			DirectoryAssert.Exists (typeMapDirectory, "trimmable build should generate typemap assemblies.");
+			DirectoryAssert.Exists (linkedAssemblyDirectory, "Release trimmable build should run ILLink.");
+
+			var unlinkedTypeMapAssemblies = Directory.GetFiles (typeMapDirectory, "*.dll")
+				.Where (file => !File.Exists (Path.Combine (linkedAssemblyDirectory, Path.GetFileName (file))))
+				.Select (Path.GetFileName)
+				.OrderBy (name => name, StringComparer.Ordinal)
+				.ToArray ();
+			Assert.IsNotEmpty (unlinkedTypeMapAssemblies, "Test setup should include typemap assemblies that ILLink removed.");
+
+			var packagedAssemblyNames = ReadPackagedManagedAssemblyNames (apkPath, AndroidTargetArch.Arm64);
+			var packagedUnlinkedTypeMapAssemblies = packagedAssemblyNames.Intersect (unlinkedTypeMapAssemblies, StringComparer.Ordinal).OrderBy (name => name, StringComparer.Ordinal).ToArray ();
+			Assert.IsEmpty (
+				packagedUnlinkedTypeMapAssemblies,
+				$"{apkPath} should package linked typemap assemblies, not untrimmed typemap assemblies removed by ILLink.");
+
+			AssertPostTrimR8InputsExcludeDeadFrameworkImplementor (apkPath, javaSourceDirectory, acwMapPath, proguardPrimaryPath);
+		}
+
 		[Test]
 		public void ReleaseCoreClrTrimmableTypeMap_DoesNotKeepMoreTypemapPeersThanLlvmIr ()
 		{
@@ -461,6 +510,64 @@ ApkComparisonProfile BuildTypemapComparisonApk (string typemapImplementation)
 			return profile;
 		}
 
+		ISet<string> ReadPackagedManagedAssemblyNames (string apkPath, AndroidTargetArch targetArch)
+		{
+			(var explorers, var errorMessage) = AssemblyStoreExplorer.Open (apkPath);
+			Assert.IsNull (errorMessage, $"{apkPath} should contain readable assembly stores.");
+			Assert.IsNotNull (explorers, $"{apkPath} should contain assembly stores.");
+
+			var explorer = explorers.FirstOrDefault (e => e.TargetArch == targetArch);
+			Assert.IsNotNull (explorer, $"{apkPath} should contain an {targetArch} assembly store.");
+
+			return explorer.Assemblies
+				.Where (a => !a.Ignore && a.Name.EndsWith (".dll", StringComparison.OrdinalIgnoreCase) && !a.Name.EndsWith (".ni.dll", StringComparison.OrdinalIgnoreCase))
+				.Select (a => a.Name)
+				.ToHashSet (StringComparer.Ordinal);
+		}
+
+		void AssertPostTrimR8InputsExcludeDeadFrameworkImplementor (string apkPath, string javaSourceDirectory, string acwMapPath, string proguardPrimaryPath)
+		{
+			const string deadManagedType = "Android.Speech.IRecognitionListenerImplementor";
+			const string deadJavaName = "mono/android/speech/RecognitionListenerImplementor";
+			const string deadJavaDotName = "mono.android.speech.RecognitionListenerImplementor";
+
+			Assert.IsTrue (
+				Directory.EnumerateFiles (javaSourceDirectory, "MainActivity.java", SearchOption.AllDirectories).Any (),
+				"Post-trim Java source generation should keep the app activity JCW.");
+			FileAssert.DoesNotExist (
+				Path.Combine (javaSourceDirectory, "mono", "android", "speech", "RecognitionListenerImplementor.java"),
+				"Post-trim Java source generation should not copy framework listener implementors removed by ILLink.");
+
+			FileAssert.Exists (acwMapPath, "Post-trim scan should rewrite acw-map.txt for R8.");
+			var acwMap = File.ReadAllText (acwMapPath);
+			Assert.IsFalse (acwMap.Contains (deadManagedType, StringComparison.Ordinal), $"{acwMapPath} should be based on linked assemblies.");
+			Assert.IsFalse (acwMap.Contains (deadJavaDotName, StringComparison.Ordinal), $"{acwMapPath} should not keep removed framework listener implementors.");
+
+			FileAssert.Exists (proguardPrimaryPath, "R8 should generate a primary proguard configuration from the post-trim acw-map.");
+			Assert.IsFalse (
+				File.ReadAllText (proguardPrimaryPath).Contains (deadJavaDotName, StringComparison.Ordinal),
+				$"{proguardPrimaryPath} should not keep removed framework listener implementors.");
+
+			Assert.IsFalse (
+				ReadDexClassNames (apkPath).Contains (deadJavaName),
+				$"{apkPath} should not contain the removed framework listener implementor in classes.dex.");
+		}
+
+		ISet<string> ReadDexClassNames (string apkPath)
+		{
+			var classNames = new HashSet<string> (StringComparer.Ordinal);
+			using var zip = ZipFile.OpenRead (apkPath);
+			foreach (var entry in zip.Entries.Where (e => Regex.IsMatch (e.FullName, @"^classes(\d*)\.dex$", RegexOptions.CultureInvariant))) {
+				using var stream = entry.Open ();
+				using var memory = new MemoryStream ();
+				stream.CopyTo (memory);
+				foreach (var javaClass in DexProfileReader.Read (memory.ToArray ()).Classes) {
+					classNames.Add (javaClass.Name);
+				}
+			}
+			return classNames;
+		}
+
 		ApkComparisonProfile ReadApkProfile (string name, string apkPath, string acwMapPath, string javaSourceDirectory, string typeMapDirectory, string linkedAssemblyDirectory)
 		{
 			var profile = new ApkComparisonProfile {

From 9d74d353709624e92cc628e4cbfd7ed11478572e Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Wed, 20 May 2026 17:26:07 +0200
Subject: [PATCH 8/9] Support DynamicCodeSupport=false with trimmable typemaps

Emit array typemap sentinels when dynamic code support is explicitly disabled so CoreCLR trimmable typemap builds can use the no-dynamic-code array path. Keep DynamicCodeSupport enabled by default and cover the explicit opt-out path in tests.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ...soft.Android.Sdk.TypeMap.Trimmable.targets |  6 +-
 .../TrimmableTypeMapBuildTests.cs             | 87 ++++++++++++++++++-
 2 files changed, 86 insertions(+), 7 deletions(-)

diff --git a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
index 1955c4c2580..bae58e324e5 100644
--- a/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
+++ b/src/Xamarin.Android.Build.Tasks/Microsoft.Android.Sdk/targets/Microsoft.Android.Sdk.TypeMap.Trimmable.targets
@@ -31,10 +31,10 @@
     <_TrimmableJavaSourceStamp Condition=" '$(_TrimmableJavaSourceStamp)' == '' and '$(_AndroidRuntime)' == 'CoreCLR' and '$(PublishTrimmed)' == 'true' ">$(_PostTrimTrimmableTypeMapJavaStamp)</_TrimmableJavaSourceStamp>
     <_TrimmableJavaSourceStamp Condition=" '$(_TrimmableJavaSourceStamp)' == '' ">$(_TypeMapOutputDirectory)$(_TypeMapAssemblyName).dll</_TrimmableJavaSourceStamp>
 
-    <!-- Max array rank for __ArrayMapRank{N} sentinel emission. Defaults to 3 for NativeAOT
-         (PublishAot=true, dynamic code is unavailable, so array creation uses the typemap path);
+    <!-- Max array rank for __ArrayMapRank{N} sentinel emission. Defaults to 3 when
+         dynamic code is unavailable, so array creation uses the typemap path;
          defaults to 0 otherwise, where dynamic code can use Array.CreateInstance directly. -->
-    <_AndroidTrimmableTypeMapMaxArrayRank Condition=" '$(_AndroidTrimmableTypeMapMaxArrayRank)' == '' and '$(PublishAot)' == 'true' ">3</_AndroidTrimmableTypeMapMaxArrayRank>
+    <_AndroidTrimmableTypeMapMaxArrayRank Condition=" '$(_AndroidTrimmableTypeMapMaxArrayRank)' == '' and ('$(PublishAot)' == 'true' or '$(DynamicCodeSupport)' == 'false') ">3</_AndroidTrimmableTypeMapMaxArrayRank>
     <_AndroidTrimmableTypeMapMaxArrayRank Condition=" '$(_AndroidTrimmableTypeMapMaxArrayRank)' == '' ">0</_AndroidTrimmableTypeMapMaxArrayRank>
   </PropertyGroup>
 
diff --git a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
index 0ec9a91085d..87b560096b6 100644
--- a/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tests/Xamarin.Android.Build.Tests/TrimmableTypeMapBuildTests.cs
@@ -205,6 +205,24 @@ public void CoreClrTrimmableTypeMap_PackagesJavaProxyThrowable ()
 				$"`{dexFile}` should include `android.runtime.JavaProxyThrowable`.");
 		}
 
+		[Test]
+		public void ReleaseCoreClrTrimmableTypeMap_SupportsExplicitDynamicCodeSupportOff ()
+		{
+			if (IgnoreUnsupportedConfiguration (AndroidRuntime.CoreCLR, release: true)) {
+				return;
+			}
+
+			var dynamicCodeDisabledTrimmable = BuildDynamicCodeSupportProfile ("trimmable", dynamicCodeSupport: false);
+
+			const string dynamicCodeSupportFalse = "\"System.Runtime.CompilerServices.RuntimeFeature.IsDynamicCodeSupported\": false";
+			Assert.IsTrue (
+				dynamicCodeDisabledTrimmable.RuntimeConfig.Contains (dynamicCodeSupportFalse, StringComparison.Ordinal),
+				"trimmable typemap builds should honor explicit DynamicCodeSupport=false.");
+			Assert.IsTrue (
+				dynamicCodeDisabledTrimmable.LinkedTypeMapAssembliesContainArrayRankSentinels,
+				"trimmable typemap builds should emit array typemap sentinels when dynamic code is disabled.");
+		}
+
 		[Test]
 		public void ReleaseCoreClrTrimmableTypeMap_SingleRuntimeIdentifier_DoesNotPackageUnlinkedTypeMapAssemblies ()
 		{
@@ -238,17 +256,17 @@ public void ReleaseCoreClrTrimmableTypeMap_SingleRuntimeIdentifier_DoesNotPackag
 			DirectoryAssert.Exists (typeMapDirectory, "trimmable build should generate typemap assemblies.");
 			DirectoryAssert.Exists (linkedAssemblyDirectory, "Release trimmable build should run ILLink.");
 
-			var unlinkedTypeMapAssemblies = Directory.GetFiles (typeMapDirectory, "*.dll")
+			var removedTypeMapAssemblies = Directory.GetFiles (typeMapDirectory, "*.dll")
+				.Where (IsTypeMapAssemblyPath)
 				.Where (file => !File.Exists (Path.Combine (linkedAssemblyDirectory, Path.GetFileName (file))))
 				.Select (Path.GetFileName)
 				.OrderBy (name => name, StringComparer.Ordinal)
 				.ToArray ();
-			Assert.IsNotEmpty (unlinkedTypeMapAssemblies, "Test setup should include typemap assemblies that ILLink removed.");
 
 			var packagedAssemblyNames = ReadPackagedManagedAssemblyNames (apkPath, AndroidTargetArch.Arm64);
-			var packagedUnlinkedTypeMapAssemblies = packagedAssemblyNames.Intersect (unlinkedTypeMapAssemblies, StringComparer.Ordinal).OrderBy (name => name, StringComparer.Ordinal).ToArray ();
+			var packagedRemovedTypeMapAssemblies = packagedAssemblyNames.Intersect (removedTypeMapAssemblies, StringComparer.Ordinal).OrderBy (name => name, StringComparer.Ordinal).ToArray ();
 			Assert.IsEmpty (
-				packagedUnlinkedTypeMapAssemblies,
+				packagedRemovedTypeMapAssemblies,
 				$"{apkPath} should package linked typemap assemblies, not untrimmed typemap assemblies removed by ILLink.");
 
 			AssertPostTrimR8InputsExcludeDeadFrameworkImplementor (apkPath, javaSourceDirectory, acwMapPath, proguardPrimaryPath);
@@ -510,6 +528,61 @@ ApkComparisonProfile BuildTypemapComparisonApk (string typemapImplementation)
 			return profile;
 		}
 
+		DynamicCodeSupportProfile BuildDynamicCodeSupportProfile (string typemapImplementation, bool? dynamicCodeSupport)
+		{
+			var dynamicCodeSuffix = dynamicCodeSupport.HasValue ? $"_{dynamicCodeSupport.Value.ToString ().ToLowerInvariant ()}" : "";
+			var projectName = $"DynamicCodeSupport_{typemapImplementation.Replace ("-", "_")}{dynamicCodeSuffix}";
+			var proj = new XamarinAndroidApplicationProject {
+				IsRelease = true,
+				PackageName = "com.xamarin.dynamiccodesupport",
+				ProjectName = projectName,
+			};
+			proj.SetRuntime (AndroidRuntime.CoreCLR);
+			proj.SetProperty (KnownProperties.RuntimeIdentifier, "android-arm64");
+			proj.SetProperty ("AndroidPackageFormat", "apk");
+			proj.SetProperty (KnownProperties.AndroidLinkTool, "r8");
+			proj.SetProperty ("TrimMode", "full");
+			proj.SetProperty ("PublishReadyToRun", "false");
+			proj.SetProperty ("_AndroidTypeMapImplementation", typemapImplementation);
+			if (dynamicCodeSupport.HasValue) {
+				proj.SetProperty ("DynamicCodeSupport", dynamicCodeSupport.Value.ToString ().ToLowerInvariant ());
+			}
+
+			using var builder = CreateApkBuilder (Path.Combine ("temp", $"{projectName}_{Guid.NewGuid ():N}"));
+			Assert.IsTrue (builder.Build (proj), $"{typemapImplementation} build should have succeeded.");
+
+			var runtimeConfigPath = FindOutputFile (builder, proj, $"{proj.ProjectName}.runtimeconfig.json");
+			var linkedAssemblyDirectory = builder.Output.GetIntermediaryPath (Path.Combine ("android-arm64", "linked"));
+			return new DynamicCodeSupportProfile {
+				RuntimeConfig = File.ReadAllText (runtimeConfigPath),
+				LinkedTypeMapAssembliesContainArrayRankSentinels = TypeMapAssembliesContainType (linkedAssemblyDirectory, "__ArrayMapRank1"),
+			};
+		}
+
+		string FindOutputFile (ProjectBuilder builder, XamarinAndroidApplicationProject proj, string fileName)
+		{
+			var outputDirectory = Path.Combine (Root, builder.ProjectDirectory, proj.OutputPath);
+			var files = Directory.GetFiles (outputDirectory, fileName, SearchOption.AllDirectories);
+			Assert.AreEqual (1, files.Length, $"{outputDirectory} should contain one {fileName}.");
+			return files [0];
+		}
+
+		bool TypeMapAssembliesContainType (string directory, string typeName)
+		{
+			if (!Directory.Exists (directory)) {
+				return false;
+			}
+
+			foreach (var file in Directory.EnumerateFiles (directory, "*.dll", SearchOption.TopDirectoryOnly).Where (IsTypeMapAssemblyPath)) {
+				using var assembly = AssemblyDefinition.ReadAssembly (file);
+				if (assembly.Modules.SelectMany (m => m.Types).Any (type => type.Name == typeName)) {
+					return true;
+				}
+			}
+
+			return false;
+		}
+
 		ISet<string> ReadPackagedManagedAssemblyNames (string apkPath, AndroidTargetArch targetArch)
 		{
 			(var explorers, var errorMessage) = AssemblyStoreExplorer.Open (apkPath);
@@ -1058,6 +1131,12 @@ class ApkComparisonProfile
 			public readonly List<TypeMapAssemblyMetrics> TypeMapAssemblies = new List<TypeMapAssemblyMetrics> ();
 		}
 
+		class DynamicCodeSupportProfile
+		{
+			public string RuntimeConfig;
+			public bool LinkedTypeMapAssembliesContainArrayRankSentinels;
+		}
+
 		class TypeMapAssemblyMetrics
 		{
 			public string Stage;

From 6daf3c7f9bcfb4a0caaa6e35b3dfac28abdd6e57 Mon Sep 17 00:00:00 2001
From: Simon Rozsival <simon@rozsival.com>
Date: Wed, 20 May 2026 18:04:49 +0200
Subject: [PATCH 9/9] Use coded errors for trimmable typemap task

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 Documentation/docs-mobile/messages/index.md   |  2 ++
 Documentation/docs-mobile/messages/xa4253.md  |  2 +-
 Documentation/docs-mobile/messages/xa4254.md  | 25 +++++++++++++++++
 Documentation/docs-mobile/messages/xa4255.md  | 27 +++++++++++++++++++
 .../Properties/Resources.Designer.cs          | 18 +++++++++++++
 .../Properties/Resources.resx                 | 11 ++++++++
 .../Tasks/GenerateTrimmableTypeMap.cs         |  4 +--
 7 files changed, 86 insertions(+), 3 deletions(-)
 create mode 100644 Documentation/docs-mobile/messages/xa4254.md
 create mode 100644 Documentation/docs-mobile/messages/xa4255.md

diff --git a/Documentation/docs-mobile/messages/index.md b/Documentation/docs-mobile/messages/index.md
index eba78e5367c..cb6423a2a25 100644
--- a/Documentation/docs-mobile/messages/index.md
+++ b/Documentation/docs-mobile/messages/index.md
@@ -214,6 +214,8 @@ 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}
diff --git a/Documentation/docs-mobile/messages/xa4253.md b/Documentation/docs-mobile/messages/xa4253.md
index 74632be962c..8c27b5fb802 100644
--- a/Documentation/docs-mobile/messages/xa4253.md
+++ b/Documentation/docs-mobile/messages/xa4253.md
@@ -10,7 +10,7 @@ f1_keywords:
 
 ## Example messages
 
-```
+```text
 error XA4253: Generated Java callable wrapper code changed: 'obj/Release/android/src/mono/MonoRuntimeProvider.java'
 ```
 
diff --git a/Documentation/docs-mobile/messages/xa4254.md b/Documentation/docs-mobile/messages/xa4254.md
new file mode 100644
index 00000000000..6997cf235b1
--- /dev/null
+++ b/Documentation/docs-mobile/messages/xa4254.md
@@ -0,0 +1,25 @@
+---
+title: .NET for Android error XA4254
+description: XA4254 error code
+ms.date: 05/20/2026
+f1_keywords:
+  - "XA4254"
+---
+
+# .NET for Android error XA4254
+
+## Example message
+
+```text
+error XA4254: Trimmable type map Java source input directory 'obj/Release/net11.0-android/typemap/java' and output directory 'obj/Release/net11.0-android/typemap/java' must be different.
+```
+
+## Issue
+
+The trimmable type map build tried to clean the Java source output directory, but the configured input and output directories resolved to the same path.
+
+Cleaning the output directory in this configuration would delete the input Java sources before they can be copied.
+
+## Solution
+
+This error indicates an internal build configuration problem. File an issue at <https://github.com/dotnet/android/issues> and include the full build log.
diff --git a/Documentation/docs-mobile/messages/xa4255.md b/Documentation/docs-mobile/messages/xa4255.md
new file mode 100644
index 00000000000..633df761ecb
--- /dev/null
+++ b/Documentation/docs-mobile/messages/xa4255.md
@@ -0,0 +1,27 @@
+---
+title: .NET for Android error XA4255
+description: XA4255 error code
+ms.date: 05/20/2026
+f1_keywords:
+  - "XA4255"
+---
+
+# .NET for Android error XA4255
+
+## Example message
+
+```text
+error XA4255: Generated trimmable type map Java source 'obj/Release/net11.0-android/typemap/java/my/app/MainActivity.java' was not found.
+```
+
+## Issue
+
+The post-trim trimmable type map scan expected to copy a generated Java source file from the pre-trim Java source directory, but the file was missing.
+
+This can happen if intermediate build outputs are stale or if the generated Java source list no longer matches the files on disk.
+
+## Solution
+
+Delete the project's `obj` and `bin` directories, then rebuild.
+
+If the error persists after a clean rebuild, file an issue at <https://github.com/dotnet/android/issues> and include the full build log.
diff --git a/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs b/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs
index 7d2fe163ff9..6cfdd56fa24 100644
--- a/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs
+++ b/src/Xamarin.Android.Build.Tasks/Properties/Resources.Designer.cs
@@ -1506,6 +1506,24 @@ public static string XA4251 {
             }
         }
 
+        /// <summary>
+        ///   Looks up a localized string similar to Trimmable type map Java source input directory &apos;{0}&apos; and output directory &apos;{1}&apos; must be different..
+        /// </summary>
+        public static string XA4254 {
+            get {
+                return ResourceManager.GetString("XA4254", resourceCulture);
+            }
+        }
+
+        /// <summary>
+        ///   Looks up a localized string similar to Generated trimmable type map Java source &apos;{0}&apos; was not found..
+        /// </summary>
+        public static string XA4255 {
+            get {
+                return ResourceManager.GetString("XA4255", resourceCulture);
+            }
+        }
+
         /// <summary>
         ///   Looks up a localized string similar to Native library &apos;{0}&apos; will not be bundled because it has an unsupported ABI. Move this file to a directory with a valid Android ABI name such as &apos;libs/armeabi-v7a/&apos;..
         /// </summary>
diff --git a/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx b/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx
index 25fb32571a5..bc949a02578 100644
--- a/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx
+++ b/src/Xamarin.Android.Build.Tasks/Properties/Resources.resx
@@ -1103,6 +1103,17 @@ To use a custom JDK path for a command line build, set the 'JavaSdkDirectory' MS
     <value>Generated Java callable wrapper code changed: '{0}'</value>
     <comment>{0} - The path to the generated Java callable wrapper file</comment>
   </data>
+  <data name="XA4254" xml:space="preserve">
+    <value>Trimmable type map Java source input directory '{0}' and output directory '{1}' must be different.</value>
+    <comment>The following are literal names and should not be translated: Trimmable type map, Java.
+{0} - Full path to the Java source input directory
+{1} - Full path to the Java source output directory</comment>
+  </data>
+  <data name="XA4255" xml:space="preserve">
+    <value>Generated trimmable type map Java source '{0}' was not found.</value>
+    <comment>The following are literal names and should not be translated: trimmable type map, Java.
+{0} - Full path to the generated Java source file</comment>
+  </data>
   <data name="XA0142" xml:space="preserve">
     <value>Command '{0}' failed.\n{1}</value>
     <comment>'{0}' is a failed command name (potentially with path) followed by all the arguments passed to it. {1} is the combined output on the standard error and standard output streams.</comment>
diff --git a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
index 2dd34547a16..2b3d67477f2 100644
--- a/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
+++ b/src/Xamarin.Android.Build.Tasks/Tasks/GenerateTrimmableTypeMap.cs
@@ -124,7 +124,7 @@ public override bool RunTask ()
 			var inputDirectory = Path.GetFullPath (JavaSourceInputDirectory);
 			var outputDirectory = Path.GetFullPath (JavaSourceOutputDirectory);
 			if (string.Equals (inputDirectory, outputDirectory, StringComparison.OrdinalIgnoreCase)) {
-				Log.LogError ($"{nameof (JavaSourceInputDirectory)} and {nameof (JavaSourceOutputDirectory)} must be different when {nameof (CleanJavaSourceOutputDirectory)} is true.");
+				Log.LogCodedError ("XA4254", Properties.Resources.XA4254, inputDirectory, outputDirectory);
 				return false;
 			}
 		}
@@ -273,7 +273,7 @@ ITaskItem [] CopyJavaSourcesFromInputDirectory (IReadOnlyList<GeneratedJavaSourc
 		foreach (var source in javaSources) {
 			string inputPath = Path.Combine (JavaSourceInputDirectory ?? "", source.RelativePath);
 			if (!File.Exists (inputPath)) {
-				Log.LogError ($"Generated Java source '{inputPath}' was not found.");
+				Log.LogCodedError ("XA4255", Properties.Resources.XA4255, inputPath);
 				continue;
 			}