feat: workspace discovery

Author: onbjerg

Cargo.lock

@@ -60,7 +60,7 @@ pub struct SpanLabel {
 /// A collection of `Span`s.
 ///
 /// Spans have two orthogonal attributes:
-/// - They can be *primary spans*. In this case they are the locus of the error, and would be
+/// - They can be *primary spans*. In this case they are the focus of the error, and would be
 ///   rendered with `^^^`.
 /// - They can have a *label*. In this case, the label is written next to the mark in the snippet
 ///   when we render.

crates/interface/src/diagnostics/message.rs

@@ -32,6 +32,8 @@ async-lsp = { workspace = true, features = ["omni-trait"] }
 crop = { workspace = true, features = ["utf16-metric"] }
 lsp-types.workspace = true
 normalize-path.workspace = true
+serde.workspace = true
+serde_json.workspace = true
 tower.workspace = true
 tokio = { workspace = true, features = ["rt"] }
 tracing.workspace = true

crates/lsp/Cargo.toml

@@ -1,12 +1,79 @@
+use std::{
+    env,
+    path::{Path, PathBuf},
+};
+
 use lsp_types::{
     InitializeParams, ServerCapabilities, TextDocumentSyncCapability, TextDocumentSyncKind,
     TextDocumentSyncOptions,
 };
+use tracing::{error, info};
+
+use crate::workspace::manifest::ProjectManifest;
+
+/// The LSP config.
+///
+/// This struct is internal only and should not be serialized or deserialized. Instead, values in
+/// this struct are the full view of all merged config sources, such as `initialization_opts`,
+/// on-disk config files (e.g. `foundry.toml`).
+#[derive(Default, Clone, Debug)]
+pub(crate) struct Config {
+    root_path: PathBuf,
+    workspace_roots: Vec<PathBuf>,
+    discovered_projects: Vec<ProjectManifest>,
+}
+
+impl Config {
+    pub(crate) fn new(root_path: PathBuf, workspace_roots: Vec<PathBuf>) -> Self {
+        Config { root_path, workspace_roots, discovered_projects: Default::default() }
+    }
+
+    pub(crate) fn rediscover_workspaces(&mut self) {
+        let discovered = ProjectManifest::discover_all(&self.workspace_roots);
+        info!("discovered projects: {:?}", discovered);
+        if discovered.is_empty() {
+            error!("failed to find any projects in {:?}", &self.workspace_roots);
+        }
+        self.discovered_projects = discovered;
+    }
+
+    pub(crate) fn remove_workspace(&mut self, path: &PathBuf) {
+        if let Some(pos) = self.workspace_roots.iter().position(|it| it == path) {
+            self.workspace_roots.remove(pos);
+        }
+    }
+
+    pub(crate) fn add_workspaces(&mut self, paths: impl Iterator<Item = PathBuf>) {
+        self.workspace_roots.extend(paths);
+    }
+
+    pub(crate) fn root_path(&self) -> &Path {
+        self.root_path.as_path()
+    }
+}
+
+pub(crate) fn negotiate_capabilities(params: InitializeParams) -> (ServerCapabilities, Config) {
+    // todo: make this absolute guaranteed
+    #[allow(deprecated)]
+    let root_path = match params.root_uri.and_then(|it| it.to_file_path().ok()) {
+        Some(it) => it,
+        None => {
+            // todo: unwrap
+            env::current_dir().unwrap()
+        }
+    };
 
-#[derive(Default)]
-pub(crate) struct Config {}
+    // todo: make this absolute guaranteed
+    // The latest LSP spec mandates clients report `workspace_folders`, but some might still report
+    // `root_uri`.
+    let workspace_roots = params
+        .workspace_folders
+        .map(|workspaces| {
+            workspaces.into_iter().filter_map(|it| it.uri.to_file_path().ok()).collect::<Vec<_>>()
+        })
+        .filter(|workspaces| !workspaces.is_empty())
+        .unwrap_or_else(|| vec![root_path.clone()]);
 
-pub(crate) fn negotiate_capabilities(_: InitializeParams) -> (ServerCapabilities, Config) {
     (
         ServerCapabilities {
             text_document_sync: Some(TextDocumentSyncCapability::Options(
@@ -20,6 +87,6 @@ pub(crate) fn negotiate_capabilities(_: InitializeParams) -> (ServerCapabilities
             )),
             ..Default::default()
         },
-        Config::default(),
+        Config::new(root_path, workspace_roots),
     )
 }

crates/lsp/src/config.rs

@@ -15,25 +15,39 @@ use solar_interface::{
 use solar_sema::Compiler;
 use tokio::task::JoinHandle;
 
-use crate::{NotifyResult, config::negotiate_capabilities, proto, vfs::Vfs};
+use crate::{
+    NotifyResult,
+    config::{Config, negotiate_capabilities},
+    proto,
+    vfs::Vfs,
+};
 
 pub(crate) struct GlobalState {
     client: ClientSocket,
     pub(crate) vfs: Arc<RwLock<Vfs>>,
+    pub(crate) config: Arc<Config>,
     analysis_version: usize,
 }
 
 impl GlobalState {
     pub(crate) fn new(client: ClientSocket) -> Self {
-        Self { client, vfs: Arc::new(Default::default()), analysis_version: 0 }
+        Self {
+            client,
+            vfs: Arc::new(Default::default()),
+            analysis_version: 0,
+            config: Arc::new(Default::default()),
+        }
     }
 
     pub(crate) fn on_initialize(
         &mut self,
         params: InitializeParams,
     ) -> impl Future<Output = Result<InitializeResult, ResponseError>> + use<> {
-        let (capabilities, _config) = negotiate_capabilities(params);
+        let (capabilities, mut config) = negotiate_capabilities(params);
+
+        config.rediscover_workspaces();
 
+        self.config = Arc::new(config);
         std::future::ready(Ok(InitializeResult {
             capabilities,
             server_info: Some(ServerInfo {
@@ -98,16 +112,36 @@ impl GlobalState {
                 let _ = compiler.lower_asts();
                 let _ = compiler.analysis();
 
-                // todo handle diagnostic clearing
                 // todo clean this mess up boya
-                let diagnostics: HashMap<_, Vec<_>> = diag_buffer
+                let mut diagnostics: HashMap<lsp_types::Url, Vec<lsp_types::Diagnostic>> =
+                    HashMap::new();
+                for (path, diagnostic) in diag_buffer
                     .read()
                     .iter()
                     .filter_map(|diag| proto::diagnostic(compiler.sess().source_map(), diag))
-                    .fold(HashMap::new(), |mut diags, (path, diag)| {
-                        diags.entry(path).or_default().push(diag);
-                        diags
-                    });
+                {
+                    diagnostics.entry(path).or_default().push(diagnostic);
+                }
+
+                // For any other file that was parsed, we additionally load it into the VFS for
+                // later, and set an empty diagnostics set. This is to clear the existing
+                // diagnostics for files that went from an errored to an ok state, but tracking this
+                // separately is more efficient given most of these are wasted allocations.
+                for url in compiler
+                    .gcx()
+                    .sources
+                    .sources
+                    .iter()
+                    .filter_map(|source| source.file.name.as_real())
+                    .filter_map(|path| lsp_types::Url::from_file_path(path).ok())
+                {
+                    // todo: all of this can be a `HashMap::try_insert` (<https://github.com/rust-lang/rust/issues/82766>)
+                    if diagnostics.contains_key(&url) {
+                        continue;
+                    }
+                    diagnostics.insert(url, Vec::new());
+                }
+
                 for (uri, diagnostics) in diagnostics.into_iter() {
                     let _ = snapshot.client.publish_diagnostics(PublishDiagnosticsParams::new(
                         uri,
@@ -122,7 +156,11 @@ impl GlobalState {
     }
 
     fn snapshot(&self) -> GlobalStateSnapshot {
-        GlobalStateSnapshot { client: self.client.clone(), vfs: self.vfs.clone() }
+        GlobalStateSnapshot {
+            client: self.client.clone(),
+            vfs: self.vfs.clone(),
+            config: self.config.clone(),
+        }
     }
 
     fn spawn_with_snapshot<T: Send + 'static>(
@@ -137,4 +175,5 @@ impl GlobalState {
 pub(crate) struct GlobalStateSnapshot {
     client: ClientSocket,
     vfs: Arc<RwLock<Vfs>>,
+    config: Arc<Config>,
 }

crates/lsp/src/global_state.rs

@@ -1,18 +1,19 @@
-use std::ops::ControlFlow;
+use std::{ops::ControlFlow, sync::Arc};
 
 use crop::Rope;
 use lsp_types::{
-    DidChangeConfigurationParams, DidChangeTextDocumentParams, DidCloseTextDocumentParams,
-    DidOpenTextDocumentParams,
+    DidChangeConfigurationParams, DidChangeTextDocumentParams, DidChangeWorkspaceFoldersParams,
+    DidCloseTextDocumentParams, DidOpenTextDocumentParams,
 };
-use tracing::error;
+use tracing::{error, info};
 
 use crate::{NotifyResult, global_state::GlobalState, proto, utils::apply_document_changes};
 
 pub(crate) fn did_open_text_document(
     state: &mut GlobalState,
     params: DidOpenTextDocumentParams,
 ) -> NotifyResult {
+    info!("config: {:?}", state.config);
     if let Some(path) = proto::vfs_path(&params.text_document.uri) {
         let already_exists = state.vfs.read().exists(&path);
         if already_exists {
@@ -81,3 +82,24 @@ pub(crate) fn did_change_configuration(
     // For now this is just a stub.
     ControlFlow::Continue(())
 }
+
+pub(crate) fn did_change_workspace_folders(
+    state: &mut GlobalState,
+    params: DidChangeWorkspaceFoldersParams,
+) -> NotifyResult {
+    let config = Arc::make_mut(&mut state.config);
+
+    for workspace in params.event.removed {
+        let Ok(path) = workspace.uri.to_file_path() else {
+            continue;
+        };
+        config.remove_workspace(&path);
+    }
+
+    let added = params.event.added.into_iter().filter_map(|it| it.uri.to_file_path().ok());
+    config.add_workspaces(added);
+
+    // todo: rediscover workspaces & refetch configs
+
+    ControlFlow::Continue(())
+}

crates/lsp/src/handlers/notifs.rs

@@ -20,8 +20,10 @@ mod config;
 mod global_state;
 mod handlers;
 mod proto;
+mod serde;
 mod utils;
 mod vfs;
+mod workspace;
 
 pub(crate) type NotifyResult = ControlFlow<async_lsp::Result<()>>;
 
@@ -36,6 +38,9 @@ fn new_router(client: ClientSocket) -> Router<GlobalState> {
         .request::<req::Shutdown, _>(|_, _| std::future::ready(Ok(())))
         .notification::<notif::Exit>(|_, _| ControlFlow::Break(Ok(())));
 
+    // Workspace management
+    router.notification::<notif::DidChangeWorkspaceFolders>(handlers::did_change_workspace_folders);
+
     // Notifications
     router
         .notification::<notif::DidOpenTextDocument>(handlers::did_open_text_document)

crates/lsp/src/lib.rs

@@ -0,0 +1,87 @@
+//! Serde serializers and deserializers.
+
+pub(crate) mod display_fromstr {
+    use std::{fmt::Display, str::FromStr};
+
+    use serde::{Deserialize, Deserializer, Serializer, de};
+
+    pub(crate) fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        T: Display,
+        S: Serializer,
+    {
+        serializer.collect_str(value)
+    }
+
+    pub(crate) fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
+    where
+        T: FromStr,
+        T::Err: Display,
+        D: Deserializer<'de>,
+    {
+        String::deserialize(deserializer)?.parse().map_err(de::Error::custom)
+    }
+
+    pub(crate) mod vec {
+        use std::{
+            fmt::{self, Display},
+            marker::PhantomData,
+            str::FromStr,
+        };
+
+        use serde::{
+            Deserializer, Serializer,
+            de::{SeqAccess, Visitor},
+            ser::SerializeSeq,
+        };
+
+        pub(crate) fn serialize<T, S>(value: &[T], serializer: S) -> Result<S::Ok, S::Error>
+        where
+            T: Display,
+            S: Serializer,
+        {
+            let mut seq = serializer.serialize_seq(Some(value.len()))?;
+            for val in value {
+                seq.serialize_element(&val.to_string())?;
+            }
+            seq.end()
+        }
+
+        pub(crate) fn deserialize<'de, T, D>(deserializer: D) -> Result<Vec<T>, D::Error>
+        where
+            T: FromStr,
+            T::Err: fmt::Display,
+            D: Deserializer<'de>,
+        {
+            struct VecVisitor<T> {
+                marker: PhantomData<T>,
+            }
+
+            impl<'de, T> Visitor<'de> for VecVisitor<T>
+            where
+                T: FromStr,
+                T::Err: fmt::Display,
+            {
+                type Value = Vec<T>;
+
+                fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                    formatter.write_str("a sequence")
+                }
+
+                fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+                where
+                    A: SeqAccess<'de>,
+                {
+                    let mut values = Vec::<T>::with_capacity(seq.size_hint().unwrap_or(0));
+                    while let Some(value) = seq.next_element::<&str>()? {
+                        values.push(T::from_str(value).map_err(serde::de::Error::custom)?);
+                    }
+                    Ok(values)
+                }
+            }
+
+            let visitor = VecVisitor { marker: PhantomData };
+            deserializer.deserialize_seq(visitor)
+        }
+    }
+}

crates/lsp/src/serde.rs

@@ -71,4 +71,8 @@ impl Vfs {
     pub(crate) fn iter(&self) -> impl Iterator<Item = (&VfsPath, &Rope)> {
         self.data.iter()
     }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
 }