Require RootNamespace and add C# 10 support with global usings.

AraHaan · AraHaan · commit e804224b3e20 · 2021-10-31T00:00:28.000-04:00
The generator will not exclude global usings in the generated source as well as automatically adding the root namespace setting to the global usings as well as the namespace for the GitInformation attribute.
diff --git a/README.md b/README.md
@@ -7,3 +7,17 @@ Source Generator for dumping the git branch information, commit hash, and if the
 | Package | Version |
 |:-------:|:-------:|
 | GitBuildInfo.SourceGenerator | [![NuGet Badge](https://buildstats.info/nuget/GitBuildInfo.SourceGenerator?includePreReleases=true)](https://www.nuget.org/packages/GitBuildInfo.SourceGenerator/) |
+
+## Usage
+
+1. Install this package into your project with:
+```xml
+<PackageReference Include="GitBuildInfo.SourceGenerator" IsImplicitlyDefined="true" Version="*-*">
+  <PrivateAssets>all</PrivateAssets>
+</PackageReference>
+```
+2. Set the following msbuild properties in your project (or if you have all project file property settings stored in a project specific ``Directory.Build.props``) file:
+  * ``<GitBuildInfoIsGeneric></GitBuildInfoIsGeneric>`` (Optional, default is false)
+  * ``<GitBuildInfoAssemblyType></GitBuildInfoAssemblyType>`` (Required, Note: Do not include anything before the type name like a fully qualified namespace or any ``.``'s. For that you need to set ``RootNamespace`` below)
+  * ``<RootNamespace></RootNamespace>`` (Required unless you want the type to be assumed to be in the ``Elskom.Generic.Libs`` namespace by the generator)
+3. The generator package should now run a build task to grab information prior to it executing the generator.
diff --git a/build/GitBuildInfo.SourceGenerator.props b/build/GitBuildInfo.SourceGenerator.props
@@ -5,6 +5,15 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <!--
+    Add the namespace for the generated attribute to the global usings list only if the C# language version is 10.0 or newer.
+    -->
+    <Using Include="Elskom.Generic.Libs" Condition="'$(ImplicitUsings)' == 'enable'" />
+    <!--
+    Add the root namespace to the global usings list only if the C# language version is 10.0 or newer.
+    -->
+    <Using Include="$(RootNamespace)" Condition="'$(ImplicitUsings)' == 'enable'" />
+    <CompilerVisibleProperty Include="RootNamespace" />
     <CompilerVisibleProperty Include="GitBuildInfoAssemblyType" />
     <CompilerVisibleProperty Include="GitBuildInfoIsGeneric" />
     <CompilerVisibleProperty Include="GitHead" />
diff --git a/src/GitBuildInfo.SourceGenerator/Directory.Build.props b/src/GitBuildInfo.SourceGenerator/Directory.Build.props
@@ -6,7 +6,8 @@
     <Version>1.0.13</Version>
     <PackageReleaseNotes>Fixed issue where building can result in a build performance decrease due to having the build task being inline.
 Also made build task target .NET Standard 2.0 only.
-I think this one should work for everyone even for those using .NET Framework's msbuild.</PackageReleaseNotes>
+I think this one should work for everyone even for those using .NET Framework's msbuild.
+Also the generator now requires setting the RootNamespace msbuild property that holds the type they specifiy in the GitBuildInfoAssemblyType msbuild property.</PackageReleaseNotes>
     <Copyright>Copyright (c) 2021</Copyright>
     <!-- Suppresses the warnings about the package not having assemblies in lib/*/.dll.-->
     <NoPackageAnalysis>true</NoPackageAnalysis>
diff --git a/src/GitBuildInfo.SourceGenerator/Generator.cs b/src/GitBuildInfo.SourceGenerator/Generator.cs
@@ -22,22 +22,23 @@ public static string CreateAndGenerateCode(GeneratorOptions options, GitInfo git
             try
             {
                 var generator = Create(options, gitInfo, context);
-                var splitted = generator.options.AssemblyType.Contains(".")
-                    ? generator.options.AssemblyType.Split('.')
-                    : Array.Empty<string>();
-                var splitted2 = splitted.AsSpan().Slice(0, splitted.Length > 0 ? splitted.Length - 1 : 0);
-                return generator.GenerateCode(
-                    splitted2.ToArray(),
+                if (generator.options.IsCSharp10OrGreater)
+                {
+                    return generator.GenerateCodeCSharp10(generator.options.AssemblyType).ToFullString();
+                }
+
+                return generator.GenerateCodeCSharp9(
+                    string.IsNullOrEmpty(generator.options.RootNamespace) ? Array.Empty<string>() : generator.options.RootNamespace.Split('.'),
                     "Elskom.Generic.Libs",
-                    splitted.Length > 0 ? splitted[splitted2.Length] : generator.options.AssemblyType).ToFullString();
+                    generator.options.AssemblyType).ToFullString();
             }
             catch (InvalidOperationException)
             {
                 return string.Empty;
             }
         }
 
-        public CompilationUnitSyntax GenerateCode(string[] usings, string originalnamespace, string typeName)
+        public CompilationUnitSyntax GenerateCodeCSharp9(string[] usings, string originalnamespace, string typeName)
             => SyntaxFactory.CompilationUnit().WithUsings(
                     SyntaxFactory.List(
                         string.Equals(string.Join(".", usings), originalnamespace, StringComparison.Ordinal) ||
@@ -78,6 +79,37 @@ usings.Length is 0
                                     SyntaxKind.CloseBracketToken,
                                     SyntaxFactory.TriviaList(SyntaxFactory.LineFeed)))));
 
+        public CompilationUnitSyntax GenerateCodeCSharp10(string typeName)
+            => SyntaxFactory.CompilationUnit().WithAttributeLists(
+                SyntaxFactory.SingletonList(
+                    SyntaxFactory.AttributeList(
+                            SyntaxFactory.SingletonSeparatedList(
+                                SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("GitInformationAttribute"))
+                                    .WithArgumentList(
+                                        SyntaxFactory.AttributeArgumentList(
+                                            SyntaxFactory.SeparatedList<AttributeArgumentSyntax>(
+                                                this.MakeAttributeArgumentList(typeName))))))
+                        .WithOpenBracketToken(
+                            SyntaxFactory.Token(
+                                SyntaxFactory.TriviaList(
+                                    SyntaxFactory.Comment("// <autogenerated/>"),
+                                    SyntaxFactory.LineFeed,
+                                    SyntaxFactory.LineFeed),
+                                SyntaxKind.OpenBracketToken,
+                                SyntaxFactory.TriviaList()))
+                        .WithTarget(
+                            SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.AssemblyKeyword))
+                                .WithColonToken(
+                                    SyntaxFactory.Token(
+                                        SyntaxFactory.TriviaList(),
+                                        SyntaxKind.ColonToken,
+                                        SyntaxFactory.TriviaList(SyntaxFactory.Space))))
+                        .WithCloseBracketToken(
+                            SyntaxFactory.Token(
+                                SyntaxFactory.TriviaList(),
+                                SyntaxKind.CloseBracketToken,
+                                SyntaxFactory.TriviaList(SyntaxFactory.LineFeed)))));
+
         private static Generator Create(GeneratorOptions options, GitInfo gitInfo, GeneratorExecutionContext context)
         {
             var generator = new Generator(options, gitInfo);
diff --git a/src/GitBuildInfo.SourceGenerator/GeneratorOptions.cs b/src/GitBuildInfo.SourceGenerator/GeneratorOptions.cs
@@ -14,10 +14,14 @@ public record GeneratorOptions
             DiagnosticSeverity.Warning,
             true);
 
+        public string RootNamespace { get; init; }
+
         public string AssemblyType { get; init; }
 
         public bool IsGeneric { get; init; }
 
+        internal bool IsCSharp10OrGreater { get; init; }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Validate(GeneratorExecutionContext context)
         {
diff --git a/src/GitBuildInfo.SourceGenerator/SourceGenerator.cs b/src/GitBuildInfo.SourceGenerator/SourceGenerator.cs
@@ -21,11 +21,12 @@ public void Initialize(GeneratorInitializationContext context)
         /// <inheritdoc/>
         public void Execute(GeneratorExecutionContext context)
         {
-            if (context.Compilation is not CSharpCompilation)
+            if (context.Compilation is not CSharpCompilation compilation)
             {
                 return;
             }
 
+            _ = context.AnalyzerConfigOptions.GlobalOptions.TryGetValue("build_property.RootNamespace", out var rootNamespace);
             _ = context.AnalyzerConfigOptions.GlobalOptions.TryGetValue("build_property.GitBuildInfoAssemblyType", out var assemblyType);
             _ = context.AnalyzerConfigOptions.GlobalOptions.TryGetValue("build_property.GitBuildInfoIsGeneric", out var isGeneric);
             _ = context.AnalyzerConfigOptions.GlobalOptions.TryGetValue("build_property.GitHead", out var gitHead);
@@ -35,7 +36,15 @@ public void Execute(GeneratorExecutionContext context)
                 "GitAssemblyInfo.g.cs",
                 SourceText.From(
                     Generator.CreateAndGenerateCode(
-                        new GeneratorOptions { AssemblyType = assemblyType, IsGeneric = Convert.ToBoolean(isGeneric) },
+                        new GeneratorOptions
+                        {
+                            RootNamespace = rootNamespace,
+                            AssemblyType = assemblyType,
+                            IsGeneric = Convert.ToBoolean(isGeneric),
+                            IsCSharp10OrGreater = compilation.LanguageVersion is LanguageVersion.CSharp10
+                                or LanguageVersion.Latest
+                                or LanguageVersion.Preview,
+                        },
                         new GitInfo { GitHead = gitHead, CommitHash = commitHash, GitBranch = gitBranch },
                         context),
                     Encoding.UTF8));
diff --git a/tests/CSGeneratorTest.cs b/tests/CSGeneratorTest.cs
@@ -11,11 +11,18 @@ public class CSGeneratorTest : CSharpSourceGeneratorTest<SourceGenerator, XUnitV
     {
         public List<(string, string)> GlobalOptions { get; } = new();
 
+        public LanguageVersion LanguageVersion { get; set; }
+
         protected override GeneratorDriver CreateGeneratorDriver(Project project, ImmutableArray<ISourceGenerator> sourceGenerators)
             => CSharpGeneratorDriver.Create(
                 sourceGenerators,
                 project.AnalyzerOptions.AdditionalFiles,
-                (CSharpParseOptions)project.ParseOptions!,
+                (CSharpParseOptions)CreateParseOptions(),
                 new OptionsProvider(project.AnalyzerOptions.AnalyzerConfigOptionsProvider, GlobalOptions));
+        
+        protected override ParseOptions CreateParseOptions()
+        {
+            return ((CSharpParseOptions)base.CreateParseOptions()).WithLanguageVersion(LanguageVersion);
+        }
     }
 }
diff --git a/tests/SourceGeneratorTests.cs b/tests/SourceGeneratorTests.cs
@@ -2,18 +2,73 @@
 {
     using System.Collections.Generic;
     using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.Testing;
     using Microsoft.CodeAnalysis.Testing.Verifiers;
     using Xunit;
 
     public class SourceGeneratorTests
     {
         private const string generatedFile = "GitBuildInfo.SourceGenerator/GitBuildInfo.SourceGenerator.SourceGenerator/GitAssemblyInfo.g.cs";
+        
+#region C# 10 tests.
+        [Fact]
+        public async Task TestGeneratingDefaultNamespaceCSharp10()
+        {
+            await TestGeneratingDefaultNamespace(LanguageVersion.CSharp10).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestGeneratingNoNamespaceCSharp10()
+        {
+            await TestGeneratingNoNamespace(LanguageVersion.CSharp10).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestGeneratingCustomNamespaceCSharp10()
+        {
+            await TestGeneratingCustomNamespace(LanguageVersion.CSharp10).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestGeneratingGenericCSharp10()
+        {
+            await TestGeneratingGeneric(LanguageVersion.CSharp10).ConfigureAwait(false);
+        }
+#endregion
+
+#region C# 9 tests.
+        [Fact]
+        public async Task TestGeneratingDefaultNamespaceCSharp9()
+        {
+            await TestGeneratingDefaultNamespace().ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestGeneratingNoNamespaceCSharp9()
+        {
+            await TestGeneratingNoNamespace().ConfigureAwait(false);
+        }
 
         [Fact]
-        public async Task TestGeneratingDefaultNamespace()
+        public async Task TestGeneratingCustomNamespaceCSharp9()
         {
-            await RunTest<CSGeneratorTest>("Elskom.Generic.Libs.Test", "false", @"// <autogenerated/>
+            await TestGeneratingCustomNamespace().ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestGeneratingGenericCSharp9()
+        {
+            await TestGeneratingGeneric().ConfigureAwait(false);
+        }
+#endregion
+
+        private static async Task TestGeneratingDefaultNamespace(LanguageVersion languageVersion = LanguageVersion.CSharp9)
+        {
+            await RunTest<CSGeneratorTest>(string.Empty, "Test", "false", languageVersion == LanguageVersion.CSharp10 ? @"// <autogenerated/>
+
+[assembly: GitInformationAttribute(""fbgtgretgtre"", ""vfdbttregter"", ""vsdfvfdsv"", typeof(Test))]
+" : @"// <autogenerated/>
 using Elskom.Generic.Libs;
 
 [assembly: GitInformationAttribute(""fbgtgretgtre"", ""vfdbttregter"", ""vsdfvfdsv"", typeof(Test))]
@@ -23,13 +78,15 @@ internal static class Test
         internal static object Dummy()
             => null;
     }
-}", GetDiagnostics()).ConfigureAwait(false);
+}", languageVersion, languageVersion == LanguageVersion.CSharp10 ? GetCSharp10Diagnostics("Test", otherEndColumn: 92) : GetDiagnostics()).ConfigureAwait(false);
         }
 
-        [Fact]
-        public async Task TestGeneratingNoNamespace()
+        private async Task TestGeneratingNoNamespace(LanguageVersion languageVersion = LanguageVersion.CSharp9)
         {
-            await RunTest<CSGeneratorTest>("Test", "false", @"// <autogenerated/>
+            await RunTest<CSGeneratorTest>(string.Empty, "Test", "false", languageVersion == LanguageVersion.CSharp10 ? @"// <autogenerated/>
+
+[assembly: GitInformationAttribute(""fbgtgretgtre"", ""vfdbttregter"", ""vsdfvfdsv"", typeof(Test))]
+" : @"// <autogenerated/>
 using Elskom.Generic.Libs;
 
 [assembly: GitInformationAttribute(""fbgtgretgtre"", ""vfdbttregter"", ""vsdfvfdsv"", typeof(Test))]
@@ -39,13 +96,15 @@ internal static class Test
         internal static object Dummy()
             => null;
     }
-}", GetDiagnostics()).ConfigureAwait(false);
+}", languageVersion, languageVersion == LanguageVersion.CSharp10 ? GetCSharp10Diagnostics("Test", otherEndColumn: 92) : GetDiagnostics()).ConfigureAwait(false);
         }
 
-        [Fact]
-        public async Task TestGeneratingCustomNamespace()
+        private async Task TestGeneratingCustomNamespace(LanguageVersion languageVersion = LanguageVersion.CSharp9)
         {
-            await RunTest<CSGeneratorTest>("TestNamespace.Test", "false", @"// <autogenerated/>
+            await RunTest<CSGeneratorTest>("TestNamespace", "Test", "false", languageVersion == LanguageVersion.CSharp10 ? @"// <autogenerated/>
+
+[assembly: GitInformationAttribute(""fbgtgretgtre"", ""vfdbttregter"", ""vsdfvfdsv"", typeof(Test))]
+": @"// <autogenerated/>
 using Elskom.Generic.Libs;
 using TestNamespace;
 
@@ -56,13 +115,15 @@ internal static class Test
         internal static object Dummy()
             => null;
     }
-}", GetGenericDiagnostics()).ConfigureAwait(false);
+}", languageVersion, languageVersion == LanguageVersion.CSharp10 ? GetCSharp10Diagnostics("Test", otherEndColumn: 92) : GetGenericDiagnostics()).ConfigureAwait(false);
         }
 
-        [Fact]
-        public async Task TestGeneratingGeneric()
+        private async Task TestGeneratingGeneric(LanguageVersion languageVersion = LanguageVersion.CSharp9)
         {
-            await RunTest<CSGeneratorTest>("Test", "true", @"// <autogenerated/>
+            await RunTest<CSGeneratorTest>(string.Empty, "Test", "true", languageVersion == LanguageVersion.CSharp10 ? @"// <autogenerated/>
+
+[assembly: GitInformationAttribute(""fbgtgretgtre"", ""vfdbttregter"", ""vsdfvfdsv"", typeof(Test<>))]
+" : @"// <autogenerated/>
 using Elskom.Generic.Libs;
 
 [assembly: GitInformationAttribute(""fbgtgretgtre"", ""vfdbttregter"", ""vsdfvfdsv"", typeof(Test<>))]
@@ -72,18 +133,19 @@ internal static class Test<T>
         internal static object Dummy()
             => null;
     }
-}", GetDiagnostics()).ConfigureAwait(false);
+}", languageVersion, languageVersion == LanguageVersion.CSharp10 ? GetCSharp10Diagnostics("Test<>") : GetDiagnostics()).ConfigureAwait(false);
         }
 
         [Fact]
         public async Task TestGeneratingFailure()
         {
             await RunTest<CSGeneratorTest>(
+                string.Empty,
                 string.Empty,
                 "false",
                 string.Empty,
                 string.Empty,
-                new List<DiagnosticResult>
+                expectedDiagnostics: new List<DiagnosticResult>
                 {
                     new DiagnosticResult(GeneratorOptions.ValidationWarning).WithArguments("AssemblyType"),
                 }).ConfigureAwait(false);
@@ -93,6 +155,7 @@ await RunTest<CSGeneratorTest>(
         public async Task TestVBGeneratingAbort()
         {
             await RunTest<VBGeneratorTest>(
+                string.Empty,
                 string.Empty,
                 "false",
                 string.Empty,
@@ -107,6 +170,15 @@ private static List<DiagnosticResult> GetDiagnostics(int startLine = 4, int star
                 DiagnosticResult.CompilerError("CS0246").WithSpan(generatedFile, startLine, startColumn, endLine, endColumn).WithArguments("GitInformationAttributeAttribute"),
             };
 
+        // these diagnostics must be ignored because the Elskom.GitInformation project was moved.
+        private static List<DiagnosticResult> GetCSharp10Diagnostics(string argument, int startLine = 3, int startColumn = 12, int endLine = 3, int endColumn = 35, int otherEndColumn = 94)
+        {
+            var expected = new List<DiagnosticResult>();
+            expected.AddRange(GetDiagnostics(startLine, startColumn, endLine, endColumn));
+            expected.Add(DiagnosticResult.CompilerError("CS0246").WithSpan(generatedFile, startLine, 88, endLine, otherEndColumn).WithArguments(argument));
+            return expected;
+        }
+
         // these diagnostics must be ignored because the Elskom.GitInformation project was moved.
         private static List<DiagnosticResult> GetGenericDiagnostics()
         {
@@ -119,14 +191,15 @@ private static List<DiagnosticResult> GetGenericDiagnostics()
             return result;
         }
 
-        private static async Task RunTest<TestType>(string assemblyType, string isGeneric, string generatedSource,
-            string testSource, List<DiagnosticResult>? expectedDiagnostics = null)
+        private static async Task RunTest<TestType>(string rootNs, string assemblyType, string isGeneric, string generatedSource,
+            string testSource, LanguageVersion languageVersion = LanguageVersion.CSharp9, List<DiagnosticResult>? expectedDiagnostics = null)
             where TestType : SourceGeneratorTest<XUnitVerifier>, IGeneratorTestBase, new()
         {
             var test = new TestType
             {
                 GlobalOptions =
                 {
+                    ("build_property.RootNamespace", rootNs),
                     ("build_property.GitBuildInfoAssemblyType", assemblyType),
                     ("build_property.GitBuildInfoIsGeneric", isGeneric),
                     ("build_property.GitHead", "fbgtgretgtre"),
@@ -147,8 +220,9 @@ private static async Task RunTest<TestType>(string assemblyType, string isGeneri
                 test.ExpectedDiagnostics.AddRange(expectedDiagnostics);
             }
 
-            if (test is not VBGeneratorTest)
+            if (test is CSGeneratorTest tst)
             {
+                tst.LanguageVersion = languageVersion;
                 test.TestState.GeneratedSources.Add(
                     (typeof(SourceGenerator), "GitAssemblyInfo.g.cs", generatedSource));
             }

Original file line number	Diff line number	Diff line change
`@@ -11,11 +11,18 @@ public class CSGeneratorTest : CSharpSourceGeneratorTest<SourceGenerator, XUnitV`
`11`	`11`	`{`
`12`	`12`	`public List<(string, string)> GlobalOptions { get; } = new();`
`13`	`13`
	`14`	`+ public LanguageVersion LanguageVersion { get; set; }`
	`15`	`+`
`14`	`16`	`protected override GeneratorDriver CreateGeneratorDriver(Project project, ImmutableArray<ISourceGenerator> sourceGenerators)`
`15`	`17`	`=> CSharpGeneratorDriver.Create(`
`16`	`18`	`sourceGenerators,`
`17`	`19`	`project.AnalyzerOptions.AdditionalFiles,`
`18`		`- (CSharpParseOptions)project.ParseOptions!,`
	`20`	`+ (CSharpParseOptions)CreateParseOptions(),`
`19`	`21`	`new OptionsProvider(project.AnalyzerOptions.AnalyzerConfigOptionsProvider, GlobalOptions));`
	`22`	`+`
	`23`	`+ protected override ParseOptions CreateParseOptions()`
	`24`	`+ {`
	`25`	`+ return ((CSharpParseOptions)base.CreateParseOptions()).WithLanguageVersion(LanguageVersion);`
	`26`	`+ }`
`20`	`27`	`}`
`21`	`28`	`}`