Binding source generator

[simonrozsival]

Description of Change

This PR introduces a new convenient API that developers can use in their C# markup to use "compiled bindings" (aka typed bindings) instead of reflection-based bindings with string paths.

Example use case:

// in .NET 8
MyLabel.SetBinding(Label.TextProperty, "Text");

// in .NET 9
MyLabel.SetBinding(Label.TextProperty, static (Entry entry) => entry.Text);

The new binding has several advantages:

• better performance (benefits are already summarized in the docs: https://learn.microsoft.com/en-us/dotnet/maui/fundamentals/data-binding/compiled-bindings?view=net-maui-8.0#performance)
• intellisense while editing
• compile-time check of path validity

Overview

1. The source generator identifies calls to SetBinding<TSource, TProperty>
   • The lambda must be passed directly to the invocation, it can't be passed through a variable
2. For each identified SetBinding call, the SG generates an interceptor method
3. In the interceptor method, we instantiate TypedBinding<TSource, TProperty> based on the input lambda with the appropriate setter (if applicable) and handlers array

Sample source generator output

using Microsoft.Maui.Controls;
using MyNamespace;
var label = new Label();
label.SetBinding(Label.TextProperty, static (MySourceClass s) => (((s.A as X)?.B as Y)?.C as Z)?.D);

namespace MyNamespace
{
    public class MySourceClass
    {
        public object? A { get; set; }
    }

    public class X
    {
        public object? B { get; set; }
    }

    public class Y
    {
        public object C { get; set; } = null!;
    }

    public class Z
    {
        public MyPropertyClass D { get; set; } = null!;
    }

    public class MyPropertyClass
    {
    }
}

Generated code...

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a .NET MAUI source generator.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
#nullable enable

namespace System.Runtime.CompilerServices
{
        using System;
        using System.CodeDom.Compiler;

        [GeneratedCodeAttribute("Microsoft.Maui.Controls.BindingSourceGen, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", "1.0.0.0")]
        [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
        file sealed class InterceptsLocationAttribute : Attribute
        {
                public InterceptsLocationAttribute(string filePath, int line, int column)
                {
                        FilePath = filePath;
                        Line = line;
                        Column = column;
                }

                public string FilePath { get; }
                public int Line { get; }
                public int Column { get; }
        }
}

namespace Microsoft.Maui.Controls.Generated
{
        using System;
        using System.CodeDom.Compiler;
        using System.Runtime.CompilerServices;
        using Microsoft.Maui.Controls.Internals;

        [GeneratedCodeAttribute("Microsoft.Maui.Controls.BindingSourceGen, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", "1.0.0.0")]
        file static class GeneratedBindableObjectExtensions
        {

                [GeneratedCodeAttribute("Microsoft.Maui.Controls.BindingSourceGen, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", "1.0.0.0")]
                [InterceptsLocationAttribute(@"Path\To\Program.cs", 4, 7)]
                public static void SetBinding1(
                        this BindableObject bindableObject,
                        BindableProperty bindableProperty,
                        Func<global::MyNamespace.MySourceClass, global::MyNamespace.MyPropertyClass?> getter,
                        BindingMode mode = BindingMode.Default,
                        IValueConverter? converter = null,
                        object? converterParameter = null,
                        string? stringFormat = null,
                        object? source = null,
                        object? fallbackValue = null,
                        object? targetNullValue = null)
                {
                        Action<global::MyNamespace.MySourceClass, global::MyNamespace.MyPropertyClass?>? setter = null;
                        if (ShouldUseSetter(mode, bindableProperty))
                        {
                                setter = static (source, value) =>
                                {
                                        if (value is null)
                                        {
                                                return;
                                        }
                                        if (source.A is global::MyNamespace.X p0
                                                && p0.B is global::MyNamespace.Y p1
                                                && p1.C is global::MyNamespace.Z p2)
                                        {
                                                p2.D = value;
                                        }
                                };
                        }
                        var binding = new TypedBinding<global::MyNamespace.MySourceClass, global::MyNamespace.MyPropertyClass?>(
                                getter: source => (getter(source), true),
                                setter,
                                handlers: new Tuple<Func<global::MyNamespace.MySourceClass, object?>, string>[]
                                {
                                        new(static source => source, "A"),
                                        new(static source => (source.A as global::MyNamespace.X), "B"),
                                        new(static source => ((source.A as global::MyNamespace.X)?.B as global::MyNamespace.Y), "C"),
                                        new(static source => (((source.A as global::MyNamespace.X)?.B as global::MyNamespace.Y)?.C as global::MyNamespace.Z), "D"),
                                })
                        {
                                Mode = mode,
                                Converter = converter,
                                ConverterParameter = converterParameter,
                                StringFormat = stringFormat,
                                Source = source,
                                FallbackValue = fallbackValue,
                                TargetNullValue = targetNullValue
                        };
                        bindableObject.SetBinding(bindableProperty, binding);
                }


                private static bool ShouldUseSetter(BindingMode mode, BindableProperty bindableProperty)
                        => mode == BindingMode.OneWayToSource
                                || mode == BindingMode.TwoWay
                                || (mode == BindingMode.Default
                                        && (bindableProperty.DefaultBindingMode == BindingMode.OneWayToSource
                                                || bindableProperty.DefaultBindingMode == BindingMode.TwoWay));
        }
}

Benchmark results

Method	Mean	Error	StdDev	Gen0	Gen1	Allocated
TypedBindName	13.11 us	0.244 us	0.251 us	1.2207	0.6104	7.5 KB
SourceGeneratedBindName	14.39 us	0.137 us	0.129 us	1.3580	0.6714	8.36 KB
BindName	16.98 us	0.315 us	0.279 us	1.6785	0.8240	10.31 KB
TypedBindChild	20.47 us	0.214 us	0.190 us	2.0142	1.0071	12.42 KB
SourceGeneratedBindChild	21.09 us	0.374 us	0.349 us	2.1667	1.0681	13.28 KB
BindChild	21.51 us	0.284 us	0.266 us	2.5940	1.2817	16.02 KB
TypedBindChildIndexer	21.78 us	0.361 us	0.338 us	2.3193	1.1597	14.38 KB
SourceGeneratedBindChildIndexer	22.46 us	0.264 us	0.247 us	2.4719	1.2207	15.23 KB
BindChildIndexer	41.00 us	0.459 us	0.429 us	4.1504	2.0752	25.55 KB

Issues Fixed

Fixes #19912
Fixes #20574
Contributes to #18658
Implements most of #22384

/cc @jonathanpeppers @StephaneDelcroix @PureWeen @mattleibow @jkurdek @vitek-karas

[simonrozsival]

@PureWeen is it OK to take in code from CommunityToolkit/dotnet (EquatableArray) and dotnet/BenchmarkDotNet (HashCode)?