Introduction of Compiler Command class (Buildalyzer#243)

Author: Corniel

.editorconfig

@@ -7,6 +7,8 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" AllowedVersion="[4,)" />
+    <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic" Version="4.0.1" AllowedVersion="[4,)" />
     <PackageReference Include="Microsoft.Extensions.Logging" Version="6.0.0" />
     <PackageReference Include="MsBuildPipeLogger.Server" Version="1.1.6" />
     <PackageReference Include="Microsoft.Build" Version="17.0.1" />

src/Buildalyzer/AnalyzerResult.cs

@@ -0,0 +1,11 @@
+#nullable enable
+
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Buildalyzer;
+
+public sealed record CSharpCompilerCommand : RoslynBasedCompilerCommand<CSharpCommandLineArguments>
+{
+    /// <inheritdoc />
+    public override CompilerLanguage Language => CompilerLanguage.CSharp;
+}

src/Buildalyzer/Buildalyzer.csproj

@@ -0,0 +1,121 @@
+#nullable enable
+
+using System.IO;
+using Buildalyzer.IO;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.VisualBasic;
+
+namespace Buildalyzer;
+
+public static class Compiler
+{
+    public static class CommandLine
+    {
+        [Pure]
+        public static string[]? SplitCommandLineIntoArguments(string? commandLine, CompilerLanguage language) => language switch
+        {
+            CompilerLanguage.CSharp => RoslynCommandLineParser.SplitCommandLineIntoArguments(commandLine, "csc.dll", "csc.exe"),
+            CompilerLanguage.VisualBasic => RoslynCommandLineParser.SplitCommandLineIntoArguments(commandLine, "vbc.dll", "vbc.exe"),
+            CompilerLanguage.FSharp => FSharpCommandLineParser.SplitCommandLineIntoArguments(commandLine),
+            _ => throw new NotSupportedException($"The {language} language is not supported."),
+        };
+
+        [Pure]
+        public static CompilerCommand Parse(DirectoryInfo? baseDir, string commandLine, CompilerLanguage language)
+        {
+            var tokens = SplitCommandLineIntoArguments(commandLine, language) ?? throw new FormatException("Commandline could not be parsed.");
+            var location = new FileInfo(tokens[0]);
+            var args = tokens[1..];
+
+            return Parse(baseDir?.ToString(), location.Directory?.ToString(), args, language) with
+            {
+                Text = commandLine,
+                CompilerLocation = location,
+                Arguments = args.ToImmutableArray(),
+            };
+
+            CompilerCommand Parse(string? baseDir, string? root, string[] args, CompilerLanguage language)
+            {
+                return language switch
+                {
+                    CompilerLanguage.CSharp => CSharpParser.Parse(args, baseDir, root),
+                    CompilerLanguage.VisualBasic => VisualBasicParser.Parse(args, baseDir, root),
+                    CompilerLanguage.FSharp => FSharpParser.Parse(args),
+                    _ => throw new NotSupportedException($"The {language} language is not supported."),
+                };
+            }
+        }
+    }
+
+    private static class CSharpParser
+    {
+        [Pure]
+        public static CSharpCompilerCommand Parse(string[] args, string? baseDir, string? root)
+        {
+            var arguments = CSharpCommandLineParser.Default.Parse(args, baseDir, root);
+            var command = new CSharpCompilerCommand()
+            {
+                CommandLineArguments = arguments,
+            };
+            return RoslynParser.Enrich(command, arguments);
+        }
+    }
+
+    private static class VisualBasicParser
+    {
+        [Pure]
+        public static VisualBasicCompilerCommand Parse(string[] args, string? baseDir, string? root)
+        {
+            var arguments = VisualBasicCommandLineParser.Default.Parse(args, baseDir, root);
+            var command = new VisualBasicCompilerCommand()
+            {
+                CommandLineArguments = arguments,
+                PreprocessorSymbols = arguments.ParseOptions.PreprocessorSymbols.ToImmutableDictionary(),
+            };
+            return RoslynParser.Enrich(command, arguments);
+        }
+    }
+
+    private static class FSharpParser
+    {
+        [Pure]
+        public static FSharpCompilerCommand Parse(string[] args)
+        {
+            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()
+            {
+                MetadataReferences = metadataReferences.ToImmutableArray(),
+                PreprocessorSymbolNames = preprocessorSymbolNames.ToImmutableArray(),
+                SourceFiles = sourceFiles.ToImmutableArray(),
+            };
+        }
+    }
+
+    private static class RoslynParser
+    {
+        public static TCommand Enrich<TCommand>(TCommand command, CommandLineArguments arguments)
+            where TCommand : CompilerCommand
+
+            => command with
+            {
+                AnalyzerReferences = arguments.AnalyzerReferences.Select(AsIOPath).ToImmutableArray(),
+                AnalyzerConfigPaths = arguments.AnalyzerConfigPaths.Select(IOPath.Parse).ToImmutableArray(),
+                MetadataReferences = arguments.MetadataReferences.Select(m => m.Reference).ToImmutableArray(),
+                PreprocessorSymbolNames = arguments.ParseOptions.PreprocessorSymbolNames.ToImmutableArray(),
+
+                SourceFiles = arguments.SourceFiles.Select(AsIOPath).ToImmutableArray(),
+                AdditionalFiles = arguments.AdditionalFiles.Select(AsIOPath).ToImmutableArray(),
+                EmbeddedFiles = arguments.EmbeddedFiles.Select(AsIOPath).ToImmutableArray(),
+            };
+    }
+
+    [Pure]
+    internal static IOPath AsIOPath(CommandLineAnalyzerReference file) => IOPath.Parse(file.FilePath);
+
+    [Pure]
+    internal static IOPath AsIOPath(CommandLineSourceFile file) => IOPath.Parse(file.Path);
+}

src/Buildalyzer/Compiler/CSharpCompilerCommand.cs

@@ -0,0 +1,51 @@
+#nullable enable
+
+using System.IO;
+using Buildalyzer.IO;
+using Microsoft.CodeAnalysis;
+
+namespace Buildalyzer;
+
+[DebuggerDisplay("{Language.Display()}: {Text}")]
+public abstract record CompilerCommand
+{
+    /// <summary>The compiler lanuague.</summary>
+    public abstract CompilerLanguage Language { get; }
+
+    /// <summary>The original text of the compiler command.</summary>
+    public string Text { get; init; } = string.Empty;
+
+    /// <summary>The parsed command line arguments.</summary>
+    public ImmutableArray<string> Arguments { get; init; }
+
+    /// <summary>The location of the used compiler.</summary>
+    public FileInfo? CompilerLocation { get; init; }
+
+    /// <inheritdoc  cref="CommandLineArguments.Errors" />
+    public ImmutableArray<Diagnostic> Errors { get; init; }
+
+    /// <inheritdoc  cref="CommandLineArguments.SourceFiles" />
+    public ImmutableArray<IOPath> SourceFiles { get; init; }
+
+    /// <inheritdoc  cref="CommandLineArguments.AdditionalFiles" />
+    public ImmutableArray<IOPath> AdditionalFiles { get; init; }
+
+    /// <inheritdoc  cref="CommandLineArguments.EmbeddedFiles" />
+    public ImmutableArray<IOPath> EmbeddedFiles { get; init; }
+
+    /// <inheritdoc  cref="CommandLineArguments.AnalyzerReferences" />
+    public ImmutableArray<IOPath> AnalyzerReferences { get; init; }
+
+    /// <inheritdoc  cref="CommandLineArguments.AnalyzerConfigPaths" />
+    public ImmutableArray<IOPath> AnalyzerConfigPaths { get; init; }
+
+    /// <inheritdoc  cref="ParseOptions.PreprocessorSymbolNames" />
+    public ImmutableArray<string> PreprocessorSymbolNames { get; init; }
+
+    /// <inheritdoc  cref="CommandLineArguments.MetadataReferences" />
+    public ImmutableArray<string> MetadataReferences { get; init; }
+
+    /// <inheritdoc />
+    [Pure]
+    public override string ToString() => Text ?? string.Empty;
+}

src/Buildalyzer/Compiler/Compiler.cs

@@ -0,0 +1,17 @@
+namespace Buildalyzer;
+
+/// <summary>The compiler language.</summary>
+public enum CompilerLanguage
+{
+    /// <summary>None.</summary>
+    None = 0,
+
+    /// <summary>C#.</summary>
+    CSharp = 1,
+
+    /// <summary>VB.NET.</summary>
+    VisualBasic = 2,
+
+    /// <summary>F#.</summary>
+    FSharp = 3,
+}

src/Buildalyzer/Compiler/CompilerCommand.cs

@@ -0,0 +1,59 @@
+#nullable enable
+
+namespace Buildalyzer;
+
+internal static class FSharpCommandLineParser
+{
+    [Pure]
+    public static string[]? SplitCommandLineIntoArguments(string? commandLine)
+        => commandLine?.Split(Splitters, StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries) is { Length: > 0 } args
+        && First(args[0]).ToArray() is { Length: >= 1 } first
+            ? first.Concat(args[1..]).ToArray()
+            : null;
+
+    [Pure]
+    private static IEnumerable<string> First(string arg)
+        => Tokenize(arg)
+        .SkipWhile(NotCompilerLocation)
+        .Select(a => a.Trim())
+        .Where(a => a.Length > 0);
+
+    [Pure]
+    private static IEnumerable<string> Tokenize(string arg)
+    {
+        var first = 0;
+        var cursor = 0;
+        var quote = false;
+
+        foreach (var ch in arg)
+        {
+            if (ch == '"')
+            {
+                if (quote)
+                {
+                    quote = false;
+                    yield return arg[first..cursor];
+                }
+                else
+                {
+                    quote = true;
+                }
+                first = cursor + 1;
+            }
+            else if (ch == ' ' && cursor >= first && !quote)
+            {
+                yield return arg[first..cursor];
+                first = cursor + 1;
+            }
+            cursor++;
+        }
+        yield return arg[first..];
+    }
+
+    [Pure]
+    public static bool NotCompilerLocation(string s)
+        => !s.EndsWith("fsc.dll", StringComparison.OrdinalIgnoreCase)
+        && !s.EndsWith("fsc.exe", StringComparison.OrdinalIgnoreCase);
+
+    private static readonly char[] Splitters = ['\r', '\n'];
+}

src/Buildalyzer/Compiler/CompilerLanguage.cs

@@ -0,0 +1,10 @@
+using Buildalyzer.IO;
+using Microsoft.CodeAnalysis;
+
+namespace Buildalyzer;
+
+public sealed record FSharpCompilerCommand : CompilerCommand
+{
+    /// <inheritdoc />
+    public override CompilerLanguage Language => CompilerLanguage.FSharp;
+}

src/Buildalyzer/Compiler/FSharpCommandLineParser.cs

@@ -0,0 +1,12 @@
+#nullable enable
+
+using Microsoft.CodeAnalysis;
+
+namespace Buildalyzer;
+
+public abstract record RoslynBasedCompilerCommand<TArguments> : CompilerCommand
+    where TArguments : CommandLineArguments
+{
+    /// <summary>The Roslyn comppiler arguments.</summary>
+    public TArguments? CommandLineArguments { get; init; }
+}