Rich generators

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

@@ -0,0 +1,45 @@
+// 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.Tests.Generators
+{
+
+    using System;
+    using System.Diagnostics;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+
+    [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
+    [CodeGenerationAttribute(typeof(AddGeneratedAttributeGenerator))]
+    [Conditional("CodeGeneration")]
+    public class AddGeneratedAttributeAttribute : Attribute
+    {
+        public AddGeneratedAttributeAttribute(string attribute)
+        {
+            Attribute = attribute;
+        }
+
+        public string Attribute { get; }
+    }
+
+    [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
+    public class GeneratedAttribute : Attribute
+    { }
+
+    public class AddGeneratedAttributeGenerator : RichBaseGenerator
+    {
+
+        public AddGeneratedAttributeGenerator(AttributeData attributeData) : base(attributeData)
+        {
+            Attribute = (string)AttributeData.ConstructorArguments[0].Value;
+        }
+
+        public string Attribute { get; }
+
+        protected override void Generate(RichGenerationContext context)
+        {
+            var attribute = SyntaxFactory.Attribute(SyntaxFactory.ParseName(Attribute));
+            context.AddAttribute(attribute);
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+// 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.Tests.Generators
+{
+
+    using System;
+    using System.Diagnostics;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+
+    [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
+    [CodeGenerationAttribute(typeof(AddGeneratedExternGenerator))]
+    [Conditional("CodeGeneration")]
+    public class AddGeneratedExternAttribute : Attribute
+    {
+        public AddGeneratedExternAttribute(string @extern)
+        {
+            Extern = @extern;
+        }
+
+        public string Extern { get; }
+    }
+
+    public class AddGeneratedExternGenerator : RichBaseGenerator
+    {
+
+        public AddGeneratedExternGenerator(AttributeData attributeData) : base(attributeData)
+        {
+            Extern = (string)AttributeData.ConstructorArguments[0].Value;
+        }
+
+        public string Extern { get; }
+
+        protected override void Generate(RichGenerationContext context)
+        {
+            var externAlias = SyntaxFactory.ExternAliasDirective(Extern);
+            context.AddExtern(externAlias);
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+// 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.Diagnostics;
+
+namespace CodeGeneration.Roslyn.Tests.Generators
+{
+    using System;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+
+    [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
+    [CodeGenerationAttribute(typeof(AddGeneratedUsingGenerator))]
+    [Conditional("CodeGeneration")]
+    public class AddGeneratedUsingAttribute : Attribute
+    {
+        public AddGeneratedUsingAttribute(string @using)
+        {
+            Using = @using;
+        }
+
+        public string Using { get; }
+    }
+
+    public class AddGeneratedUsingGenerator : RichBaseGenerator
+    {
+
+        public AddGeneratedUsingGenerator(AttributeData attributeData) : base(attributeData)
+        {
+            Using = (string)AttributeData.ConstructorArguments[0].Value;
+        }
+
+        public string Using { get; }
+
+        protected override void Generate(RichGenerationContext context)
+        {
+            var usingSyntax = SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(Using));
+            context.AddUsing(usingSyntax);
+        }
+    }
+}

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

@@ -0,0 +1,59 @@
+// 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.Tests.Generators
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+    public abstract class BaseGenerator : ICodeGenerator
+    {
+        public AttributeData AttributeData { get; }
+
+        protected BaseGenerator(AttributeData attributeData)
+        {
+            AttributeData = attributeData;
+        }
+
+        Task<SyntaxList<MemberDeclarationSyntax>> ICodeGenerator.GenerateAsync(TransformationContext context, IProgress<Diagnostic> progress, CancellationToken cancellationToken)
+        {
+            var richGenerationContext = new GenerationContext(context, progress, cancellationToken);
+            Generate(richGenerationContext);
+            var result = richGenerationContext.CreateResult();
+            return Task.FromResult(result);
+        }
+
+        protected abstract void Generate(GenerationContext context);
+
+        protected class GenerationContext
+        {
+            public GenerationContext(TransformationContext transformationContext, IProgress<Diagnostic> progress, CancellationToken cancellationToken)
+            {
+                TransformationContext = transformationContext;
+                Progress = progress;
+                CancellationToken = cancellationToken;
+            }
+
+            public TransformationContext TransformationContext { get; }
+            public IProgress<Diagnostic> Progress { get; }
+            public CancellationToken CancellationToken { get; }
+            public List<MemberDeclarationSyntax> Members { get; } = new List<MemberDeclarationSyntax>();
+
+            public GenerationContext AddMember(MemberDeclarationSyntax memberDeclaration)
+            {
+                Members.Add(memberDeclaration);
+                return this;
+            }
+
+            public SyntaxList<MemberDeclarationSyntax> CreateResult()
+            {
+                return SyntaxFactory.List(Members);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+// 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.Tests.Generators
+{
+    using System;
+    using System.Diagnostics;
+
+    [AttributeUsage(AttributeTargets.All, Inherited = false, AllowMultiple = true)]
+    [CodeGenerationAttribute(typeof(DuplicateInOtherNamespaceGenerator))]
+    [Conditional("CodeGeneration")]
+    public class DuplicateInOtherNamespaceAttribute : Attribute
+    {
+        public DuplicateInOtherNamespaceAttribute(string @namespace)
+        {
+            Namespace = @namespace;
+        }
+
+        public string Namespace { get; }
+    }
+}

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

@@ -0,0 +1,35 @@
+// 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.Tests.Generators
+{
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+    public class DuplicateInOtherNamespaceGenerator : RichBaseGenerator
+    {
+
+        public DuplicateInOtherNamespaceGenerator(AttributeData attributeData) : base(attributeData)
+        {
+            Namespace = (string)AttributeData.ConstructorArguments[0].Value;
+        }
+
+        public string Namespace { get; }
+
+        protected override void Generate(RichGenerationContext context)
+        {
+            if (!(context.TransformationContext.ProcessingNode is ClassDeclarationSyntax classDeclaration))
+            {
+                return;
+            }
+            var partial = SyntaxFactory.ClassDeclaration(classDeclaration.Identifier);
+            var namespaceSyntax =
+                SyntaxFactory.NamespaceDeclaration(
+                        SyntaxFactory.ParseName(Namespace))
+                    .AddMembers(partial);
+
+            context.AddMember(namespaceSyntax);
+        }
+    }
+}

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

@@ -45,4 +45,4 @@ private static MemberDeclarationSyntax StructPartial(StructDeclarationSyntax dec
                 .WithModifiers(SyntaxTokenList.Create(SyntaxFactory.Token(SyntaxKind.PartialKeyword)));
         }
     }
-}
+}

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

@@ -0,0 +1,98 @@
+// 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.Tests.Generators
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+    public abstract class RichBaseGenerator : IRichCodeGenerator
+    {
+        public AttributeData AttributeData { get; }
+
+        protected RichBaseGenerator(AttributeData attributeData)
+        {
+            AttributeData = attributeData;
+        }
+
+        Task<SyntaxList<MemberDeclarationSyntax>> ICodeGenerator.GenerateAsync(TransformationContext context, IProgress<Diagnostic> progress, CancellationToken cancellationToken)
+        {
+            throw new NotImplementedException();
+        }
+
+        Task<RichGenerationResult> IRichCodeGenerator.GenerateRichAsync(TransformationContext context, IProgress<Diagnostic> progress, CancellationToken cancellationToken)
+        {
+            var richGenerationContext = new RichGenerationContext(context, progress, cancellationToken);
+            Generate(richGenerationContext);
+            var result = richGenerationContext.CreateResult();
+            return Task.FromResult(result);
+        }
+
+        protected abstract void Generate(RichGenerationContext context);
+
+        protected class RichGenerationContext
+        {
+            public RichGenerationContext(TransformationContext transformationContext, IProgress<Diagnostic> progress, CancellationToken cancellationToken)
+            {
+                TransformationContext = transformationContext;
+                Progress = progress;
+                CancellationToken = cancellationToken;
+            }
+
+            public TransformationContext TransformationContext { get; }
+            public IProgress<Diagnostic> Progress { get; }
+            public CancellationToken CancellationToken { get; }
+
+            public List<UsingDirectiveSyntax> Usings { get; } = new List<UsingDirectiveSyntax>();
+            public List<ExternAliasDirectiveSyntax> Externs { get; } = new List<ExternAliasDirectiveSyntax>();
+            public List<AttributeListSyntax> AttributeLists { get; } = new List<AttributeListSyntax>();
+            public List<MemberDeclarationSyntax> Members { get; } = new List<MemberDeclarationSyntax>();
+
+            public RichGenerationContext AddUsing(UsingDirectiveSyntax usingDirective)
+            {
+                Usings.Add(usingDirective);
+                return this;
+            }
+
+            public RichGenerationContext AddExtern(ExternAliasDirectiveSyntax externAliasDirective)
+            {
+                Externs.Add(externAliasDirective);
+                return this;
+            }
+
+            public RichGenerationContext AddAttribute(AttributeSyntax attribute)
+            {
+                var list = SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(attribute));
+                return AddAttributeList(list);
+            }
+
+            public RichGenerationContext AddAttributeList(AttributeListSyntax attributeList)
+            {
+                AttributeLists.Add(attributeList);
+                return this;
+            }
+
+            public RichGenerationContext AddMember(MemberDeclarationSyntax memberDeclaration)
+            {
+                Members.Add(memberDeclaration);
+                return this;
+            }
+
+            public RichGenerationResult CreateResult()
+            {
+                return new RichGenerationResult
+                {
+                    Members = SyntaxFactory.List(Members),
+                    Usings = SyntaxFactory.List(Usings),
+                    AttributeLists = SyntaxFactory.List(AttributeLists),
+                    Externs = SyntaxFactory.List(Externs),
+                };
+            }
+        }
+    }
+}