Merge pull request #67 from Pzixel/feature/global_attributes_generation

Assembly attributes support

README.md

@@ -163,7 +163,7 @@ If you build with `dotnet build`, you need to take a couple extra steps. First,
 Second, add this item to an `<ItemGroup>` in the project that will execute the code generator as part of your build:
 
 ```xml
-<DotNetCliToolReference Include="dotnet-codegen" Version="0.4.11" />
+<DotNetCliToolReference Include="dotnet-codegen" Version="0.4.12" />
 ```
 
 You should adjust the version in the above xml to match the version of this tool you are using.
@@ -187,10 +187,10 @@ to immediately see the effects of your changes on the generated code.
 You can also package up your code generator as a NuGet package for others to install
 and use. Your NuGet package should include a dependency on the `CodeGeneration.Roslyn.BuildTime`
 that matches the version of `CodeGeneration.Roslyn` that you used to produce your generator.
-For example, if you used version 0.4.11 of this project, your .nuspec file would include this tag:
+For example, if you used version 0.4.12 of this project, your .nuspec file would include this tag:
 
 ```xml
-<dependency id="CodeGeneration.Roslyn.BuildTime" version="0.4.11" />
+<dependency id="CodeGeneration.Roslyn.BuildTime" version="0.4.12" />
 ```
 
 In addition to this dependency, your NuGet package should include a `build` folder with an
@@ -219,7 +219,7 @@ so that the MSBuild Task can invoke the `dotnet codegen` command line tool:
 ```xml
 <ItemGroup>
   <PackageReference Include="YourCodeGenPackage" Version="1.2.3" PrivateAssets="all" />
-  <DotNetCliToolReference Include="dotnet-codegen" Version="0.4.11" />
+  <DotNetCliToolReference Include="dotnet-codegen" Version="0.4.12" />
 </ItemGroup>
 ```
 

src/CodeGeneration.Roslyn.Tasks/GenerateCodeFromAttributes.cs

@@ -22,6 +22,9 @@ public class GenerateCodeFromAttributes : ToolTask
         [Required]
         public ITaskItem[] GeneratorAssemblySearchPaths { get; set; }
 
+        [Required]
+        public string ProjectDirectory { get; set; }
+
         [Required]
         public string IntermediateOutputDirectory { get; set; }
 
@@ -80,6 +83,9 @@ protected override string GenerateResponseFileCommands()
             argBuilder.AppendLine("--out");
             argBuilder.AppendLine(this.IntermediateOutputDirectory);
 
+            argBuilder.AppendLine("--projectDir");
+            argBuilder.AppendLine(this.ProjectDirectory);
+
             this.generatedCompileItemsFilePath = Path.Combine(this.IntermediateOutputDirectory, Path.GetRandomFileName());
             argBuilder.AppendLine("--generatedFilesList");
             argBuilder.AppendLine(this.generatedCompileItemsFilePath);

src/CodeGeneration.Roslyn.Tasks/build/CodeGeneration.Roslyn.BuildTime.targets

@@ -19,6 +19,7 @@
   <Target Name="GenerateCodeFromAttributes" DependsOnTargets="ResolveReferences" BeforeTargets="CoreCompile">
     <GenerateCodeFromAttributes
       ToolLocationOverride="$(GenerateCodeFromAttributesToolPathOverride)"
+      ProjectDirectory="$(MSBuildProjectDirectory)"
       Compile="@(Compile)"
       ReferencePath="@(ReferencePath)"
       GeneratorAssemblySearchPaths="@(GeneratorAssemblySearchPaths)"

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

@@ -0,0 +1,16 @@
+// 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 Validation;
+
+    [AttributeUsage(AttributeTargets.Assembly)]
+    [CodeGenerationAttribute(typeof(DirectoryPathGenerator))]
+    [Conditional("CodeGeneration")]
+    public class DirectoryPathAttribute : Attribute
+    {
+    }
+}

src/CodeGeneration.Roslyn.Tests.Generators/DirectoryPathGenerator.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.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+    using Validation;
+    using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+    public class DirectoryPathGenerator : ICodeGenerator
+    {
+        public DirectoryPathGenerator(AttributeData attributeData)
+        {
+            Requires.NotNull(attributeData, nameof(attributeData));
+        }
+
+        public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(TransformationContext context, IProgress<Diagnostic> progress, CancellationToken cancellationToken)
+        {
+            var member = ClassDeclaration("DirectoryPathTest")
+                .AddMembers(
+                    FieldDeclaration(
+                        VariableDeclaration(
+                            PredefinedType(Token(SyntaxKind.StringKeyword)))
+                        .AddVariables(
+                            VariableDeclarator(Identifier("Path"))
+                            .WithInitializer(
+                                EqualsValueClause(
+                                    LiteralExpression(
+                                        SyntaxKind.StringLiteralExpression,
+                                        Literal(context.ProjectDirectory))))))
+                    .WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.ConstKeyword))));
+
+            return Task.FromResult(List<MemberDeclarationSyntax>(new []{member}));
+        }
+    }
+}

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

@@ -35,7 +35,7 @@ public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(TransformationCon
             var results = SyntaxFactory.List<MemberDeclarationSyntax>();
 
             MemberDeclarationSyntax copy = null;
-            var applyToClass = context.ProcessingMember as ClassDeclarationSyntax;
+            var applyToClass = context.ProcessingNode as ClassDeclarationSyntax;
             if (applyToClass != null)
             {
                 copy = applyToClass

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

@@ -29,7 +29,7 @@ public Task<SyntaxList<MemberDeclarationSyntax>> GenerateAsync(TransformationCon
             var results = SyntaxFactory.List<MemberDeclarationSyntax>();
 
             MemberDeclarationSyntax copy = null;
-            var applyToClass = context.ProcessingMember as ClassDeclarationSyntax;
+            var applyToClass = context.ProcessingNode as ClassDeclarationSyntax;
             if (applyToClass != null)
             {
                 var properties = applyToClass.Members.OfType<PropertyDeclarationSyntax>()

src/CodeGeneration.Roslyn.Tests/CodeGenerationTests.cs

@@ -2,12 +2,11 @@
 // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using CodeGeneration.Roslyn.Tests.Generators;
 using Xunit;
 
+[assembly: DirectoryPath]
+
 public partial class CodeGenerationTests
 {
     /// <summary>
@@ -21,6 +20,7 @@ public void SimpleGenerationWorks()
         var fooB = new CodeGenerationTests.FooB();
         var multiplied = new MultipliedBar();
         multiplied.ValueSuff1020();
+        Assert.EndsWith(@"src\CodeGeneration.Roslyn.Tests", DirectoryPathTest.Path, StringComparison.OrdinalIgnoreCase);
     }
 
     [DuplicateWithSuffixByName("A")]

src/CodeGeneration.Roslyn.Tool/Program.cs

@@ -18,11 +18,13 @@ static int Main(string[] args)
             IReadOnlyList<string> generatorSearchPaths = Array.Empty<string>();
             string generatedCompileItemFile = null;
             string outputDirectory = null;
+            string projectDir = null;
             ArgumentSyntax.Parse(args, syntax =>
             {
                 syntax.DefineOptionList("r|reference", ref refs, "Paths to assemblies being referenced");
                 syntax.DefineOptionList("generatorSearchPath", ref generatorSearchPaths, "Paths to folders that may contain generator assemblies");
                 syntax.DefineOption("out", ref outputDirectory, true, "The directory to write generated source files to");
+                syntax.DefineOption("projectDir", ref projectDir, true, "The absolute path of the directory where the project file is located");
                 syntax.DefineOption("generatedFilesList", ref generatedCompileItemFile, "The path to the file to create with a list of generated source files");
                 syntax.DefineParameterList("compile", ref compile, "Source files included in compilation");
             });
@@ -41,6 +43,7 @@ static int Main(string[] args)
 
             var generator = new CompilationGenerator
             {
+                ProjectDirectory = projectDir,
                 Compile = compile,
                 ReferencePath = refs,
                 GeneratorAssemblySearchPaths = generatorSearchPaths,

src/CodeGeneration.Roslyn/CompilationGenerator.cs

@@ -65,6 +65,8 @@ public class CompilationGenerator
         /// </summary>
         public IEnumerable<string> EmptyGeneratedFiles => this.emptyGeneratedFiles;
 
+        public string ProjectDirectory { get; set; }
+
         public void Generate(IProgress<Diagnostic> progress = null, CancellationToken cancellationToken = default(CancellationToken))
         {
             Verify.Operation(this.Compile != null, $"{nameof(Compile)} must be set first.");
@@ -104,6 +106,7 @@ public class CompilationGenerator
                                 var generatedSyntaxTree = DocumentTransform.TransformAsync(
                                     compilation,
                                     inputSyntaxTree,
+                                    this.ProjectDirectory,
                                     this.LoadAssembly,
                                     progress).GetAwaiter().GetResult();
 

src/CodeGeneration.Roslyn/DocumentTransform.cs

@@ -5,13 +5,12 @@ namespace CodeGeneration.Roslyn
 {
     using System;
     using System.Collections.Generic;
-    using System.IO;
+    using System.Collections.Immutable;
     using System.Linq;
     using System.Reflection;
     using System.Text;
     using System.Threading;
     using System.Threading.Tasks;
-    using Microsoft;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -40,7 +39,7 @@ public static class DocumentTransform
         /// <param name="assemblyLoader">A function that can load an assembly with the given name.</param>
         /// <param name="progress">Reports warnings and errors in code generation.</param>
         /// <returns>A task whose result is the generated document.</returns>
-        public static async Task<SyntaxTree> TransformAsync(CSharpCompilation compilation, SyntaxTree inputDocument, Func<AssemblyName, Assembly> assemblyLoader, IProgress<Diagnostic> progress)
+        public static async Task<SyntaxTree> TransformAsync(CSharpCompilation compilation, SyntaxTree inputDocument, string projectDirectory, Func<AssemblyName, Assembly> assemblyLoader, IProgress<Diagnostic> progress)
         {
             Requires.NotNull(compilation, nameof(compilation));
             Requires.NotNull(inputDocument, nameof(inputDocument));
@@ -51,16 +50,16 @@ public static async Task<SyntaxTree> TransformAsync(CSharpCompilation compilatio
 
             var inputFileLevelUsingDirectives = inputSyntaxTree.GetRoot().ChildNodes().OfType<UsingDirectiveSyntax>();
 
-            var memberNodes = from syntax in inputSyntaxTree.GetRoot().DescendantNodes(n => n is CompilationUnitSyntax || n is NamespaceDeclarationSyntax || n is TypeDeclarationSyntax).OfType<MemberDeclarationSyntax>()
-                              select syntax;
+            var memberNodes = inputSyntaxTree.GetRoot().DescendantNodesAndSelf(n => n is CompilationUnitSyntax || n is NamespaceDeclarationSyntax || n is TypeDeclarationSyntax).OfType<CSharpSyntaxNode>();
 
             var emittedMembers = SyntaxFactory.List<MemberDeclarationSyntax>();
             foreach (var memberNode in memberNodes)
             {
-                var generators = FindCodeGenerators(inputSemanticModel, memberNode, assemblyLoader);
+                var attributeData = GetAttributeData(compilation, inputSemanticModel, memberNode);
+                var generators = FindCodeGenerators(attributeData, assemblyLoader);
                 foreach (var generator in generators)
                 {
-                    var context = new TransformationContext(memberNode, inputSemanticModel, compilation);
+                    var context = new TransformationContext(memberNode, inputSemanticModel, compilation, projectDirectory);
                     var generatedTypes = await generator.GenerateAsync(context, progress, CancellationToken.None);
 
                     // Figure out ancestry for the generated type, including nesting types and namespaces.
@@ -112,22 +111,29 @@ public static async Task<SyntaxTree> TransformAsync(CSharpCompilation compilatio
             return compilationUnit.SyntaxTree;
         }
 
-        private static IEnumerable<ICodeGenerator> FindCodeGenerators(SemanticModel document, SyntaxNode nodeWithAttributesApplied, Func<AssemblyName, Assembly> assemblyLoader)
+        private static ImmutableArray<AttributeData> GetAttributeData(Compilation compilation, SemanticModel document, SyntaxNode syntaxNode)
         {
-            Requires.NotNull(document, "document");
-            Requires.NotNull(nodeWithAttributesApplied, "nodeWithAttributesApplied");
+            Requires.NotNull(document, nameof(document));
+            Requires.NotNull(syntaxNode, nameof(syntaxNode));
 
-            var symbol = document.GetDeclaredSymbol(nodeWithAttributesApplied);
-            if (symbol != null)
+            switch (syntaxNode)
             {
-                foreach (var attributeData in symbol.GetAttributes())
+                case CompilationUnitSyntax syntax:
+                    return compilation.Assembly.GetAttributes().Where(x => x.ApplicationSyntaxReference.SyntaxTree == syntax.SyntaxTree).ToImmutableArray();
+                default:
+                    return document.GetDeclaredSymbol(syntaxNode)?.GetAttributes() ?? ImmutableArray<AttributeData>.Empty;
+            }
+        }
+
+        private static IEnumerable<ICodeGenerator> FindCodeGenerators(ImmutableArray<AttributeData> nodeAttributes, Func<AssemblyName, Assembly> assemblyLoader)
+        {
+            foreach (var attributeData in nodeAttributes)
+            {
+                Type generatorType = GetCodeGeneratorTypeForAttribute(attributeData.AttributeClass, assemblyLoader);
+                if (generatorType != null)
                 {
-                    Type generatorType = GetCodeGeneratorTypeForAttribute(attributeData.AttributeClass, assemblyLoader);
-                    if (generatorType != null)
-                    {
-                        ICodeGenerator generator = (ICodeGenerator)Activator.CreateInstance(generatorType, attributeData);
-                        yield return generator;
-                    }
+                    ICodeGenerator generator = (ICodeGenerator)Activator.CreateInstance(generatorType, attributeData);
+                    yield return generator;
                 }
             }
         }

src/CodeGeneration.Roslyn/TransformationContext.cs

@@ -1,7 +1,5 @@
-using System;
-using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
 
 namespace CodeGeneration.Roslyn
 {
@@ -10,23 +8,31 @@ public class TransformationContext
         /// <summary>
         /// Initializes a new instance of the <see cref="TransformationContext" /> class.
         /// </summary>
-        /// <param name="processingMember">The syntax node the generator attribute is found on.</param>
+        /// <param name="processingNode">The syntax node the generator attribute is found on.</param>
         /// <param name="semanticModel">The semantic model.</param>
         /// <param name="compilation">The overall compilation being generated for.</param>
-        public TransformationContext(MemberDeclarationSyntax processingMember, SemanticModel semanticModel, CSharpCompilation compilation)
+        /// <param name="projectDirectory">The absolute path of the directory where the project file is located</param>
+        public TransformationContext(CSharpSyntaxNode processingNode, SemanticModel semanticModel, CSharpCompilation compilation,
+                                     string projectDirectory)
         {
-            ProcessingMember = processingMember;
+            ProcessingNode = processingNode;
             SemanticModel = semanticModel;
             Compilation = compilation;
+            ProjectDirectory = projectDirectory;
         }
 
         /// <summary>Gets the syntax node the generator attribute is found on.</summary>
-        public MemberDeclarationSyntax ProcessingMember { get; }
+        public CSharpSyntaxNode ProcessingNode { get; }
 
         /// <summary>Gets the semantic model for the <see cref="Compilation" />.</summary>
         public SemanticModel SemanticModel { get; }
 
         /// <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>
+        public string ProjectDirectory { get; }
     }
 }