Topic/2024.2/bug 35213 tests

Metalama.Testing.UnitTesting/TestCompilationFactory.cs

@@ -214,6 +214,56 @@ public static CSharpCompilation CreateCSharpCompilation(
         return mainRoslynCompilation;
     }
 
+    public static SyntaxTree[] ParseCSharpSyntaxTrees( IReadOnlyDictionary<string, string> code, IEnumerable<string>? preprocessorSymbols = null )
+    {
+        var parseOptions = GetParseOptions( preprocessorSymbols );
+        return code.SelectAsArray( c => SyntaxFactory.ParseSyntaxTree( c.Value, path: c.Key, options: parseOptions ) );
+    }
+
+    public static CSharpCompilation ReplaceSyntaxTrees( CSharpCompilation compilation, IReadOnlyDictionary<string, string> code, IEnumerable<string>? preprocessorSymbols = null )
+    {
+        HashSet<SyntaxTree> originalSyntaxTrees = new( compilation.SyntaxTrees );
+
+        foreach (var syntaxTree in ParseCSharpSyntaxTrees(code, preprocessorSymbols))
+        {
+            var originalSyntaxTree = originalSyntaxTrees.FirstOrDefault( t => t.FilePath == syntaxTree.FilePath );
+
+            if ( originalSyntaxTree != null )
+            {
+                compilation = compilation.ReplaceSyntaxTree( originalSyntaxTree, syntaxTree );
+                originalSyntaxTrees.Remove( originalSyntaxTree );
+            }
+            else
+            {
+                compilation = compilation.AddSyntaxTrees( syntaxTree );
+            }
+        }
+
+        return compilation.RemoveSyntaxTrees( originalSyntaxTrees );
+    }
+
+    public static CSharpCompilation ReplaceReferences( CSharpCompilation compilation, IReadOnlyList<MetadataReference> references )
+    {
+        HashSet<MetadataReference> originalReferences = new( compilation.References );
+
+        foreach ( var reference in references )
+        {
+            var originalReference = originalReferences.FirstOrDefault( r => r .Display== reference.Display );
+
+            if ( originalReference != null )
+            {
+                compilation = compilation.ReplaceReference( originalReference, reference );
+                originalReferences.Remove( reference );
+            }
+            else
+            {
+                compilation = compilation.AddReferences( reference );
+            }
+        }
+
+        return compilation;
+    }
+
     private static void AssertNoError( CSharpCompilation mainRoslynCompilation )
     {
         var diagnostics = mainRoslynCompilation.GetDiagnostics();

tests/Metalama.Framework.Tests.UnitTests/DesignTime/Pipeline/CompilationChangesTests.GetChanges.cs

@@ -266,4 +266,29 @@ public void DuplicateTrees()
 
         Assert.False( changes.HasChange );
     }
+
+    [Fact]
+    public void ChangeDeleteAddSyntaxTree()
+    {
+        var code = new Dictionary<string, string>();
+        var compilation1 = TestCompilationFactory.CreateCSharpCompilation( code, name: nameof( this.AddSyntaxTree_Standard ) );
+
+        code.Add( "code.cs", "class C { }" );
+
+        var compilation2 = TestCompilationFactory.CreateCSharpCompilation( code, name: nameof( this.AddSyntaxTree_Standard ) );
+        var changes = this.CompareSyntaxTrees( compilation1, compilation2 );
+
+        Assert.False( changes.HasCompileTimeCodeChange );
+        Assert.True( changes.HasChange );
+        Assert.True( changes.IsIncremental );
+        Assert.Equal( compilation2, changes.NewProjectVersion.CompilationToAnalyze );
+        Assert.Single( changes.SyntaxTreeChanges );
+
+        var syntaxTreeChange = changes.SyntaxTreeChanges.Single().Value;
+
+        Assert.Equal( SyntaxTreeChangeKind.Added, syntaxTreeChange.SyntaxTreeChangeKind );
+        Assert.Equal( CompileTimeChangeKind.None, syntaxTreeChange.CompileTimeChangeKind );
+        Assert.True( syntaxTreeChange.OldSyntaxTreeVersionDangerous.IsDefault );
+        Assert.NotNull( syntaxTreeChange.NewTree );
+    }
 }