Refactor language server input/output handling (#967)

- Introduced `Input` and `Output` structs for managing stdin and stdout connections.
- Updated the `run` function to accept `Input` and `Output` as parameters.
- Removed the `stdio` function in favor of direct instantiation of `Input` and `Output` from stdin and stdout.
- Enhanced the `Input` and `Output` structs with new constructors for better encapsulation.
- Added `modify_lsp_full_range` method to `ServerSource` for modifying the entire file content.
- Updated `did_change_text_document` function to handle full range modifications when no specific range is provided.

Author: mnixry

crates/rune-languageserver/src/main.rs

@@ -16,6 +16,7 @@
 //!
 //! A language server for the Rune Language, an embeddable dynamic programming language for Rust.
 use anyhow::{bail, Result};
+use rune::languageserver::{Input, Output};
 use rune::Options;
 use std::env;
 use std::path::PathBuf;
@@ -80,7 +81,11 @@ fn main() -> Result<()> {
         .enable_all()
         .build()?;
 
-    let result = runtime.block_on(rune::languageserver::run(context, options));
+    let result = runtime.block_on(rune::languageserver::run(
+        context,
+        options,
+        (Input::from_stdin()?, Output::from_stdout()?),
+    ));
 
     match result {
         Ok(()) => {

crates/rune/src/cli/languageserver.rs

@@ -1,9 +1,17 @@
 use anyhow::Result;
 
-use crate::{Context, Options};
+use crate::{
+    languageserver::{Input, Output},
+    Context, Options,
+};
 
 pub(super) async fn run(context: Context) -> Result<()> {
     let options = Options::from_default_env()?;
-    crate::languageserver::run(context, options).await?;
+    crate::languageserver::run(
+        context,
+        options,
+        (Input::from_stdin()?, Output::from_stdout()?),
+    )
+    .await?;
     Ok(())
 }

crates/rune/src/languageserver/connection.rs

@@ -1,11 +1,9 @@
 use core::fmt;
 
-use rust_alloc::sync::Arc;
-
 use anyhow::{anyhow, bail, Result};
-use tokio::io;
 use tokio::io::{
-    AsyncBufRead, AsyncBufReadExt as _, AsyncReadExt as _, AsyncWriteExt as _, BufReader,
+    self, AsyncBufRead, AsyncBufReadExt as _, AsyncReadExt as _, AsyncWrite, AsyncWriteExt as _,
+    BufReader,
 };
 use tokio::sync::Mutex;
 
@@ -19,15 +17,30 @@ pub(super) struct Frame<'a> {
 }
 
 /// Input connection.
-pub(super) struct Input {
+pub struct Input {
     buf: rust_alloc::vec::Vec<u8>,
-    stdin: BufReader<io::Stdin>,
+    reader: rust_alloc::boxed::Box<dyn AsyncBufRead + Unpin>,
 }
 
 impl Input {
+    /// Create a new input connection.
+    pub fn new(reader: rust_alloc::boxed::Box<dyn AsyncBufRead + Unpin>) -> Self {
+        Self {
+            buf: rust_alloc::vec::Vec::new(),
+            reader,
+        }
+    }
+
+    /// Create a new input connection from stdin.
+    pub fn from_stdin() -> Result<Self> {
+        let stdin = io::stdin();
+        let reader = rust_alloc::boxed::Box::new(BufReader::new(stdin));
+        Ok(Self::new(reader))
+    }
+
     /// Get the next input frame.
     pub(super) async fn next(&mut self) -> Result<Option<Frame<'_>>> {
-        let headers = match Headers::read(&mut self.buf, &mut self.stdin).await? {
+        let headers = match Headers::read(&mut self.buf, &mut self.reader).await? {
             Some(headers) => headers,
             None => return Ok(None),
         };
@@ -40,18 +53,31 @@ impl Input {
         };
 
         self.buf.resize(length, 0u8);
-        self.stdin.read_exact(&mut self.buf[..]).await?;
+        self.reader.read_exact(&mut self.buf[..]).await?;
         Ok(Some(Frame { content: &self.buf }))
     }
 }
 
 /// Output connection.
-#[derive(Clone)]
-pub(super) struct Output {
-    stdout: Arc<Mutex<io::Stdout>>,
+pub struct Output {
+    writer: Mutex<rust_alloc::boxed::Box<dyn AsyncWrite + Unpin>>,
 }
 
 impl Output {
+    /// Create a new output connection.
+    pub fn new(writer: rust_alloc::boxed::Box<dyn AsyncWrite + Unpin>) -> Self {
+        Self {
+            writer: Mutex::new(writer),
+        }
+    }
+
+    /// Create a new output connection from stdout.
+    pub fn from_stdout() -> Result<Self> {
+        let stdout = io::stdout();
+        let writer = rust_alloc::boxed::Box::new(stdout);
+        Ok(Self::new(writer))
+    }
+
     /// Send the given response.
     pub(super) async fn response<R>(&self, id: Option<envelope::RequestId>, result: R) -> Result<()>
     where
@@ -148,30 +174,13 @@ impl Output {
         write!(m, "\r\n")?;
         m.append(bytes);
 
-        let mut stdout = self.stdout.lock().await;
+        let mut stdout = self.writer.lock().await;
         stdout.write_all(&m).await?;
         stdout.flush().await?;
         Ok(())
     }
 }
 
-/// Setup a stdin/stdout connection.
-pub(super) fn stdio() -> Result<(Input, Output)> {
-    let stdin = io::stdin();
-    let stdout = io::stdout();
-
-    let input = Input {
-        buf: rust_alloc::vec::Vec::new(),
-        stdin: BufReader::new(stdin),
-    };
-
-    let output = Output {
-        stdout: Arc::new(Mutex::new(stdout)),
-    };
-
-    Ok((input, output))
-}
-
 #[derive(Debug)]
 pub(super) enum ContentType {
     JsonRPC,

crates/rune/src/languageserver/mod.rs

@@ -18,7 +18,6 @@ use serde::Deserialize;
 use tokio::sync::Notify;
 
 use crate::alloc::String;
-use crate::languageserver::connection::stdio;
 use crate::languageserver::envelope::Code;
 use crate::languageserver::state::State;
 use crate::support::Result;
@@ -27,15 +26,19 @@ use crate::{Context, Options};
 
 use self::state::StateEncoding;
 
+pub use connection::{Input, Output};
+
 enum Language {
     Rune,
     Other,
 }
 
 /// Run a language server with the given options.
-pub async fn run(context: Context, options: Options) -> Result<()> {
-    let (mut input, output) = stdio()?;
-
+pub async fn run(
+    context: Context,
+    options: Options,
+    (mut input, output): (Input, Output),
+) -> Result<()> {
     let rebuild_notify = Notify::new();
 
     let rebuild = rebuild_notify.notified();
@@ -322,8 +325,10 @@ async fn did_change_text_document(
         for change in params.content_changes {
             if let Some(range) = change.range {
                 source.modify_lsp_range(&s.encoding, range, &change.text)?;
-                interest = true;
+            } else {
+                source.modify_lsp_full_range(&change.text)?;
             }
+            interest = true;
         }
     } else {
         tracing::warn!(

crates/rune/src/languageserver/state.rs

@@ -894,6 +894,11 @@ impl ServerSource {
         self.modify_range(start, end, content)
     }
 
+    /// Modify the full range of the file.
+    pub(super) fn modify_lsp_full_range(&mut self, content: &str) -> Result<()> {
+        self.modify_range(0, self.content.len_chars(), content)
+    }
+
     fn modify_range(&mut self, start: usize, end: usize, content: &str) -> Result<()> {
         self.content.try_remove(start..end)?;