rune: Remove boxing and mutex in lsp and introduce builder (#969)

Author: udoprog

crates/rune-cli/Cargo.toml

@@ -16,7 +16,7 @@ categories = ["parser-implementations"]
 default-run = "rune"
 
 [dependencies]
-rune = { version = "0.14.0", path = "../rune", features = ["cli"] }
+rune = { version = "0.14.0", path = "../rune", features = ["cli", "tracing"] }
 rune-modules = { version = "0.14.0", path = "../rune-modules", features = ["full"] }
 
 [build-dependencies]

crates/rune-languageserver/Cargo.toml

@@ -20,7 +20,7 @@ tracing = "0.1.37"
 tracing-appender = "0.2.2"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 
-rune = { version = "0.14.0", path = "../rune", features = ["languageserver"] }
+rune = { version = "0.14.0", path = "../rune", features = ["languageserver", "tracing"] }
 rune-modules = { version = "0.14.0", path = "../rune-modules", features = ["full"] }
 
 [build-dependencies]

crates/rune-languageserver/src/main.rs

@@ -15,44 +15,46 @@
 //! <br>
 //!
 //! A language server for the Rune Language, an embeddable dynamic programming language for Rust.
-use anyhow::{bail, Result};
-use rune::languageserver::{Input, Output};
+
+use anyhow::{anyhow, bail, Result};
+use rune::languageserver;
 use rune::Options;
 use std::env;
+use std::fs::File;
 use std::path::PathBuf;
-use tracing_appender::non_blocking::WorkerGuard;
 use tracing_subscriber::EnvFilter;
 
 pub const VERSION: &str = include_str!(concat!(env!("OUT_DIR"), "/version.txt"));
 
-fn setup_logging() -> Result<Option<WorkerGuard>> {
-    let mut guard = None;
-
-    let env_filter = EnvFilter::from_env("RUNE_LOG");
+fn setup_logging() -> Result<()> {
+    let Ok(env_filter) = EnvFilter::try_from_env("RUNE_LOG") else {
+        return Ok(());
+    };
 
     // Set environment variable to get the language server to trace log to the
     // given file.
-    if let Some(log_path) = std::env::var_os("RUNE_LOG_FILE") {
-        let log_path = PathBuf::from(log_path);
+    let Some(log_path) = std::env::var_os("RUNE_LOG_FILE") else {
+        return Ok(());
+    };
 
-        if let (Some(d), Some(name)) = (log_path.parent(), log_path.file_name()) {
-            let file_appender = tracing_appender::rolling::never(d, name);
-            let (non_blocking, g) = tracing_appender::non_blocking(file_appender);
+    let log_path = PathBuf::from(log_path);
 
-            tracing_subscriber::fmt()
-                .with_env_filter(env_filter)
-                .with_writer(non_blocking)
-                .init();
-
-            guard = Some(g);
-        }
+    if let Some(d) = log_path.parent() {
+        _ = std::fs::create_dir_all(d);
     }
 
-    Ok(guard)
+    tracing_subscriber::fmt()
+        .with_env_filter(env_filter)
+        .with_writer(File::options().append(true).create(true).open(log_path)?)
+        .try_init()
+        .map_err(|e| anyhow!("{e}"))?;
+
+    Ok(())
 }
 
-fn main() -> Result<()> {
-    let _guard = setup_logging()?;
+#[tokio::main]
+async fn main() -> Result<()> {
+    setup_logging()?;
 
     let mut it = env::args();
     it.next();
@@ -74,20 +76,15 @@ fn main() -> Result<()> {
     }
 
     let context = rune_modules::default_context()?;
-
     let options = Options::from_default_env()?;
 
-    let runtime = tokio::runtime::Builder::new_current_thread()
-        .enable_all()
+    let languageserver = languageserver::builder()
+        .with_context(context)
+        .with_options(options)
+        .with_stdio()
         .build()?;
 
-    let result = runtime.block_on(rune::languageserver::run(
-        context,
-        options,
-        (Input::from_stdin()?, Output::from_stdout()?),
-    ));
-
-    match result {
+    match languageserver.run().await {
         Ok(()) => {
             tracing::info!("Server shutting down");
         }

crates/rune/Cargo.toml

@@ -29,7 +29,7 @@ byte-code = ["alloc", "musli/storage", "musli/std", "rune-alloc/std"]
 capture-io = ["alloc", "parking_lot"]
 disable-io = ["alloc"]
 fmt = ["alloc", "anyhow"]
-std = ["alloc", "num/std", "serde/std", "rune-core/std", "rune-alloc/std", "musli?/std", "once_cell/std", "anyhow?/std", "syntree/std"]
+std = ["alloc", "num/std", "serde/std", "rune-core/std", "rune-alloc/std", "musli?/std", "once_cell/std", "anyhow?/std", "syntree/std", "tokio?/io-std"]
 alloc = ["rune-alloc/alloc", "rune-core/alloc", "once_cell/alloc", "serde?/alloc"]
 musli = ["dep:musli", "rune-core/musli", "rune-alloc/musli"]
 serde = ["dep:serde", "rune-alloc/serde", "relative-path?/serde"]
@@ -62,7 +62,7 @@ rust-embed = { version = "8.7.2", optional = true }
 semver = { version = "1.0.17", optional = true, features = ["serde"] }
 serde-hashkey = { version = "0.4.5", optional = true }
 syntect = { version = "5.2.0", optional = true, default-features = false, features = ["default-fancy"] }
-tokio = { version = "1.28.1", features = ["rt-multi-thread", "fs", "macros", "sync", "io-std", "io-util"], optional = true }
+tokio = { version = "1.28.1", features = ["rt-multi-thread", "fs", "macros", "sync", "io-util"], optional = true }
 toml = { version = "0.8.19", optional = true, features = ["parse"] }
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"], optional = true }
 webbrowser = { version = "1.0.2", optional = true }

crates/rune/src/cli/languageserver.rs

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