Preserve executable output kind when evaluating generator methods (top-level statements support) (#78)

* Initial plan

* Preserve compilation output kind for generator execution and add top-level statements regression test

Co-authored-by: dex3r <3155725+dex3r@users.noreply.github.com>

* Apply review cleanup and finalize executable output-kind fix

Co-authored-by: dex3r <3155725+dex3r@users.noreply.github.com>

* Add explicit System.Console metadata reference in runtime regression tests

Co-authored-by: dex3r <3155725+dex3r@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: dex3r <3155725+dex3r@users.noreply.github.com>
Co-authored-by: Mateusz Krzaczek <dex3r@users.noreply.github.com>

Author: Copilot

EasySourceGenerators.GeneratorTests/GeneratesMethodExecutionRuntimeTests.cs

@@ -57,6 +57,39 @@ public static class GenHost
         Assert.That(result.value, Is.EqualTo("hello"));
     }
 
+    [Test]
+    public void ExecuteSimpleGeneratorMethod_ExecutesWhenCompilationHasTopLevelStatements()
+    {
+        CSharpCompilation compilation = CreateCompilation("""
+                                                         using System;
+
+                                                         Console.WriteLine("warmup");
+
+                                                         namespace TestNamespace
+                                                         {
+                                                             public partial class Target
+                                                             {
+                                                                 public partial string GetValue();
+                                                             }
+
+                                                             public static class GenHost
+                                                             {
+                                                                 public static string Generate() => "hello";
+                                                             }
+                                                         }
+                                                         """,
+            outputKind: OutputKind.ConsoleApplication);
+
+        IMethodSymbol generatorMethod = GetMethodSymbol(compilation, "TestNamespace.GenHost", "Generate");
+        IMethodSymbol partialMethod = GetMethodSymbol(compilation, "TestNamespace.Target", "GetValue");
+
+        (string? value, string? error) result =
+            GeneratesMethodExecutionRuntime.ExecuteSimpleGeneratorMethod(generatorMethod, partialMethod, compilation);
+
+        Assert.That(result.error, Is.Null);
+        Assert.That(result.value, Is.EqualTo("hello"));
+    }
+
     [Test]
     public void ExecuteGeneratorMethodWithArgs_ConvertsArgumentsToMethodParameterType()
     {
@@ -253,14 +286,17 @@ public static string Generate()
         Assert.That(result.error, Does.StartWith("Compilation failed:"));
     }
 
-    private static CSharpCompilation CreateCompilation(string source, string assemblyName = "TestAssembly")
+    private static CSharpCompilation CreateCompilation(
+        string source,
+        string assemblyName = "TestAssembly",
+        OutputKind outputKind = OutputKind.DynamicallyLinkedLibrary)
     {
         SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(source);
         CSharpCompilation compilation = CSharpCompilation.Create(
             assemblyName: assemblyName,
             syntaxTrees: new[] { syntaxTree },
             references: GetMetadataReferences(),
-            options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+            options: new CSharpCompilationOptions(outputKind));
         return compilation;
     }
 
@@ -273,6 +309,7 @@ private static ImmutableArray<MetadataReference> GetMetadataReferences()
             MetadataReference.CreateFromFile(Path.Combine(dotnetDirectory, "System.Runtime.dll")),
             MetadataReference.CreateFromFile(Path.Combine(dotnetDirectory, "System.Collections.dll")),
             MetadataReference.CreateFromFile(Path.Combine(dotnetDirectory, "System.Linq.dll")),
+            MetadataReference.CreateFromFile(Path.Combine(dotnetDirectory, "System.Console.dll")),
             MetadataReference.CreateFromFile(Path.Combine(dotnetDirectory, "netstandard.dll")),
             MetadataReference.CreateFromFile(typeof(Generate).Assembly.Location),
             MetadataReference.CreateFromFile(typeof(GeneratesMethodExecutionRuntime).Assembly.Location)

EasySourceGenerators.Generators/GeneratesMethodExecutionRuntime.cs

@@ -345,7 +345,6 @@ private static CSharpCompilation BuildExecutionCompilation(
                                          ?? CSharpParseOptions.Default;
 
         return (CSharpCompilation)compilation
-            .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
             .AddSyntaxTrees(
                 CSharpSyntaxTree.ParseText(dummySource, parseOptions),
                 CSharpSyntaxTree.ParseText(methodBuilderSource, parseOptions),