[TrimmableTypeMap] Root manifest-referenced types as unconditional

Parse the user's AndroidManifest.xml template for activity, service, receiver,
and provider elements with android:name attributes. Mark matching scanned
Java peer types as IsUnconditional = true so the ILLink TypeMap step preserves
them even if no managed code references them directly.

Changes:
- JavaPeerInfo.IsUnconditional: init → set (must be mutated after scanning)
- TrimmableTypeMapGenerator: add warn callback, RootManifestReferencedTypes()
  called between scanning and typemap generation
- GenerateTrimmableTypeMap task: pass Log.LogWarning as warn callback
- 4 new xUnit tests covering rooting, unresolved warnings, already-unconditional
  skip, and empty manifest

Replaces #11016 (closed — depended on old PR shape with TaskLoggingHelper).

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

Author: simonrozsival

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

@@ -69,8 +69,10 @@ public sealed record JavaPeerInfo
 	/// Types with component attributes ([Activity], [Service], etc.),
 	/// custom views from layout XML, or manifest-declared components
 	/// are unconditionally preserved (not trimmable).
+	/// May be set after scanning when the manifest references a type
+	/// that the scanner did not mark as unconditional.
 	/// </summary>
-	public bool IsUnconditional { get; init; }
+	public bool IsUnconditional { get; set; }
 
 	/// <summary>
 	/// True for Application and Instrumentation types. These types cannot call

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

@@ -3,16 +3,19 @@
 using System.IO;
 using System.Linq;
 using System.Reflection.PortableExecutable;
+using System.Xml.Linq;
 
 namespace Microsoft.Android.Sdk.TrimmableTypeMap;
 
 public class TrimmableTypeMapGenerator
 {
 	readonly Action<string> log;
+	readonly Action<string>? warn;
 
-	public TrimmableTypeMapGenerator (Action<string> log)
+	public TrimmableTypeMapGenerator (Action<string> log, Action<string>? warn = null)
 	{
 		this.log = log ?? throw new ArgumentNullException (nameof (log));
+		this.warn = warn;
 	}
 
 	/// <summary>
@@ -38,6 +41,8 @@ public TrimmableTypeMapResult Execute (
 			return new TrimmableTypeMapResult ([], [], allPeers);
 		}
 
+		RootManifestReferencedTypes (allPeers, manifestTemplatePath);
+
 		var generatedAssemblies = GenerateTypeMapAssemblies (allPeers, systemRuntimeVersion);
 		var jcwPeers = allPeers.Where (p =>
 			!frameworkAssemblyNames.Contains (p.AssemblyName)
@@ -144,4 +149,74 @@ List<GeneratedJavaSource> GenerateJcwJavaSources (List<JavaPeerInfo> allPeers)
 		log ($"Generated {sources.Count} JCW Java source files.");
 		return sources.ToList ();
 	}
+
+	void RootManifestReferencedTypes (List<JavaPeerInfo> allPeers, string? manifestTemplatePath)
+	{
+		if (manifestTemplatePath.IsNullOrEmpty () || !File.Exists (manifestTemplatePath)) {
+			return;
+		}
+
+		XDocument doc;
+		try {
+			doc = XDocument.Load (manifestTemplatePath);
+		} catch (Exception ex) {
+			warn?.Invoke ($"Failed to parse ManifestTemplate '{manifestTemplatePath}': {ex.Message}");
+			return;
+		}
+
+		RootManifestReferencedTypes (allPeers, doc);
+	}
+
+	internal void RootManifestReferencedTypes (List<JavaPeerInfo> allPeers, XDocument doc)
+	{
+		var root = doc.Root;
+		if (root is null) {
+			return;
+		}
+
+		XNamespace androidNs = "http://schemas.android.com/apk/res/android";
+		XName attName = androidNs + "name";
+
+		var componentNames = new HashSet<string> (StringComparer.Ordinal);
+		foreach (var element in root.Descendants ()) {
+			switch (element.Name.LocalName) {
+			case "activity":
+			case "service":
+			case "receiver":
+			case "provider":
+				var name = (string?) element.Attribute (attName);
+				if (name is not null) {
+					componentNames.Add (name);
+				}
+				break;
+			}
+		}
+
+		if (componentNames.Count == 0) {
+			return;
+		}
+
+		var peersByDotName = new Dictionary<string, List<JavaPeerInfo>> (StringComparer.Ordinal);
+		foreach (var peer in allPeers) {
+			var dotName = peer.JavaName.Replace ('/', '.').Replace ('$', '.');
+			if (!peersByDotName.TryGetValue (dotName, out var list)) {
+				list = [];
+				peersByDotName [dotName] = list;
+			}
+			list.Add (peer);
+		}
+
+		foreach (var name in componentNames) {
+			if (peersByDotName.TryGetValue (name, out var peers)) {
+				foreach (var peer in peers) {
+					if (!peer.IsUnconditional) {
+						peer.IsUnconditional = true;
+						log ($"Rooting manifest-referenced type '{name}' ({peer.ManagedTypeName}) as unconditional.");
+					}
+				}
+			} else {
+				warn?.Invoke ($"Manifest-referenced type '{name}' was not found in any scanned assembly. It may be a framework type.");
+			}
+		}
+	}
 }

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

@@ -94,7 +94,9 @@ public override bool RunTask ()
 ApplicationJavaClass: ApplicationJavaClass);
 }
 
-var generator = new TrimmableTypeMapGenerator (msg => Log.LogMessage (MessageImportance.Low, msg));
+var generator = new TrimmableTypeMapGenerator (
+	msg => Log.LogMessage (MessageImportance.Low, msg),
+	msg => Log.LogWarning (msg));
 result = generator.Execute (
 assemblies,
 systemRuntimeVersion,

tests/Microsoft.Android.Sdk.TrimmableTypeMap.Tests/Generator/TrimmableTypeMapGeneratorTests.cs

@@ -81,6 +81,119 @@ public void Execute_JavaSourcesHaveCorrectStructure ()
 
 	TrimmableTypeMapGenerator CreateGenerator () => new (msg => logMessages.Add (msg));
 
+	TrimmableTypeMapGenerator CreateGenerator (List<string> warnings) =>
+		new (msg => logMessages.Add (msg), msg => warnings.Add (msg));
+
+	[Fact]
+	public void RootManifestReferencedTypes_RootsMatchingPeers ()
+	{
+		var peers = new List<JavaPeerInfo> {
+			new JavaPeerInfo {
+				JavaName = "com/example/MyActivity", CompatJniName = "com.example.MyActivity",
+				ManagedTypeName = "MyApp.MyActivity", ManagedTypeNamespace = "MyApp", ManagedTypeShortName = "MyActivity",
+				AssemblyName = "MyApp", IsUnconditional = false,
+			},
+			new JavaPeerInfo {
+				JavaName = "com/example/MyService", CompatJniName = "com.example.MyService",
+				ManagedTypeName = "MyApp.MyService", ManagedTypeNamespace = "MyApp", ManagedTypeShortName = "MyService",
+				AssemblyName = "MyApp", IsUnconditional = false,
+			},
+		};
+
+		var doc = System.Xml.Linq.XDocument.Parse ("""
+			<?xml version="1.0" encoding="utf-8"?>
+			<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example">
+			  <application>
+			    <activity android:name="com.example.MyActivity" />
+			  </application>
+			</manifest>
+			""");
+
+		var generator = CreateGenerator ();
+		generator.RootManifestReferencedTypes (peers, doc);
+
+		Assert.True (peers [0].IsUnconditional, "MyActivity should be rooted as unconditional.");
+		Assert.False (peers [1].IsUnconditional, "MyService should remain conditional.");
+		Assert.Contains (logMessages, m => m.Contains ("Rooting manifest-referenced type"));
+	}
+
+	[Fact]
+	public void RootManifestReferencedTypes_WarnsForUnresolvedTypes ()
+	{
+		var peers = new List<JavaPeerInfo> {
+			new JavaPeerInfo {
+				JavaName = "com/example/MyActivity", CompatJniName = "com.example.MyActivity",
+				ManagedTypeName = "MyApp.MyActivity", ManagedTypeNamespace = "MyApp", ManagedTypeShortName = "MyActivity",
+				AssemblyName = "MyApp",
+			},
+		};
+
+		var doc = System.Xml.Linq.XDocument.Parse ("""
+			<?xml version="1.0" encoding="utf-8"?>
+			<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example">
+			  <application>
+			    <service android:name="com.example.NonExistentService" />
+			  </application>
+			</manifest>
+			""");
+
+		var warnings = new List<string> ();
+		var generator = CreateGenerator (warnings);
+		generator.RootManifestReferencedTypes (peers, doc);
+
+		Assert.Contains (warnings, w => w.Contains ("com.example.NonExistentService"));
+	}
+
+	[Fact]
+	public void RootManifestReferencedTypes_SkipsAlreadyUnconditional ()
+	{
+		var peers = new List<JavaPeerInfo> {
+			new JavaPeerInfo {
+				JavaName = "com/example/MyActivity", CompatJniName = "com.example.MyActivity",
+				ManagedTypeName = "MyApp.MyActivity", ManagedTypeNamespace = "MyApp", ManagedTypeShortName = "MyActivity",
+				AssemblyName = "MyApp", IsUnconditional = true,
+			},
+		};
+
+		var doc = System.Xml.Linq.XDocument.Parse ("""
+			<?xml version="1.0" encoding="utf-8"?>
+			<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example">
+			  <application>
+			    <activity android:name="com.example.MyActivity" />
+			  </application>
+			</manifest>
+			""");
+
+		var generator = CreateGenerator ();
+		generator.RootManifestReferencedTypes (peers, doc);
+
+		Assert.True (peers [0].IsUnconditional);
+		Assert.DoesNotContain (logMessages, m => m.Contains ("Rooting manifest-referenced type"));
+	}
+
+	[Fact]
+	public void RootManifestReferencedTypes_EmptyManifest_NoChanges ()
+	{
+		var peers = new List<JavaPeerInfo> {
+			new JavaPeerInfo {
+				JavaName = "com/example/MyActivity", CompatJniName = "com.example.MyActivity",
+				ManagedTypeName = "MyApp.MyActivity", ManagedTypeNamespace = "MyApp", ManagedTypeShortName = "MyActivity",
+				AssemblyName = "MyApp",
+			},
+		};
+
+		var doc = System.Xml.Linq.XDocument.Parse ("""
+			<?xml version="1.0" encoding="utf-8"?>
+			<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example">
+			</manifest>
+			""");
+
+		var generator = CreateGenerator ();
+		generator.RootManifestReferencedTypes (peers, doc);
+
+		Assert.False (peers [0].IsUnconditional);
+	}
+
 	static PEReader CreateTestFixturePEReader ()
 	{
 		var dir = Path.GetDirectoryName (typeof (FixtureTestBase).Assembly.Location)