Rich generators

src/CodeGeneration.Roslyn/CodeGeneration.Roslyn.csproj

@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard1.6</TargetFramework>
+    <LangVersion>7.1</LangVersion>
     <SignAssembly>True</SignAssembly>
     <AssemblyOriginatorKeyFile>..\opensource.snk</AssemblyOriginatorKeyFile>
     <PackageTargetFallback>$(PackageTargetFallback);portable-net45+win8+wp8+wpa81;</PackageTargetFallback>

src/CodeGeneration.Roslyn/DocumentTransform.cs

@@ -49,14 +49,15 @@ public static async Task<SyntaxTree> TransformAsync(CSharpCompilation compilatio
             var inputSyntaxTree = inputSemanticModel.SyntaxTree;
             var inputCompilationUnit = inputSyntaxTree.GetCompilationUnitRoot();
 
-            var inputFileLevelExternAliases = inputCompilationUnit
+            var compilationUnitExterns = inputCompilationUnit
                 .Externs
                 .Select(x => x.WithoutTrivia())
                 .ToImmutableArray();
-            var inputFileLevelUsingDirectives = inputCompilationUnit
+            var compilationUnitUsings = inputCompilationUnit
                 .Usings
                 .Select(x => x.WithoutTrivia())
                 .ToImmutableArray();
+            var compilationUnitAttributeLists = ImmutableArray<AttributeListSyntax>.Empty;
 
             var memberNodes = inputSyntaxTree.GetRoot().DescendantNodesAndSelf(n => n is CompilationUnitSyntax || n is NamespaceDeclarationSyntax || n is TypeDeclarationSyntax).OfType<CSharpSyntaxNode>();
 
@@ -67,26 +68,34 @@ public static async Task<SyntaxTree> TransformAsync(CSharpCompilation compilatio
                 var generators = FindCodeGenerators(attributeData, assemblyLoader);
                 foreach (var generator in generators)
                 {
-                    var context = new TransformationContext(memberNode, inputSemanticModel, compilation, projectDirectory);
-                    var generatedMembers = await generator.GenerateAsync(context, progress, CancellationToken.None);
+                    var context = new TransformationContext(memberNode, inputSemanticModel, compilation, projectDirectory,
+                        compilationUnitUsings, compilationUnitExterns);
 
-                    // Figure out ancestry for the generated type, including nesting types and namespaces.
-                    foreach (var ancestor in memberNode.Ancestors())
+                    if (generator is IRichCodeGenerator richGenerator)
                     {
-                        generatedMembers = WrapInAncestor(generatedMembers, ancestor);
+                        var (members, usings, attributeLists, externs) = await richGenerator.GenerateRichAsync(context, progress, CancellationToken.None);
+                        compilationUnitExterns = compilationUnitExterns.AddRange(externs);
+                        compilationUnitUsings =  compilationUnitUsings.AddRange(usings);
+                        compilationUnitAttributeLists = compilationUnitAttributeLists.AddRange(attributeLists);
+                        emittedMembers = emittedMembers.AddRange(members);
+                    }
+                    else
+                    {
+                        var generatedMembers = await generator.GenerateAsync(context, progress, CancellationToken.None);
+                        // Figure out ancestry for the generated type, including nesting types and namespaces.
+                        generatedMembers = memberNode.Ancestors().Aggregate(generatedMembers, WrapInAncestor);
+                        emittedMembers = emittedMembers.AddRange(generatedMembers);
                     }
-
-                    emittedMembers = emittedMembers.AddRange(generatedMembers);
                 }
             }
 
             // By default, retain all the using directives that came from the input file.
-            var resultFileLevelExternAliases = SyntaxFactory.List(inputFileLevelExternAliases);
-            var resultFileLevelUsingDirectives = SyntaxFactory.List(inputFileLevelUsingDirectives);
+            var resultFileLevelExterns = SyntaxFactory.List(compilationUnitExterns);
+            var resultFileLevelUsings = SyntaxFactory.List(compilationUnitUsings);
 
             var compilationUnit = SyntaxFactory.CompilationUnit()
-                .WithExterns(resultFileLevelExternAliases)
-                .WithUsings(resultFileLevelUsingDirectives)
+                .WithExterns(resultFileLevelExterns)
+                .WithUsings(resultFileLevelUsings)
                 .WithMembers(emittedMembers)
                 .WithLeadingTrivia(SyntaxFactory.Comment(GeneratedByAToolPreamble))
                 .WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed)

src/CodeGeneration.Roslyn/IRichCodeGenerator.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Andrew Arnott. All rights reserved.
+// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+
+namespace CodeGeneration.Roslyn
+{
+    using System;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis;
+
+    /// <summary>
+    /// Describes a code generator that responds to attributes on members to generate code,
+    /// and returns compilation unit members
+    /// </summary>
+    public interface IRichCodeGenerator : ICodeGenerator
+    {
+        Task<RichGenerationResult> GenerateRichAsync(TransformationContext context, IProgress<Diagnostic> progress, CancellationToken cancellationToken);
+    }
+}

src/CodeGeneration.Roslyn/RichGenerationResult.cs

@@ -0,0 +1,67 @@
+// Copyright (c) Andrew Arnott. All rights reserved.
+// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+
+namespace CodeGeneration.Roslyn
+{
+    using System.Diagnostics;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+    /// <summary>
+    /// Contains <see cref="CompilationUnitSyntax"/> additions generated by the <see cref="IRichCodeGenerator"/>.
+    /// </summary>
+    public struct RichGenerationResult
+    {
+        /// <summary>
+        /// Creates <see cref="RichGenerationResult"/> with provided arguments as property values.
+        /// </summary>
+        /// <param name="members">Assigned to <see cref="Members"/>.</param>
+        /// <param name="usings">Assigned to <see cref="Usings"/>.</param>
+        /// <param name="attributeLists">Assigned to <see cref="AttributeLists"/>.</param>
+        /// <param name="externs">Assigned to <see cref="Externs"/>.</param>
+        [DebuggerStepThrough]
+        public RichGenerationResult(
+            SyntaxList<MemberDeclarationSyntax> members,
+            SyntaxList<UsingDirectiveSyntax> usings = default,
+            SyntaxList<AttributeListSyntax> attributeLists = default,
+            SyntaxList<ExternAliasDirectiveSyntax> externs = default)
+        {
+            Members = members;
+            Usings = usings;
+            AttributeLists = attributeLists;
+            Externs = externs;
+        }
+
+        /// <summary>
+        /// Gets <see cref="MemberDeclarationSyntax"/> to add to generated <see cref="CompilationUnitSyntax"/>.
+        /// </summary>
+        public SyntaxList<MemberDeclarationSyntax> Members { get; }
+
+        /// <summary>
+        /// Gets <see cref="UsingDirectiveSyntax"/> to add to generated <see cref="CompilationUnitSyntax"/>.
+        /// </summary>
+        public SyntaxList<UsingDirectiveSyntax> Usings { get; }
+
+        /// <summary>
+        /// Gets <see cref="ExternAliasDirectiveSyntax"/> to add to generated <see cref="CompilationUnitSyntax"/>.
+        /// </summary>
+        public SyntaxList<ExternAliasDirectiveSyntax> Externs { get; }
+
+        /// <summary>
+        /// Gets <see cref="AttributeListSyntax"/> to add to generated <see cref="CompilationUnitSyntax"/>.
+        /// </summary>
+        public SyntaxList<AttributeListSyntax> AttributeLists { get; }
+
+        [DebuggerHidden, DebuggerStepThrough]
+        public void Deconstruct(out SyntaxList<MemberDeclarationSyntax> members,
+            out SyntaxList<UsingDirectiveSyntax> usings,
+            out SyntaxList<AttributeListSyntax> attributeLists,
+            out SyntaxList<ExternAliasDirectiveSyntax> externs)
+        {
+            members = Members;
+            usings = Usings;
+            attributeLists = AttributeLists;
+            externs = Externs;
+        }
+    }
+}

src/CodeGeneration.Roslyn/TransformationContext.cs

@@ -1,5 +1,10 @@
-using Microsoft.CodeAnalysis;
+// Copyright (c) Andrew Arnott. All rights reserved.
+// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
+
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace CodeGeneration.Roslyn
 {
@@ -12,13 +17,19 @@ public class TransformationContext
         /// <param name="semanticModel">The semantic model.</param>
         /// <param name="compilation">The overall compilation being generated for.</param>
         /// <param name="projectDirectory">The absolute path of the directory where the project file is located</param>
+        /// <param name="compilationUnitUsings">The using directives already queued to be generated.</param>
+        /// <param name="compilationUnitExterns">The extern aliases already queued to be generated.</param>
         public TransformationContext(CSharpSyntaxNode processingNode, SemanticModel semanticModel, CSharpCompilation compilation,
-                                     string projectDirectory)
+                                     string projectDirectory,
+                                     IEnumerable<UsingDirectiveSyntax> compilationUnitUsings,
+                                     IEnumerable<ExternAliasDirectiveSyntax> compilationUnitExterns)
         {
             ProcessingNode = processingNode;
             SemanticModel = semanticModel;
             Compilation = compilation;
             ProjectDirectory = projectDirectory;
+            CompilationUnitUsings = compilationUnitUsings;
+            CompilationUnitExterns = compilationUnitExterns;
         }
 
         /// <summary>Gets the syntax node the generator attribute is found on.</summary>
@@ -30,9 +41,13 @@ public TransformationContext(CSharpSyntaxNode processingNode, SemanticModel sema
         /// <summary>Gets the overall compilation being generated for.</summary>
         public CSharpCompilation Compilation { get; }
 
-        /// <summary>
-        /// Gets the absolute path of the directory where the project file is located
-        /// </summary>
+        /// <summary>Gets the absolute path of the directory where the project file is located.</summary>
         public string ProjectDirectory { get; }
+
+        /// <summary>Gets a collection of using directives already queued to be generated.</summary>
+        public IEnumerable<UsingDirectiveSyntax> CompilationUnitUsings { get; }
+
+        /// <summary>Gets a collection of extern aliases already queued to be generated.</summary>
+        public IEnumerable<ExternAliasDirectiveSyntax> CompilationUnitExterns { get; }
     }
 }