Add option for choosing stdio as the LSP communication channel

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer.UnitTests/Utilities/LanguageServerTestComposition.cs

@@ -39,7 +39,8 @@ public static Task<ExportProvider> CreateExportProviderAsync(
             RazorSourceGenerator: null,
             RazorDesignTimePath: null,
             ExtensionLogDirectory: string.Empty,
-            ServerPipeName: null);
+            ServerPipeName: null,
+            UseStdIo: false);
         var extensionManager = ExtensionAssemblyManager.Create(serverConfiguration, loggerFactory);
         assemblyLoader = new CustomExportAssemblyLoader(extensionManager, loggerFactory);
         return ExportProviderBuilder.CreateExportProviderAsync(extensionManager, assemblyLoader, devKitDependencyPath, cacheDirectory, loggerFactory);

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/Program.cs

@@ -40,7 +40,19 @@
 
 static async Task RunAsync(ServerConfiguration serverConfiguration, CancellationToken cancellationToken)
 {
-    // Before we initialize the LSP server we can't send LSP log messages.
+    // Redirect Console.Out when using stdio to try prevent corruption of the LSP output
+    if (serverConfiguration.UseStdIo)
+    {
+        if (serverConfiguration.ServerPipeName is not null)
+        {
+            throw new Exception("Server cannot be started with both --stdio and --pipe options.");
+        }
+
+        // Redirect Console.Out to try prevent the standard output stream from being corrupted.
+        Console.SetOut(new StreamWriter(Console.OpenStandardError()));
+    }
+
+    // Before we initalize the LSP server we can't send LSP log messages.
     // Create a console logger as a fallback to use before the LSP server starts.
     using var loggerFactory = LoggerFactory.Create(builder =>
     {
@@ -125,23 +137,32 @@ static async Task RunAsync(ServerConfiguration serverConfiguration, Cancellation
 
     var languageServerLogger = loggerFactory.CreateLogger(nameof(LanguageServerHost));
 
-    var (clientPipeName, serverPipeName) = serverConfiguration.ServerPipeName is null
-        ? CreateNewPipeNames()
-        : (serverConfiguration.ServerPipeName, serverConfiguration.ServerPipeName);
+    LanguageServerHost? server = null;
+    if (serverConfiguration.UseStdIo)
+    {
+        server = new LanguageServerHost(Console.OpenStandardInput(), Console.OpenStandardOutput(), exportProvider, languageServerLogger, typeRefResolver);
+    }
+    else
+    {
+        var (clientPipeName, serverPipeName) = serverConfiguration.ServerPipeName is null
+            ? CreateNewPipeNames()
+            : (serverConfiguration.ServerPipeName, serverConfiguration.ServerPipeName);
 
-    var pipeServer = new NamedPipeServerStream(serverPipeName,
-        PipeDirection.InOut,
-        maxNumberOfServerInstances: 1,
-        PipeTransmissionMode.Byte,
-        PipeOptions.CurrentUserOnly | PipeOptions.Asynchronous);
+        var pipeServer = new NamedPipeServerStream(serverPipeName,
+            PipeDirection.InOut,
+            maxNumberOfServerInstances: 1,
+            PipeTransmissionMode.Byte,
+            PipeOptions.CurrentUserOnly | PipeOptions.Asynchronous);
 
-    // Send the named pipe connection info to the client 
-    Console.WriteLine(JsonSerializer.Serialize(new NamedPipeInformation(clientPipeName)));
+        // Send the named pipe connection info to the client 
+        Console.WriteLine(JsonSerializer.Serialize(new NamedPipeInformation(clientPipeName)));
 
-    // Wait for connection from client
-    await pipeServer.WaitForConnectionAsync(cancellationToken);
+        // Wait for connection from client
+        await pipeServer.WaitForConnectionAsync(cancellationToken);
+
+        server = new LanguageServerHost(pipeServer, pipeServer, exportProvider, languageServerLogger, typeRefResolver);
+    }
 
-    var server = new LanguageServerHost(pipeServer, pipeServer, exportProvider, languageServerLogger, typeRefResolver);
     server.Start();
 
     logger.LogInformation("Language server initialized");
@@ -230,7 +251,15 @@ static CliRootCommand CreateCommandLineParser()
     var serverPipeNameOption = new CliOption<string?>("--pipe")
     {
         Description = "The name of the pipe the server will connect to.",
+        Required = false
+    };
+
+    var useStdIoOption = new CliOption<bool>("--stdio")
+    {
+        Description = "Use stdio for communication with the client.",
         Required = false,
+        DefaultValueFactory = _ => false,
+
     };
 
     var rootCommand = new CliRootCommand()
@@ -246,7 +275,8 @@ static CliRootCommand CreateCommandLineParser()
         razorSourceGeneratorOption,
         razorDesignTimePathOption,
         extensionLogDirectoryOption,
-        serverPipeNameOption
+        serverPipeNameOption,
+        useStdIoOption
     };
     rootCommand.SetAction((parseResult, cancellationToken) =>
     {
@@ -261,6 +291,7 @@ static CliRootCommand CreateCommandLineParser()
         var razorDesignTimePath = parseResult.GetValue(razorDesignTimePathOption);
         var extensionLogDirectory = parseResult.GetValue(extensionLogDirectoryOption)!;
         var serverPipeName = parseResult.GetValue(serverPipeNameOption);
+        var useStdIo = parseResult.GetValue(useStdIoOption);
 
         var serverConfiguration = new ServerConfiguration(
             LaunchDebugger: launchDebugger,
@@ -273,6 +304,7 @@ static CliRootCommand CreateCommandLineParser()
             RazorSourceGenerator: razorSourceGenerator,
             RazorDesignTimePath: razorDesignTimePath,
             ServerPipeName: serverPipeName,
+            UseStdIo: useStdIo,
             ExtensionLogDirectory: extensionLogDirectory);
 
         return RunAsync(serverConfiguration, cancellationToken);

src/LanguageServer/Microsoft.CodeAnalysis.LanguageServer/ServerConfigurationFactory.cs

@@ -52,6 +52,7 @@ internal record class ServerConfiguration(
     string? RazorSourceGenerator,
     string? RazorDesignTimePath,
     string? ServerPipeName,
+    bool UseStdIo,
     string ExtensionLogDirectory);
 
 internal class LogConfiguration