Cache builtin docs and canonicalized resolutions in LSP hot path

Author: akhilles

crates/pcb-zen-core/src/lang/eval.rs

@@ -245,7 +245,10 @@ pub struct EvalContextConfig {
 
 impl EvalContextConfig {
     /// Create a new root EvalContextConfig.
-    pub fn new(file_provider: Arc<dyn FileProvider>, resolution: ResolutionResult) -> Self {
+    ///
+    /// The resolution's `package_resolutions` keys should already be
+    /// canonicalized (see [`EvalContext::new`] which handles this).
+    pub fn new(file_provider: Arc<dyn FileProvider>, resolution: Arc<ResolutionResult>) -> Self {
         use std::sync::OnceLock;
         static BUILTIN_DOCS: OnceLock<Arc<HashMap<String, String>>> = OnceLock::new();
         let builtin_docs = BUILTIN_DOCS
@@ -259,25 +262,10 @@ impl EvalContextConfig {
             })
             .clone();
 
-        // Canonicalize package_resolutions keys to match canonicalized file paths during lookup.
-        let canon_resolutions = resolution
-            .package_resolutions
-            .iter()
-            .map(|(root, deps)| {
-                let canon_root = file_provider
-                    .canonicalize(root)
-                    .unwrap_or_else(|_| root.clone());
-                (canon_root, deps.clone())
-            })
-            .collect();
-
-        let mut resolution = resolution;
-        resolution.package_resolutions = canon_resolutions;
-
         Self {
             builtin_docs,
             file_provider,
-            resolution: Arc::new(resolution),
+            resolution,
             path_to_spec: Arc::new(RwLock::new(HashMap::new())),
             module_path: ModulePath::root(),
             load_chain: HashSet::new(),
@@ -848,8 +836,13 @@ fn json_value_to_heap_value<'v>(json: &serde_json::Value, heap: &'v Heap) -> Val
 
 impl EvalContext {
     /// Create a new EvalContext with a fresh session.
+    ///
+    /// Canonicalizes `package_resolutions` keys so that path lookups during
+    /// evaluation match the canonicalized file paths used elsewhere.
     pub fn new(file_provider: Arc<dyn FileProvider>, resolution: ResolutionResult) -> Self {
-        let config = EvalContextConfig::new(file_provider, resolution);
+        let mut resolution = resolution;
+        resolution.canonicalize_keys(&*file_provider);
+        let config = EvalContextConfig::new(file_provider, Arc::new(resolution));
         EvalSession::default().create_context(config)
     }
 

crates/pcb-zen-core/src/resolution.rs

@@ -398,6 +398,20 @@ impl ResolutionResult {
         }
     }
 
+    /// Canonicalize `package_resolutions` keys using the given file provider.
+    pub fn canonicalize_keys(&mut self, file_provider: &dyn crate::FileProvider) {
+        self.package_resolutions = self
+            .package_resolutions
+            .iter()
+            .map(|(root, deps)| {
+                let canon = file_provider
+                    .canonicalize(root)
+                    .unwrap_or_else(|_| root.clone());
+                (canon, deps.clone())
+            })
+            .collect();
+    }
+
     /// Compute the transitive dependency closure for a package.
     pub fn package_closure(&self, package_url: &str) -> PackageClosure {
         let workspace_info = &self.workspace_info;

crates/pcb-zen/src/lsp/mod.rs

@@ -35,7 +35,7 @@ pub struct LspEvalContext {
     inner: EvalContext,
     builtin_docs: HashMap<LspUrl, String>,
     file_provider: Arc<dyn FileProvider>,
-    resolution_cache: RwLock<HashMap<PathBuf, ResolutionResult>>,
+    resolution_cache: RwLock<HashMap<PathBuf, Arc<ResolutionResult>>>,
     workspace_root_cache: RwLock<HashMap<PathBuf, PathBuf>>,
     open_files: Arc<RwLock<HashMap<PathBuf, String>>>,
     netlist_subscriptions: Arc<RwLock<HashMap<PathBuf, HashMap<String, JsonValue>>>>,
@@ -273,8 +273,8 @@ impl LspEvalContext {
         let uri = LspUrl::File(path_buf.to_path_buf());
         let maybe_contents = self.get_load_contents(&uri).ok().flatten();
 
-        let resolution = self.resolution_for(path_buf);
-        let mut ctx = EvalContext::new(self.file_provider.clone(), resolution)
+        let config = self.config_for(path_buf);
+        let mut ctx = EvalContext::from_session_and_config(Default::default(), config)
             .set_source_path(path_buf.to_path_buf());
 
         if let Some(contents) = maybe_contents {
@@ -343,26 +343,28 @@ impl LspEvalContext {
         workspace_root
     }
 
-    fn resolution_for(&self, file_path: &Path) -> ResolutionResult {
+    /// Return the cached, canonicalized resolution for the workspace that owns `file_path`.
+    fn resolution_for(&self, file_path: &Path) -> Arc<ResolutionResult> {
         let workspace_root = self.workspace_root_for(file_path);
         if let Some(cached) = self.resolution_cache.read().unwrap().get(&workspace_root) {
             return cached.clone();
         }
 
-        let resolution = crate::get_workspace_info(&self.file_provider, &workspace_root)
+        let mut resolution = crate::get_workspace_info(&self.file_provider, &workspace_root)
             .and_then(|mut ws| crate::resolve_dependencies(&mut ws, false, false))
             .unwrap_or_else(|_| ResolutionResult::empty());
+        resolution.canonicalize_keys(&*self.file_provider);
+        let resolution = Arc::new(resolution);
         self.resolution_cache
             .write()
             .unwrap()
             .insert(workspace_root, resolution.clone());
         resolution
     }
 
-    /// Create an EvalContextConfig for the given file.
+    /// Create a fresh EvalContextConfig for the given file.
     fn config_for(&self, file_path: &Path) -> EvalContextConfig {
-        let resolution = self.resolution_for(file_path);
-        EvalContextConfig::new(self.file_provider.clone(), resolution)
+        EvalContextConfig::new(self.file_provider.clone(), self.resolution_for(file_path))
             .set_eager(self.inner.is_eager())
     }
 
@@ -904,8 +906,9 @@ impl LspContext for LspEvalContext {
                             let maybe_contents = self.get_load_contents(&params.uri).ok().flatten();
 
                             // Evaluate the module
-                            let resolution = self.resolution_for(path_buf);
-                            let ctx = EvalContext::new(self.file_provider.clone(), resolution);
+                            let config = self.config_for(path_buf);
+                            let ctx =
+                                EvalContext::from_session_and_config(Default::default(), config);
 
                             let eval_result = if let Some(contents) = maybe_contents {
                                 ctx.set_source_path(path_buf.clone())