feat: add hover to ide

psteinroe · psteinroe · commit 8e02824a2295 · 2024-05-29T16:02:30.000+02:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/hover/src/lib.rs b/crates/hover/src/lib.rs
@@ -4,11 +4,11 @@ use resolve::Hoverable;
 use schema_cache::SchemaCache;
 use text_size::{TextRange, TextSize};
 
-pub struct HoverParams {
+pub struct HoverParams<'a> {
     pub position: text_size::TextSize,
     pub source: String,
-    pub ast: Option<sql_parser::EnrichedAst>,
-    pub tree: tree_sitter::Tree,
+    pub enriched_ast: Option<&'a sql_parser::EnrichedAst>,
+    pub tree: &'a tree_sitter::Tree,
     pub schema_cache: SchemaCache,
 }
 
@@ -19,8 +19,8 @@ pub struct HoverResult {
 }
 
 pub fn hover(params: HoverParams) -> Option<HoverResult> {
-    let elem = if params.ast.is_some() {
-        resolve::resolve_from_enriched_ast(params.position, params.ast.unwrap())
+    let elem = if params.enriched_ast.is_some() {
+        resolve::resolve_from_enriched_ast(params.position, params.enriched_ast.unwrap())
     } else {
         resolve::resolve_from_tree_sitter(params.position, params.tree, &params.source)
     };
diff --git a/crates/hover/src/resolve.rs b/crates/hover/src/resolve.rs
@@ -23,7 +23,7 @@ pub enum Hoverable {
     Column(HoverableColumn),
 }
 
-pub fn resolve_from_enriched_ast(pos: TextSize, ast: EnrichedAst) -> Option<Hoverable> {
+pub fn resolve_from_enriched_ast(pos: TextSize, ast: &EnrichedAst) -> Option<Hoverable> {
     let node = ast.covering_node(TextRange::empty(pos));
 
     if node.is_none() {
@@ -46,7 +46,7 @@ pub fn resolve_from_enriched_ast(pos: TextSize, ast: EnrichedAst) -> Option<Hove
     }
 }
 
-pub fn resolve_from_tree_sitter(pos: TextSize, tree: Tree, source: &str) -> Option<Hoverable> {
+pub fn resolve_from_tree_sitter(pos: TextSize, tree: &Tree, source: &str) -> Option<Hoverable> {
     let r = tree
         .root_node()
         .named_descendant_for_byte_range(usize::from(pos), usize::from(pos));
@@ -90,7 +90,7 @@ mod tests {
         let root = sql_parser::parse_sql_statement(input).unwrap();
         let ast = parse_ast(input, &root).ast;
 
-        let hover = super::resolve_from_enriched_ast(position, ast);
+        let hover = super::resolve_from_enriched_ast(position, &ast);
 
         assert!(hover.is_some());
 
@@ -116,7 +116,7 @@ mod tests {
 
         let tree = parser.parse(input, None).unwrap();
 
-        let hover = super::resolve_from_tree_sitter(position, tree, input);
+        let hover = super::resolve_from_tree_sitter(position, &tree, input);
 
         assert!(hover.is_some());
 
diff --git a/crates/ide/Cargo.toml b/crates/ide/Cargo.toml
@@ -7,6 +7,7 @@ edition = "2021"
 text-size = "1.1.1"
 dashmap = "5.5.3"
 base_db.workspace =  true
+hover.workspace =  true
 sql_parser.workspace = true
 diagnostics.workspace = true
 tree-sitter.workspace = true
diff --git a/crates/ide/src/features.rs b/crates/ide/src/features.rs
@@ -0,0 +1 @@
+pub mod hover;
diff --git a/crates/ide/src/features/hover.rs b/crates/ide/src/features/hover.rs
@@ -0,0 +1,7 @@
+use base_db::PgLspPath;
+use text_size::TextSize;
+
+pub struct HoverParams {
+    pub position: TextSize,
+    pub url: PgLspPath,
+}
diff --git a/crates/ide/src/lib.rs b/crates/ide/src/lib.rs
@@ -1,14 +1,13 @@
+mod features;
 mod pg_query;
 mod tree_sitter;
 
 use std::sync::{RwLock, RwLockWriteGuard};
 
 use base_db::{Document, DocumentChange, PgLspPath, StatementRef};
 use dashmap::{DashMap, DashSet};
-use diagnostics::Diagnostic;
 use pg_query::PgQueryParser;
 use schema_cache::SchemaCache;
-use text_size::TextRange;
 use tracing::{event, span, Level};
 use tree_sitter::TreeSitterParser;
 
@@ -101,8 +100,42 @@ impl IDE {
         diagnostics
     }
 
-    /// Analyse all statements that were changed since the last analysis
-    pub fn analyse(&self) {}
+    pub fn hover(&self, params: features::hover::HoverParams) -> Option<hover::HoverResult> {
+        let doc = self.documents.get(&params.url)?;
+        let stmt = doc.statement_at_offset(&params.position)?;
+
+        let tree = self.tree_sitter.tree(&stmt);
+
+        if tree.is_none() {
+            return None;
+        }
+
+        hover::hover(hover::HoverParams {
+            tree: tree.unwrap().as_ref(),
+            enriched_ast: self
+                .pg_query
+                .enriched_ast(&stmt)
+                .as_ref()
+                .map(|x| x.as_ref()),
+            // TODO translate position to statement position range
+            position: params.position,
+            source: stmt.text,
+            schema_cache: self.schema_cache.read().unwrap().clone(),
+        })
+    }
+
+    /// Drain changed statements to kick off analysis
+    pub fn drain_changed_stmt(&self) -> Vec<StatementRef> {
+        let changed: Vec<StatementRef> = self
+            .changed_stmts
+            .iter()
+            .map(|arc| (*arc).clone())
+            .collect();
+
+        self.changed_stmts.clear();
+
+        changed
+    }
 
     pub fn set_schema_cache(&self, cache: SchemaCache) {
         let mut schema_cache: RwLockWriteGuard<SchemaCache> = self.schema_cache.write().unwrap();
diff --git a/crates/ide/src/pg_query.rs b/crates/ide/src/pg_query.rs
@@ -1,13 +1,15 @@
+use std::sync::Arc;
+
 use base_db::{ChangedStatement, StatementRef};
 use dashmap::DashMap;
 use diagnostics::{Diagnostic, Severity};
 use text_size::TextRange;
 
 pub struct PgQueryParser {
-    ast_db: DashMap<StatementRef, sql_parser::AstNode>,
-    native_diagnostics: DashMap<StatementRef, sql_parser::NativeError>,
-    enriched_ast_db: DashMap<StatementRef, sql_parser::EnrichedAst>,
-    cst_db: DashMap<StatementRef, sql_parser::Cst>,
+    ast_db: DashMap<StatementRef, Arc<sql_parser::AstNode>>,
+    native_diagnostics: DashMap<StatementRef, Arc<sql_parser::NativeError>>,
+    enriched_ast_db: DashMap<StatementRef, Arc<sql_parser::EnrichedAst>>,
+    cst_db: DashMap<StatementRef, Arc<sql_parser::Cst>>,
 }
 
 impl PgQueryParser {
@@ -20,6 +22,31 @@ impl PgQueryParser {
         }
     }
 
+    pub fn ast(&self, statement: &StatementRef) -> Option<Arc<sql_parser::AstNode>> {
+        self.ast_db.get(statement).map(|x| x.clone())
+    }
+
+    pub fn enriched_ast(&self, statement: &StatementRef) -> Option<Arc<sql_parser::EnrichedAst>> {
+        self.enriched_ast_db.get(statement).map(|x| x.clone())
+    }
+
+    pub fn cst(&self, statement: &StatementRef) -> Option<Arc<sql_parser::Cst>> {
+        self.cst_db.get(statement).map(|x| x.clone())
+    }
+
+    pub fn compute_cst(&self, statement: &StatementRef) {
+        if self.cst_db.contains_key(statement) {
+            return;
+        }
+
+        if let Some(ast) = self.ast_db.get(statement) {
+            let r = sql_parser::parse_ast(&statement.text, &ast);
+            self.cst_db.insert(statement.clone(), Arc::new(r.cst));
+            self.enriched_ast_db
+                .insert(statement.clone(), Arc::new(r.ast));
+        }
+    }
+
     pub fn diagnostics(&self, statement: &StatementRef, at_range: TextRange) -> Vec<Diagnostic> {
         let mut diagnostics = Vec::new();
         if let Some(err) = self.native_diagnostics.get(statement) {
@@ -37,10 +64,10 @@ impl PgQueryParser {
     pub fn add_statement(&self, statement: &StatementRef) {
         let r = sql_parser::parse_sql_statement(statement.text.as_str());
         if r.is_ok() {
-            self.ast_db.insert(statement.clone(), r.unwrap());
+            self.ast_db.insert(statement.clone(), Arc::new(r.unwrap()));
         } else {
             self.native_diagnostics
-                .insert(statement.clone(), r.unwrap_err());
+                .insert(statement.clone(), Arc::new(r.unwrap_err()));
         }
     }
 
diff --git a/crates/ide/src/tree_sitter.rs b/crates/ide/src/tree_sitter.rs
@@ -1,12 +1,12 @@
-use std::sync::RwLock;
+use std::sync::{Arc, RwLock};
 
 use base_db::{ChangedStatement, StatementRef};
 use dashmap::DashMap;
 use text_size::TextRange;
-use tree_sitter::{InputEdit, Tree};
+use tree_sitter::InputEdit;
 
 pub struct TreeSitterParser {
-    db: DashMap<StatementRef, Tree>,
+    db: DashMap<StatementRef, Arc<tree_sitter::Tree>>,
 
     parser: RwLock<tree_sitter::Parser>,
 }
@@ -24,12 +24,16 @@ impl TreeSitterParser {
         }
     }
 
+    pub fn tree(&self, statement: &StatementRef) -> Option<Arc<tree_sitter::Tree>> {
+        self.db.get(statement).map(|x| x.clone())
+    }
+
     pub fn add_statement(&self, statement: &StatementRef) {
         let mut guard = self.parser.write().expect("Error reading parser");
         // todo handle error
         let tree = guard.parse(&statement.text, None).unwrap();
         drop(guard);
-        self.db.insert(statement.clone(), tree);
+        self.db.insert(statement.clone(), Arc::new(tree));
     }
 
     pub fn remove_statement(&self, statement: &StatementRef) {
@@ -60,8 +64,10 @@ impl TreeSitterParser {
 
         let mut guard = self.parser.write().expect("Error reading parser");
         // todo handle error
-        self.db
-            .insert(new_stmt, guard.parse(new_text, Some(&tree)).unwrap());
+        self.db.insert(
+            new_stmt,
+            Arc::new(guard.parse(new_text, Some(&tree)).unwrap()),
+        );
         drop(guard);
     }
 }
diff --git a/crates/lsp/src/server.rs b/crates/lsp/src/server.rs
@@ -5,21 +5,22 @@ use async_std::task::{self};
 use base_db::{Change, Document, DocumentChange, PgLspPath, StatementRef};
 use crossbeam_channel::{unbounded, Receiver, Sender};
 use ide::IDE;
-use lsp_server::{Connection, Message, Notification};
+use lsp_server::{Connection, Message, Notification, RequestId};
 use lsp_types::{
     notification::{
         DidChangeConfiguration, DidChangeTextDocument, DidCloseTextDocument, DidOpenTextDocument,
         DidSaveTextDocument, LogMessage, Notification as _, PublishDiagnostics, ShowMessage,
     },
-    request::{RegisterCapability, WorkspaceConfiguration},
+    request::{HoverRequest, RegisterCapability, WorkspaceConfiguration},
     ConfigurationItem, ConfigurationParams, DidChangeConfigurationParams,
     DidChangeTextDocumentParams, DidCloseTextDocumentParams, DidOpenTextDocumentParams,
-    DidSaveTextDocumentParams, InitializeParams, InitializeResult, LogMessageParams,
-    PublishDiagnosticsParams, Registration, RegistrationParams, SaveOptions, ServerCapabilities,
-    ServerInfo, ShowMessageParams, TextDocumentSyncCapability, TextDocumentSyncKind,
-    TextDocumentSyncOptions, TextDocumentSyncSaveOptions,
+    DidSaveTextDocumentParams, HoverParams, HoverProviderCapability, InitializeParams,
+    InitializeResult, LogMessageParams, PublishDiagnosticsParams, Registration, RegistrationParams,
+    SaveOptions, ServerCapabilities, ServerInfo, ShowMessageParams, TextDocumentSyncCapability,
+    TextDocumentSyncKind, TextDocumentSyncOptions, TextDocumentSyncSaveOptions,
 };
 use schema_cache::SchemaCache;
+use serde::Serialize;
 use std::sync::Arc;
 use threadpool::ThreadPool;
 use tracing::{event, instrument, Level};
@@ -65,7 +66,7 @@ pub struct Server {
     internal_rx: Receiver<InternalMessage>,
     pool: ThreadPool,
     client_flags: Arc<ClientFlags>,
-    ide: IDE,
+    ide: Arc<IDE>,
     db_conn: Option<DbConnection>,
 }
 
@@ -192,6 +193,7 @@ impl Server {
                     })),
                 },
             )),
+            hover_provider: Some(HoverProviderCapability::Simple(true)),
             ..ServerCapabilities::default()
         }
     }
@@ -302,6 +304,28 @@ impl Server {
         Ok(())
     }
 
+    fn hover(&mut self, id: RequestId, mut params: HoverParams) -> anyhow::Result<()> {
+        normalize_uri(&mut params.text_document_position_params.text_document.uri);
+
+        self.run_query(id, move |ide| ide.hover(params));
+
+        Ok(())
+    }
+
+    fn run_query<R, Q>(&self, id: RequestId, query: Q)
+    where
+        R: Serialize,
+        Q: FnOnce(&IDE) -> R + Send + 'static,
+    {
+        let client = self.client.clone();
+        let ide = Arc::clone(&self.ide);
+
+        self.pool.execute(move || {
+            let response = lsp_server::Response::new_ok(id, query(&ide));
+            client.send_response(response).unwrap();
+        });
+    }
+
     #[instrument(skip(self), name = "pglsp/refresh_schema_cache")]
     fn refresh_schema_cache(&self) {
         if self.db_conn.is_none() {
@@ -350,6 +374,7 @@ impl Server {
                             }
 
                             if let Some(response) = dispatch::RequestDispatcher::new(request)
+                                .on::<HoverRequest, _>(|id, params| self.hover(id, params))?
                                 .default()
                             {
                                 self.client.send_response(response)?;
diff --git a/crates/sql_parser/src/parser/parse_ast/ast_builder.rs b/crates/sql_parser/src/parser/parse_ast/ast_builder.rs
@@ -20,6 +20,7 @@ impl RangedNode {
     }
 }
 
+#[derive(Debug, Clone)]
 pub struct EnrichedAst {
     inner: StableGraph<RangedNode, ()>,
 }

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ impl RangedNode {`
`20`	`20`	`}`
`21`	`21`	`}`
`22`	`22`
	`23`	`+#[derive(Debug, Clone)]`
`23`	`24`	`pub struct EnrichedAst {`
`24`	`25`	`inner: StableGraph<RangedNode, ()>,`
`25`	`26`	`}`