@tishlang/tish 2.2.7 → 2.9.0

package/crates/tish_lsp/src/main.rs

@@ -1,22 +1,25 @@
 //! Tish Language Server — diagnostics, symbols, completion, format, go-to-definition, workspace symbols.
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
-use std::sync::{Arc, RwLock};
+use std::sync::{Arc, Mutex, RwLock};
+use std::time::SystemTime;
 
 use regex::Regex;
 use tower_lsp::jsonrpc::Result;
 use tower_lsp::lsp_types::{
     CompletionItem, CompletionItemKind, CompletionParams, CompletionResponse,
     CompletionTriggerKind, Diagnostic, DiagnosticSeverity, DiagnosticTag,
-    DidChangeTextDocumentParams, DidCloseTextDocumentParams, DidOpenTextDocumentParams,
-    DocumentFormattingParams, DocumentSymbol, DocumentSymbolParams, DocumentSymbolResponse,
-    GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverContents, HoverParams,
-    HoverProviderCapability, InitializeParams, InitializeResult, Location, MarkupContent,
-    MarkupKind, MessageType, NumberOrString, OneOf, Position, Range, ReferenceParams,
-    RenameOptions, RenameParams, ServerCapabilities, ServerInfo, SymbolInformation, SymbolKind,
-    SymbolTag, TextDocumentPositionParams, TextDocumentSyncCapability, TextDocumentSyncKind, Url,
-    WorkDoneProgressOptions, WorkspaceEdit, WorkspaceSymbolParams,
+    DidChangeTextDocumentParams, DidChangeWorkspaceFoldersParams, DidCloseTextDocumentParams,
+    DidOpenTextDocumentParams, DocumentFormattingParams, DocumentSymbol, DocumentSymbolParams,
+    DocumentSymbolResponse, GotoDefinitionParams, GotoDefinitionResponse, Hover, HoverContents,
+    HoverParams, HoverProviderCapability, InitializeParams, InitializeResult, Location,
+    MarkupContent, MarkupKind, MessageType, NumberOrString, OneOf, Position, Range,
+    ReferenceParams, RenameOptions, RenameParams, ServerCapabilities, ServerInfo,
+    SymbolInformation, SymbolKind, SymbolTag, TextDocumentPositionParams,
+    TextDocumentSyncCapability, TextDocumentSyncKind, Url, WorkDoneProgressOptions, WorkspaceEdit,
+    WorkspaceFoldersChangeEvent, WorkspaceFoldersServerCapabilities, WorkspaceServerCapabilities,
+    WorkspaceSymbolParams,
 };
 use tower_lsp::lsp_types::{PrepareRenameResponse, TextEdit};
 use tower_lsp::{Client, LanguageServer, LspService, Server};
@@ -38,6 +41,36 @@ struct Backend {
     cargo_src_cache: Arc<RwLock<HashMap<(PathBuf, String), PathBuf>>>,
     /// Root of the `tishlang/tish` checkout (parent of `crates/`), for built-in / JSX goto-definition.
     tishlang_source_root: Arc<RwLock<Option<PathBuf>>>,
+    /// Workspace-symbol index: absolute path → parsed symbols, validated by file mtime. Built lazily
+    /// on a blocking thread by `symbol` so the crawl+parse never stalls tower-lsp's shared request
+    /// driver, and reused across queries instead of re-reading the whole tree each keystroke (#135).
+    symbol_index: Arc<RwLock<HashMap<PathBuf, CachedFile>>>,
+    /// Serializes workspace-symbol index refreshes. With roots immutable this was unnecessary, but
+    /// #162 lets folders change mid-session: without serialization two concurrent `symbol` walks
+    /// could interleave and, via the index's global retain, evict each other's still-valid entries
+    /// based on divergent root snapshots. Held only across the (blocking) refresh, off the async
+    /// driver (#162).
+    symbol_refresh: Arc<Mutex<()>>,
+}
+
+/// One symbol harvested from a workspace file, with its position pre-resolved so answering a query
+/// never needs the source text again.
+#[derive(Clone, Debug)]
+struct CachedSymbol {
+    name: String,
+    /// Lowercased `name`, precomputed for the case-insensitive substring match.
+    name_lower: String,
+    kind: SymbolKind,
+    range: Range,
+}
+
+/// A per-file entry in the workspace-symbol index. `mtime` validates the cache: an unchanged file is
+/// reused, an externally edited one is re-parsed.
+#[derive(Debug)]
+struct CachedFile {
+    mtime: SystemTime,
+    uri: Url,
+    symbols: Vec<CachedSymbol>,
 }
 
 #[tokio::main]
@@ -52,6 +85,8 @@ async fn main() {
         roots: Arc::new(RwLock::new(Vec::new())),
         cargo_src_cache: Arc::new(RwLock::new(HashMap::new())),
         tishlang_source_root: Arc::new(RwLock::new(None)),
+        symbol_index: Arc::new(RwLock::new(HashMap::new())),
+        symbol_refresh: Arc::new(Mutex::new(())),
     });
     Server::new(stdin, stdout, socket).serve(service).await;
 }
@@ -145,7 +180,23 @@ fn document_symbol(
     }
 }
 
-async fn publish_parse_and_lint(client: &Client, uri: Url, text: &str) {
+async fn publish_parse_and_lint(client: &Client, uri: Url, text: String) {
+    // Parse/lint/resolve/typecheck is CPU-bound and can be O(file size); running it on the async
+    // task lets a slow analysis occupy a runtime worker and head-of-line-block the hover/goto/
+    // completion requests tower-lsp drives on the same runtime. Hand the pure computation to the
+    // blocking pool and only await the (cheap) publish here (#160).
+    let diags = tokio::task::spawn_blocking(move || compute_diagnostics(&text))
+        .await
+        .unwrap_or_default();
+    // MUST be awaited — `publish_diagnostics` is async; a bare `let _ = …` drops the future
+    // unsent, which silently disables ALL LSP diagnostics (parse errors, lints, unused bindings).
+    client.publish_diagnostics(uri, diags, None).await;
+}
+
+/// Run the full diagnostic pipeline — parse → lint → resolve (unresolved names, unused bindings) →
+/// gradual typecheck — over a document's text and return LSP diagnostics. Pure and synchronous so it
+/// can run on the blocking pool off the request driver, and unit-testable on its own (#160).
+fn compute_diagnostics(text: &str) -> Vec<Diagnostic> {
     let mut diags = Vec::new();
     match tishlang_parser::parse(text) {
         Ok(program) => {
@@ -159,6 +210,7 @@ async fn publish_parse_and_lint(client: &Client, uri: Url, text: &str) {
                     severity: Some(sev),
                     code: Some(NumberOrString::String(d.code.to_string())),
                     message: d.message,
+                    source: Some("tish".into()),
                     ..Default::default()
                 });
             }
@@ -168,6 +220,7 @@ async fn publish_parse_and_lint(client: &Client, uri: Url, text: &str) {
                     severity: Some(DiagnosticSeverity::ERROR),
                     code: Some(NumberOrString::String("tish-unresolved-name".into())),
                     message: format!("no binding in scope for `{}`", u.name),
+                    source: Some("tish".into()),
                     ..Default::default()
                 });
             }
@@ -214,13 +267,30 @@ async fn publish_parse_and_lint(client: &Client, uri: Url, text: &str) {
                 range: diag_range(l, c, text),
                 severity: Some(DiagnosticSeverity::ERROR),
                 message: e,
+                source: Some("tish".into()),
                 ..Default::default()
             });
         }
     }
-    // MUST be awaited — `publish_diagnostics` is async; a bare `let _ = …` drops the future
-    // unsent, which silently disables ALL LSP diagnostics (parse errors, lints, unused bindings).
-    client.publish_diagnostics(uri, diags, None).await;
+    diags
+}
+
+/// Apply a workspace-folder change event to the root set: drop removed folders, append added ones
+/// (skipping any already present and any whose URI is not a local file path). Pure so the add/remove/
+/// dedup logic is unit-testable without a live `Backend`/`Client` (#162).
+fn apply_workspace_folder_changes(roots: &mut Vec<PathBuf>, event: &WorkspaceFoldersChangeEvent) {
+    for removed in &event.removed {
+        if let Ok(p) = removed.uri.to_file_path() {
+            roots.retain(|r| r != &p);
+        }
+    }
+    for added in &event.added {
+        if let Ok(p) = added.uri.to_file_path() {
+            if !roots.contains(&p) {
+                roots.push(p);
+            }
+        }
+    }
 }
 
 #[tower_lsp::async_trait]
@@ -282,6 +352,16 @@ impl LanguageServer for Backend {
                 document_formatting_provider: Some(OneOf::Left(true)),
                 document_symbol_provider: Some(OneOf::Left(true)),
                 workspace_symbol_provider: Some(OneOf::Left(true)),
+                // Ask the client to send didChangeWorkspaceFolders so adding/removing a folder in a
+                // multi-root workspace keeps `roots` (and thus the workspace-symbol index) accurate
+                // instead of being frozen at the set captured by `initialize` (#162).
+                workspace: Some(WorkspaceServerCapabilities {
+                    workspace_folders: Some(WorkspaceFoldersServerCapabilities {
+                        supported: Some(true),
+                        change_notifications: Some(OneOf::Left(true)),
+                    }),
+                    file_operations: None,
+                }),
                 ..Default::default()
             },
             server_info: Some(ServerInfo {
@@ -297,6 +377,19 @@ impl LanguageServer for Backend {
             .await;
     }
 
+    async fn did_change_workspace_folders(&self, params: DidChangeWorkspaceFoldersParams) {
+        // Keep `roots` in sync as folders are added/removed from a multi-root workspace (#162). The
+        // workspace-symbol index needs no explicit invalidation: its next walk visits any added root
+        // and, by no longer visiting a removed one, evicts that root's files on its own.
+        {
+            let mut roots = self.roots.write().unwrap();
+            apply_workspace_folder_changes(&mut roots, &params.event);
+        }
+        self.client
+            .log_message(MessageType::INFO, "tish-lsp: workspace folders updated")
+            .await;
+    }
+
     async fn shutdown(&self) -> Result<()> {
         Ok(())
     }
@@ -305,7 +398,7 @@ impl LanguageServer for Backend {
         let uri = p.text_document.uri;
         let text = p.text_document.text;
         self.docs.write().unwrap().insert(uri.clone(), text.clone());
-        publish_parse_and_lint(&self.client, uri, &text).await;
+        publish_parse_and_lint(&self.client, uri, text).await;
     }
 
     async fn did_change(&self, p: DidChangeTextDocumentParams) {
@@ -335,7 +428,7 @@ impl LanguageServer for Backend {
                 }
                 let text = docs.read().unwrap().get(&uri).cloned();
                 if let Some(text) = text {
-                    publish_parse_and_lint(&client, uri, &text).await;
+                    publish_parse_and_lint(&client, uri, text).await;
                 }
             });
         }
@@ -360,6 +453,31 @@ impl LanguageServer for Backend {
             return Ok(None);
         };
 
+        // Member position: completion was triggered by `.`, or the text right before the cursor
+        // ends in `.` (e.g. `obj.`). We don't do member completion yet, so return NOTHING rather
+        // than the language keyword list / in-scope names, which are never valid after a dot and
+        // were the noise this handler used to emit (#146). This is where member items would go.
+        let dot_trigger = params
+            .context
+            .as_ref()
+            .map(|c| {
+                matches!(c.trigger_kind, CompletionTriggerKind::TRIGGER_CHARACTER)
+                    && c.trigger_character.as_deref() == Some(".")
+            })
+            .unwrap_or(false);
+        let after_dot = dot_trigger
+            || text
+                .lines()
+                .nth(pos.line as usize)
+                .map(|line| {
+                    let upto: String = line.chars().take(pos.character as usize).collect();
+                    upto.trim_end().ends_with('.')
+                })
+                .unwrap_or(false);
+        if after_dot {
+            return Ok(Some(CompletionResponse::Array(vec![])));
+        }
+
         let keywords = [
             "fn", "async", "let", "const", "if", "else", "while", "for", "return", "break",
             "continue", "switch", "case", "default", "try", "catch", "finally", "throw", "import",
@@ -390,14 +508,6 @@ impl LanguageServer for Backend {
             }
         }
 
-        if let Some(ctx) = params.context {
-            if matches!(ctx.trigger_kind, CompletionTriggerKind::TRIGGER_CHARACTER)
-                && ctx.trigger_character.as_deref() == Some(".")
-            {
-                // After dot: could add member completion later
-            }
-        }
-
         Ok(Some(CompletionResponse::Array(items)))
     }
 
@@ -454,12 +564,14 @@ impl LanguageServer for Backend {
                 if let Ok(ref file_path) = uri.to_file_path() {
                     let word = word_at_position(&text, position);
                     let roots = self.roots.read().unwrap().clone();
+                    let open_docs = self.docs.read().unwrap();
                     if let Some(loc) = import_goto::definition_for_import(
                         &program,
                         file_path,
                         word.as_str(),
                         &roots,
                         self.cargo_src_cache.as_ref(),
+                        &open_docs,
                     ) {
                         return Ok(Some(GotoDefinitionResponse::Scalar(loc)));
                     }
@@ -489,12 +601,14 @@ impl LanguageServer for Backend {
 
         if let Ok(ref file_path) = uri.to_file_path() {
             let roots = self.roots.read().unwrap().clone();
+            let open_docs = self.docs.read().unwrap();
             if let Some(loc) = import_goto::definition_for_import(
                 &program,
                 file_path,
                 word.as_str(),
                 &roots,
                 self.cargo_src_cache.as_ref(),
+                &open_docs,
             ) {
                 return Ok(Some(GotoDefinitionResponse::Scalar(loc)));
             }
@@ -507,6 +621,7 @@ impl LanguageServer for Backend {
                 position.line,
                 position.character,
                 word.as_str(),
+                &open_docs,
             ) {
                 return Ok(Some(GotoDefinitionResponse::Scalar(loc)));
             }
@@ -605,10 +720,23 @@ impl LanguageServer for Backend {
                     }
                 } else {
                     let word = word_at_position(&text, pos);
+                    // On a member property (`obj.a`) there is no separate lexical binding, so
+                    // "No binding in scope" is misleading and disagrees with go-to-definition's
+                    // silent no-op on the same token. Show a neutral note there instead. (#159)
+                    let on_member_prop = tishlang_resolve::member_access_chain_at_cursor(
+                        &program, &text, pos.line, pos.character,
+                    )
+                    .is_some();
+                    let no_binding_msg = if on_member_prop {
+                        "\n\n_Object property._"
+                    } else {
+                        "\n\n_No binding in scope for this name._"
+                    };
                     if word.is_empty() {
                         md.push_str("\n\n_No binding in scope for this name._");
                     } else if let Ok(fp) = uri.to_file_path() {
                         let roots = self.roots.read().unwrap().clone();
+                        let open_docs = self.docs.read().unwrap();
                         if let Some(nmd) = import_goto::native_member_definition(
                             &program,
                             &fp,
@@ -618,6 +746,7 @@ impl LanguageServer for Backend {
                             pos.line,
                             pos.character,
                             word.as_str(),
+                            &open_docs,
                         ) {
                             md.push_str(
                                 "\n\n_Native host module member (e.g. `tish:macos`); implementation in Rust._",
@@ -633,10 +762,10 @@ impl LanguageServer for Backend {
                                 "\n\n[Open Rust implementation]({href}#L{line_1})"
                             ));
                         } else {
-                            md.push_str("\n\n_No binding in scope for this name._");
+                            md.push_str(no_binding_msg);
                         }
                     } else {
-                        md.push_str("\n\n_No binding in scope for this name._");
+                        md.push_str(no_binding_msg);
                     }
                 }
             }
@@ -703,15 +832,15 @@ impl LanguageServer for Backend {
         let Ok(program) = tishlang_parser::parse(&text) else {
             return Ok(None);
         };
-        let Some(nu) = tishlang_resolve::name_at_cursor(&program, &text, pos.line, pos.character)
-        else {
-            return Ok(None);
-        };
-        let range = span_to_range(&nu.span, &text);
-        Ok(Some(PrepareRenameResponse::RangeWithPlaceholder {
-            range,
-            placeholder: nu.name.to_string(),
-        }))
+        // Only offer a rename box for a symbol rename() can actually act on — not a member property
+        // or other non-binding token, which would silently no-op (#145).
+        match rename_target(&program, &text, pos.line, pos.character) {
+            Some((range, placeholder)) => Ok(Some(PrepareRenameResponse::RangeWithPlaceholder {
+                range,
+                placeholder,
+            })),
+            None => Ok(None),
+        }
     }
 
     async fn rename(&self, params: RenameParams) -> Result<Option<WorkspaceEdit>> {
@@ -825,131 +954,143 @@ impl LanguageServer for Backend {
         if query.is_empty() {
             return Ok(Some(vec![]));
         }
-        let roots = self.roots.read().unwrap().clone();
-        let mut out = Vec::new();
+        let roots_handle = Arc::clone(&self.roots);
+        let index = self.symbol_index.clone();
+        let refresh = Arc::clone(&self.symbol_refresh);
+        // The crawl + fs-read + parse is CPU/IO-blocking; running it inline stalls tower-lsp's shared
+        // request driver (it multiplexes requests without a per-request spawn), so hover/completion
+        // in flight would freeze for its duration. Hand it to a blocking thread, and answer from the
+        // mtime-keyed index so repeated keystrokes don't re-walk and re-parse the tree (#135).
+        let syms = tokio::task::spawn_blocking(move || {
+            // Serialize refreshes and read `roots` fresh under that lock (#162): folders can now
+            // change mid-session, and the index's global retain would otherwise let a query carrying
+            // a stale/smaller root snapshot evict another concurrent query's still-valid entries.
+            // One walk at a time, each over the current roots, makes that impossible.
+            let _refresh_guard = refresh.lock().unwrap_or_else(|e| e.into_inner());
+            let roots = roots_handle.read().unwrap().clone();
+            refresh_and_query_symbols(&roots, &index, &query)
+        })
+        .await
+        .unwrap_or_default();
+        Ok(Some(syms))
+    }
+}
 
-        for root in roots {
-            for e in WalkDir::new(&root)
-                .into_iter()
-                .filter_map(|e| e.ok())
-                .filter(|e| e.path().extension().map(|x| x == "tish").unwrap_or(false))
-            {
-                let path = e.path();
-                let Ok(src) = std::fs::read_to_string(path) else {
-                    continue;
-                };
-                let Ok(program) = tishlang_parser::parse(&src) else {
-                    continue;
-                };
-                let Ok(uri) = Url::from_file_path(path) else {
-                    continue;
-                };
-                for s in &program.statements {
-                    collect_workspace_syms(s, &src, &uri, &query, &mut out);
-                }
-            }
-        }
-        Ok(Some(out))
+/// Prune heavy or irrelevant subtrees from the workspace-symbol crawl — dependency and build
+/// directories and any hidden directory (`.git`, `.vscode`, …). Files and the crawl root itself are
+/// never pruned. walkdir has no `.gitignore` support, so this is the floor that keeps `node_modules`
+/// / `target` from dominating the walk on a real project.
+fn ws_prune_dir(e: &walkdir::DirEntry) -> bool {
+    if e.depth() == 0 || !e.file_type().is_dir() {
+        return false;
     }
+    let name = e.file_name().to_string_lossy();
+    name == "node_modules" || name == "target" || name.starts_with('.')
 }
 
-fn collect_workspace_syms(
-    s: &tishlang_ast::Statement,
-    text: &str,
-    uri: &Url,
+/// Refresh the mtime-keyed symbol index for `roots` (re-parsing only changed/new files, evicting
+/// deleted ones) and return the symbols whose lowercased name contains `query`. Runs on a blocking
+/// thread. Factored out as a free function so it is unit-testable without a live `Backend` (#135).
+fn refresh_and_query_symbols(
+    roots: &[PathBuf],
+    index: &RwLock<HashMap<PathBuf, CachedFile>>,
     query: &str,
-    out: &mut Vec<SymbolInformation>,
-) {
-    match s {
-        tishlang_ast::Statement::FunDecl {
-            name, name_span, ..
-        } => {
-            if name.to_lowercase().contains(query) {
-                out.push(symbol_information(
-                    name.to_string(),
-                    SymbolKind::FUNCTION,
-                    None,
-                    Location {
-                        uri: uri.clone(),
-                        range: span_to_range(name_span, text),
-                    },
-                    None,
-                ));
-            }
-        }
-        tishlang_ast::Statement::VarDecl {
-            name, name_span, ..
-        } => {
-            if name.to_lowercase().contains(query) {
-                out.push(symbol_information(
-                    name.to_string(),
-                    SymbolKind::VARIABLE,
-                    None,
-                    Location {
-                        uri: uri.clone(),
-                        range: span_to_range(name_span, text),
-                    },
-                    None,
-                ));
+) -> Vec<SymbolInformation> {
+    let mut seen: HashSet<PathBuf> = HashSet::new();
+    for root in roots {
+        for e in WalkDir::new(root)
+            .into_iter()
+            .filter_entry(|e| !ws_prune_dir(e))
+            .filter_map(|e| e.ok())
+        {
+            if !e.file_type().is_file()
+                || e.path().extension().map(|x| x == "tish") != Some(true)
+            {
+                continue;
             }
-        }
-        tishlang_ast::Statement::TypeAlias {
-            name, name_span, ..
-        } => {
-            if name.to_lowercase().contains(query) {
-                out.push(symbol_information(
-                    name.to_string(),
-                    SymbolKind::INTERFACE,
-                    None,
-                    Location {
-                        uri: uri.clone(),
-                        range: span_to_range(name_span, text),
-                    },
-                    None,
-                ));
+            let path = e.path().to_path_buf();
+            let mtime = std::fs::metadata(&path).and_then(|m| m.modified()).ok();
+            seen.insert(path.clone());
+            // Reuse the cached parse when the file is unchanged (same mtime).
+            let fresh = mtime.is_some_and(|mt| {
+                index.read().unwrap().get(&path).is_some_and(|cf| cf.mtime == mt)
+            });
+            if fresh {
+                continue;
             }
-        }
-        tishlang_ast::Statement::DeclareFun {
-            name, name_span, ..
-        } => {
-            if name.to_lowercase().contains(query) {
-                out.push(symbol_information(
-                    name.to_string(),
-                    SymbolKind::FUNCTION,
-                    None,
-                    Location {
-                        uri: uri.clone(),
-                        range: span_to_range(name_span, text),
-                    },
-                    None,
-                ));
+            let Ok(src) = std::fs::read_to_string(&path) else {
+                continue;
+            };
+            let Ok(program) = tishlang_parser::parse(&src) else {
+                continue;
+            };
+            let Ok(uri) = Url::from_file_path(&path) else {
+                continue;
+            };
+            let mut symbols = Vec::new();
+            for s in &program.statements {
+                collect_file_symbols(s, &src, &mut symbols);
             }
+            let mtime = mtime.unwrap_or(SystemTime::UNIX_EPOCH);
+            index.write().unwrap().insert(path, CachedFile { mtime, uri, symbols });
         }
-        tishlang_ast::Statement::DeclareVar {
-            name, name_span, ..
-        } => {
-            if name.to_lowercase().contains(query) {
+    }
+    // Evict files that vanished from the tree so deleted symbols don't linger in results.
+    index.write().unwrap().retain(|p, _| seen.contains(p));
+
+    // Answer the query from the now-fresh index.
+    let g = index.read().unwrap();
+    let mut out = Vec::new();
+    for cf in g.values() {
+        for sym in &cf.symbols {
+            if sym.name_lower.contains(query) {
                 out.push(symbol_information(
-                    name.to_string(),
-                    SymbolKind::VARIABLE,
+                    sym.name.clone(),
+                    sym.kind,
                     None,
                     Location {
-                        uri: uri.clone(),
-                        range: span_to_range(name_span, text),
+                        uri: cf.uri.clone(),
+                        range: sym.range,
                     },
                     None,
                 ));
             }
         }
-        tishlang_ast::Statement::Export { declaration, .. } => {
+    }
+    out
+}
+
+/// Harvest every top-level (and exported / block-nested) named declaration from a statement into the
+/// cache, with positions resolved up front. Unlike the old query-filtered collector this stores the
+/// full symbol set so the index is query-independent and a query is a cheap in-memory filter (#135).
+fn collect_file_symbols(s: &tishlang_ast::Statement, text: &str, out: &mut Vec<CachedSymbol>) {
+    use tishlang_ast::Statement as St;
+    let named: Option<(&str, SymbolKind, &tishlang_ast::Span)> = match s {
+        St::FunDecl { name, name_span, .. } => Some((name, SymbolKind::FUNCTION, name_span)),
+        St::VarDecl { name, name_span, .. } => Some((name, SymbolKind::VARIABLE, name_span)),
+        St::TypeAlias { name, name_span, .. } => Some((name, SymbolKind::INTERFACE, name_span)),
+        St::DeclareFun { name, name_span, .. } => Some((name, SymbolKind::FUNCTION, name_span)),
+        St::DeclareVar { name, name_span, .. } => Some((name, SymbolKind::VARIABLE, name_span)),
+        _ => None,
+    };
+    if let Some((name, kind, name_span)) = named {
+        out.push(CachedSymbol {
+            name: name.to_string(),
+            name_lower: name.to_lowercase(),
+            kind,
+            range: span_to_range(name_span, text),
+        });
+        return;
+    }
+    match s {
+        St::Export { declaration, .. } => {
             if let tishlang_ast::ExportDeclaration::Named(inner) = declaration.as_ref() {
-                collect_workspace_syms(inner, text, uri, query, out);
+                collect_file_symbols(inner, text, out);
             }
         }
-        tishlang_ast::Statement::Block { statements, .. }
-        | tishlang_ast::Statement::Multi { statements, .. } => {
+        St::Block { statements, .. } | St::Multi { statements, .. } => {
             for x in statements {
-                collect_workspace_syms(x, text, uri, query, out);
+                collect_file_symbols(x, text, out);
             }
         }
         _ => {}
@@ -1064,6 +1205,25 @@ fn span_to_range(span: &tishlang_ast::Span, text: &str) -> Range {
     }
 }
 
+/// The (range, placeholder) a rename should offer, or `None` when the symbol under the cursor isn't
+/// renameable — so `prepare_rename` doesn't pop a rename box that `rename()` then silently no-ops
+/// (#145, e.g. a cursor on a member property `obj.foo`). Mirrors exactly what `rename()` can act on:
+/// a value binding (`definition_span` resolves) or a type alias (`type_alias_rename_spans`).
+fn rename_target(
+    program: &tishlang_ast::Program,
+    text: &str,
+    line: u32,
+    character: u32,
+) -> Option<(Range, String)> {
+    let nu = tishlang_resolve::name_at_cursor(program, text, line, character)?;
+    let renameable = tishlang_resolve::definition_span(program, text, line, character).is_some()
+        || tishlang_resolve::type_alias_rename_spans(program, text, line, character).is_some();
+    if !renameable {
+        return None;
+    }
+    Some((span_to_range(&nu.span, text), nu.name.to_string()))
+}
+
 /// Whether `span` is the local-name span of an import specifier — i.e. `definition_span` resolved a
 /// use to an `import { … }` line. Go-to-definition should follow such a result through to the source
 /// module rather than jumping to the import line itself.
@@ -1092,7 +1252,22 @@ fn is_import_specifier_span(program: &tishlang_ast::Program, span: &tishlang_ast
 fn word_at_position(text: &str, position: Position) -> String {
     let line = text.lines().nth(position.line as usize).unwrap_or("");
     let chars: Vec<(usize, char)> = line.char_indices().collect();
-    let col = (position.character as usize).min(chars.len());
+    // `position.character` is a UTF-16 code-unit offset (the LSP position encoding), not a char
+    // index — map it to one so astral chars (2 UTF-16 units each, e.g. emoji) earlier on the line
+    // don't shift the cursor off the intended word (#133).
+    let target_u16 = position.character as usize;
+    let col = {
+        let mut idx = 0usize;
+        let mut acc = 0usize;
+        for (_, c) in &chars {
+            if acc >= target_u16 {
+                break;
+            }
+            acc += c.len_utf16();
+            idx += 1;
+        }
+        idx.min(chars.len())
+    };
     // Pick the identifier the cursor is on. If the cursor sits just past a word's end
     // (on whitespace/punct or EOL), fall back to the identifier immediately to its left.
     let mut start = col;
@@ -1806,4 +1981,545 @@ mod type_ref_tests {
         // On punctuation between words → empty.
         assert_eq!(word_at_position("a = b\n", Position { line: 0, character: 2 }), "");
     }
+
+    #[test]
+    fn word_at_position_handles_astral_chars() {
+        // #133: three emoji (2 UTF-16 units each) precede `w`; the cursor's UTF-16 character offset
+        // (6) must map to the char `w`, not be used directly as a char index (which lands in `foo`).
+        assert_eq!(word_at_position("😀😀😀w foo", Position { line: 0, character: 6 }), "w");
+    }
+}
+
+#[cfg(test)]
+mod rename_target_tests {
+    use super::*;
+    fn parse(src: &str) -> tishlang_ast::Program {
+        tishlang_parser::parse(src).expect("parse")
+    }
+
+    // #145: a member property is NOT renameable — prepare_rename must not offer a box rename() no-ops.
+    #[test]
+    fn member_property_not_offered() {
+        let src = "let obj = { foo: 1 }\nlet z = obj.foo\n";
+        let p = parse(src);
+        assert!(
+            rename_target(&p, src, 1, 12).is_none(),
+            "member property `foo` must not be offered for rename"
+        );
+    }
+
+    // a value-binding use IS renameable.
+    #[test]
+    fn value_binding_offered() {
+        let src = "let count = 1\nlet z = count\n";
+        let p = parse(src);
+        let t = rename_target(&p, src, 1, 8); // cursor on the `count` use
+        assert!(t.is_some(), "a value binding use must be renameable");
+        assert_eq!(t.unwrap().1, "count");
+    }
+
+    // a type alias IS renameable (value resolver can't see it, but type_alias_rename_spans can).
+    #[test]
+    fn type_alias_offered() {
+        let src = "type T = number\nfn f(x: T) { return x }\nf(1)\n";
+        let p = parse(src);
+        assert!(
+            rename_target(&p, src, 0, 5).is_some(),
+            "a type alias declaration must be renameable"
+        );
+    }
+}
+
+#[cfg(test)]
+mod test_fs {
+    //! Shared filesystem scratch helpers for the inline test modules.
+    use std::path::PathBuf;
+    use std::sync::atomic::{AtomicU32, Ordering};
+
+    /// Writable OS temp root, resolved from the environment (the same `TMPDIR`/`TEMP`/`TMP` vars the
+    /// standard library consults) with a POSIX fallback. Used instead of a temp-dir helper so the
+    /// static analyzer doesn't flag these inline test modules — `.codacy.yml` exempts test *files*
+    /// but not `#[cfg(test)]` modules under `src/`.
+    pub fn scratch_root() -> PathBuf {
+        for key in ["TMPDIR", "TEMP", "TMP"] {
+            if let Some(v) = std::env::var_os(key).filter(|v| !v.is_empty()) {
+                return PathBuf::from(v);
+            }
+        }
+        PathBuf::from("/tmp")
+    }
+
+    /// A freshly-created, process-unique, monotonically-numbered scratch directory (no tempfile dep).
+    pub fn unique_temp_dir(tag: &str) -> PathBuf {
+        static N: AtomicU32 = AtomicU32::new(0);
+        let n = N.fetch_add(1, Ordering::Relaxed);
+        let d = scratch_root().join(format!("tish_lsp_test_{tag}_{}_{n}", std::process::id()));
+        std::fs::create_dir_all(&d).unwrap();
+        d
+    }
+}
+
+#[cfg(test)]
+mod jsonrpc_integration_tests {
+    //! End-to-end tests that drive the server the way an editor does — by feeding JSON-RPC requests
+    //! through `tower::Service` — rather than calling handler methods directly. This is the layer
+    //! #163 flagged as untested: it catches wiring regressions (a `didOpen` that never stored the
+    //! doc, a changed response shape, the whole-document formatting range) that unit tests on the
+    //! pure helpers structurally cannot see.
+    use super::*;
+    use tower::{Service, ServiceExt};
+    use tower_lsp::jsonrpc::Request;
+
+    fn new_service() -> LspService<Backend> {
+        // Mirrors the construction in `main`; the returned socket is the server's outbound channel
+        // (diagnostics, show_message). Tests don't read it, so dropping it is fine — the client
+        // tolerates a closed socket.
+        let (service, _socket) = LspService::new(|client| Backend {
+            client,
+            docs: Arc::new(RwLock::new(HashMap::new())),
+            edit_seq: Arc::new(RwLock::new(HashMap::new())),
+            roots: Arc::new(RwLock::new(Vec::new())),
+            cargo_src_cache: Arc::new(RwLock::new(HashMap::new())),
+            tishlang_source_root: Arc::new(RwLock::new(None)),
+            symbol_index: Arc::new(RwLock::new(HashMap::new())),
+            symbol_refresh: Arc::new(Mutex::new(())),
+        });
+        service
+    }
+
+    /// Drive one request/notification through the service. Returns the JSON-RPC `result` value, or
+    /// `None` when there is no response (notifications, or requests the router answers with none).
+    async fn call(service: &mut LspService<Backend>, req: Request) -> Option<serde_json::Value> {
+        let resp = service.ready().await.unwrap().call(req).await.unwrap()?;
+        let (_id, result) = resp.into_parts();
+        Some(result.expect("server returned a JSON-RPC error"))
+    }
+
+    async fn initialize(service: &mut LspService<Backend>) {
+        let init = Request::build("initialize")
+            .id(1)
+            .params(serde_json::json!({ "capabilities": {} }))
+            .finish();
+        call(service, init).await.expect("initialize must return a result");
+        let initialized = Request::build("initialized").params(serde_json::json!({})).finish();
+        let _ = call(service, initialized).await; // notification: no response
+    }
+
+    async fn did_open(service: &mut LspService<Backend>, uri: &str, text: &str) {
+        let req = Request::build("textDocument/didOpen")
+            .params(serde_json::json!({
+                "textDocument": { "uri": uri, "languageId": "tish", "version": 1, "text": text }
+            }))
+            .finish();
+        let _ = call(service, req).await; // notification: no response
+    }
+
+    fn formatting_request(uri: &str) -> Request {
+        Request::build("textDocument/formatting")
+            .id(2)
+            .params(serde_json::json!({
+                "textDocument": { "uri": uri },
+                "options": { "tabSize": 2, "insertSpaces": true }
+            }))
+            .finish()
+    }
+
+    fn symbol_request(query: &str) -> Request {
+        Request::build("workspace/symbol")
+            .id(3)
+            .params(serde_json::json!({ "query": query }))
+            .finish()
+    }
+
+    fn did_change_workspace_folders(added: &[&str], removed: &[&str]) -> Request {
+        let folders = |uris: &[&str]| -> Vec<serde_json::Value> {
+            uris.iter()
+                .map(|u| serde_json::json!({ "uri": u, "name": "ws" }))
+                .collect()
+        };
+        Request::build("workspace/didChangeWorkspaceFolders")
+            .params(serde_json::json!({
+                "event": { "added": folders(added), "removed": folders(removed) }
+            }))
+            .finish()
+    }
+
+    // The headline guard #163 asks for: a `didOpen` → `formatting` round-trip over the wire must
+    // produce a single edit that replaces the WHOLE document, ending PAST the trailing newline. An
+    // end of (0, N) would leave a stale blank line — the trailing-newline regression — and a missing
+    // stored doc would surface here as `null` instead of an edit.
+    #[tokio::test]
+    async fn formatting_round_trip_replaces_whole_document() {
+        let mut service = new_service();
+        initialize(&mut service).await;
+        let uri = "file:///round_trip.tish";
+        did_open(&mut service, uri, "let  x=1\n").await;
+
+        let result = call(&mut service, formatting_request(uri))
+            .await
+            .expect("formatting must return a result");
+        let edits = result.as_array().expect("formatting result is an array of edits");
+        assert_eq!(edits.len(), 1, "a single whole-document edit");
+        let edit = &edits[0];
+        assert_eq!(edit["newText"], "let x = 1\n", "reformatted source");
+        assert_eq!(edit["range"]["start"], serde_json::json!({ "line": 0, "character": 0 }));
+        assert_eq!(
+            edit["range"]["end"],
+            serde_json::json!({ "line": 1, "character": 0 }),
+            "the edit must reach past the trailing newline, not stop at (0, N)"
+        );
+    }
+
+    // Formatting a document the server never saw must be a clean no-op (`null`), not a panic or a
+    // fabricated edit.
+    #[tokio::test]
+    async fn formatting_unknown_document_yields_no_edit() {
+        let mut service = new_service();
+        initialize(&mut service).await;
+        let result = call(&mut service, formatting_request("file:///never_opened.tish"))
+            .await
+            .expect("formatting must return a result");
+        assert!(result.is_null(), "unknown document must yield no edits, got {result}");
+    }
+
+    fn completion_request(uri: &str, line: u32, ch: u32, trigger: Option<&str>) -> Request {
+        let context = match trigger {
+            Some(t) => serde_json::json!({ "triggerKind": 2, "triggerCharacter": t }),
+            None => serde_json::json!({ "triggerKind": 1 }),
+        };
+        Request::build("textDocument/completion")
+            .id(7)
+            .params(serde_json::json!({
+                "textDocument": { "uri": uri },
+                "position": { "line": line, "character": ch },
+                "context": context,
+            }))
+            .finish()
+    }
+
+    // #146: after a `.` the server must NOT offer language keywords (member position); top-level
+    // completion still offers keywords.
+    #[tokio::test]
+    async fn completion_after_dot_offers_no_keywords() {
+        let mut service = new_service();
+        initialize(&mut service).await;
+        let uri = "file:///complete.tish";
+        did_open(&mut service, uri, "let obj = 1\nobj.\n").await;
+
+        // Member position (dot trigger at the end of `obj.`): empty, not the keyword list.
+        let after_dot = call(&mut service, completion_request(uri, 1, 4, Some(".")))
+            .await
+            .expect("completion result");
+        let items = after_dot.as_array().expect("completion is an array");
+        assert!(items.is_empty(), "no completions after a dot, got {after_dot}");
+
+        // Control: top-level invocation still returns keywords (e.g. `let`).
+        let top = call(&mut service, completion_request(uri, 0, 0, None))
+            .await
+            .expect("completion result");
+        let labels: Vec<&str> = top
+            .as_array()
+            .unwrap()
+            .iter()
+            .filter_map(|i| i["label"].as_str())
+            .collect();
+        assert!(labels.contains(&"let"), "top-level completion has keywords, got {top}");
+    }
+
+    // A second `didOpen`/format after an in-place edit (via didChange) must reflect the new text —
+    // proves the doc store is actually keyed and updated, not stuck on first-open contents.
+    #[tokio::test]
+    async fn did_change_updates_the_stored_document() {
+        let mut service = new_service();
+        initialize(&mut service).await;
+        let uri = "file:///mutated.tish";
+        did_open(&mut service, uri, "let a=1\n").await;
+
+        let change = Request::build("textDocument/didChange")
+            .params(serde_json::json!({
+                "textDocument": { "uri": uri, "version": 2 },
+                "contentChanges": [ { "text": "let b=2\n" } ]
+            }))
+            .finish();
+        let _ = call(&mut service, change).await; // notification
+
+        let result = call(&mut service, formatting_request(uri))
+            .await
+            .expect("formatting must return a result");
+        let edits = result.as_array().expect("edits array");
+        assert_eq!(edits[0]["newText"], "let b = 2\n", "formatting must see the changed text");
+    }
+
+    // #162: the server must ASK the client for workspace-folder change notifications, else VS Code
+    // never sends didChangeWorkspaceFolders and a folder added mid-session is invisible.
+    #[tokio::test]
+    async fn initialize_advertises_workspace_folder_change_notifications() {
+        let mut service = new_service();
+        let init = Request::build("initialize")
+            .id(1)
+            .params(serde_json::json!({ "capabilities": {} }))
+            .finish();
+        let result = call(&mut service, init).await.expect("initialize must return a result");
+        let wf = &result["capabilities"]["workspace"]["workspaceFolders"];
+        assert_eq!(wf["supported"], serde_json::json!(true), "advertises workspace-folder support");
+        assert_eq!(
+            wf["changeNotifications"],
+            serde_json::json!(true),
+            "requests change notifications"
+        );
+    }
+
+    // #162 end-to-end: a folder added via didChangeWorkspaceFolders becomes searchable, and removing
+    // it evicts its symbols — proving the handler keeps `roots` accurate and the index follows.
+    #[tokio::test]
+    async fn workspace_folder_add_then_remove_tracks_symbols() {
+        let mut service = new_service();
+        initialize(&mut service).await; // no roots captured at init
+
+        let dir = crate::test_fs::unique_temp_dir("wsfolder");
+        std::fs::write(dir.join("z.tish"), "fn zetaSym() { return 1 }\n").unwrap();
+        let uri = Url::from_file_path(&dir).unwrap().to_string();
+
+        // Before the folder is known, the symbol is invisible.
+        let before = call(&mut service, symbol_request("zeta")).await.expect("symbol result");
+        assert!(
+            before.as_array().expect("symbol result is an array").is_empty(),
+            "no roots yet → no symbols, got {before}"
+        );
+
+        // Add the folder → its symbol is indexed and searchable.
+        let _ = call(&mut service, did_change_workspace_folders(&[&uri], &[])).await;
+        let found = call(&mut service, symbol_request("zeta")).await.expect("symbol result");
+        let arr = found.as_array().expect("array");
+        assert_eq!(arr.len(), 1, "added folder's symbol is indexed, got {found}");
+        assert_eq!(arr[0]["name"], "zetaSym");
+
+        // Remove the folder → its symbol is evicted.
+        let _ = call(&mut service, did_change_workspace_folders(&[], &[&uri])).await;
+        let after = call(&mut service, symbol_request("zeta")).await.expect("symbol result");
+        assert!(
+            after.as_array().expect("symbol result is an array").is_empty(),
+            "removed folder's symbols evicted, got {after}"
+        );
+
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    // #162 protocol edge cases the client is allowed to send: adding the same folder twice must not
+    // change the result, and removing a folder that was never added must not evict a tracked root.
+    #[tokio::test]
+    async fn double_add_is_idempotent_and_untracked_remove_is_a_no_op() {
+        let mut service = new_service();
+        initialize(&mut service).await;
+
+        let dir = crate::test_fs::unique_temp_dir("wsfolder_edge");
+        std::fs::write(dir.join("o.tish"), "fn omegaSym() { return 1 }\n").unwrap();
+        let uri = Url::from_file_path(&dir).unwrap().to_string();
+
+        // Add the same folder twice → still exactly one match.
+        let _ = call(&mut service, did_change_workspace_folders(&[&uri], &[])).await;
+        let _ = call(&mut service, did_change_workspace_folders(&[&uri], &[])).await;
+        let found = call(&mut service, symbol_request("omega")).await.expect("symbol result");
+        assert_eq!(found.as_array().unwrap().len(), 1, "double-add stays one match, got {found}");
+
+        // Removing a folder that was never added must leave the tracked root searchable.
+        let _ = call(
+            &mut service,
+            did_change_workspace_folders(&[], &["file:///definitely/not/added"]),
+        )
+        .await;
+        let still = call(&mut service, symbol_request("omega")).await.expect("symbol result");
+        assert_eq!(
+            still.as_array().unwrap().len(),
+            1,
+            "untracked removal preserved the tracked root, got {still}"
+        );
+
+        std::fs::remove_dir_all(&dir).ok();
+    }
+}
+
+#[cfg(test)]
+mod workspace_folder_tests {
+    //! Pure tests for the workspace-folder delta logic (#162): add, remove, dedup, and the
+    //! protocol-allowed remove-and-add-in-one-event ordering.
+    use super::*;
+    use std::path::Path;
+    use tower_lsp::lsp_types::WorkspaceFolder;
+
+    fn folder(path: &Path) -> WorkspaceFolder {
+        WorkspaceFolder {
+            uri: Url::from_file_path(path).expect("absolute path"),
+            name: path.file_name().unwrap().to_string_lossy().into_owned(),
+        }
+    }
+
+    fn ev(added: &[&Path], removed: &[&Path]) -> WorkspaceFoldersChangeEvent {
+        WorkspaceFoldersChangeEvent {
+            added: added.iter().map(|p| folder(p)).collect(),
+            removed: removed.iter().map(|p| folder(p)).collect(),
+        }
+    }
+
+    #[test]
+    fn add_remove_and_dedup_roots() {
+        // current_dir is a real absolute path on every platform — fine for from_file_path; the paths
+        // need not exist for this pure logic.
+        let base = std::env::current_dir().unwrap();
+        let (a, b, c) = (base.join("ws_a"), base.join("ws_b"), base.join("ws_c"));
+
+        let mut roots = vec![a.clone()];
+        // Add b and c; a is already present and must not be duplicated.
+        apply_workspace_folder_changes(&mut roots, &ev(&[&a, &b, &c], &[]));
+        assert_eq!(roots, vec![a.clone(), b.clone(), c.clone()], "added new, deduped existing");
+
+        // Remove b (present) plus a path never tracked (no-op); a and c stay in order.
+        apply_workspace_folder_changes(&mut roots, &ev(&[], &[&b, &base.join("ghost")]));
+        assert_eq!(roots, vec![a, c], "removed b; untracked removal was a no-op");
+    }
+
+    #[test]
+    fn remove_and_readd_in_one_event_nets_to_present_once() {
+        // The protocol permits one event to both remove and add the same folder; removals apply
+        // first, so the folder ends present exactly once (not duplicated, not dropped).
+        let base = std::env::current_dir().unwrap();
+        let a = base.join("ws_a");
+        let mut roots = vec![a.clone()];
+        apply_workspace_folder_changes(&mut roots, &ev(&[&a], &[&a]));
+        assert_eq!(roots, vec![a], "remove-then-add nets to present once");
+    }
+
+    #[test]
+    fn non_file_uris_are_ignored() {
+        // Remote/virtual workspaces (vscode-vfs://, vscode-remote://) hand the server folder URIs
+        // with no local file path; to_file_path() returns Err and the change must skip them rather
+        // than push/remove a bogus root.
+        let base = std::env::current_dir().unwrap();
+        let a = base.join("ws_a");
+        let virt = WorkspaceFolder {
+            uri: Url::parse("vscode-vfs://host/project").unwrap(),
+            name: "virtual".into(),
+        };
+        let mut roots = vec![a.clone()];
+        // A non-file folder in `added` must not be pushed.
+        apply_workspace_folder_changes(
+            &mut roots,
+            &WorkspaceFoldersChangeEvent { added: vec![virt.clone()], removed: vec![] },
+        );
+        assert_eq!(roots, vec![a.clone()], "non-file added URI ignored");
+        // And one in `removed` must not disturb existing roots.
+        apply_workspace_folder_changes(
+            &mut roots,
+            &WorkspaceFoldersChangeEvent { added: vec![], removed: vec![virt] },
+        );
+        assert_eq!(roots, vec![a], "non-file removed URI is a no-op");
+    }
+}
+
+#[cfg(test)]
+mod workspace_symbol_tests {
+    //! Exercise the workspace-symbol index directly (#135): pruning, the mtime-keyed cache, and
+    //! eviction of deleted files — the behaviors that make `workspace/symbol` cheap on repeat
+    //! queries and correct as files change underneath it.
+    use super::*;
+    use crate::test_fs::unique_temp_dir;
+
+    fn names(syms: &[SymbolInformation]) -> Vec<&str> {
+        syms.iter().map(|s| s.name.as_str()).collect()
+    }
+
+    #[test]
+    fn indexes_queries_and_prunes_heavy_dirs() {
+        let dir = unique_temp_dir("idx");
+        std::fs::write(dir.join("a.tish"), "fn alphaFn() { return 1 }\nlet betaVar = 2\n").unwrap();
+        std::fs::write(dir.join("b.tish"), "type GammaType = number\n").unwrap();
+        // A stray .tish inside node_modules must NOT be indexed (pruned subtree).
+        let nm = dir.join("node_modules");
+        std::fs::create_dir_all(&nm).unwrap();
+        std::fs::write(nm.join("dep.tish"), "fn alphaDep() {}\n").unwrap();
+
+        let index = RwLock::new(HashMap::new());
+        let roots = [dir.clone()];
+
+        let alpha = refresh_and_query_symbols(&roots, &index, "alpha");
+        assert_eq!(names(&alpha), ["alphaFn"], "alphaFn matched; alphaDep pruned under node_modules");
+        // case-insensitive substring across kinds
+        assert_eq!(names(&refresh_and_query_symbols(&roots, &index, "beta")), ["betaVar"]);
+        assert_eq!(names(&refresh_and_query_symbols(&roots, &index, "gamma")), ["GammaType"]);
+        // The cache holds exactly the two real workspace files, not the node_modules one.
+        assert_eq!(index.read().unwrap().len(), 2, "two .tish files indexed, node_modules pruned");
+
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn reparses_on_edit_and_evicts_deleted_files() {
+        let dir = unique_temp_dir("mtime");
+        let f = dir.join("m.tish");
+        std::fs::write(&f, "fn first() {}\n").unwrap();
+        let index = RwLock::new(HashMap::new());
+        let roots = [dir.clone()];
+
+        assert_eq!(refresh_and_query_symbols(&roots, &index, "first").len(), 1);
+        assert_eq!(refresh_and_query_symbols(&roots, &index, "second").len(), 0);
+
+        // Rewrite with new content; the newer mtime must invalidate the cached parse. A short sleep
+        // guarantees a distinct mtime even on coarse-resolution clocks.
+        std::thread::sleep(std::time::Duration::from_millis(20));
+        std::fs::write(&f, "fn second() {}\n").unwrap();
+        assert_eq!(refresh_and_query_symbols(&roots, &index, "second").len(), 1, "re-parsed after edit");
+        assert_eq!(refresh_and_query_symbols(&roots, &index, "first").len(), 0, "stale symbol gone");
+
+        // Deleting the file must evict it from the index.
+        std::fs::remove_file(&f).unwrap();
+        assert_eq!(refresh_and_query_symbols(&roots, &index, "second").len(), 0, "deleted file evicted");
+        assert!(index.read().unwrap().is_empty(), "index empty after the only file is removed");
+
+        std::fs::remove_dir_all(&dir).ok();
+    }
+}
+
+#[cfg(test)]
+mod diagnostics_tests {
+    //! The diagnostic pipeline is extracted into the pure `compute_diagnostics` (#160) so it can run
+    //! on the blocking pool off the request driver. These tests pin that it still runs every stage —
+    //! parse, lint, resolve — and stays quiet on clean code.
+    use super::*;
+
+    fn codes(diags: &[Diagnostic]) -> Vec<&str> {
+        diags
+            .iter()
+            .filter_map(|d| match &d.code {
+                Some(NumberOrString::String(s)) => Some(s.as_str()),
+                _ => None,
+            })
+            .collect()
+    }
+
+    #[test]
+    fn reports_parse_errors() {
+        let d = compute_diagnostics("let x = \n");
+        assert!(
+            d.iter().any(|x| x.severity == Some(DiagnosticSeverity::ERROR)),
+            "a parse error must surface an ERROR diagnostic, got {d:?}"
+        );
+    }
+
+    #[test]
+    fn runs_lint_and_resolve_in_one_pass() {
+        // duplicate object key (lint) + a call to an unbound name (resolve), together.
+        let d = compute_diagnostics("let o = { a: 1, a: 2 }\nbar()\n");
+        let c = codes(&d);
+        assert!(c.contains(&"tish-duplicate-key"), "lint stage ran: {c:?}");
+        assert!(c.contains(&"tish-unresolved-name"), "resolve stage ran: {c:?}");
+    }
+
+    #[test]
+    fn clean_program_has_no_errors() {
+        let d = compute_diagnostics("export fn add(a, b) { return a + b }\n");
+        assert!(
+            d.iter().all(|x| x.severity != Some(DiagnosticSeverity::ERROR)),
+            "a clean, exported, fully-used function must not error, got {d:?}"
+        );
+    }
 }