Incremental generation tests

src/Controls/src/BindingSourceGen/BindingCodeWriter.cs

@@ -211,7 +211,7 @@ public void AppendSetBindingInterceptor(int id, CodeWriterBinding binding)
 				""");
 		}
 
-		private void AppendInterceptorAttribute(SourceCodeLocation location)
+		private void AppendInterceptorAttribute(InterceptorLocation location)
 		{
 			AppendLine($"[InterceptsLocationAttribute(@\"{location.FilePath}\", {location.Line}, {location.Column})]");
 		}

src/Controls/src/BindingSourceGen/BindingSourceGenerator.cs

@@ -1,6 +1,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Text;
 
 namespace Microsoft.Maui.Controls.BindingSourceGen;
 
@@ -17,21 +18,21 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 			predicate: static (node, _) => IsSetBindingMethod(node),
 			transform: static (ctx, t) => GetBindingForGeneration(ctx, t)
 		)
-		.WithTrackingName("BindingsWithDiagnostics");
+		.WithTrackingName(TrackingNames.BindingsWithDiagnostics);
 
 
 		context.RegisterSourceOutput(bindingsWithDiagnostics, (spc, bindingWithDiagnostic) =>
 		{
 			foreach (var diagnostic in bindingWithDiagnostic.Diagnostics)
 			{
-				spc.ReportDiagnostic(diagnostic);
+				spc.ReportDiagnostic(Diagnostic.Create(diagnostic.Descriptor, diagnostic.Location?.ToLocation()));
 			}
 		});
 
 		var bindings = bindingsWithDiagnostics
 			.Where(static binding => binding.Diagnostics.Length == 0 && binding.Binding != null)
 			.Select(static (binding, t) => binding.Binding!)
-			.WithTrackingName("Bindings")
+			.WithTrackingName(TrackingNames.Bindings)
 			.Collect();
 
 
@@ -57,18 +58,18 @@ static bool IsSetBindingMethod(SyntaxNode node)
 
 	static BindingDiagnosticsWrapper GetBindingForGeneration(GeneratorSyntaxContext context, CancellationToken t)
 	{
-		var diagnostics = new List<Diagnostic>();
+		var diagnostics = new List<DiagnosticInfo>();
 		NullableContext nullableContext = context.SemanticModel.GetNullableContext(context.Node.Span.Start);
 		var enabledNullable = (nullableContext & NullableContext.Enabled) == NullableContext.Enabled;
 
 		var invocation = (InvocationExpressionSyntax)context.Node;
 		var method = (MemberAccessExpressionSyntax)invocation.Expression;
 
-		var sourceCodeLocation = new SourceCodeLocation(
-			context.Node.SyntaxTree.FilePath,
-			method.Name.GetLocation().GetLineSpan().StartLinePosition.Line + 1,
-			method.Name.GetLocation().GetLineSpan().StartLinePosition.Character + 1
-		);
+		var sourceCodeLocation = SourceCodeLocation.CreateFrom(method.Name.GetLocation());
+		if (sourceCodeLocation == null)
+		{
+			return ReportDiagnostics([DiagnosticsFactory.UnableToResolvePath(invocation.GetLocation())]);
+		}
 
 		var overloadDiagnostics = VerifyCorrectOverload(invocation, context, t);
 
@@ -98,15 +99,15 @@ static BindingDiagnosticsWrapper GetBindingForGeneration(GeneratorSyntaxContext
 		}
 
 		var codeWriterBinding = new CodeWriterBinding(
-			Location: sourceCodeLocation,
+			Location: sourceCodeLocation.ToInterceptorLocation(),
 			SourceType: BindingGenerationUtilities.CreateTypeNameFromITypeSymbol(lambdaSymbol.Parameters[0].Type, enabledNullable),
 			PropertyType: BindingGenerationUtilities.CreateTypeNameFromITypeSymbol(lambdaTypeInfo.Type, enabledNullable),
 			Path: parts.ToArray(),
 			SetterOptions: DeriveSetterOptions(lambdaBody, context.SemanticModel, enabledNullable));
 		return new BindingDiagnosticsWrapper(codeWriterBinding, diagnostics.ToArray());
 	}
 
-	private static Diagnostic[] VerifyCorrectOverload(InvocationExpressionSyntax invocation, GeneratorSyntaxContext context, CancellationToken t)
+	private static DiagnosticInfo[] VerifyCorrectOverload(InvocationExpressionSyntax invocation, GeneratorSyntaxContext context, CancellationToken t)
 	{
 		var argumentList = invocation.ArgumentList.Arguments;
 		if (argumentList.Count < 2)
@@ -120,10 +121,10 @@ private static Diagnostic[] VerifyCorrectOverload(InvocationExpressionSyntax inv
 			return [DiagnosticsFactory.SuboptimalSetBindingOverload(getter.GetLocation())];
 		}
 
-		return Array.Empty<Diagnostic>();
+		return Array.Empty<DiagnosticInfo>();
 	}
 
-	private static (ExpressionSyntax? lambdaBodyExpression, IMethodSymbol? lambdaSymbol, Diagnostic[] diagnostics) GetLambda(InvocationExpressionSyntax invocation, SemanticModel semanticModel)
+	private static (ExpressionSyntax? lambdaBodyExpression, IMethodSymbol? lambdaSymbol, DiagnosticInfo[] diagnostics) GetLambda(InvocationExpressionSyntax invocation, SemanticModel semanticModel)
 	{
 		var argumentList = invocation.ArgumentList.Arguments;
 		var lambda = (LambdaExpressionSyntax)argumentList[1].Expression;
@@ -138,7 +139,7 @@ private static (ExpressionSyntax? lambdaBodyExpression, IMethodSymbol? lambdaSym
 			return (null, null, [DiagnosticsFactory.GetterIsNotLambda(lambda.GetLocation())]);
 		}
 
-		return (lambdaBody, lambdaSymbol, Array.Empty<Diagnostic>());
+		return (lambdaBody, lambdaSymbol, Array.Empty<DiagnosticInfo>());
 	}
 
 	private static SetterOptions DeriveSetterOptions(ExpressionSyntax? lambdaBodyExpression, SemanticModel semanticModel, bool enabledNullable)
@@ -192,21 +193,45 @@ static bool AcceptsNullValue(ISymbol? symbol, bool enabledNullable)
 			};
 	}
 
-	private static BindingDiagnosticsWrapper ReportDiagnostics(Diagnostic[] diagnostics) => new(null, diagnostics);
+	private static BindingDiagnosticsWrapper ReportDiagnostics(DiagnosticInfo[] diagnostics) => new(null, diagnostics);
+}
+
+internal class TrackingNames
+{
+	public const string BindingsWithDiagnostics = nameof(BindingsWithDiagnostics);
+	public const string Bindings = nameof(Bindings);
 }
 
 public sealed record BindingDiagnosticsWrapper(
 	CodeWriterBinding? Binding,
-	Diagnostic[] Diagnostics); // TODO: use an "equatable array" type
+	DiagnosticInfo[] Diagnostics); // TODO: use an "equatable array" type
 
 public sealed record CodeWriterBinding(
-	SourceCodeLocation Location,
+	InterceptorLocation Location,
 	TypeDescription SourceType,
 	TypeDescription PropertyType,
 	IPathPart[] Path, // TODO: use an "equatable array" type
 	SetterOptions SetterOptions);
 
-public sealed record SourceCodeLocation(string FilePath, int Line, int Column);
+public sealed record SourceCodeLocation(string FilePath, TextSpan TextSpan, LinePositionSpan LineSpan)
+{
+	public static SourceCodeLocation? CreateFrom(Location location)
+		=> location.SourceTree is null
+			? null
+			: new SourceCodeLocation(location.SourceTree.FilePath, location.SourceSpan, location.GetLineSpan().Span);
+
+	public Location ToLocation() 
+	{
+		return Location.Create(FilePath, TextSpan, LineSpan);
+	}
+
+	public InterceptorLocation ToInterceptorLocation()
+	{
+		return new InterceptorLocation(FilePath, LineSpan.Start.Line + 1, LineSpan.Start.Character + 1);
+	}
+}
+
+public sealed record InterceptorLocation(string FilePath, int Line, int Column);
 
 public sealed record TypeDescription(
 	string GlobalName,

src/Controls/src/BindingSourceGen/DiagnosticsFactory.cs

@@ -2,10 +2,22 @@
 
 namespace Microsoft.Maui.Controls.BindingSourceGen;
 
+public sealed record DiagnosticInfo
+{
+    public DiagnosticInfo(DiagnosticDescriptor descriptor, Location? location)
+    {
+        Descriptor = descriptor;
+        Location = location is not null ? SourceCodeLocation.CreateFrom(location) : null;
+    }
+
+    public DiagnosticDescriptor Descriptor { get; }
+    public SourceCodeLocation? Location { get; }
+}
+
 internal static class DiagnosticsFactory
 {
-    public static Diagnostic UnableToResolvePath(Location location)
-        => Diagnostic.Create(
+    public static DiagnosticInfo UnableToResolvePath(Location location)
+        => new(
             new DiagnosticDescriptor(
                 id: "BSG0001",
                 title: "Unable to resolve path",
@@ -15,8 +27,8 @@ public static Diagnostic UnableToResolvePath(Location location)
                 isEnabledByDefault: true),
             location);
 
-    public static Diagnostic GetterIsNotLambda(Location location)
-        => Diagnostic.Create(
+    public static DiagnosticInfo GetterIsNotLambda(Location location)
+        => new(
             new DiagnosticDescriptor(
                 id: "BSG0002",
                 title: "Getter must be a lambda",
@@ -26,8 +38,8 @@ public static Diagnostic GetterIsNotLambda(Location location)
                 isEnabledByDefault: true),
             location);
 
-    public static Diagnostic GetterLambdaBodyIsNotExpression(Location location)
-        => Diagnostic.Create(
+    public static DiagnosticInfo GetterLambdaBodyIsNotExpression(Location location)
+        => new(
             new DiagnosticDescriptor(
                 id: "BSG0003",
                 title: "Getter lambda's body must be an expression",
@@ -37,8 +49,8 @@ public static Diagnostic GetterLambdaBodyIsNotExpression(Location location)
                 isEnabledByDefault: true),
             location);
 
-    public static Diagnostic SuboptimalSetBindingOverload(Location location)
-        => Diagnostic.Create(
+    public static DiagnosticInfo SuboptimalSetBindingOverload(Location location)
+        => new(
             new DiagnosticDescriptor(
                 id: "BSG0004",
                 title: "SetBinding with string path",

src/Controls/src/BindingSourceGen/EquatableArray.cs

@@ -0,0 +1,113 @@
+using System.Collections;
+using System.Collections.Immutable;
+using System.Runtime.CompilerServices;
+
+namespace Microsoft.Maui.Controls.BindingSourceGen;
+
+public static class EquatableArray
+{
+    public static EquatableArray<T> AsEquatableArray<T>(this T[] array)
+        where T : IEquatable<T>
+    {
+        return new(array);
+    }
+}
+
+public readonly struct EquatableArray<T> : IEquatable<EquatableArray<T>>, IEnumerable<T>
+    where T : IEquatable<T>
+{
+    private readonly T[]? array;
+
+    private EquatableArray(ImmutableArray<T> array)
+    {
+        this.array = Unsafe.As<ImmutableArray<T>, T[]?>(ref array);
+    }
+
+    public EquatableArray(T[] array) : this(array.ToImmutableArray())
+    {
+    }
+
+    public ref readonly T this[int index]
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        get => ref AsImmutableArray().ItemRef(index);
+    }
+
+    public int Length
+    {
+        get => array?.Length ?? 0;
+    }
+
+    public bool Equals(EquatableArray<T> array)
+    {
+        return AsSpan().SequenceEqual(array.AsSpan());
+    }
+
+    public override bool Equals(object? obj)
+    {
+        return obj is EquatableArray<T> array && Equals(this, array);
+    }
+
+    public override int GetHashCode()
+    {
+        if (this.array is not T[] array)
+        {
+            return 0;
+        }
+
+        HashCode hashCode = default;
+
+        foreach (T item in array)
+        {
+            hashCode.Add(item);
+        }
+
+        return hashCode.ToHashCode();
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public ImmutableArray<T> AsImmutableArray()
+    {
+        return Unsafe.As<T[]?, ImmutableArray<T>>(ref Unsafe.AsRef(in this.array));
+    }
+
+    public static EquatableArray<T> FromImmutableArray(ImmutableArray<T> array)
+    {
+        return new(array);
+    }
+
+    public ReadOnlySpan<T> AsSpan()
+    {
+        return AsImmutableArray().AsSpan();
+    }
+
+    public T[] ToArray()
+    {
+        return AsImmutableArray().ToArray();
+    }
+
+    public ImmutableArray<T>.Enumerator GetEnumerator()
+    {
+        return AsImmutableArray().GetEnumerator();
+    }
+
+    IEnumerator<T> IEnumerable<T>.GetEnumerator()
+    {
+        return ((IEnumerable<T>)AsImmutableArray()).GetEnumerator();
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return ((IEnumerable)AsImmutableArray()).GetEnumerator();
+    }
+
+    public static bool operator ==(EquatableArray<T> left, EquatableArray<T> right)
+    {
+        return left.Equals(right);
+    }
+
+    public static bool operator !=(EquatableArray<T> left, EquatableArray<T> right)
+    {
+        return !left.Equals(right);
+    }
+}