fix: Correctly support incremental source generation

.gitignore

@@ -5,3 +5,5 @@ obj
 *.DotSettings.user
 .vs
 .DS_Store
+
+Generator.Equals.Tests/Generated/**

Generator.Equals.DynamicGenerationTests/Base_Assertions.cs

@@ -0,0 +1,83 @@
+extern alias genEquals;
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Generator.Equals.Tests.DynamicGeneration;
+
+public class Base_Assertions
+{
+    // Check if immutable arrays are comparable
+    [Fact]
+    public void Immutable_Arrays_Eqatable()
+    {
+        var a = ImmutableArray.Create(1, 2, 3);
+        var b = ImmutableArray.Create(1, 2, 3);
+        Assert.Equal(a, b);
+    }
+
+    [Fact]
+    public void Immutable_Arrays_Comparable()
+    {
+        var a = ImmutableArray.Create(1, 2, 3);
+        var b = ImmutableArray.Create(1, 2, 3);
+        Assert.True(a.SequenceEqual(b));
+    }
+
+    // Check if equality type model is comparable by value
+    [Fact]
+    public void EqualityTypeModel_Eqatable()
+    {
+        var a = CreateEqualityTypeModelMock();
+        var b = CreateEqualityTypeModelMock();
+        Assert.Equal(a, b);
+    }
+
+    [Fact]
+    public void AttributesMetadata_Equatable()
+    {
+        var a = AttributesMetadata.CreateDefault();
+        var b = AttributesMetadata.CreateDefault();
+        Assert.True(a.Equals(b));
+    }
+
+    internal static EqualityTypeModel CreateEqualityTypeModelMock()
+    {
+        var containingSymbols = ImmutableArray.Create<ContainingSymbol>(
+            new NamespaceContainingSymbol { Name = "Namespace1" },
+            new TypeContainingSymbol { Name = "ContainingType", Kind = null }
+        );
+
+        var attributesMetadata = AttributesMetadata.Instance;
+
+        var equalityMemberModels = ImmutableArray.Create(
+            new EqualityMemberModel
+            {
+                PropertyName = "Property1",
+                TypeName = "int",
+                EqualityType = EqualityType.DefaultEquality
+            },
+            new EqualityMemberModel
+            {
+                PropertyName = "Property2",
+                TypeName = "string",
+                EqualityType = EqualityType.StringEquality,
+                StringComparer = attributesMetadata.StringComparisonLookup[4]
+            }
+        );
+
+        return new EqualityTypeModel(
+            typeName: "MyType",
+            containingSymbols: containingSymbols,
+            attributesMetadata: attributesMetadata,
+            explicitMode: false,
+            ignoreInheritedMembers: false
+        )
+        {
+            SyntaxKind = SyntaxKind.ClassDeclaration,
+            BaseTypeName = "BaseType",
+            IsSealed = true,
+            BuildEqualityModels = equalityMemberModels,
+            Fullname = "Namespace1.MyType"
+        };
+    }
+}

Generator.Equals.DynamicGenerationTests/Generator.Equals.Tests.DynamicGeneration.csproj

@@ -0,0 +1,33 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="xunit" Version="2.5.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
+	<PackageReference Include="SourceGeneratorTestHelpers" Version="8.1.0" />
+
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Generator.Equals.Runtime\Generator.Equals.Runtime.csproj" />
+	  <ProjectReference Include="..\Generator.Equals\Generator.Equals.csproj">
+		  <Aliases>genEquals</Aliases>
+	  </ProjectReference>
+  </ItemGroup>
+
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>

Generator.Equals.DynamicGenerationTests/Globals.cs

@@ -0,0 +1,4 @@
+extern alias genEquals;
+
+global using genEquals::Generator.Equals.Models;
+global using genEquals::Generator.Equals;

Generator.Equals.DynamicGenerationTests/SourceText.cs

@@ -0,0 +1,10 @@
+extern alias genEquals;
+
+using genEquals::System.Diagnostics.CodeAnalysis;
+
+namespace Generator.Equals.DynamicGenerationTests;
+
+internal static class SourceText
+{
+    public static string CSharp([StringSyntax("c#-test")] string source) => source;
+}

Generator.Equals.DynamicGenerationTests/UnitTest1.cs

@@ -0,0 +1,216 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+using SourceGeneratorTestHelpers;
+
+namespace Generator.Equals.DynamicGenerationTests;
+
+public class UnitTest1
+{
+    public static readonly List<PortableExecutableReference> References2 =
+        AppDomain.CurrentDomain.GetAssemblies()
+            .Where(_ => !_.IsDynamic && !string.IsNullOrWhiteSpace(_.Location))
+            .Select(_ => MetadataReference.CreateFromFile(_.Location))
+            .Concat(new[]
+            {
+                // add your app/lib specifics, e.g.:
+                MetadataReference.CreateFromFile(typeof(EquatableAttribute).Assembly.Location),
+            })
+            .ToList();
+
+    [Fact]
+    public void Test1()
+    {
+        var input = SourceText.CSharp(
+            """
+            using System;
+            using Generator.Equals;
+
+             namespace Tests;
+
+             [Equatable]
+             public partial record MyRecord(
+                 [property: OrderedEquality] string[] Fruits,
+                 [property: StringEquality(StringComparison.OrdinalIgnoreCase)] string Fruit
+             );
+
+            """
+        );
+
+        var result = IncrementalGenerator.Run<EqualsGenerator>
+        (
+            input,
+            new CSharpParseOptions()
+            {
+            },
+            References2
+        );
+
+        var gensource = result.Results
+                .SelectMany(x => x.GeneratedSources)
+                .Select(x => x.SourceText)
+                .ToList()
+            ;
+
+        Assert.NotNull(gensource);
+    }
+
+    [Fact]
+    public void Test2_Nested()
+    {
+        var input = SourceText.CSharp(
+            """
+            using System;
+            using System.Collections.Generic;
+            using Generator.Equals;
+
+
+            namespace Generator.Equals.Tests.Records
+            {
+                public partial class CustomEquality
+                {
+                    [Equatable]
+                    public partial record Sample
+                    {
+                        public Sample(string name1, string name2, string name3)
+                        {
+                            Name1 = name1;
+                            Name2 = name2;
+                            Name3 = name3;
+                        }
+
+                        [CustomEquality(typeof(Comparer1))] public string Name1 { get; }
+                        [CustomEquality(typeof(Comparer2), nameof(Comparer2.Instance))] public string Name2 { get; }
+                        [CustomEquality(typeof(LengthEqualityComparer))] public string Name3 { get; }
+                    }
+
+                    class Comparer1
+                    {
+                        public static readonly LengthEqualityComparer Default = new();
+                    }
+
+                    class Comparer2
+                    {
+                        public static readonly LengthEqualityComparer Instance = new();
+                    }
+
+                    class LengthEqualityComparer : IEqualityComparer<string>
+                    {
+                        public bool Equals(string? x, string? y) => x?.Length == y?.Length;
+
+                        public int GetHashCode(string obj) => obj.Length.GetHashCode();
+                    }
+
+                }
+            }
+            """
+        );
+
+        var result = IncrementalGenerator.Run<EqualsGenerator>
+        (
+            input,
+            new CSharpParseOptions()
+            {
+            },
+            References2
+        );
+
+        var gensource = result.Results
+                .SelectMany(x => x.GeneratedSources)
+                .Select(x => x.SourceText)
+                .ToList()
+            ;
+
+        Assert.NotNull(gensource);
+    }
+
+    [Fact]
+    public void Test3_Struct_UnorderedEquality()
+    {
+        var input = SourceText.CSharp(
+            """
+            using System.Collections.Generic;
+
+            namespace Generator.Equals.Tests.Structs
+            {
+                public partial class UnorderedEquality
+                {
+                    [Equatable]
+                    public partial struct Sample
+                    {
+                        [UnorderedEquality] public List<int>? Properties { get; set; }
+                    }
+                }
+            }
+            """
+        );
+
+        var result = IncrementalGenerator.Run<EqualsGenerator>
+        (
+            input,
+            new CSharpParseOptions()
+            {
+            },
+            References2
+        );
+
+        var gensource = result.Results
+                .SelectMany(x => x.GeneratedSources)
+                .Select(x => x.SourceText)
+                .ToList()
+            ;
+
+        Assert.NotNull(gensource);
+    }
+
+    [Fact]
+    public void Test3_Struct_ExplicitMode()
+    {
+        var input = SourceText.CSharp(
+            """
+            namespace Generator.Equals.Tests.Structs
+            {
+                public partial class ExplicitMode
+                {
+                    [Equatable(Explicit = true)]
+                    public partial struct Sample
+                    {
+                        bool _flag;
+
+                        public Sample(string name, int age, bool flag)
+                        {
+                            _flag = flag;
+                            Name = name;
+                            Age = age;
+                        }
+
+                        public string Name { get; }
+
+                        [DefaultEquality]
+                        public int Age { get; }
+                    }
+                }
+            }
+            """
+        );
+
+        var result = IncrementalGenerator.Run<EqualsGenerator>
+        (
+            input,
+            new CSharpParseOptions()
+            {
+            },
+            References2
+        );
+
+        var gensource = result.Results
+                .SelectMany(x => x.GeneratedSources)
+                .Select(x => x.SourceText)
+                .ToList()
+            ;
+
+        Assert.NotNull(gensource);
+    }
+
+
+}