feat: workspace discovery

Author: onbjerg

Cargo.lock

@@ -51,7 +51,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,68 @@
+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`).
+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 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 +76,6 @@ pub(crate) fn negotiate_capabilities(_: InitializeParams) -> (ServerCapabilities
             )),
             ..Default::default()
         },
-        Config::default(),
+        Config::new(root_path, workspace_roots),
     )
 }

crates/lsp/src/config.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<()>>;
 

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

@@ -0,0 +1,14 @@
+use serde::Deserialize;
+use solar_config::{EvmVersion, ImportRemapping};
+
+/// A subset of `foundry.toml` that the LSP will parse
+/// using `forge config --json`.
+///
+/// This will be merged into the main configuration.
+#[derive(Debug, Deserialize)]
+pub(crate) struct FoundryConfig {
+    #[serde(with = "crate::serde::display_fromstr::vec")]
+    remappings: Vec<ImportRemapping>,
+    #[serde(with = "crate::serde::display_fromstr")]
+    evm_version: EvmVersion,
+}

crates/lsp/src/workspace/foundry.rs

@@ -0,0 +1,70 @@
+use std::{
+    fs::{ReadDir, read_dir},
+    path::{Path, PathBuf},
+};
+
+use solar_interface::data_structures::map::rustc_hash::FxHashSet;
+use tokio::io;
+
+#[derive(Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub(crate) enum ProjectManifest {
+    // todo: guarantee this to be absolute
+    Foundry(PathBuf),
+}
+
+impl ProjectManifest {
+    fn discover(path: &Path) -> io::Result<Vec<Self>> {
+        return find_foundry_toml(path)
+            .map(|paths| paths.into_iter().map(ProjectManifest::Foundry).collect());
+
+        fn find_foundry_toml(path: &Path) -> io::Result<Vec<PathBuf>> {
+            match find_in_parent_dirs(path, "foundry.toml") {
+                Some(it) => Ok(vec![it]),
+                None => Ok(find_foundry_toml_in_child_dir(read_dir(path)?)),
+            }
+        }
+
+        fn find_in_parent_dirs(path: &Path, target_file_name: &str) -> Option<PathBuf> {
+            if path.file_name().unwrap_or_default() == target_file_name {
+                return Some(path.to_path_buf());
+            }
+
+            let mut curr = Some(path);
+
+            while let Some(path) = curr {
+                let candidate = path.join(target_file_name);
+                if std::fs::metadata(&candidate).is_ok() {
+                    return Some(candidate);
+                }
+
+                curr = path.parent();
+            }
+
+            None
+        }
+
+        fn find_foundry_toml_in_child_dir(entities: ReadDir) -> Vec<PathBuf> {
+            entities
+                .filter_map(Result::ok)
+                .map(|it| it.path().join("foundry.toml"))
+                .filter(|it| it.exists())
+                .collect()
+        }
+    }
+
+    /// Discover all project manifests at the given paths.
+    ///
+    /// Returns a `Vec` of discovered [`ProjectManifest`]s, which is guaranteed to be unique and
+    /// sorted.
+    pub(crate) fn discover_all(paths: &[PathBuf]) -> Vec<Self> {
+        let mut res = paths
+            .iter()
+            .filter_map(|it| Self::discover(it.as_ref()).ok())
+            .flatten()
+            .collect::<FxHashSet<_>>()
+            .into_iter()
+            .collect::<Vec<_>>();
+        res.sort();
+        res
+    }
+}

crates/lsp/src/workspace/manifest.rs

@@ -0,0 +1,37 @@
+//! Workspace models.
+//!
+//! Solar LSP supports multiple workspace models that are configured in different ways.
+//!
+//! This module contains a generic workspace concept, as well as implementations of different
+//! project models (e.g. Foundry projects), and a project discovery algorithm to try and determine
+//! what kind of project the LSP is dealing with based on different heuristics.
+//!
+//! Once a project type is identified, the configuration for that project model is merged into the
+//! overall LSP config.
+use crate::workspace::foundry::FoundryConfig;
+
+mod foundry;
+pub(crate) mod manifest;
+
+#[derive(Debug)]
+pub(crate) struct Workspace {
+    pub(crate) kind: WorkspaceKind,
+}
+
+#[derive(Debug)]
+pub(crate) enum WorkspaceKind {
+    Foundry {
+        foundry: FoundryConfig,
+    },
+    /// A naked workspace is a workspace with no specific configuration.
+    ///
+    /// Naked workspaces have no remappings or toolchain-style dependencies, so all imports are
+    /// assumed to be relative to the file being parsed.
+    Naked,
+}
+
+impl Workspace {
+    pub(crate) fn load() -> Self {
+        todo!()
+    }
+}