Making the library language/compiler agnostic

src/Buildalyzer/AnalyzerManager.cs

@@ -39,12 +39,14 @@ public class AnalyzerManager : IAnalyzerManager
 
     public SolutionFile SolutionFile { get; }
 
+    public List<ICompilerOptionsParser> CompilerOptionsParsers { get; }
+
     public AnalyzerManager(AnalyzerManagerOptions options = null)
         : this(null, options)
     {
     }
 
-    public AnalyzerManager(string solutionFilePath, AnalyzerManagerOptions options = null)
+    public AnalyzerManager(string solutionFilePath, AnalyzerManagerOptions? options = null)
     {
         options ??= new AnalyzerManagerOptions();
         LoggerFactory = options.LoggerFactory;
@@ -58,13 +60,15 @@ public AnalyzerManager(string solutionFilePath, AnalyzerManagerOptions options =
             foreach (ProjectInSolution projectInSolution in SolutionFile.ProjectsInOrder)
             {
                 if (!SupportedProjectTypes.Contains(projectInSolution.ProjectType)
-                    || (options?.ProjectFilter != null && !options.ProjectFilter(projectInSolution)))
+                    || (options.ProjectFilter != null && !options.ProjectFilter(projectInSolution)))
                 {
                     continue;
                 }
                 GetProject(projectInSolution.AbsolutePath, projectInSolution);
             }
         }
+
+        CompilerOptionsParsers = options.CompilerOptionsParsers;
     }
 
     public void SetGlobalProperty(string key, string value)

src/Buildalyzer/AnalyzerManagerOptions.cs

@@ -30,4 +30,9 @@ public TextWriter LogWriter
             LoggerFactory.AddProvider(new TextWriterLoggerProvider(value));
         }
     }
+
+    public List<ICompilerOptionsParser> CompilerOptionsParsers { get; set; } = [
+        CscOptionsParser.Instance,
+        VbcOptionsParser.Instance,
+        FscOptionsParser.Instance];
 }

src/Buildalyzer/AnalyzerResult.cs

@@ -11,7 +11,7 @@ public class AnalyzerResult : IAnalyzerResult
     private readonly Dictionary<string, IProjectItem[]> _items = new Dictionary<string, IProjectItem[]>(StringComparer.OrdinalIgnoreCase);
     private readonly Guid _projectGuid;
 
-    public CompilerCommand CompilerCommand { get; private set; }
+    public CompilerCommand CompilerCommand { get; internal set; }
 
     internal AnalyzerResult(string projectFilePath, AnalyzerManager manager, ProjectAnalyzer analyzer)
     {
@@ -107,26 +107,6 @@ internal void ProcessProject(PropertiesAndItems propertiesAndItems)
         }
     }
 
-    internal void ProcessCscCommandLine(string commandLine, bool coreCompile)
-    {
-        // Some projects can have multiple Csc calls (see #92) so if this is the one inside CoreCompile use it, otherwise use the first
-        if (string.IsNullOrWhiteSpace(commandLine) || (CompilerCommand != null && !coreCompile))
-        {
-            return;
-        }
-        CompilerCommand = Compiler.CommandLine.Parse(new FileInfo(ProjectFilePath).Directory, commandLine, CompilerLanguage.CSharp);
-    }
-
-    internal void ProcessVbcCommandLine(string commandLine)
-    {
-        CompilerCommand = Compiler.CommandLine.Parse(new FileInfo(ProjectFilePath).Directory, commandLine, CompilerLanguage.VisualBasic);
-    }
-
-    internal void ProcessFscCommandLine(string commandLine)
-    {
-        CompilerCommand = Compiler.CommandLine.Parse(new FileInfo(ProjectFilePath).Directory, commandLine, CompilerLanguage.FSharp);
-    }
-
     private class ProjectItemItemSpecEqualityComparer : IEqualityComparer<IProjectItem>
     {
         public bool Equals(IProjectItem x, IProjectItem y) => x.ItemSpec.Equals(y.ItemSpec, StringComparison.OrdinalIgnoreCase);

src/Buildalyzer/Compiler/CSharpCompilerCommand.cs

@@ -7,5 +7,5 @@ namespace Buildalyzer;
 public sealed record CSharpCompilerCommand : RoslynBasedCompilerCommand<CSharpCommandLineArguments>
 {
     /// <inheritdoc />
-    public override CompilerLanguage Language => CompilerLanguage.CSharp;
+    public override string Language => "C#";
 }

src/Buildalyzer/Compiler/CompilerCommand.cs

@@ -10,7 +10,7 @@ namespace Buildalyzer;
 public abstract record CompilerCommand
 {
     /// <summary>The compiler lanuague.</summary>
-    public abstract CompilerLanguage Language { get; }
+    public abstract string Language { get; }
 
     /// <summary>The original text of the compiler command.</summary>
     public string Text { get; init; } = string.Empty;

src/Buildalyzer/Compiler/CscOptionsParser.cs

@@ -0,0 +1,52 @@
+using System.IO;
+using Buildalyzer.IO;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Buildalyzer;
+
+/// <summary>
+/// A parser for the csc compiler options (Roslyn).
+/// </summary>
+public sealed class CscOptionsParser : ICompilerOptionsParser
+{
+    /// <summary>
+    /// A singleton instance of the parser.
+    /// </summary>
+    public static CscOptionsParser Instance { get; } = new CscOptionsParser();
+
+    public string Language => "C#";
+
+    private CscOptionsParser()
+    {
+    }
+
+    public bool IsSupportedInvocation(object sender, BuildMessageEventArgs eventArgs, CompilerOptionsContext context) =>
+        eventArgs is TaskCommandLineEventArgs cmd
+        && string.Equals(cmd.TaskName, "Csc", StringComparison.OrdinalIgnoreCase);
+
+    public CompilerCommand? Parse(string commandLine, CompilerOptionsContext context)
+    {
+        if (string.IsNullOrWhiteSpace(commandLine) || (!context.IsFirstInvocation && !context.CoreCompile))
+        {
+            return null;
+        }
+
+        var tokens = RoslynParser.SplitCommandLineIntoArguments(commandLine, "csc.dll", "csc.exe")
+                  ?? throw new FormatException("Commandline could not be parsed.");
+        var location = new FileInfo(tokens[0]);
+        var args = tokens[1..];
+
+        var arguments = CSharpCommandLineParser.Default.Parse(args, context.BaseDirectory?.ToString(), location.Directory?.ToString());
+        var command = new CSharpCompilerCommand()
+        {
+            CommandLineArguments = arguments,
+            Text = commandLine,
+            CompilerLocation = location,
+            Arguments = args.ToImmutableArray(),
+        };
+        return RoslynParser.Enrich(command, arguments);
+    }
+}

src/Buildalyzer/Compiler/FSharpCompilerCommand.cs

@@ -6,5 +6,5 @@ namespace Buildalyzer;
 public sealed record FSharpCompilerCommand : CompilerCommand
 {
     /// <inheritdoc />
-    public override CompilerLanguage Language => CompilerLanguage.FSharp;
+    public override string Language => "F#";
 }

src/Buildalyzer/Compiler/FSharpCommandLineParser.cs → src/Buildalyzer/Compiler/FSharpParser.cs

@@ -2,7 +2,7 @@
 
 namespace Buildalyzer;
 
-internal static class FSharpCommandLineParser
+internal static class FSharpParser
 {
     [Pure]
     public static string[]? SplitCommandLineIntoArguments(string? commandLine)

src/Buildalyzer/Compiler/FscOptionsParser.cs

@@ -0,0 +1,52 @@
+using System.IO;
+using Buildalyzer.IO;
+using Microsoft.Build.Framework;
+using Microsoft.CodeAnalysis.VisualBasic;
+
+namespace Buildalyzer;
+
+/// <summary>
+/// A parser for the fsc compiler options (F#).
+/// </summary>
+public sealed class FscOptionsParser : ICompilerOptionsParser
+{
+    /// <summary>
+    /// A singleton instance of the parser.
+    /// </summary>
+    public static FscOptionsParser Instance { get; } = new FscOptionsParser();
+
+    public string Language => "F#";
+
+    private FscOptionsParser()
+    {
+    }
+
+    public bool IsSupportedInvocation(object sender, BuildMessageEventArgs eventArgs, CompilerOptionsContext context) =>
+        eventArgs.SenderName?.Equals("Fsc", StringComparison.OrdinalIgnoreCase) == true
+        && !string.IsNullOrWhiteSpace(eventArgs.Message)
+        && context.TargetStack.Any(x => x.TargetName == "CoreCompile")
+        && context.IsFirstInvocation;
+
+    public CompilerCommand? Parse(string commandLine, CompilerOptionsContext context)
+    {
+        var tokens = FSharpParser.SplitCommandLineIntoArguments(commandLine)
+                  ?? throw new FormatException("Commandline could not be parsed.");
+
+        var location = new FileInfo(tokens[0]);
+        var args = tokens[1..];
+
+        var sourceFiles = args.Where(a => a[0] != '-').Select(IOPath.Parse);
+        var preprocessorSymbolNames = args.Where(a => a.StartsWith("--define:")).Select(a => a[9..]);
+        var metadataReferences = args.Where(a => a.StartsWith("-r:")).Select(a => a[3..]);
+
+        return new FSharpCompilerCommand()
+        {
+            MetadataReferences = metadataReferences.ToImmutableArray(),
+            PreprocessorSymbolNames = preprocessorSymbolNames.ToImmutableArray(),
+            SourceFiles = sourceFiles.ToImmutableArray(),
+            Text = commandLine,
+            CompilerLocation = location,
+            Arguments = args.ToImmutableArray(),
+        };
+    }
+}