lsp is fast on OA project

Author: roryc89

.gitignore

@@ -24,6 +24,7 @@ Thumbs.db
 
 
 # lsp vscode client
-
 /editors/code/node_modules
 /editors/code/out
+/editors/code/.vscode-test
+/editors/code/package-lock.json

src/build/cache.rs

@@ -123,6 +123,11 @@ impl ModuleCache {
         Self::default()
     }
 
+    /// Returns true if the cache has any module entries (i.e. a prior build populated it).
+    pub fn has_entries(&self) -> bool {
+        !self.entries.is_empty()
+    }
+
     /// Compute a content hash for a source string.
     pub fn content_hash(source: &str) -> u64 {
         let mut hasher = std::collections::hash_map::DefaultHasher::new();

src/js_ffi.rs

@@ -326,7 +326,7 @@ pub fn validate_foreign_module(
         .cloned()
         .collect();
 
-    let unused: Vec<String> = info
+    let _unused: Vec<String> = info
         .es_exports
         .iter()
         .filter(|name| !import_set.contains(name.as_str()))

src/lsp/handlers/completion.rs

@@ -53,7 +53,7 @@ impl Backend {
         // Find insert position for new imports (after last import, or after module header)
         let import_insert_line = find_import_insert_line(&source, &module);
 
-        let registry = self.registry.read().await;
+        let comp_index = self.completion_index.read().await;
         let mut items = Vec::new();
         let mut seen = HashSet::new();
 
@@ -85,52 +85,53 @@ impl Backend {
         }
 
         // 2. Already-imported names (higher priority than unimported)
-        // 3. All exported values from all modules in the registry
-        for (mod_path, mod_exports) in registry.iter_all() {
-            let mod_name = interner::resolve_module_name(mod_path);
-            if mod_name == current_module_name {
+        // 3. All exported names from all modules via lightweight completion index
+        for (mod_name, mod_entries) in &comp_index.entries {
+            if mod_name == &current_module_name {
                 continue;
             }
 
-            for (qi, scheme) in &mod_exports.values {
-                let name = match interner::resolve(qi.name) {
-                    Some(n) => n.to_string(),
-                    None => continue,
-                };
-                if !name.starts_with(&prefix) {
+            for entry in mod_entries {
+                if !entry.name.starts_with(&prefix) {
                     continue;
                 }
-                if seen.contains(&name) {
+                if seen.contains(&entry.name) {
                     continue;
                 }
-                seen.insert(name.clone());
+                seen.insert(entry.name.clone());
 
-                let type_str = format!("{}", scheme.ty);
-                let is_imported = already_imported.contains(&name);
-                let is_constructor = name.starts_with(|c: char| c.is_uppercase());
+                let is_imported = already_imported.contains(&entry.name);
+                let is_constructor = matches!(entry.kind, crate::lsp::CompletionEntryKind::Constructor);
+
+                let kind = match entry.kind {
+                    crate::lsp::CompletionEntryKind::Value => CompletionItemKind::FUNCTION,
+                    crate::lsp::CompletionEntryKind::Constructor => CompletionItemKind::CONSTRUCTOR,
+                    crate::lsp::CompletionEntryKind::Type => CompletionItemKind::CLASS,
+                    crate::lsp::CompletionEntryKind::Class => CompletionItemKind::INTERFACE,
+                };
 
-                let kind = if is_constructor {
-                    CompletionItemKind::CONSTRUCTOR
+                let detail = if entry.type_string.is_empty() {
+                    Some(mod_name.clone())
                 } else {
-                    CompletionItemKind::FUNCTION
+                    Some(format!("{mod_name} :: {}", entry.type_string))
                 };
 
                 // Imported items sort before unimported
                 let sort_prefix = if is_imported { "1" } else { "2" };
 
                 let mut item = CompletionItem {
-                    label: name.clone(),
+                    label: entry.name.clone(),
                     kind: Some(kind),
-                    detail: Some(format!("{mod_name} :: {type_str}")),
+                    detail,
                     sort_text: Some(format!("{sort_prefix}{}", items.len())),
                     ..Default::default()
                 };
 
                 // Auto-import: add additional_text_edits if not already imported
                 if !is_imported {
                     if let Some(edit) = build_import_edit(
-                        &mod_name,
-                        &name,
+                        mod_name,
+                        &entry.name,
                         is_constructor,
                         &module,
                         &source,
@@ -142,29 +143,8 @@ impl Backend {
 
                 items.push(item);
             }
-
-            // Also add type constructors
-            for (type_qi, ctor_names) in &mod_exports.data_constructors {
-                for ctor_qi in ctor_names {
-                    let ctor_name = match interner::resolve(ctor_qi.name) {
-                        Some(n) => n.to_string(),
-                        None => continue,
-                    };
-                    if !ctor_name.starts_with(&prefix) {
-                        continue;
-                    }
-                    if seen.contains(&ctor_name) {
-                        continue;
-                    }
-                    // Only add if the constructor has a value entry (it's exported)
-                    if !mod_exports.values.contains_key(ctor_qi) {
-                        continue;
-                    }
-                    // Already handled in the values loop above
-                }
-                let _ = type_qi;
-            }
         }
+        drop(comp_index);
 
         Ok(Some(CompletionResponse::List(CompletionList {
             is_incomplete: items.len() > 100,

src/lsp/handlers/diagnostics.rs

@@ -2,8 +2,10 @@ use std::fmt::Display;
 
 use tower_lsp::lsp_types::*;
 
+use crate::cst::Module;
 use crate::interner;
 use crate::build::cache::ModuleCache;
+use crate::typechecker::registry::ModuleRegistry;
 
 use super::super::{Backend, FileState};
 
@@ -14,7 +16,34 @@ impl Backend {
             .await;
     }
 
+    /// Ensure all modules imported by `module` have their exports loaded into the registry.
+    /// Loads missing exports lazily from the ModuleCache (which reads from disk on demand).
+    async fn ensure_imports_loaded(&self, module: &Module, registry: &mut ModuleRegistry) {
+        for import_decl in &module.imports {
+            let import_parts = &import_decl.module.parts;
+
+            // Skip if already in registry
+            if registry.lookup(import_parts).is_some() {
+                continue;
+            }
+
+            let import_name = interner::resolve_module_name(import_parts);
+
+            // Try to load from module cache (lazy disk load)
+            let exports = {
+                let mut cache = self.module_cache.write().await;
+                cache.get_exports(&import_name).cloned()
+            };
+
+            if let Some(exports) = exports {
+                registry.register(import_parts, exports);
+                log::debug!("Lazy-loaded exports for {import_name}");
+            }
+        }
+    }
+
     pub(crate) async fn on_change(&self, uri: Url, source: String) {
+        let on_change_start = std::time::Instant::now();
         {
             let mut files = self.files.write().await;
             files.insert(
@@ -31,6 +60,7 @@ impl Backend {
             return;
         }
 
+        let t = std::time::Instant::now();
         let module = match crate::parser::parse(&source) {
             Ok(module) => {
                 let module_name = format!("{}", module.name.value);
@@ -58,13 +88,21 @@ impl Backend {
                 return;
             }
         };
+        self.info(format!("[on_change] parse: {:.2?}", t.elapsed())).await;
 
         let module_name = interner::resolve_module_name(&module.name.value.parts);
         let module_parts: Vec<interner::Symbol> = module.name.value.parts.clone();
 
-        // Type-check against the registry (use stacker to extend stack for deep recursion)
+        // Ensure imported modules' exports are in the registry (lazy load from cache)
+        let t = std::time::Instant::now();
         let mut registry = self.registry.write().await;
+        self.ensure_imports_loaded(&module, &mut registry).await;
+        self.info(format!("[on_change] ensure_imports_loaded: {:.2?}", t.elapsed())).await;
+
+        // Type-check against the registry
+        let t = std::time::Instant::now();
         let check_result = crate::typechecker::check_module_with_registry(&module, &registry);
+        self.info(format!("[on_change] typecheck {module_name}: {:.2?}", t.elapsed())).await;
 
         // Update registry with new exports
         registry.register(&module_parts, check_result.exports.clone());
@@ -76,10 +114,6 @@ impl Backend {
             .collect();
         let mut cache = self.module_cache.write().await;
         cache.update(module_name.clone(), source_hash, check_result.exports, import_names);
-        cache.build_reverse_deps();
-
-        // Find transitive dependents that need re-checking
-        let dependents = cache.transitive_dependents(&module_name);
         drop(cache);
 
         // Publish diagnostics for the changed module
@@ -88,63 +122,7 @@ impl Backend {
             .publish_diagnostics(uri, diagnostics, None)
             .await;
 
-        // Update source map
-        {
-            let mfmap = self.module_file_map.read().await;
-            let mut smap = self.source_map.write().await;
-            // Update the changed module's source in source_map
-            if let Some(file_uri) = mfmap.get(&module_name) {
-                smap.insert(file_uri.clone(), source);
-            }
-        }
-
-        // Cascade: re-typecheck dependents
-        if !dependents.is_empty() {
-            log::debug!("Cascade rebuild: {} dependents of {}", dependents.len(), module_name);
-
-            let mfmap = self.module_file_map.read().await;
-            let smap = self.source_map.read().await;
-
-            for dep_name in &dependents {
-                let dep_uri_str = match mfmap.get(dep_name) {
-                    Some(u) => u.clone(),
-                    None => continue,
-                };
-                let dep_source = match smap.get(&dep_uri_str) {
-                    Some(s) => s.clone(),
-                    None => continue,
-                };
-                let dep_uri = match Url::parse(&dep_uri_str) {
-                    Ok(u) => u,
-                    Err(_) => continue,
-                };
-
-                let dep_module = match crate::parser::parse(&dep_source) {
-                    Ok(m) => m,
-                    Err(_) => continue,
-                };
-
-                let dep_result = crate::typechecker::check_module_with_registry(&dep_module, &registry);
-
-                // Update registry with dependent's exports
-                let dep_parts: Vec<interner::Symbol> = dep_module.name.value.parts.clone();
-                registry.register(&dep_parts, dep_result.exports.clone());
-
-                // Update cache for dependent
-                let dep_hash = ModuleCache::content_hash(&dep_source);
-                let dep_imports: Vec<String> = dep_module.imports.iter()
-                    .map(|imp| interner::resolve_module_name(&imp.module.parts))
-                    .collect();
-                let mut cache = self.module_cache.write().await;
-                cache.update(dep_name.clone(), dep_hash, dep_result.exports, dep_imports);
-                drop(cache);
-
-                let dep_diagnostics = type_errors_to_diagnostics(&dep_result.errors, &dep_source);
-                self.client
-                    .publish_diagnostics(dep_uri, dep_diagnostics, None)
-                    .await;
-            }
-        }
+        self.info(format!("[on_change] total: {:.2?}", on_change_start.elapsed())).await;
     }
 }