Fix for RelativeSource AncestorType bindings not generating compiled bindings under AOT

src/Controls/src/SourceGen/KnownMarkups.cs

@@ -343,20 +343,37 @@ private static bool ProvideValueForBindingExtension(ElementNode markupNode, Inde
 		returnType = context.Compilation.GetTypeByMetadataName("Microsoft.Maui.Controls.BindingBase")!;
 		ITypeSymbol? dataTypeSymbol = null;
 
-		// When Source is RelativeSource, the type is determined at runtime — skip compilation.
-		// When Source is x:Reference, resolve the referenced element's type and compile against it.
-		// Otherwise, use x:DataType from the current scope.
-		bool hasRelativeSource = HasRelativeSourceBinding(markupNode);
-
 		context.Variables.TryGetValue(markupNode, out ILocalValue? extVariable);
 
-		if (   !hasRelativeSource
-			&& extVariable is not null)
+		if (extVariable is not null)
 		{
-			ITypeSymbol? xRefSourceType = TryResolveXReferenceSourceType(markupNode, context);
-			dataTypeSymbol = xRefSourceType;
-			if (dataTypeSymbol is null)
-				TryGetXDataType(markupNode, context, out dataTypeSymbol);
+			// Determine the source type for compiled binding based on the binding's Source configuration:
+			//
+			// 1. RelativeSource with a resolvable AncestorType: use the AncestorType as the source
+			//    type. The symbol is already registered in context.Types by
+			//    ProvideValueForRelativeSourceExtension, enabling trim-safe TypedBinding generation.
+			//
+			// 2. RelativeSource without AncestorType (Self, TemplatedParent, or FindAncestor without
+			//    a type): the binding source is resolved at runtime. Using x:DataType as the source
+			//    type here would produce a compiled binding with an incorrect source type, leading to
+			//    runtime failures. Fall through to the string-based Binding path instead.
+			//
+			// 3. x:Reference: resolve the referenced element's type and compile against it.
+			//
+			// 4. No explicit source: use x:DataType if available to produce a compiled TypedBinding.
+			ITypeSymbol? xRefSourceType = null;
+			if (TryGetRelativeSourceAncestorType(markupNode, context, out var ancestorTypeSymbol)
+				&& ancestorTypeSymbol is not null)
+			{
+				dataTypeSymbol = ancestorTypeSymbol;
+			}
+			else if (!HasRelativeSourceBinding(markupNode))
+			{
+				xRefSourceType = TryResolveXReferenceSourceType(markupNode, context);
+				dataTypeSymbol = xRefSourceType;
+				if (dataTypeSymbol is null)
+					TryGetXDataType(markupNode, context, out dataTypeSymbol);
+			}
 
 			if (dataTypeSymbol is not null)
 			{
@@ -708,6 +725,50 @@ static bool HasRelativeSourceBinding(ElementNode bindingNode)
 
 			return null;
 		}
+
+		// Checks if the binding has a Source property that is a RelativeSource extension
+		// with a resolvable AncestorType. If so, returns the already-resolved AncestorType
+		// symbol from context.Types (populated earlier by ProvideValueForRelativeSourceExtension).
+		// This allows AncestorType bindings to use the compiled (trim-safe) TypedBinding path.
+		static bool TryGetRelativeSourceAncestorType(ElementNode bindingNode, SourceGenContext context, out ITypeSymbol? ancestorType)
+		{
+			ancestorType = null;
+
+			// Check if Source property exists
+			if (!bindingNode.Properties.TryGetValue(new XmlName("", "Source"), out INode? sourceNode)
+				&& !bindingNode.Properties.TryGetValue(new XmlName(null, "Source"), out sourceNode))
+			{
+				return false;
+			}
+
+			// Check if the Source is a RelativeSourceExtension
+			if (sourceNode is not ElementNode relativeSourceNode
+				|| (relativeSourceNode.XmlType.Name != "RelativeSourceExtension"
+					&& relativeSourceNode.XmlType.Name != "RelativeSource"))
+			{
+				return false;
+			}
+
+			// Find the AncestorType property on the RelativeSource node
+			if (!relativeSourceNode.Properties.TryGetValue(new XmlName("", "AncestorType"), out INode? ancestorTypeNode)
+				&& !relativeSourceNode.Properties.TryGetValue(new XmlName(null, "AncestorType"), out ancestorTypeNode))
+				relativeSourceNode.Properties.TryGetValue(new XmlName(XamlParser.MauiUri, "AncestorType"), out ancestorTypeNode);
+
+			if (ancestorTypeNode is null)
+			{
+				return false;
+			}
+
+			// The AncestorType is typically an x:Type extension (ElementNode).
+			// ProvideValueForRelativeSourceExtension already resolved this type
+			// and registered it in context.Types — just look it up.
+			if (ancestorTypeNode is ElementNode typeExtNode)
+			{
+				return context.Types.TryGetValue(typeExtNode, out ancestorType) && ancestorType is not null;
+			}
+
+			return false;
+		}
 	}
 
 	internal static bool ProvideValueForDataTemplateExtension(ElementNode markupNode, IndentedTextWriter writer, SourceGenContext context, NodeSGExtensions.GetNodeValueDelegate? getNodeValue, out ITypeSymbol? returnType, out string value)

src/Controls/tests/Xaml.UnitTests/Issues/Maui34056.xaml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             xmlns:local="clr-namespace:Microsoft.Maui.Controls.Xaml.UnitTests"
+             x:Class="Microsoft.Maui.Controls.Xaml.UnitTests.Maui34056"
+             x:DataType="local:Maui34056PageViewModel">
+    <VerticalStackLayout>
+        <!-- Scenario 1: RelativeSource AncestorType inside DataTemplate with x:DataType (issue fix) -->
+        <CollectionView x:Name="TestCollectionView"
+                        ItemsSource="{Binding Items}">
+            <CollectionView.ItemTemplate>
+                <DataTemplate x:DataType="local:Maui34056ItemViewModel">
+                    <Button x:Name="TestButton"
+                            Text="{Binding ItemName}"
+                            Command="{Binding x:DataType='local:Maui34056PageViewModel', Source={RelativeSource AncestorType={x:Type local:Maui34056PageViewModel}}, Path=TestCommand}" />
+                </DataTemplate>
+            </CollectionView.ItemTemplate>
+        </CollectionView>
+
+        <!-- Scenario 2: {RelativeSource Self} inside DataTemplate with x:DataType.
+             SourceGen must not use x:DataType as the source type; the source is the element itself.
+             Path=ItemName exists on Maui34056ItemViewModel to ensure the guard, not a failed lookup, prevents compiled binding. -->
+        <CollectionView x:Name="SelfBindingCollectionView"
+                        ItemsSource="{Binding Items}">
+            <CollectionView.ItemTemplate>
+                <DataTemplate x:DataType="local:Maui34056ItemViewModel">
+                    <Label x:Name="SelfBindingLabel"
+                           Text="{Binding Path=ItemName, Source={RelativeSource Self}}" />
+                </DataTemplate>
+            </CollectionView.ItemTemplate>
+        </CollectionView>
+    </VerticalStackLayout>
+</ContentPage>

src/Controls/tests/Xaml.UnitTests/Issues/Maui34056.xaml.cs

@@ -0,0 +1,93 @@
+using System.Collections.ObjectModel;
+using System.Windows.Input;
+using Microsoft.Maui.Controls.Internals;
+using Xunit;
+
+namespace Microsoft.Maui.Controls.Xaml.UnitTests;
+
+// Page-level ViewModel — this is what the RelativeSource AncestorType points to
+public class Maui34056PageViewModel
+{
+    public ObservableCollection<Maui34056ItemViewModel> Items { get; } =
+        [new Maui34056ItemViewModel { ItemName = "Item 1" }];
+
+    public ICommand TestCommand { get; } = new Command(() => { });
+}
+
+// Item ViewModel — this is what the DataTemplate's x:DataType is set to
+public class Maui34056ItemViewModel
+{
+    public string ItemName { get; set; } = "";
+}
+
+public partial class Maui34056 : ContentPage
+{
+    public Maui34056()
+    {
+        InitializeComponent();
+        BindingContext = new Maui34056PageViewModel();
+    }
+
+    [Collection("Issue")]
+    public class Maui34056Tests
+    {
+        [Theory]
+        [XamlInflatorData]
+        internal void RelativeSourceAncestorTypeInDataTemplateGeneratesCompiledBinding(XamlInflator inflator)
+        {
+            var page = new Maui34056(inflator);
+
+            var template = ((CollectionView)page.TestCollectionView).ItemTemplate;
+            var content = template.CreateContent() as Button;
+            Assert.NotNull(content);
+
+            var bindingContext = content.GetContext(Button.CommandProperty);
+            Assert.NotNull(bindingContext);
+            var binding = bindingContext.Bindings.GetValue();
+
+            if (inflator is XamlInflator.Runtime)
+            {
+                // Runtime inflator uses the string-based Binding — no compile-time type info available.
+                Assert.IsType<Binding>(binding);
+            }
+            else
+            {
+                // Both XamlC and SourceGen produce a trim-safe TypedBinding when x:DataType is present
+                // on the binding node alongside RelativeSource AncestorType.
+                Assert.IsType<TypedBinding<Maui34056PageViewModel, ICommand>>(binding);
+            }
+        }
+
+        [Theory]
+        [XamlInflatorData]
+        internal void RelativeSourceSelfInDataTemplateWithXDataTypeUsesStringBinding(XamlInflator inflator)
+        {
+            // Verifies SourceGen does not use the DataTemplate's x:DataType as the source type for
+            // {RelativeSource Self} bindings. The source is the element itself, resolved at runtime.
+            // Path=ItemName exists on Maui34056ItemViewModel to ensure the guard is what prevents
+            // compiled binding, not a failed type lookup. XamlC behavior is pre-existing and separate.
+            var page = new Maui34056(inflator);
+
+            var template = ((CollectionView)page.SelfBindingCollectionView).ItemTemplate;
+            var content = template.CreateContent() as Label;
+            Assert.NotNull(content);
+
+            var bindingContext = content.GetContext(Label.TextProperty);
+            Assert.NotNull(bindingContext);
+            var binding = bindingContext.Bindings.GetValue();
+
+            if (inflator is XamlInflator.XamlC)
+            {
+                // XamlC pre-existing behavior: compiles RelativeSource Self using DataTemplate x:DataType.
+                // This is a separate issue, not addressed by this fix.
+                Assert.IsType<TypedBinding<Maui34056ItemViewModel, string>>(binding);
+            }
+            else
+            {
+                // Runtime: no compile-time type info, always string-based Binding.
+                // SourceGen (the fix): HasRelativeSourceBinding blocks x:DataType path for Self bindings.
+                Assert.IsType<Binding>(binding);
+            }
+        }
+    }
+}