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,82 @@
+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
+        {
+            SyntaxKind = SyntaxKind.ClassDeclaration,
+            TypeName = "MyType",
+            BaseTypeName = "BaseType",
+            IsSealed = true,
+            ContainingSymbols = containingSymbols,
+            AttributesMetadata = attributesMetadata,
+            ExplicitMode = false,
+            IgnoreInheritedMembers = false,
+            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.Tests/Generator.Equals.Tests.csproj

@@ -7,7 +7,19 @@
         <NoWarn>NU1701</NoWarn>
         <Nullable>enable</Nullable>
     </PropertyGroup>
-
+
+    <!-- For debugging -->
+    <!--
+    <PropertyGroup>
+        <EmitCompilerGeneratedFiles>true</EmitCompilerGeneratedFiles>
+        <CompilerGeneratedFilesOutputPath>$(MSBuildProjectDirectory)\Generated</CompilerGeneratedFilesOutputPath>
+    </PropertyGroup>
+    <ItemGroup>
+      <Compile Remove="Generated\**" />
+      <None Include="Generated\**" />
+    </ItemGroup>
+    -->
+
     <ItemGroup>
 
         <PackageReference Include="Microsoft.Bcl.HashCode" Version="1.1.1" Condition="'$(TargetFramework.TrimEnd(`0123456789`))' == 'net'" />

Generator.Equals.Tests/Structs/UnorderedEquality.Sample.cs

@@ -10,4 +10,4 @@ public partial struct Sample
             [UnorderedEquality] public List<int>? Properties { get; set; }
         }
     }
-}
+}

Generator.Equals.sln

@@ -9,9 +9,11 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Generator.Equals.Tests", "G
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Generator.Equals.SnapshotTests", "Generator.Equals.SnapshotTests\Generator.Equals.SnapshotTests.csproj", "{F11B4229-E761-4135-B758-E61AC4FF5303}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Generator.Equals.Tests.TopLevel", "Generator.Equals.Tests.TopLevel\Generator.Equals.Tests.TopLevel.csproj", "{9A48A8A6-4213-4CBB-B184-FE1E50F3721E}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Generator.Equals.Tests.TopLevel", "Generator.Equals.Tests.TopLevel\Generator.Equals.Tests.TopLevel.csproj", "{9A48A8A6-4213-4CBB-B184-FE1E50F3721E}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Generator.Equals.Runtime", "Generator.Equals.Runtime\Generator.Equals.Runtime.csproj", "{2AD99F42-5E2C-451A-97EE-59C64EC8B270}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Generator.Equals.Runtime", "Generator.Equals.Runtime\Generator.Equals.Runtime.csproj", "{2AD99F42-5E2C-451A-97EE-59C64EC8B270}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Generator.Equals.Tests.DynamicGeneration", "Generator.Equals.DynamicGenerationTests\Generator.Equals.Tests.DynamicGeneration.csproj", "{20F96A29-3BC9-4115-B99D-1E6D45C6340F}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -39,6 +41,10 @@ Global
 		{2AD99F42-5E2C-451A-97EE-59C64EC8B270}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2AD99F42-5E2C-451A-97EE-59C64EC8B270}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2AD99F42-5E2C-451A-97EE-59C64EC8B270}.Release|Any CPU.Build.0 = Release|Any CPU
+		{20F96A29-3BC9-4115-B99D-1E6D45C6340F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{20F96A29-3BC9-4115-B99D-1E6D45C6340F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{20F96A29-3BC9-4115-B99D-1E6D45C6340F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{20F96A29-3BC9-4115-B99D-1E6D45C6340F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

Generator.Equals/ContainingTypesBuilder.cs

@@ -1,88 +1,51 @@
 using System;
 using System.CodeDom.Compiler;
-using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.IO;
 using System.Linq;
 using System.Text;
-using Microsoft.CodeAnalysis;
+
+using Generator.Equals.Models;
+
 using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace Generator.Equals
 {
-    static class ContainingTypesBuilder
+    internal static class ContainingTypesBuilder
     {
-        static IEnumerable<INamespaceOrTypeSymbol> ContainingNamespaceAndTypes(ISymbol symbol, bool includeSelf)
-        {
-            foreach (var item in AllContainingNamespacesAndTypes(symbol, includeSelf))
-            {
-                yield return item;
-
-                if (item.IsNamespace)
-                    yield break;
-            }
-        }
-
-        static IEnumerable<INamespaceOrTypeSymbol> AllContainingNamespacesAndTypes(ISymbol symbol, bool includeSelf)
+        public static string Build(ImmutableArray<ContainingSymbol> containingSymbols, Action<IndentedTextWriter> content)
         {
-            if (includeSelf && symbol is INamespaceOrTypeSymbol self)
-                yield return self;
+            using var buffer = new StringWriter(new StringBuilder(capacity: 4096));
+            using var writer = new IndentedTextWriter(buffer);
 
-            while (true)
+            foreach (var parentSymbol in containingSymbols.Reverse())
             {
-                symbol = symbol.ContainingSymbol;
-
-                if (!(symbol is INamespaceOrTypeSymbol namespaceOrTypeSymbol))
-                    yield break;
-
-                yield return namespaceOrTypeSymbol;
-            }
-        }
-
-        public static string Build(ISymbol symbol, Action<IndentedTextWriter> content, bool includeSelf = false)
-        {
-            var buffer = new StringWriter(new StringBuilder(capacity: 4096));
-            var writer = new IndentedTextWriter(buffer);
-            var symbols = ContainingNamespaceAndTypes(symbol, includeSelf).ToList();
-
-            for (var i = symbols.Count - 1; i >= 0; i--)
-            {
-                var s = symbols[i];
-
-                if (s.IsNamespace)
+                if (parentSymbol is NamespaceContainingSymbol namespaceSymbol)
                 {
                     writer.WriteLine();
                     writer.WriteLine(EqualityGeneratorBase.EnableNullableContext);
                     writer.WriteLine(EqualityGeneratorBase.SuppressObsoleteWarningsPragma);
                     writer.WriteLine(EqualityGeneratorBase.SuppressTypeConflictsWarningsPragma);
                     writer.WriteLine();
 
-                    var namespaceName = s.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat.WithGlobalNamespaceStyle(SymbolDisplayGlobalNamespaceStyle.Omitted));
-
-                    if (!string.IsNullOrEmpty(namespaceName))
+                    if (!string.IsNullOrEmpty(namespaceSymbol.Name))
                     {
-                        writer.WriteLine($"namespace {namespaceName}");
+                        writer.WriteLine($"namespace {namespaceSymbol.Name}");
                         writer.AppendOpenBracket();
                     }
                 }
-                else
+                else if (parentSymbol is TypeContainingSymbol typeContainingSymbol)
                 {
-                    var typeDeclarationSyntax = s.DeclaringSyntaxReferences
-                        .Select(x => x.GetSyntax())
-                        .OfType<TypeDeclarationSyntax>()
-                        .First();
-
-                    var keyword = typeDeclarationSyntax.Kind() switch
+                    var keyword = typeContainingSymbol.Kind switch
                     {
                         SyntaxKind.ClassDeclaration => "class",
                         SyntaxKind.RecordDeclaration => "record",
-                        (SyntaxKind)9068 => "record struct", // RecordStructDeclaration
+                        SyntaxKind.RecordStructDeclaration => "record struct",
                         SyntaxKind.StructDeclaration => "struct",
                         var x => throw new ArgumentOutOfRangeException($"Syntax kind {x} not supported")
                     };
 
-                    var typeName = s.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
-                    writer.WriteLine($"partial {keyword} {typeName}");
+                    writer.WriteLine($"partial {keyword} {parentSymbol.Name}");
                     writer.AppendOpenBracket();
                 }
             }