Make config binding gen incremental

src/libraries/Common/src/Roslyn/DiagnosticDescriptorHelper.cs

@@ -1,8 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Microsoft.CodeAnalysis;
-
 namespace Microsoft.CodeAnalysis.DotnetRuntime.Extensions
 {
     internal static partial class DiagnosticDescriptorHelper
@@ -21,5 +19,11 @@ internal static partial class DiagnosticDescriptorHelper
 
             return new DiagnosticDescriptor(id, title, messageFormat, category, defaultSeverity, isEnabledByDefault, description, helpLink, customTags);
         }
+
+        /// <summary>
+        /// Creates a copy of the Location instance that does not capture a reference to Compilation.
+        /// </summary>
+        public static Location GetTrimmedLocation(this Location location)
+            => Location.Create(location.SourceTree?.FilePath ?? "", location.SourceSpan, location.GetLineSpan().Span);
     }
 }

src/libraries/Common/src/SourceGenerators/DiagnosticInfo.cs

@@ -0,0 +1,44 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Linq;
+using System.Numerics.Hashing;
+using Microsoft.CodeAnalysis;
+
+namespace SourceGenerators;
+
+/// <summary>
+/// Descriptor for diagnostic instances using structural equality comparison.
+/// Provides a work-around for https://github.com/dotnet/roslyn/issues/68291.
+/// </summary>
+internal readonly struct DiagnosticInfo : IEquatable<DiagnosticInfo>
+{
+    public required DiagnosticDescriptor Descriptor { get; init; }
+    public required object?[] MessageArgs { get; init; }
+    public required Location? Location { get; init; }
+
+    public Diagnostic CreateDiagnostic()
+        => Diagnostic.Create(Descriptor, Location, MessageArgs);
+
+    public override readonly bool Equals(object? obj) => obj is DiagnosticInfo info && Equals(info);
+
+    public readonly bool Equals(DiagnosticInfo other)
+    {
+        return Descriptor.Equals(other.Descriptor) &&
+            MessageArgs.SequenceEqual(other.MessageArgs) &&
+            Location == other.Location;
+    }
+
+    public override readonly int GetHashCode()
+    {
+        int hashCode = Descriptor.GetHashCode();
+        foreach (object? messageArg in MessageArgs)
+        {
+            hashCode = HashHelpers.Combine(hashCode, messageArg?.GetHashCode() ?? 0);
+        }
+
+        hashCode = HashHelpers.Combine(hashCode, Location?.GetHashCode() ?? 0);
+        return hashCode;
+    }
+}

src/libraries/Common/src/SourceGenerators/ImmutableEquatableArray.cs

@@ -0,0 +1,84 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics.Hashing;
+
+namespace SourceGenerators
+{
+    /// <summary>
+    /// Provides an immutable list implementation which implements sequence equality.
+    /// </summary>
+    public sealed class ImmutableEquatableArray<T> : IEquatable<ImmutableEquatableArray<T>>, IReadOnlyList<T>
+        where T : IEquatable<T>
+    {
+        public static ImmutableEquatableArray<T> Empty { get; } = new ImmutableEquatableArray<T>(Array.Empty<T>());
+
+        private readonly T[] _values;
+        public T this[int index] => _values[index];
+        public int Count => _values.Length;
+
+        public ImmutableEquatableArray(IEnumerable<T> values)
+            => _values = values.ToArray();
+
+        public bool Equals(ImmutableEquatableArray<T>? other)
+            => other != null && ((ReadOnlySpan<T>)_values).SequenceEqual(other._values);
+
+        public override bool Equals(object? obj)
+            => obj is ImmutableEquatableArray<T> other && Equals(other);
+
+        public override int GetHashCode()
+        {
+            int hash = 0;
+            foreach (T value in _values)
+            {
+                hash = HashHelpers.Combine(hash, value is null ? 0 : value.GetHashCode());
+            }
+
+            return hash;
+        }
+
+        public Enumerator GetEnumerator() => new Enumerator(_values);
+        IEnumerator<T> IEnumerable<T>.GetEnumerator() => ((IEnumerable<T>)_values).GetEnumerator();
+        IEnumerator IEnumerable.GetEnumerator() => _values.GetEnumerator();
+
+        public struct Enumerator
+        {
+            private readonly T[] _values;
+            private int _index;
+
+            internal Enumerator(T[] values)
+            {
+                _values = values;
+                _index = -1;
+            }
+
+            public bool MoveNext()
+            {
+                int newIndex = _index + 1;
+
+                if ((uint)newIndex < (uint)_values.Length)
+                {
+                    _index = newIndex;
+                    return true;
+                }
+
+                return false;
+            }
+
+            public readonly T Current => _values[_index];
+        }
+    }
+
+    internal static class ImmutableEquatableArray
+    {
+        public static ImmutableEquatableArray<T> Empty<T>() where T : IEquatable<T>
+            => ImmutableEquatableArray<T>.Empty;
+
+        public static ImmutableEquatableArray<T> ToImmutableEquatableArray<T>(this IEnumerable<T> values) where T : IEquatable<T>
+            => new(values);
+    }
+}

src/libraries/Common/src/SourceGenerators/TypeModelHelper.cs

@@ -3,6 +3,8 @@
 
 using Microsoft.CodeAnalysis;
 using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Linq;
 
 namespace SourceGenerators
 {
@@ -32,5 +34,62 @@ void TraverseContainingTypes(INamedTypeSymbol current)
                 }
             }
         }
+
+        public static string GetFullyQualifiedName(this ITypeSymbol type) => type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+
+        /// <summary>
+        /// Removes any type metadata that is erased at compile time, such as NRT annotations and tuple labels.
+        /// </summary>
+        public static ITypeSymbol EraseCompileTimeMetadata(this Compilation compilation, ITypeSymbol type)
+        {
+            if (type.NullableAnnotation is NullableAnnotation.Annotated)
+            {
+                type = type.WithNullableAnnotation(NullableAnnotation.None);
+            }
+
+            if (type is INamedTypeSymbol namedType)
+            {
+                if (namedType.IsTupleType)
+                {
+                    if (namedType.TupleElements.Length < 2)
+                    {
+                        return type;
+                    }
+
+                    ImmutableArray<ITypeSymbol> erasedElements = namedType.TupleElements
+                        .Select(e => compilation.EraseCompileTimeMetadata(e.Type))
+                        .ToImmutableArray();
+
+                    type = compilation.CreateTupleTypeSymbol(erasedElements);
+                }
+                else if (namedType.IsGenericType)
+                {
+                    if (namedType.IsUnboundGenericType)
+                    {
+                        return namedType;
+                    }
+
+                    ImmutableArray<ITypeSymbol> typeArguments = namedType.TypeArguments;
+                    INamedTypeSymbol? containingType = namedType.ContainingType;
+
+                    if (containingType?.IsGenericType == true)
+                    {
+                        containingType = (INamedTypeSymbol)compilation.EraseCompileTimeMetadata(containingType);
+                        type = namedType = containingType.GetTypeMembers().First(t => t.Name == namedType.Name && t.Arity == namedType.Arity);
+                    }
+
+                    if (typeArguments.Length > 0)
+                    {
+                        ITypeSymbol[] erasedTypeArgs = typeArguments
+                            .Select(compilation.EraseCompileTimeMetadata)
+                            .ToArray();
+
+                        type = namedType.ConstructedFrom.Construct(erasedTypeArgs);
+                    }
+                }
+            }
+
+            return type;
+        }
     }
 }

src/libraries/System.Text.Json/gen/Model/TypeRef.cs → src/libraries/Common/src/SourceGenerators/TypeRef.cs

@@ -1,10 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.Diagnostics;
 using Microsoft.CodeAnalysis;
 
-namespace System.Text.Json.SourceGeneration
+namespace SourceGenerators
 {
     /// <summary>
     /// An equatable value representing type identity.

src/libraries/Common/tests/SourceGenerators/GeneratorTestHelpers.cs

@@ -0,0 +1,84 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using Xunit;
+
+namespace SourceGenerators.Tests
+{
+    internal static class GeneratorTestHelpers
+    {
+        /// <summary>
+        /// Asserts for structural equality, returning a path to the mismatching data when not equal.
+        /// </summary>
+        public static void AssertStructurallyEqual<T>(T expected, T actual)
+        {
+            CheckAreEqualCore(expected, actual, new());
+            static void CheckAreEqualCore(object expected, object actual, Stack<string> path)
+            {
+                if (expected is null || actual is null)
+                {
+                    if (expected is not null || actual is not null)
+                    {
+                        FailNotEqual();
+                    }
+
+                    return;
+                }
+
+                Type type = expected.GetType();
+                if (type != actual.GetType())
+                {
+                    FailNotEqual();
+                    return;
+                }
+
+                if (expected is IEnumerable leftCollection)
+                {
+                    if (actual is not IEnumerable rightCollection)
+                    {
+                        FailNotEqual();
+                        return;
+                    }
+
+                    object?[] expectedValues = leftCollection.Cast<object?>().ToArray();
+                    object?[] actualValues = rightCollection.Cast<object?>().ToArray();
+
+                    for (int i = 0; i < Math.Max(expectedValues.Length, actualValues.Length); i++)
+                    {
+                        object? expectedElement = i < expectedValues.Length ? expectedValues[i] : "<end of collection>";
+                        object? actualElement = i < actualValues.Length ? actualValues[i] : "<end of collection>";
+
+                        path.Push($"[{i}]");
+                        CheckAreEqualCore(expectedElement, actualElement, path);
+                        path.Pop();
+                    }
+                }
+
+                if (type.GetProperty("EqualityContract", BindingFlags.Instance | BindingFlags.NonPublic, null, returnType: typeof(Type), types: Array.Empty<Type>(), null) != null)
+                {
+                    // Type is a C# record, run pointwise equality comparison.
+                    foreach (PropertyInfo property in type.GetProperties(BindingFlags.Public | BindingFlags.Instance))
+                    {
+                        path.Push("." + property.Name);
+                        CheckAreEqualCore(property.GetValue(expected), property.GetValue(actual), path);
+                        path.Pop();
+                    }
+
+                    return;
+                }
+
+                if (!expected.Equals(actual))
+                {
+                    FailNotEqual();
+                }
+
+                void FailNotEqual() => Assert.Fail($"Value not equal in ${string.Join("", path.Reverse())}: expected {expected}, but was {actual}.");
+            }
+        }
+    }
+}

src/libraries/Microsoft.Extensions.Configuration.Binder/gen/ConfigurationBindingGenerator.Emitter.cs

@@ -1,7 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
 using SourceGenerators;
 
@@ -11,19 +10,22 @@ public sealed partial class ConfigurationBindingGenerator : IIncrementalGenerato
     {
         private sealed partial class Emitter
         {
-            private readonly SourceProductionContext _context;
-            private readonly SourceGenerationSpec _sourceGenSpec;
+            private readonly InterceptorInfo _interceptorInfo;
+            private readonly BindingHelperInfo _bindingHelperInfo;
+            private readonly TypeIndex _typeIndex;
+
             private readonly SourceWriter _writer = new();
 
-            public Emitter(SourceProductionContext context, SourceGenerationSpec sourceGenSpec)
+            public Emitter(SourceGenerationSpec sourceGenSpec)
             {
-                _context = context;
-                _sourceGenSpec = sourceGenSpec;
+                _interceptorInfo = sourceGenSpec.InterceptorInfo;
+                _bindingHelperInfo = sourceGenSpec.BindingHelperInfo;
+                _typeIndex = new TypeIndex(sourceGenSpec.ConfigTypes);
             }
 
-            public void Emit()
+            public void Emit(SourceProductionContext context)
             {
-                if (!ShouldEmitBindingExtensions())
+                if (!ShouldEmitMethods(MethodsToGen.Any))
                 {
                     return;
                 }
@@ -52,7 +54,7 @@ public void Emit()
 
                 EmitEndBlock(); // Binding namespace.
 
-                _context.AddSource($"{Identifier.BindingExtensions}.g.cs", _writer.ToSourceText());
+                context.AddSource($"{Identifier.BindingExtensions}.g.cs", _writer.ToSourceText());
             }
 
             private void EmitInterceptsLocationAttrDecl()
@@ -79,7 +81,7 @@ public InterceptsLocationAttribute(string filePath, int line, int column)
 
             private void EmitUsingStatements()
             {
-                foreach (string @namespace in _sourceGenSpec.Namespaces.ToImmutableSortedSet())
+                foreach (string @namespace in _bindingHelperInfo.Namespaces)
                 {
                     _writer.WriteLine($"using {@namespace};");
                 }