chore: add ImmutableEquatableArray

src/Riok.Mapperly/Descriptors/DescriptorBuilder.cs

@@ -45,7 +45,7 @@ SymbolAccessor symbolAccessor
         );
     }
 
-    public (MapperDescriptor descriptor, List<Diagnostic> errors) Build()
+    public (MapperDescriptor descriptor, List<Diagnostic> diagnostics) Build()
     {
         ReserveMethodNames();
         ExtractObjectFactories();

src/Riok.Mapperly/Helpers/HashHelper.cs

@@ -0,0 +1,12 @@
+namespace Riok.Mapperly.Helpers;
+
+internal class HashHelper
+{
+    public static int Combine(int h1, int h2)
+    {
+        // RyuJIT optimizes this to use the ROL instruction
+        // Related GitHub pull request: https://github.com/dotnet/coreclr/pull/1830
+        uint rol5 = ((uint)h1 << 5) | ((uint)h1 >> 27);
+        return ((int)rol5 + h1) ^ h2;
+    }
+}

src/Riok.Mapperly/Helpers/IncrementalValuesProviderExtensions.cs

@@ -1,4 +1,3 @@
-using System.Collections.Immutable;
 using Microsoft.CodeAnalysis;
 
 namespace Riok.Mapperly.Helpers;
@@ -19,7 +18,7 @@ public static IncrementalValuesProvider<TSource> WhereNotNull<TSource>(this Incr
     /// <param name="diagnostics">The input <see cref="IncrementalValuesProvider{TValues}"/> sequence of diagnostics.</param>
     public static void ReportDiagnostics(
         this IncrementalGeneratorInitializationContext context,
-        IncrementalValueProvider<ImmutableArray<Diagnostic>> diagnostics
+        IncrementalValueProvider<ImmutableEquatableArray<Diagnostic>> diagnostics
     )
     {
         context.RegisterSourceOutput(

src/Riok.Mapperly/ImmutableEquatableArray.cs

@@ -0,0 +1,82 @@
+// 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;
+using Riok.Mapperly.Helpers;
+
+namespace Riok.Mapperly;
+
+/// <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(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()
+    {
+        var hash = 0;
+        foreach (T value in _values)
+        {
+            hash = HashHelper.Combine(hash, 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()
+        {
+            var newIndex = _index + 1;
+
+            if ((uint)newIndex < (uint)_values.Length)
+            {
+                _index = newIndex;
+                return true;
+            }
+
+            return false;
+        }
+
+        public readonly T Current => _values[_index];
+    }
+}
+
+public 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);
+
+    public static ImmutableEquatableArray<T> Create<T>(params T[] values)
+        where T : IEquatable<T> => values is { Length: > 0 } ? new(values) : ImmutableEquatableArray<T>.Empty;
+}

src/Riok.Mapperly/MapperGenerator.cs

@@ -14,6 +14,8 @@ namespace Riok.Mapperly;
 public class MapperGenerator : IIncrementalGenerator
 {
     private const string GeneratedFileSuffix = ".g.cs";
+    public const string AddMappersStep = "ImplementationSourceOutput";
+    public const string ReportDiagnosticsStep = "Diagnostics";
 
     public static readonly string MapperAttributeName = typeof(MapperAttribute).FullName;
 
@@ -27,7 +29,9 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
         );
 
         // output the diagnostics
-        context.ReportDiagnostics(mappersWithDiagnostics.Select(static (source, _) => source.Diagnostics).WithTrackingName("diagnostics"));
+        context.ReportDiagnostics(
+            mappersWithDiagnostics.Select(static (source, _) => source.Diagnostics).WithTrackingName(ReportDiagnosticsStep)
+        );
 
         // split into mapper name pairs
         var mappers = mappersWithDiagnostics.SelectMany(static (x, _) => x.Mappers);
@@ -75,16 +79,14 @@ CancellationToken cancellationToken
             if (!symbolAccessor.HasAttribute<MapperAttribute>(mapperSymbol))
                 continue;
 
-            var builder = new DescriptorBuilder(ctx, compilation, mapperSyntax, mapperSymbol, wellKnownTypes, symbolAccessor);
-            var descriptor = builder.Build();
-            var builder = new DescriptorBuilder(compilation, mapperSyntax, mapperSymbol, wellKnownTypes);
+            var builder = new DescriptorBuilder(compilation, mapperSyntax, mapperSymbol, wellKnownTypes, symbolAccessor);
             var (descriptor, descriptorDiagnostics) = builder.Build();
 
             diagnostics.AddRange(descriptorDiagnostics);
             members.Add(new MapperNode(SourceEmitter.Build(descriptor), uniqueNameBuilder.New(descriptor.Name) + GeneratedFileSuffix));
         }
 
         cancellationToken.ThrowIfCancellationRequested();
-        return new MapperResults(members.ToImmutableArray(), diagnostics.ToImmutableArray());
+        return new MapperResults(members.ToImmutableEquatableArray(), diagnostics.ToImmutableEquatableArray());
     }
 }

src/Riok.Mapperly/MapperResults.cs

@@ -1,50 +1,8 @@
-using System.Collections.Immutable;
-using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis;
 
 namespace Riok.Mapperly;
 
-public readonly struct MapperResults : IEquatable<MapperResults>
+public readonly record struct MapperResults(ImmutableEquatableArray<MapperNode> Mappers, ImmutableEquatableArray<Diagnostic> Diagnostics)
 {
-    public static readonly MapperResults Empty = new(ImmutableArray<MapperNode>.Empty, ImmutableArray<Diagnostic>.Empty);
-
-    public MapperResults(ImmutableArray<MapperNode> mappers, ImmutableArray<Diagnostic> diagnostics)
-    {
-        Mappers = mappers;
-        Diagnostics = diagnostics;
-    }
-
-    public ImmutableArray<MapperNode> Mappers { get; }
-    public ImmutableArray<Diagnostic> Diagnostics { get; }
-
-    public bool Equals(MapperResults other)
-    {
-        return Mappers.SequenceEqual(other.Mappers) && Diagnostics.SequenceEqual(other.Diagnostics);
-    }
-
-    public override bool Equals(object? obj) => obj is MapperResults other && Equals(other);
-
-    public override int GetHashCode()
-    {
-        unchecked
-        {
-            var hash = 0;
-            foreach (var mapper in Mappers)
-            {
-                hash = Combine(hash, mapper.GetHashCode());
-            }
-            foreach (var diagnostic in Diagnostics)
-            {
-                hash = Combine(hash, diagnostic.GetHashCode());
-            }
-            return hash;
-        }
-
-        static int Combine(int h1, int h2)
-        {
-            // RyuJIT optimizes this to use the ROL instruction
-            // Related GitHub pull request: https://github.com/dotnet/coreclr/pull/1830
-            uint rol5 = ((uint)h1 << 5) | ((uint)h1 >> 27);
-            return ((int)rol5 + h1) ^ h2;
-        }
-    }
+    public static readonly MapperResults Empty = new(ImmutableEquatableArray<MapperNode>.Empty, ImmutableEquatableArray<Diagnostic>.Empty);
 }

test/Riok.Mapperly.Tests/Generator/IncrementalGeneratorTest.cs

@@ -7,9 +7,6 @@ namespace Riok.Mapperly.Tests.Generator;
 [UsesVerify]
 public class IncrementalGeneratorTest
 {
-    private const string AddMappersStep = "ImplementationSourceOutput";
-    private const string ReportDiagnosticsStep = "diagnostics";
-
     [Fact]
     public void AddingUnrelatedTypeDoesNotRegenerateOriginal()
     {
@@ -23,8 +20,8 @@ public void AddingUnrelatedTypeDoesNotRegenerateOriginal()
         var compilation2 = compilation1.AddSyntaxTrees(TestSourceBuilder.SyntaxTree("struct MyValue {}"));
         var driver2 = driver1.RunGenerators(compilation2);
 
-        AssertRunResults(AddMappersStep, driver2, IncrementalStepRunReason.Cached);
-        AssertRunResults(ReportDiagnosticsStep, driver2, IncrementalStepRunReason.Cached);
+        AssertRunResults(MapperGenerator.AddMappersStep, driver2, IncrementalStepRunReason.Cached);
+        AssertRunResults(MapperGenerator.ReportDiagnosticsStep, driver2, IncrementalStepRunReason.Cached);
     }
 
     [Fact]
@@ -38,17 +35,17 @@ public void AddingNewMapperDoesNotRegenerateOriginal()
 
         var secondary = TestSourceBuilder.SyntaxTree(
             """
-using Riok.Mapperly.Abstractions;
-
-namespace Test.B
-{
-    [Mapper]
-    internal partial class BarFooMapper
-    {
-        internal partial string BarToFoo(string value);
-    }
-}
-"""
+                    using Riok.Mapperly.Abstractions;
+
+                    namespace Test.B
+                    {
+                        [Mapper]
+                        internal partial class BarFooMapper
+                        {
+                            internal partial string BarToFoo(string value);
+                        }
+                    }
+                    """
         );
 
         var syntaxTree = CSharpSyntaxTree.ParseText(source, CSharpParseOptions.Default);
@@ -59,8 +56,8 @@ internal partial class BarFooMapper
         var compilation2 = compilation1.AddSyntaxTrees(secondary);
         var driver2 = driver1.RunGenerators(compilation2);
 
-        AssertRunResults(AddMappersStep, driver2, IncrementalStepRunReason.Cached, IncrementalStepRunReason.New);
-        AssertRunResults(ReportDiagnosticsStep, driver2, IncrementalStepRunReason.Modified);
+        AssertRunResults(MapperGenerator.AddMappersStep, driver2, IncrementalStepRunReason.Cached, IncrementalStepRunReason.New);
+        AssertRunResults(MapperGenerator.ReportDiagnosticsStep, driver2, IncrementalStepRunReason.Modified);
     }
 
     [Fact]
@@ -80,8 +77,8 @@ public void AppendingUnrelatedTypeDoesNotRegenerateOriginal()
         var compilation2 = compilation1.ReplaceSyntaxTree(compilation1.SyntaxTrees.First(), newTree);
         var driver2 = driver1.RunGenerators(compilation2);
 
-        AssertRunResults(AddMappersStep, driver2, IncrementalStepRunReason.Cached);
-        AssertRunResults(ReportDiagnosticsStep, driver2, IncrementalStepRunReason.Cached);
+        AssertRunResults(MapperGenerator.AddMappersStep, driver2, IncrementalStepRunReason.Cached);
+        AssertRunResults(MapperGenerator.ReportDiagnosticsStep, driver2, IncrementalStepRunReason.Cached);
     }
 
     [Fact]
@@ -107,8 +104,8 @@ public void ModifyingMapperDoesRegenerateOriginal()
         var compilation2 = compilation1.ReplaceSyntaxTree(compilation1.SyntaxTrees.First(), newTree);
         var driver2 = driver1.RunGenerators(compilation2);
 
-        AssertRunResults(AddMappersStep, driver2, IncrementalStepRunReason.New);
-        AssertRunResults(ReportDiagnosticsStep, driver2, IncrementalStepRunReason.Modified);
+        AssertRunResults(MapperGenerator.AddMappersStep, driver2, IncrementalStepRunReason.New);
+        AssertRunResults(MapperGenerator.ReportDiagnosticsStep, driver2, IncrementalStepRunReason.Modified);
     }
 
     private static void AssertRunResults(string name, GeneratorDriver driver, params IncrementalStepRunReason[] runReasons)