feat: document store

Author: onbjerg

Cargo.lock

@@ -154,7 +154,9 @@ async-lsp = { version = "0.2", default-features = false, features = [
     "client-monitor",
     "stdio",
     "tokio",
+    "tracing",
 ] }
+crop = "0.4"
 # See <https://github.com/gluon-lang/lsp-types/issues/284>
 lsp-types = "0.95.0"
 tower = "0.5"
@@ -176,6 +178,7 @@ inturn = "0.1.0"
 libc = "0.2"
 md-5 = "0.10"
 memchr = "2.7"
+normalize-path = "0.2.1"
 once_map = { version = "0.4.20", default-features = false, features = ["std"] }
 paste = "1.0"
 petgraph = "0.8"

Cargo.toml

@@ -37,7 +37,7 @@ hex.workspace = true
 itertools.workspace = true
 itoa.workspace = true
 inturn.workspace = true
-normalize-path = "0.2.1"
+normalize-path.workspace = true
 rayon.workspace = true
 scoped-tls.workspace = true
 tracing.workspace = true

crates/interface/Cargo.toml

@@ -28,8 +28,11 @@ solar-config = { workspace = true, features = ["version"] }
 solar-interface.workspace = true
 
 async-lsp.workspace = true
+crop = { workspace = true, features = ["utf16-metric"] }
 lsp-types.workspace = true
+normalize-path.workspace = true
 tower.workspace = true
+tracing.workspace = true
 
 # This is needed because Windows does not support truly asynchronous pipes.
 [target.'cfg(not(unix))'.dependencies]

crates/lsp/Cargo.toml

@@ -0,0 +1,60 @@
+use std::{ops::ControlFlow, sync::Arc};
+
+use async_lsp::{ClientSocket, ResponseError};
+use lsp_types::{
+    InitializeParams, InitializeResult, InitializedParams, LogMessageParams, MessageType,
+    ServerInfo, notification as notif,
+};
+use solar_config::version::SHORT_VERSION;
+use solar_interface::data_structures::sync::RwLock;
+
+use crate::{NotifyResult, vfs::Vfs};
+
+pub(crate) struct GlobalState {
+    client: ClientSocket,
+    pub(crate) vfs: Arc<RwLock<Vfs>>,
+}
+
+impl GlobalState {
+    pub(crate) fn new(client: ClientSocket) -> Self {
+        Self { client, vfs: Arc::new(Default::default()) }
+    }
+
+    pub(crate) fn on_initialize(
+        &mut self,
+        _: InitializeParams,
+    ) -> impl Future<Output = Result<InitializeResult, ResponseError>> + use<> {
+        std::future::ready(Ok(InitializeResult {
+            server_info: Some(ServerInfo {
+                name: "solar".into(),
+                version: Some(SHORT_VERSION.into()),
+            }),
+            ..Default::default()
+        }))
+    }
+
+    pub(crate) fn on_initialized(&mut self, _: InitializedParams) -> NotifyResult {
+        self.info_msg("solar initialized".into());
+        ControlFlow::Continue(())
+    }
+}
+
+impl GlobalState {
+    fn warn_msg(&self, message: String) {
+        let _ = self
+            .client
+            .notify::<notif::LogMessage>(LogMessageParams { typ: MessageType::WARNING, message });
+    }
+
+    fn error_msg(&self, message: String) {
+        let _ = self
+            .client
+            .notify::<notif::LogMessage>(LogMessageParams { typ: MessageType::ERROR, message });
+    }
+
+    fn info_msg(&self, message: String) {
+        let _ = self
+            .client
+            .notify::<notif::LogMessage>(LogMessageParams { typ: MessageType::INFO, message });
+    }
+}

crates/lsp/src/global_state.rs

@@ -0,0 +1,5 @@
+mod notifs;
+mod reqs;
+
+pub(crate) use notifs::*;
+pub(crate) use reqs::*;

crates/lsp/src/handlers/mod.rs

@@ -0,0 +1,62 @@
+use std::ops::ControlFlow;
+
+use crop::Rope;
+use lsp_types::{
+    DidChangeTextDocumentParams, DidCloseTextDocumentParams, DidOpenTextDocumentParams,
+};
+use tracing::error;
+
+use crate::{NotifyResult, global_state::GlobalState, proto, utils::apply_document_changes};
+
+pub(crate) fn did_open_text_document(
+    state: &mut GlobalState,
+    params: DidOpenTextDocumentParams,
+) -> NotifyResult {
+    if let Some(path) = proto::vfs_path(&params.text_document.uri) {
+        let already_exists = state.vfs.read().exists(&path);
+        if already_exists {
+            error!(?path, "duplicate DidOpenTextDocument");
+        }
+
+        state.vfs.write().set_file_contents(path, Some(Rope::from(params.text_document.text)));
+    }
+
+    ControlFlow::Continue(())
+}
+
+pub(crate) fn did_change_text_document(
+    state: &mut GlobalState,
+    params: DidChangeTextDocumentParams,
+) -> NotifyResult {
+    if let Some(path) = proto::vfs_path(&params.text_document.uri) {
+        let (changed, new_contents) = {
+            let _guard = state.vfs.read();
+            // todo: unwrap is not safe
+            let contents = _guard.get_file_contents(&path).unwrap();
+            let new_contents = apply_document_changes(contents, params.content_changes);
+
+            (contents != &new_contents, new_contents)
+        };
+
+        if changed {
+            state.vfs.write().set_file_contents(path, Some(new_contents));
+        }
+    }
+
+    ControlFlow::Continue(())
+}
+
+pub(crate) fn did_close_text_document(
+    state: &mut GlobalState,
+    params: DidCloseTextDocumentParams,
+) -> NotifyResult {
+    if let Some(path) = proto::vfs_path(&params.text_document.uri) {
+        if !state.vfs.read().exists(&path) {
+            error!(?path, "orphan DidCloseTextDocument");
+        }
+
+        state.vfs.write().set_file_contents(path, None);
+    }
+
+    ControlFlow::Continue(())
+}

crates/lsp/src/handlers/notifs.rs

@@ -0,0 +1 @@
+

crates/lsp/src/handlers/reqs.rs

@@ -5,15 +5,44 @@
 )]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
+use std::ops::ControlFlow;
+
 use async_lsp::{
-    client_monitor::ClientProcessMonitorLayer, concurrency::ConcurrencyLayer,
-    server::LifecycleLayer,
+    ClientSocket, client_monitor::ClientProcessMonitorLayer, concurrency::ConcurrencyLayer,
+    router::Router, server::LifecycleLayer, tracing::TracingLayer,
 };
+use lsp_types::{notification as notif, request as req};
 use tower::ServiceBuilder;
 
-use crate::server::Server;
+use crate::global_state::GlobalState;
+
+mod global_state;
+mod handlers;
+mod proto;
+mod utils;
+mod vfs;
+
+pub(crate) type NotifyResult = ControlFlow<async_lsp::Result<()>>;
+
+fn new_router(client: ClientSocket) -> Router<GlobalState> {
+    let this = GlobalState::new(client);
+    let mut router = Router::new(this);
 
-mod server;
+    // Lifecycle
+    router
+        .request::<req::Initialize, _>(GlobalState::on_initialize)
+        .notification::<notif::Initialized>(GlobalState::on_initialized)
+        .request::<req::Shutdown, _>(|_, _| std::future::ready(Ok(())))
+        .notification::<notif::Exit>(|_, _| ControlFlow::Break(Ok(())));
+
+    // Notifications
+    router
+        .notification::<notif::DidOpenTextDocument>(handlers::did_open_text_document)
+        .notification::<notif::DidCloseTextDocument>(handlers::did_close_text_document)
+        .notification::<notif::DidChangeTextDocument>(handlers::did_change_text_document);
+
+    router
+}
 
 /// Start the LSP server over stdin/stdout.
 ///
@@ -35,11 +64,12 @@ pub async fn run_server_stdio() -> solar_interface::Result<()> {
 
     let (eloop, _) = async_lsp::MainLoop::new_server(|client| {
         ServiceBuilder::new()
+            .layer(TracingLayer::default())
             .layer(LifecycleLayer::default())
             // TODO: infer concurrency
             .layer(ConcurrencyLayer::new(2.try_into().unwrap()))
             .layer(ClientProcessMonitorLayer::new(client.clone()))
-            .service(Server::new_router(client))
+            .service(new_router(client))
     });
 
     eloop.run_buffered(stdin, stdout).await.unwrap();

crates/lsp/src/lib.rs

@@ -0,0 +1,30 @@
+use crop::Rope;
+
+use crate::vfs::{self, VfsPath};
+
+pub(crate) fn vfs_path(url: &lsp_types::Url) -> Option<vfs::VfsPath> {
+    url.to_file_path().map(VfsPath::from).ok()
+}
+
+/// Converts an [`lsp_types::Range`] to a [`Range`].
+///
+/// This assumes the position encoding in LSP is UTF-16, which is mandatory to support in the LSP
+/// spec.
+///
+/// [`Range`]: std::ops::Range
+pub(crate) fn text_range(rope: &Rope, range: lsp_types::Range) -> std::ops::Range<usize> {
+    let start_line = if range.start.line > rope.line_len() as u32 {
+        0usize
+    } else {
+        rope.byte_of_line(range.start.line as usize)
+    };
+    let start = rope.byte_of_utf16_code_unit(start_line + range.start.character as usize);
+    let end_line = if range.end.line > rope.line_len() as u32 {
+        0usize
+    } else {
+        rope.byte_of_line(range.end.line as usize)
+    };
+    let end = rope.byte_of_utf16_code_unit(end_line + range.end.character as usize);
+
+    std::ops::Range { start, end }
+}