Replace AdhocWorkspace with CSharpCompilation

This is a breaking change to our extensibility API, but it is necessary to completely eliminate the MEF cost that we incur for every project build. And should not adversely impact what code generators can achieve.

Fixes #18

Author: AArnott

src/CodeGeneration.Roslyn.Tasks.Helper/Helper.cs

@@ -21,6 +21,7 @@ namespace CodeGeneration.Roslyn.Tasks
     using Microsoft.CodeAnalysis.Text;
     using Task = System.Threading.Tasks.Task;
     using Validation;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
 
     public class Helper
 #if NET46
@@ -76,7 +77,7 @@ public void Execute()
 
             Task.Run(async delegate
             {
-                var project = this.CreateProject();
+                var compilation = this.CreateCompilation();
                 var outputFiles = new List<ITaskItem>();
                 var writtenFiles = new List<ITaskItem>();
 
@@ -91,35 +92,36 @@ where string.Equals(item.GetMetadata("Generator"), $"MSBuild:{this.TargetName}",
                     select item.ItemSpec,
                     StringComparer.OrdinalIgnoreCase);
 
-                foreach (var inputDocument in project.Documents)
+                foreach (var inputSyntaxTree in compilation.SyntaxTrees)
                 {
                     this.CancellationToken.ThrowIfCancellationRequested();
 
                     // Skip over documents that aren't on the prescribed list of files to scan.
-                    if (!explicitIncludeList.Contains(inputDocument.Name))
+                    if (!explicitIncludeList.Contains(inputSyntaxTree.FilePath))
                     {
                         continue;
                     }
 
-                    string sourceHash = inputDocument.Name.GetHashCode().ToString("x", CultureInfo.InvariantCulture);
-                    string outputFilePath = Path.Combine(this.IntermediateOutputDirectory, Path.GetFileNameWithoutExtension(inputDocument.Name) + $".{sourceHash}.generated.cs");
+                    string sourceHash = inputSyntaxTree.FilePath.GetHashCode().ToString("x", CultureInfo.InvariantCulture);
+                    string outputFilePath = Path.Combine(this.IntermediateOutputDirectory, Path.GetFileNameWithoutExtension(inputSyntaxTree.FilePath) + $".{sourceHash}.generated.cs");
 
                     // Code generation is relatively fast, but it's not free.
                     // And when we run the Simplifier.ReduceAsync it's dog slow.
                     // So skip files that haven't changed since we last generated them.
                     bool generated = false;
                     DateTime outputLastModified = File.GetLastWriteTime(outputFilePath);
-                    if (File.GetLastWriteTime(inputDocument.Name) > outputLastModified || assembliesLastModified > outputLastModified)
+                    if (File.GetLastWriteTime(inputSyntaxTree.FilePath) > outputLastModified || assembliesLastModified > outputLastModified)
                     {
-                        var outputDocument = await DocumentTransform.TransformAsync(
-                            inputDocument,
-                            new ProgressLogger(this.Log, inputDocument.Name));
-
-                        // Only produce a new file if the generated document is not empty.
-                        var semanticModel = await outputDocument.GetSemanticModelAsync(this.CancellationToken);
-                        if (!CSharpDeclarationComputer.GetDeclarationsInSpan(semanticModel, TextSpan.FromBounds(0, semanticModel.SyntaxTree.Length), false, this.CancellationToken).IsEmpty)
+                        var generatedSyntaxTree = await DocumentTransform.TransformAsync(
+                            compilation,
+                            inputSyntaxTree,
+                            new ProgressLogger(this.Log, inputSyntaxTree.FilePath));
+
+                        // Only produce a new file if the generated document has generated a type.
+                        bool anyMembersGenerated = generatedSyntaxTree?.GetRoot(this.CancellationToken).DescendantNodes().OfType<TypeDeclarationSyntax>().Any() ?? false;
+                        if (anyMembersGenerated)
                         {
-                            var outputText = await outputDocument.GetTextAsync(this.CancellationToken);
+                            var outputText = generatedSyntaxTree.GetText(this.CancellationToken);
                             using (var outputFileStream = File.OpenWrite(outputFilePath))
                             using (var outputWriter = new StreamWriter(outputFileStream))
                             {
@@ -130,12 +132,12 @@ where string.Equals(item.GetMetadata("Generator"), $"MSBuild:{this.TargetName}",
                                 outputFileStream.SetLength(outputFileStream.Position);
                             }
 
-                            this.Log.LogMessage(MessageImportance.Normal, "{0} -> {1}", inputDocument.Name, outputFilePath);
+                            this.Log.LogMessage(MessageImportance.Normal, "{0} -> {1}", inputSyntaxTree.FilePath, outputFilePath);
                             generated = true;
                         }
                         else
                         {
-                            this.Log.LogMessage(MessageImportance.Low, "{0} used no code generation attributes.", inputDocument.Name);
+                            this.Log.LogMessage(MessageImportance.Low, "{0} used no code generation attributes.", inputSyntaxTree.FilePath);
                         }
                     }
                     else
@@ -238,24 +240,22 @@ private Assembly TryLoadAssembly(AssemblyName assemblyName)
             return null;
         }
 
-        private Project CreateProject()
+        private CSharpCompilation CreateCompilation()
         {
-            var workspace = new AdhocWorkspace();
-            var project = workspace.CurrentSolution.AddProject("codegen", "codegen", "C#")
-                .WithCompilationOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
-                .WithMetadataReferences(this.ReferencePath.Select(p => MetadataReference.CreateFromFile(p.ItemSpec)));
-
+            var compilation = CSharpCompilation.Create("codegen")
+                .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
+                .WithReferences(this.ReferencePath.Select(p => MetadataReference.CreateFromFile(p.ItemSpec)));
             foreach (var sourceFile in this.Compile)
             {
-                using (var stream = File.OpenRead(sourceFile.ItemSpec))
+                using (var stream = File.OpenRead(sourceFile.GetMetadata("FullPath")))
                 {
                     this.CancellationToken.ThrowIfCancellationRequested();
                     var text = SourceText.From(stream);
-                    project = project.AddDocument(sourceFile.ItemSpec, text).Project;
+                    compilation = compilation.AddSyntaxTrees(CSharpSyntaxTree.ParseText(text, path: sourceFile.ItemSpec, cancellationToken: this.CancellationToken));
                 }
             }
 
-            return project;
+            return compilation;
         }
     }
 

src/CodeGeneration.Roslyn.Tests.Generators/DuplicateWithSuffixGenerator.cs

@@ -30,7 +30,7 @@ public DuplicateWithSuffixGenerator(AttributeData attributeData)
             this.data = this.attributeData.NamedArguments.ToImmutableDictionary(kv => kv.Key, kv => kv.Value);
         }
 
-        public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(MemberDeclarationSyntax applyTo, Document document, IProgress<Diagnostic> progress, CancellationToken cancellationToken)
+        public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(MemberDeclarationSyntax applyTo, CSharpCompilation compilation, IProgress<Diagnostic> progress, CancellationToken cancellationToken)
         {
             var results = SyntaxFactory.List<MemberDeclarationSyntax>();
 

src/CodeGeneration.Roslyn/CodeGeneration.Roslyn.csproj

@@ -15,7 +15,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="1.3.2" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="1.3.2" />
     <PackageReference Include="Validation" Version="2.4.13" />
   </ItemGroup>
 

src/CodeGeneration.Roslyn/DocumentTransform.cs

@@ -15,8 +15,6 @@ namespace CodeGeneration.Roslyn
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
-    using Microsoft.CodeAnalysis.Formatting;
-    using Microsoft.CodeAnalysis.Simplification;
     using Validation;
 
     /// <summary>
@@ -27,7 +25,7 @@ public class DocumentTransform
         private static readonly string GeneratedByAToolPreamble = @"// ------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//  
+//
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
 // </auto-generated>
@@ -41,19 +39,16 @@ private DocumentTransform()
         /// <summary>
         /// Produces a new document in response to any code generation attributes found in the specified document.
         /// </summary>
+        /// <param name="compilation">The compilation to which the document belongs.</param>
         /// <param name="inputDocument">The document to scan for generator attributes.</param>
         /// <param name="progress">Reports warnings and errors in code generation.</param>
-        /// <param name="simplify">
-        /// A value indicating whether to simplify the generated document.
-        /// This produces a more visually appealing code file, but costs significant time during code generation.
-        /// </param>
         /// <returns>A task whose result is the generated document.</returns>
-        public static async Task<Document> TransformAsync(Document inputDocument, IProgress<Diagnostic> progress, bool simplify = false)
+        public static async Task<SyntaxTree> TransformAsync(CSharpCompilation compilation, SyntaxTree inputDocument, IProgress<Diagnostic> progress)
         {
+            Requires.NotNull(compilation, nameof(compilation));
             Requires.NotNull(inputDocument, nameof(inputDocument));
 
-            var workspace = inputDocument.Project.Solution.Workspace;
-            var inputSemanticModel = await inputDocument.GetSemanticModelAsync();
+            var inputSemanticModel = compilation.GetSemanticModel(inputDocument);
             var inputSyntaxTree = inputSemanticModel.SyntaxTree;
 
             var inputFileLevelUsingDirectives = inputSyntaxTree.GetRoot().ChildNodes().OfType<UsingDirectiveSyntax>();
@@ -67,7 +62,7 @@ public static async Task<Document> TransformAsync(Document inputDocument, IProgr
                 var generators = FindCodeGenerators(inputSemanticModel, memberNode);
                 foreach (var generator in generators)
                 {
-                    var generatedTypes = await generator.GenerateAsync(memberNode, inputDocument, progress, CancellationToken.None);
+                    var generatedTypes = await generator.GenerateAsync(memberNode, compilation, progress, CancellationToken.None);
 
                     // Figure out ancestry for the generated type, including nesting types and namespaces.
                     foreach (var ancestor in memberNode.Ancestors())
@@ -108,36 +103,14 @@ public static async Task<Document> TransformAsync(Document inputDocument, IProgr
             // By default, retain all the using directives that came from the input file.
             var resultFileLevelUsingDirectives = SyntaxFactory.List(inputFileLevelUsingDirectives);
 
-            // Add a using directive for the ImmutableObjectGraph if there isn't one.
-            ////var immutableObjectGraphName = nameof(ImmutableObjectGraph);
-            ////if (!resultFileLevelUsingDirectives.Any(u => u.Name.ToString() == immutableObjectGraphName))
-            ////{
-            ////    resultFileLevelUsingDirectives = resultFileLevelUsingDirectives.Add(
-            ////        SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName(immutableObjectGraphName)));
-            ////}
-
-            var emittedTree = SyntaxFactory.CompilationUnit()
+            var compilationUnit = SyntaxFactory.CompilationUnit()
                 .WithUsings(resultFileLevelUsingDirectives)
                 .WithMembers(emittedMembers)
                 .WithLeadingTrivia(SyntaxFactory.Comment(GeneratedByAToolPreamble))
                 .WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed)
                 .NormalizeWhitespace();
 
-            // Format the tree to get reasonably good whitespace.
-            var formattedTree = Formatter.Format(emittedTree, workspace, workspace.Options);
-
-            // Reduce the document to get rid of unnecessary fully-qualified type names that just hurt readability.
-            var formattedText = formattedTree.GetText();
-            var document = inputDocument.Project.AddDocument("generated.cs", formattedText);
-            if (simplify)
-            {
-                var annotatedDocument = document
-                    .WithSyntaxRoot((await document.GetSyntaxRootAsync())
-                    .WithAdditionalAnnotations(Simplifier.Annotation)); // allow simplification of the entire document
-                document = await Simplifier.ReduceAsync(annotatedDocument);
-            }
-
-            return document;
+            return compilationUnit.SyntaxTree;
         }
 
         private static IEnumerable<ICodeGenerator> FindCodeGenerators(SemanticModel document, SyntaxNode nodeWithAttributesApplied)

src/CodeGeneration.Roslyn/ICodeGenerator.cs

@@ -9,6 +9,7 @@ namespace CodeGeneration.Roslyn
     using System.Threading.Tasks;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
+    using Microsoft.CodeAnalysis.CSharp;
 
     /// <summary>
     /// Describes a code generator that responds to attributes on members to generate code.
@@ -19,10 +20,10 @@ public interface ICodeGenerator
         /// Create the syntax tree representing the expansion of some member to which this attribute is applied.
         /// </summary>
         /// <param name="applyTo">The syntax node this attribute is found on.</param>
-        /// <param name="document">The document with the semantic model in which this attribute was found.</param>
+        /// <param name="compilation">The overall compilation being generated for.</param>
         /// <param name="progress">A way to report diagnostic messages.</param>
         /// <param name="cancellationToken">A cancellation token.</param>
         /// <returns>The generated member syntax to be added to the project.</returns>
-        Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(MemberDeclarationSyntax applyTo, Document document, IProgress<Diagnostic> progress, CancellationToken cancellationToken);
+        Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(MemberDeclarationSyntax applyTo, CSharpCompilation compilation, IProgress<Diagnostic> progress, CancellationToken cancellationToken);
     }
 }

src/version.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://raw.githubusercontent.com/AArnott/Nerdbank.GitVersioning/master/src/NerdBank.GitVersioning/version.schema.json",
-  "version": "0.2",
+  "version": "0.3",
   "publicReleaseRefSpec": [
     "^refs/heads/master$", // we release out of master
     "^refs/tags/v\\d\\.\\d" // we also release tags starting with vN.N