Add explicit support for assembly aliases (Buildalyzer#294)

Author: dupdob

.github/workflows/build.yml

@@ -30,7 +30,7 @@ jobs:
       - name: Build and Test
         run: dotnet test --logger "trx;LogFileName=test-results.trx"
       - name: Upload Test Results
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
         if: success() || failure()
         with:
           name: test-results-${{ matrix.os }}

src/Buildalyzer.Workspaces/AnalyzerResultExtensions.cs

@@ -293,7 +293,7 @@ private static IEnumerable<DocumentInfo> GetAdditionalDocuments(IAnalyzerResult
     private static IEnumerable<MetadataReference> GetMetadataReferences(IAnalyzerResult analyzerResult) =>
         analyzerResult
             .References?.Where(File.Exists)
-            .Select(x => MetadataReference.CreateFromFile(x))
+            .Select(x => MetadataReference.CreateFromFile(x, new MetadataReferenceProperties(aliases: analyzerResult.ReferenceAliases.GetValueOrDefault(x))))
             ?? [];
 
     private static IEnumerable<AnalyzerReference> GetAnalyzerReferences(IAnalyzerResult analyzerResult, Workspace workspace)

src/Buildalyzer/AnalyzerResult.cs

@@ -71,6 +71,9 @@ public string GetProperty(string name) =>
     public string[] References =>
         CompilerCommand?.MetadataReferences.ToArray() ?? [];
 
+    public ImmutableDictionary<string, ImmutableArray<string>> ReferenceAliases => 
+        CompilerCommand?.Aliases ?? ImmutableDictionary<string, ImmutableArray<string>>.Empty;
+
     public string[] AnalyzerReferences =>
           CompilerCommand?.AnalyzerReferences.Select(r => r.ToString()).ToArray() ?? [];
 

src/Buildalyzer/Compiler/Compiler.cs

@@ -102,8 +102,8 @@ public static TCommand Enrich<TCommand>(TCommand command, CommandLineArguments a
                 AnalyzerReferences = arguments.AnalyzerReferences.Select(AsIOPath).ToImmutableArray(),
                 AnalyzerConfigPaths = arguments.AnalyzerConfigPaths.Select(IOPath.Parse).ToImmutableArray(),
                 MetadataReferences = arguments.MetadataReferences.Select(m => m.Reference).ToImmutableArray(),
+                Aliases = arguments.MetadataReferences.Where(m => !m.Properties.Aliases.IsEmpty).ToImmutableDictionary(m => m.Reference, m => m.Properties.Aliases),
                 PreprocessorSymbolNames = arguments.ParseOptions.PreprocessorSymbolNames.ToImmutableArray(),
-
                 SourceFiles = arguments.SourceFiles.Select(AsIOPath).ToImmutableArray(),
                 AdditionalFiles = arguments.AdditionalFiles.Select(AsIOPath).ToImmutableArray(),
                 EmbeddedFiles = arguments.EmbeddedFiles.Select(AsIOPath).ToImmutableArray(),
@@ -115,4 +115,4 @@ public static TCommand Enrich<TCommand>(TCommand command, CommandLineArguments a
 
     [Pure]
     internal static IOPath AsIOPath(CommandLineSourceFile file) => IOPath.Parse(file.Path);
-}
+}

src/Buildalyzer/Compiler/CompilerCommand.cs

@@ -45,6 +45,11 @@ public abstract record CompilerCommand
     /// <inheritdoc  cref="CommandLineArguments.MetadataReferences" />
     public ImmutableArray<string> MetadataReferences { get; init; }
 
+    /// <summary>
+    /// The aliases used in the command line arguments.
+    /// </summary>
+    public ImmutableDictionary<string, ImmutableArray<string>> Aliases { get; init; }
+
     /// <inheritdoc />
     [Pure]
     public override string ToString() => Text ?? string.Empty;

src/Buildalyzer/IAnalyzerResult.cs

@@ -38,6 +38,8 @@ public interface IAnalyzerResult
 
     string[] References { get; }
 
+    ImmutableDictionary<string, ImmutableArray<string>> ReferenceAliases {get; }
+
     string[] AnalyzerReferences { get; }
 
     string[] SourceFiles { get; }

src/Buildalyzer/Logging/EventProcessor.cs

@@ -172,7 +172,6 @@ private void MessageRaised(object sender, BuildMessageEventArgs e)
         }
 
         bool IsRelevant() => string.IsNullOrEmpty(result.Command) || AnalyzerManager.NormalizePath(e.ProjectFile) == _projectFilePath;
-        
     }
 
     private void BuildFinished(object sender, BuildFinishedEventArgs e)

tests/Buildalyzer.Tests/Integration/SimpleProjectsFixture.cs

@@ -41,6 +41,7 @@ public class SimpleProjectsFixture
         @"SdkNet6ImplicitUsings\SdkNet6ImplicitUsings.csproj",
         @"SdkNet7Project\SdkNet7Project.csproj",
         @"SdkNet8CS12FeaturesProject\SdkNet8CS12FeaturesProject.csproj",
+        @"SdkNet8Alias\SdkNet8Alias.csproj",
         @"SdkNetCore2ProjectImport\SdkNetCore2ProjectImport.csproj",
         @"SdkNetCore2ProjectWithReference\SdkNetCore2ProjectWithReference.csproj",
         @"SdkNetCore2ProjectWithImportedProps\SdkNetCore2ProjectWithImportedProps.csproj",

tests/Buildalyzer.Workspaces.Tests/ProjectAnalyzerExtensionsFixture.cs

@@ -198,6 +198,25 @@ public async Task SupportsLangVersion12Features()
         diagnostics.ShouldBeEmpty();
     }
 
+
+    [Test(Description = "Test Reference Alias support")]
+
+    public async Task SupportAssemblyAliases()
+    {
+        // Given
+        StringWriter log = new StringWriter();
+        IProjectAnalyzer analyzer = GetProjectAnalyzer(@"projects\SdkNet8Alias\SdkNet8Alias.csproj", log);
+        AdhocWorkspace workspace = analyzer.GetWorkspace();
+        Project project = workspace.CurrentSolution.Projects.Single();
+
+        // When
+        Compilation compilation = await project.GetCompilationAsync();
+
+        Diagnostic[] diagnostics = compilation.GetDiagnostics().Where(d => d.Severity == DiagnosticSeverity.Error).ToArray();
+
+        diagnostics.ShouldBeEmpty();
+    }
+
 #if Is_Windows
     [Test]
     public void HandlesWpfCustomControlLibrary()

tests/projects/SdkNet8Alias/Class1.cs

@@ -0,0 +1,15 @@
+extern alias Alias;
+
+using Alias::Xunit;
+
+namespace SdkNet8Alias
+{
+    public class Class1
+    {
+        [Fact]
+        public void Test1()
+        {
+
+        }
+    }
+}