Add Visual Basic compilation support

Bot/Sharp/Compilation/CSharpCompiler.cs

@@ -1,13 +1,11 @@
 using System.Text;
 
-using Basic.Reference.Assemblies;
-
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 
 namespace Sharp.Compilation;
 
-public class CSharpCompiler : ICompiler
+public class CSharpCompiler : RoslynCompiler
 {
     private static readonly CSharpCompilationOptions _executableOptions = new(
         outputKind: OutputKind.ConsoleApplication,
@@ -32,8 +30,6 @@ private static CSharpCompilationOptions GetOptions(SyntaxTree syntaxTree, Compil
         return syntaxTree.GetRoot().ChildNodes().Any(node => node.IsKind(SyntaxKind.GlobalStatement)) ? _executableOptions : _libraryOptions;
     }
 
-    private static readonly MetadataReference[] _references = [.. Net80.References.All, MetadataReference.CreateFromFile(typeof(JitGenericAttribute).Assembly.Location)];
-
     private static readonly SyntaxTree _globalUsingsSyntaxTree = CreateGlobalUsingsSyntaxTree("System",
                                                                                               "System.Collections.Generic",
                                                                                               "System.IO",
@@ -58,22 +54,12 @@ private static SyntaxTree CreateGlobalUsingsSyntaxTree(params string[] namespace
         return CSharpSyntaxTree.ParseText(stringBuilder.ToString());
     }
 
-    public Language Language => Language.CSharp;
+    public override Language Language => Language.CSharp;
 
-    public ValueTask<bool> CompileAsync(string code, ICollection<Diagnostic> diagnostics, Stream assembly, CompilationOutput? output)
+    protected override Microsoft.CodeAnalysis.Compilation CreateCompilation(string code, CompilationOutput? output)
     {
         var syntaxTree = CSharpSyntaxTree.ParseText(code);
 
-        var compilation = CSharpCompilation.Create("_", [_globalUsingsSyntaxTree, syntaxTree], _references, GetOptions(syntaxTree, output));
-
-        var result = compilation.Emit(assembly);
-
-        var resultDiagnostic = result.Diagnostics;
-        int length = resultDiagnostic.Length;
-
-        for (int i = 0; i < length; i++)
-            diagnostics.Add(resultDiagnostic[i]);
-
-        return new(result.Success);
+        return CSharpCompilation.Create("_", [_globalUsingsSyntaxTree, syntaxTree], _references, GetOptions(syntaxTree, output));
     }
 }

Bot/Sharp/Compilation/RoslynCompiler.cs

@@ -0,0 +1,29 @@
+using Basic.Reference.Assemblies;
+
+using Microsoft.CodeAnalysis;
+
+namespace Sharp.Compilation;
+
+public abstract class RoslynCompiler : ICompiler
+{
+    protected static readonly MetadataReference[] _references = [.. Net80.References.All, MetadataReference.CreateFromFile(typeof(JitGenericAttribute).Assembly.Location)];
+
+    public abstract Language Language { get; }
+
+    protected abstract Microsoft.CodeAnalysis.Compilation CreateCompilation(string code, CompilationOutput? output);
+
+    public ValueTask<bool> CompileAsync(string code, ICollection<Diagnostic> diagnostics, Stream assembly, CompilationOutput? output)
+    {
+        var compilation = CreateCompilation(code, output);
+
+        var result = compilation.Emit(assembly);
+
+        var resultDiagnostics = result.Diagnostics;
+        int length = resultDiagnostics.Length;
+
+        for (int i = 0; i < length; i++)
+            diagnostics.Add(resultDiagnostics[i]);
+
+        return new(result.Success);
+    }
+}

Bot/Sharp/Compilation/VisualBasicCompiler.cs

@@ -0,0 +1,64 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.VisualBasic;
+
+namespace Sharp.Compilation;
+
+public class VisualBasicCompiler : RoslynCompiler
+{
+    static VisualBasicCompiler()
+    {
+        var globalImports = CreateGlobalImports("System",
+                                                "Microsoft.VisualBasic",
+                                                "System.Collections.Generic",
+                                                "System.Linq",
+                                                "System.Collections",
+                                                "System.Diagnostics",
+                                                "System.Threading.Tasks",
+                                                "Sharp");
+
+        _executableOptions = new(
+            outputKind: OutputKind.ConsoleApplication,
+            optimizationLevel: OptimizationLevel.Release,
+            globalImports: globalImports);
+
+        _libraryOptions = new(
+            outputKind: OutputKind.DynamicallyLinkedLibrary,
+            optimizationLevel: OptimizationLevel.Release,
+            globalImports: globalImports);
+    }
+
+    private static GlobalImport[] CreateGlobalImports(params string[] namespaces)
+    {
+        int length = namespaces.Length;
+        var result = new GlobalImport[length];
+
+        for (int i = 0; i < length; i++)
+            result[i] = GlobalImport.Parse(namespaces[i]);
+
+        return result;
+    }
+
+    private static readonly VisualBasicCompilationOptions _executableOptions;
+
+    private static readonly VisualBasicCompilationOptions _libraryOptions;
+
+    private static VisualBasicCompilationOptions GetOptions(CompilationOutput? output)
+    {
+        if (output.HasValue)
+            return output.GetValueOrDefault() switch
+            {
+                CompilationOutput.Executable => _executableOptions,
+                CompilationOutput.Library => _libraryOptions,
+                _ => throw new ArgumentOutOfRangeException(nameof(output))
+            };
+
+        return _libraryOptions;
+    }
+
+    public override Language Language => Language.VisualBasic;
+
+    protected override Microsoft.CodeAnalysis.Compilation CreateCompilation(string code, CompilationOutput? output)
+    {
+        return VisualBasicCompilation.Create("_", [VisualBasicSyntaxTree.ParseText(code)], _references, GetOptions(output));
+    }
+}

Bot/Sharp/Language.cs

@@ -5,6 +5,9 @@ public enum Language : byte
     [LanguageAliases("c#", "cs", "csharp")]
     CSharp,
 
+    [LanguageAliases("vb", "vb.net", "vbnet", "visualbasic", "visualbasic.net", "visualbasicnet")]
+    VisualBasic,
+
     [LanguageAliases("il", "cil", "msil")]
     IL,
 

Bot/Sharp/Program.cs

@@ -41,6 +41,7 @@
     .AddSingleton<IBackendUriProvider, BackendUriProvider>()
     .AddSingleton<IBackendProvider, BackendProvider>()
     .AddSingleton<ICompiler, CSharpCompiler>()
+    .AddSingleton<ICompiler, VisualBasicCompiler>()
     .AddSingleton<ICompiler, ILCompiler>()
     .AddSingleton<ICompilerProvider, CompilerProvider>()
     .AddSingleton<IDecompiler, CSharpDecompiler>()

Bot/Sharp/Responding/ResponseProvider.cs

@@ -146,6 +146,7 @@ public class ResponseProvider(IOptions<Options> options, ICompilationFormatter c
                                                 ## Support
                                                 ### Compilation
                                                 - C#
+                                                - Visual Basic
                                                 - IL
                                                 ### Decompilation
                                                 - C#

Bot/Sharp/Sharp.csproj

@@ -12,6 +12,7 @@
     <PackageReference Include="Basic.Reference.Assemblies.Net80" Version="1.7.2" />
     <PackageReference Include="ICSharpCode.Decompiler" Version="8.2.0.7535" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.10.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.VisualBasic" Version="4.10.0" />
     <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="8.0.0" />
     <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0" />
     <PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0" />