Initial support for workspace symbols

purefunctor · purefunctor · commit 1fee06bc017d · 2025-10-28T20:50:44.000+08:00
diff --git a/compiler-bin/src/lsp.rs b/compiler-bin/src/lsp.rs
@@ -98,6 +98,7 @@ fn initialize(
                 definition_provider: Some(OneOf::Left(true)),
                 hover_provider: Some(HoverProviderCapability::Simple(true)),
                 references_provider: Some(OneOf::Left(true)),
+                workspace_symbol_provider: Some(OneOf::Left(true)),
                 text_document_sync: Some(TextDocumentSyncCapability::Kind(
                     TextDocumentSyncKind::FULL,
                 )),
@@ -244,6 +245,13 @@ fn references(
         .on_non_fatal(None)
 }
 
+fn workspace_symbols(
+    snapshot: StateSnapshot,
+    p: WorkspaceSymbolParams,
+) -> Result<Option<WorkspaceSymbolResponse>, ResponseError> {
+    analyzer::symbols::workspace(&snapshot.engine, &snapshot.files(), &p.query).on_non_fatal(None)
+}
+
 fn did_change(state: &mut State, p: DidChangeTextDocumentParams) -> Result<(), LspError> {
     let uri = p.text_document.uri.as_str();
 
@@ -325,6 +333,7 @@ pub async fn start(config: Arc<cli::Config>) {
             .request_snapshot::<request::Completion>(completion)
             .request_snapshot::<request::ResolveCompletionItem>(resolve_completion_item)
             .request_snapshot::<request::References>(references)
+            .request_snapshot::<request::WorkspaceSymbolRequest>(workspace_symbols)
             .notification::<notification::Initialized>(adapt_notification(initialized))
             .notification::<notification::DidOpenTextDocument>(|_, _| ControlFlow::Continue(()))
             .notification::<notification::DidSaveTextDocument>(|_, _| ControlFlow::Continue(()))
diff --git a/compiler-lsp/analyzer/src/common.rs b/compiler-lsp/analyzer/src/common.rs
@@ -0,0 +1,73 @@
+use async_lsp::lsp_types::*;
+use building::{QueryEngine, prim};
+use files::{FileId, Files};
+use indexing::{TermItemId, TypeItemId};
+use syntax::{SyntaxNode, SyntaxNodePtr};
+
+use crate::{AnalyzerError, locate};
+
+pub fn file_term_location(
+    engine: &QueryEngine,
+    files: &Files,
+    file_id: FileId,
+    term_id: TermItemId,
+) -> Result<Location, AnalyzerError> {
+    let uri = file_uri(engine, files, file_id)?;
+
+    let content = engine.content(file_id);
+    let (parsed, _) = engine.parsed(file_id)?;
+
+    let stabilized = engine.stabilized(file_id)?;
+    let indexed = engine.indexed(file_id)?;
+
+    let root = parsed.syntax_node();
+    let pointers = indexed.term_item_ptr(&stabilized, term_id);
+
+    let range = pointers_range(&content, root, pointers)?;
+    Ok(Location { uri, range })
+}
+
+pub fn file_type_location(
+    engine: &QueryEngine,
+    files: &Files,
+    file_id: FileId,
+    type_id: TypeItemId,
+) -> Result<Location, AnalyzerError> {
+    let uri = file_uri(engine, files, file_id)?;
+
+    let content = engine.content(file_id);
+    let (parsed, _) = engine.parsed(file_id)?;
+
+    let stabilized = engine.stabilized(file_id)?;
+    let indexed = engine.indexed(file_id)?;
+
+    let root = parsed.syntax_node();
+    let pointers = indexed.type_item_ptr(&stabilized, type_id);
+
+    let range = pointers_range(&content, root, pointers)?;
+
+    Ok(Location { uri, range })
+}
+
+pub fn file_uri(
+    engine: &QueryEngine,
+    files: &Files,
+    file_id: FileId,
+) -> Result<Url, AnalyzerError> {
+    let path = files.path(file_id);
+    let content = engine.content(file_id);
+
+    let uri = Url::parse(&path)?;
+    prim::handle_generated(uri, &content).ok_or(AnalyzerError::NonFatal)
+}
+
+fn pointers_range(
+    content: &str,
+    root: SyntaxNode,
+    pointers: impl Iterator<Item = SyntaxNodePtr>,
+) -> Result<Range, AnalyzerError> {
+    pointers
+        .filter_map(|ptr| locate::syntax_range(&content, &root, &ptr))
+        .reduce(|start, end| Range { start: start.start, end: end.end })
+        .ok_or(AnalyzerError::NonFatal)
+}
diff --git a/compiler-lsp/analyzer/src/definition.rs b/compiler-lsp/analyzer/src/definition.rs
@@ -1,5 +1,5 @@
 use async_lsp::lsp_types::*;
-use building::{QueryEngine, prim};
+use building::QueryEngine;
 use files::{FileId, Files};
 use indexing::{ImportItemId, TermItemId, TypeItemId};
 use lowering::{
@@ -10,7 +10,7 @@ use rowan::ast::{AstNode, AstPtr};
 use smol_str::ToSmolStr;
 use syntax::cst;
 
-use crate::{AnalyzerError, locate};
+use crate::{AnalyzerError, common, locate};
 
 pub fn implementation(
     engine: &QueryEngine,
@@ -77,7 +77,6 @@ fn definition_module_name(
     let module_name = module_name.syntax().text().to_smolstr();
     let module_id = engine.module_file(&module_name).ok_or(AnalyzerError::NonFatal)?;
 
-    let path = files.path(module_id);
     let content = engine.content(module_id);
 
     let (parsed, _) = engine.parsed(module_id)?;
@@ -87,8 +86,7 @@ fn definition_module_name(
     let start = locate::offset_to_position(&content, range.start());
     let end = locate::offset_to_position(&content, range.end());
 
-    let uri = Url::parse(&path)?;
-    let uri = prim::handle_generated(uri, &content).ok_or(AnalyzerError::NonFatal)?;
+    let uri = common::file_uri(engine, files, module_id)?;
 
     let range = Range { start, end };
 
@@ -294,31 +292,8 @@ fn definition_file_term(
     file_id: FileId,
     term_id: TermItemId,
 ) -> Result<Option<GotoDefinitionResponse>, AnalyzerError> {
-    let uri = {
-        let path = files.path(file_id);
-        let content = files.content(file_id);
-
-        let uri = Url::parse(&path)?;
-        prim::handle_generated(uri, &content).ok_or(AnalyzerError::NonFatal)?
-    };
-
-    let content = engine.content(file_id);
-    let (parsed, _) = engine.parsed(file_id)?;
-
-    let stabilized = engine.stabilized(file_id)?;
-    let indexed = engine.indexed(file_id)?;
-
-    // TODO: Once we implement textDocument/typeDefinition, we
-    // should probably also add a term_item_type_ptr function.
-    let root = parsed.syntax_node();
-    let pointers = indexed.term_item_ptr(&stabilized, term_id);
-
-    let range = pointers
-        .filter_map(|ptr| locate::syntax_range(&content, &root, &ptr))
-        .reduce(|start, end| Range { start: start.start, end: end.end })
-        .ok_or(AnalyzerError::NonFatal)?;
-
-    Ok(Some(GotoDefinitionResponse::Scalar(Location { uri, range })))
+    let location = common::file_term_location(engine, files, file_id, term_id)?;
+    Ok(Some(GotoDefinitionResponse::Scalar(location)))
 }
 
 fn definition_file_type(
@@ -327,27 +302,6 @@ fn definition_file_type(
     file_id: FileId,
     type_id: TypeItemId,
 ) -> Result<Option<GotoDefinitionResponse>, AnalyzerError> {
-    let uri = {
-        let path = files.path(file_id);
-        let content = files.content(file_id);
-
-        let uri = Url::parse(&path)?;
-        prim::handle_generated(uri, &content).ok_or(AnalyzerError::NonFatal)?
-    };
-
-    let content = engine.content(file_id);
-    let (parsed, _) = engine.parsed(file_id)?;
-
-    let stabilized = engine.stabilized(file_id)?;
-    let indexed = engine.indexed(file_id)?;
-
-    let root = parsed.syntax_node();
-    let pointers = indexed.type_item_ptr(&stabilized, type_id);
-
-    let range = pointers
-        .filter_map(|ptr| locate::syntax_range(&content, &root, &ptr))
-        .reduce(|start, end| Range { start: start.start, end: end.end })
-        .ok_or(AnalyzerError::NonFatal)?;
-
-    Ok(Some(GotoDefinitionResponse::Scalar(Location { uri, range })))
+    let location = common::file_type_location(engine, files, file_id, type_id)?;
+    Ok(Some(GotoDefinitionResponse::Scalar(location)))
 }
diff --git a/compiler-lsp/analyzer/src/lib.rs b/compiler-lsp/analyzer/src/lib.rs
@@ -1,10 +1,12 @@
+pub mod common;
 pub mod completion;
 pub mod definition;
 pub mod error;
 pub mod extract;
 pub mod hover;
 pub mod locate;
 pub mod references;
+pub mod symbols;
 
 pub use building::{QueryEngine, QueryError, prim};
 pub use error::AnalyzerError;
diff --git a/compiler-lsp/analyzer/src/references.rs b/compiler-lsp/analyzer/src/references.rs
@@ -1,5 +1,5 @@
 use async_lsp::lsp_types::*;
-use building::{QueryEngine, prim};
+use building::QueryEngine;
 use files::{FileId, Files};
 use indexing::{ImportId, ImportItemId, ImportKind, TermItemId, TypeItemId};
 use lowering::{
@@ -13,7 +13,7 @@ use smol_str::ToSmolStr;
 use stabilizing::{AstId, StabilizedModule};
 use syntax::{PureScript, cst};
 
-use crate::{AnalyzerError, locate};
+use crate::{AnalyzerError, common, locate};
 
 pub fn implementation(
     engine: &QueryEngine,
@@ -82,12 +82,9 @@ fn references_module_name(
 
     let mut locations = vec![];
     for (candidate_id, import_id) in candidates {
-        let path = files.path(candidate_id);
-        let content = files.content(candidate_id);
-
-        let uri = Url::parse(&path)?;
-        let uri = prim::handle_generated(uri, &content).ok_or(AnalyzerError::NonFatal)?;
+        let uri = common::file_uri(engine, files, candidate_id)?;
 
+        let content = engine.content(candidate_id);
         let (parsed, _) = engine.parsed(candidate_id)?;
         let root = parsed.syntax_node();
 
@@ -263,13 +260,7 @@ fn references_file_term(
 
     let mut locations = vec![];
     for candidate_id in candidates {
-        let uri = {
-            let path = files.path(candidate_id);
-            let content = files.content(candidate_id);
-
-            let uri = Url::parse(&path)?;
-            prim::handle_generated(uri, &content).ok_or(AnalyzerError::NonFatal)?
-        };
+        let uri = common::file_uri(engine, files, candidate_id)?;
 
         let content = engine.content(candidate_id);
         let (parsed, _) = engine.parsed(candidate_id)?;
@@ -334,13 +325,7 @@ fn references_file_type(
 
     let mut locations = vec![];
     for candidate_id in candidates {
-        let uri = {
-            let path = files.path(candidate_id);
-            let content = files.content(candidate_id);
-
-            let uri = Url::parse(&path)?;
-            prim::handle_generated(uri, &content).ok_or(AnalyzerError::NonFatal)?
-        };
+        let uri = common::file_uri(engine, files, candidate_id)?;
 
         let content = engine.content(candidate_id);
         let (parsed, _) = engine.parsed(candidate_id)?;
diff --git a/compiler-lsp/analyzer/src/symbols.rs b/compiler-lsp/analyzer/src/symbols.rs
@@ -0,0 +1,57 @@
+use async_lsp::lsp_types::*;
+use building::QueryEngine;
+use files::Files;
+
+use crate::{AnalyzerError, common};
+
+pub fn workspace(
+    engine: &QueryEngine,
+    files: &Files,
+    query: &str,
+) -> Result<Option<WorkspaceSymbolResponse>, AnalyzerError> {
+    let mut symbols = vec![];
+
+    let allow_query = |name: &str| query.is_empty() || name.starts_with(query);
+
+    for file_id in files.iter_id() {
+        let resolved = engine.resolved(file_id)?;
+
+        let terms = resolved
+            .locals
+            .iter_terms()
+            .filter_map(|(name, _, id)| if allow_query(&name) { Some((name, id)) } else { None });
+
+        let types = resolved
+            .locals
+            .iter_types()
+            .filter_map(|(name, _, id)| if allow_query(&name) { Some((name, id)) } else { None });
+
+        for (name, term_id) in terms {
+            let location = common::file_term_location(engine, files, file_id, term_id)?;
+            symbols.push(SymbolInformation {
+                name: name.to_string(),
+                kind: SymbolKind::FUNCTION,
+                tags: None,
+                #[allow(deprecated)]
+                deprecated: None,
+                location,
+                container_name: None,
+            })
+        }
+
+        for (name, type_id) in types {
+            let location = common::file_type_location(engine, files, file_id, type_id)?;
+            symbols.push(SymbolInformation {
+                name: name.to_string(),
+                kind: SymbolKind::CLASS,
+                tags: None,
+                #[allow(deprecated)]
+                deprecated: None,
+                location,
+                container_name: None,
+            })
+        }
+    }
+
+    Ok(Some(WorkspaceSymbolResponse::Flat(symbols)))
+}
