add capabilities, normalize offset

Author: juleswritescode

crates/pg_lsp_new/src/capabilities.rs

@@ -1,8 +1,8 @@
 use pg_lsp_converters::{negotiated_encoding, PositionEncoding, WideEncoding};
 use tower_lsp::lsp_types::{
-    ClientCapabilities, PositionEncodingKind, SaveOptions, ServerCapabilities,
+    ClientCapabilities, CompletionOptions, PositionEncodingKind, SaveOptions, ServerCapabilities,
     TextDocumentSyncCapability, TextDocumentSyncKind, TextDocumentSyncOptions,
-    TextDocumentSyncSaveOptions,
+    TextDocumentSyncSaveOptions, WorkDoneProgressOptions,
 };
 
 /// The capabilities to send from server as part of [`InitializeResult`]
@@ -28,6 +28,24 @@ pub(crate) fn server_capabilities(capabilities: &ClientCapabilities) -> ServerCa
                 })),
             },
         )),
+        completion_provider: Some(CompletionOptions {
+            // currently not supporting the completionItem/resolve request.
+            // The request is used to get more information about a simple CompletionItem.
+            resolve_provider: None,
+
+            trigger_characters: Some(vec![".".to_owned(), ",".to_owned(), " ".to_owned()]),
+
+            // No character will lead to automatically inserting the selected completion-item
+            all_commit_characters: None,
+
+            // No special support for completionItem/resolve requests
+            completion_item: None,
+
+            // We do not report the progress of the completion process
+            work_done_progress_options: WorkDoneProgressOptions {
+                work_done_progress: None,
+            },
+        }),
         document_formatting_provider: None,
         document_range_formatting_provider: None,
         document_on_type_formatting_provider: None,

crates/pg_lsp_new/src/handlers/completions.rs

@@ -1,22 +1,22 @@
 use crate::session::Session;
 use anyhow::Result;
 use pg_workspace_new::workspace::CompletionParams;
-use text_size::TextSize;
 use tower_lsp::lsp_types::{self, CompletionItem, CompletionItemLabelDetails};
 
+#[tracing::instrument(level = "debug", skip_all)]
 pub fn get_completions(
     session: &Session,
     params: lsp_types::CompletionParams,
 ) -> Result<lsp_types::CompletionResponse> {
-    let pos = params.text_document_position.position;
     let url = params.text_document_position.text_document.uri;
-
     let path = session.file_path(&url)?;
+    let column = params.text_document_position.position.character;
+    let line = params.text_document_position.position.line;
 
-    let completion_result = session.workspace.get_completions(CompletionParams {
-        path,
-        position: TextSize::from(pos.character),
-    })?;
+    let completion_result =
+        session
+            .workspace
+            .get_completions(CompletionParams { path, line, column })?;
 
     let items: Vec<CompletionItem> = completion_result
         .into_iter()

crates/pg_lsp_new/src/handlers/text_document.rs

@@ -43,48 +43,36 @@ pub(crate) async fn did_open(
 }
 
 // Handler for `textDocument/didChange` LSP notification
-#[tracing::instrument(level = "info", skip_all, fields(url = field::display(&params.text_document.uri), version = params.text_document.version), err)]
+#[tracing::instrument(level = "debug", skip_all, fields(url = field::display(&params.text_document.uri), version = params.text_document.version), err)]
 pub(crate) async fn did_change(
     session: &Session,
     params: lsp_types::DidChangeTextDocumentParams,
 ) -> Result<()> {
     let url = params.text_document.uri;
     let version = params.text_document.version;
 
-    info!("Reading LSP Path...");
-
     let pglsp_path = session.file_path(&url)?;
 
-    info!("Getting file content...");
-
     // we need to keep the documents here too for the line index
     let old_text = session.workspace.get_file_content(GetFileContentParams {
         path: pglsp_path.clone(),
     })?;
 
-    info!("Finding start…");
-
     let start = params
         .content_changes
         .iter()
         .rev()
         .position(|change| change.range.is_none())
         .map_or(0, |idx| params.content_changes.len() - idx - 1);
 
-    info!("Getting finalized text...");
-
     let text = apply_document_changes(
         session.position_encoding(),
         old_text,
         &params.content_changes[start..],
     );
 
-    info!("Creating new doc…");
-
     let new_doc = Document::new(version, &text);
 
-    info!("Changing File in Workspace...");
-
     session.workspace.change_file(ChangeFileParams {
         path: pglsp_path,
         version,
@@ -99,12 +87,8 @@ pub(crate) async fn did_change(
             .collect(),
     })?;
 
-    info!("Inserting document...");
-
     session.insert_document(url.clone(), new_doc);
 
-    info!("Updating diagnostics...");
-
     if let Err(err) = session.update_diagnostics(url).await {
         error!("Failed to update diagnostics: {}", err);
     }

crates/pg_lsp_new/src/server.rs

@@ -210,35 +210,35 @@ impl LanguageServer for LSPServer {
         }
     }
 
-    #[tracing::instrument(level = "info", skip(self))]
+    #[tracing::instrument(level = "trace", skip(self))]
     async fn did_open(&self, params: DidOpenTextDocumentParams) {
         handlers::text_document::did_open(&self.session, params)
             .await
             .ok();
     }
 
-    #[tracing::instrument(level = "info", skip(self, params))]
+    #[tracing::instrument(level = "trace", skip(self, params))]
     async fn did_change(&self, params: DidChangeTextDocumentParams) {
         if let Err(e) = handlers::text_document::did_change(&self.session, params).await {
             error!("{}", e);
         };
     }
 
-    #[tracing::instrument(level = "info", skip(self))]
+    #[tracing::instrument(level = "trace", skip(self))]
     async fn did_save(&self, params: DidSaveTextDocumentParams) {
         // handlers::text_document::did_save(&self.session, params)
         //     .await
         //     .ok();
     }
 
-    #[tracing::instrument(level = "info", skip(self))]
+    #[tracing::instrument(level = "trace", skip(self))]
     async fn did_close(&self, params: DidCloseTextDocumentParams) {
         handlers::text_document::did_close(&self.session, params)
             .await
             .ok();
     }
 
-    #[tracing::instrument(level = "info", skip(self))]
+    #[tracing::instrument(level = "trace", skip(self))]
     async fn completion(&self, params: CompletionParams) -> LspResult<Option<CompletionResponse>> {
         match handlers::completions::get_completions(&self.session, params) {
             Ok(result) => LspResult::Ok(Some(result)),

crates/pg_workspace_new/src/workspace.rs

@@ -44,7 +44,8 @@ pub struct CompletionParams {
     /// The File for which a completion is requested.
     pub path: PgLspPath,
     /// The Cursor position in the file for which a completion is requested.
-    pub position: TextSize,
+    pub column: u32,
+    pub line: u32,
 }
 
 #[derive(Debug, serde::Serialize, serde::Deserialize)]

crates/pg_workspace_new/src/workspace/server.rs

@@ -343,7 +343,7 @@ impl Workspace for WorkspaceServer {
         })
     }
 
-    #[tracing::instrument(level = "info", skip(self))]
+    #[tracing::instrument(level = "debug", skip(self))]
     fn get_completions(
         &self,
         params: super::CompletionParams,
@@ -353,27 +353,39 @@ impl Workspace for WorkspaceServer {
             .get(&params.path)
             .ok_or(WorkspaceError::not_found())?;
 
-        tracing::info!("Found the document.");
-        tracing::info!("Looking for statement at position: {:?}", &params.position);
+        let offset = doc.line_and_col_to_offset(params.line, params.column);
 
-        let statement_ref = match doc.statement_ref_at_offset(&params.position) {
+        tracing::info!(
+            "Found the document. Looking for statement in file {:?} at position: {:?}",
+            &params.path,
+            &offset
+        );
+
+        let statement = match doc.statement_at_offset(&offset) {
             Some(s) => s,
             None => return Ok(pg_completions::CompletionResult::default()),
         };
+        let statement_ref = &statement.ref_;
+
+        // `offset` is the position in the document,
+        // but we need the position within the *statement*.
+        let stmt_range = doc
+            .statement_range(statement_ref)
+            .expect("Range of statement should be defined.");
+        let position = offset - stmt_range.start();
+
+        let tree = self.tree_sitter.fetch(statement_ref);
+        let text = statement.text;
 
-        let tree = self.tree_sitter.fetch(&statement_ref);
-        let text = doc
-            .statement_by_id(statement_ref.id)
-            .expect("Found statement_ref but no matching statement")
-            .text;
+        tracing::info!("Found the statement. We're looking for position {:?}. Statement Range {:?} to {:?}. Statement: {}", position, stmt_range.start(), stmt_range.end(), text);
 
         let schema_cache = self
             .schema_cache
             .read()
             .map_err(|_| WorkspaceError::runtime("Unable to load SchemaCache"))?;
 
         let result = pg_completions::complete(pg_completions::CompletionParams {
-            position: params.position,
+            position,
             schema: &schema_cache,
             tree: tree.as_deref(),
             text,

crates/pg_workspace_new/src/workspace/server/document.rs

@@ -81,6 +81,31 @@ impl Document {
             .collect()
     }
 
+    pub fn line_and_col_to_offset(&self, line: u32, col: u32) -> TextSize {
+        let line = line as usize;
+        let pos = col as usize;
+
+        let mut offset: usize = 0;
+
+        for (current_line_num, current_line) in self.content.lines().enumerate() {
+            let current_line_num = current_line_num + 1;
+            if current_line_num < line {
+                offset += current_line.len();
+            } else if current_line_num == line {
+                offset += pos;
+            };
+        }
+
+        // Normalize in case we exceed the length of the content
+        if offset > self.content.len() {
+            offset = self.content.len()
+        }
+
+        let offset = u32::try_from(offset).expect("Offset should be within u32 bounds");
+
+        TextSize::from(offset)
+    }
+
     #[allow(dead_code)]
     /// Returns the statement ref at the given offset
     pub fn statement_ref_at_offset(&self, offset: &TextSize) -> Option<StatementRef> {
@@ -129,20 +154,20 @@ impl Document {
             .collect()
     }
 
-    pub(super) fn statement_by_id(&self, id: StatementId) -> Option<Statement> {
-        self.statements
-            .iter()
-            .find(|s| s.0 == id)
-            .map(|pos| self.statement(pos))
-    }
-
     pub(super) fn statement_ref(&self, inner_ref: &StatementPosition) -> StatementRef {
         StatementRef {
             id: inner_ref.0,
             path: self.path.clone(),
         }
     }
 
+    pub(super) fn statement_range(&self, sref: &StatementRef) -> Option<TextRange> {
+        self.statements
+            .iter()
+            .find(|s| s.0 == sref.id)
+            .map(|it| it.1)
+    }
+
     pub(super) fn statement(&self, inner_ref: &StatementPosition) -> Statement {
         Statement {
             ref_: self.statement_ref(inner_ref),