add diagnostics to lsp

Author: psteinroe

.env

@@ -1 +1 @@
-DATABASE_URL=postgresql://postgres:[email protected]:5432/postgres
+DATABASE_URL=postgresql://postgres:[email protected]:54322/postgres

crates/pg_lsp_new/src/handlers/text_document.rs

@@ -5,7 +5,7 @@ use pg_workspace_new::workspace::{
     ChangeFileParams, ChangeParams, CloseFileParams, GetFileContentParams, OpenFileParams,
 };
 use tower_lsp::lsp_types;
-use tracing::field;
+use tracing::{error, field};
 
 /// Handler for `textDocument/didOpen` LSP notification
 #[tracing::instrument(
@@ -35,9 +35,9 @@ pub(crate) async fn did_open(
 
     session.insert_document(url.clone(), doc);
 
-    // if let Err(err) = session.update_diagnostics(url).await {
-    //     error!("Failed to update diagnostics: {}", err);
-    // }
+    if let Err(err) = session.update_diagnostics(url).await {
+        error!("Failed to update diagnostics: {}", err);
+    }
 
     Ok(())
 }
@@ -89,9 +89,9 @@ pub(crate) async fn did_change(
 
     session.insert_document(url.clone(), new_doc);
 
-    // if let Err(err) = session.update_diagnostics(url).await {
-    //     error!("Failed to update diagnostics: {}", err);
-    // }
+    if let Err(err) = session.update_diagnostics(url).await {
+        error!("Failed to update diagnostics: {}", err);
+    }
 
     Ok(())
 }

crates/pg_lsp_new/src/server.rs

@@ -160,7 +160,7 @@ impl LanguageServer for LSPServer {
         self.setup_capabilities().await;
 
         // Diagnostics are disabled by default, so update them after fetching workspace config
-        // self.session.update_all_diagnostics().await;
+        self.session.update_all_diagnostics().await;
     }
 
     async fn shutdown(&self) -> LspResult<()> {
@@ -172,7 +172,7 @@ impl LanguageServer for LSPServer {
         let _ = params;
         self.session.load_workspace_settings().await;
         self.setup_capabilities().await;
-        // self.session.update_all_diagnostics().await;
+        self.session.update_all_diagnostics().await;
     }
 
     #[tracing::instrument(level = "trace", skip(self))]
@@ -378,6 +378,7 @@ impl ServerFactory {
         workspace_method!(builder, open_file);
         workspace_method!(builder, change_file);
         workspace_method!(builder, close_file);
+        workspace_method!(builder, pull_diagnostics);
 
         let (service, socket) = builder.finish();
         ServerConnection { socket, service }

crates/pg_lsp_new/src/session.rs

@@ -1,12 +1,16 @@
+use crate::diagnostics::LspError;
 use crate::documents::Document;
+use crate::utils;
 use anyhow::Result;
+use futures::stream::FuturesUnordered;
+use futures::StreamExt;
 use pg_configuration::ConfigurationPathHint;
 use pg_diagnostics::{DiagnosticExt, Error};
 use pg_fs::{FileSystem, PgLspPath};
 use pg_lsp_converters::{negotiated_encoding, PositionEncoding, WideEncoding};
 use pg_workspace_new::configuration::{load_configuration, LoadedConfiguration};
 use pg_workspace_new::settings::PartialConfigurationExt;
-use pg_workspace_new::workspace::UpdateSettingsParams;
+use pg_workspace_new::workspace::{PullDiagnosticsParams, UpdateSettingsParams};
 use pg_workspace_new::Workspace;
 use pg_workspace_new::{DynRef, WorkspaceError};
 use rustc_hash::FxHashMap;
@@ -237,6 +241,75 @@ impl Session {
         }
     }
 
+    /// Computes diagnostics for the file matching the provided url and publishes
+    /// them to the client. Called from [`handlers::text_document`] when a file's
+    /// contents changes.
+    #[tracing::instrument(level = "trace", skip_all, fields(url = display(&url), diagnostic_count), err)]
+    pub(crate) async fn update_diagnostics(&self, url: lsp_types::Url) -> Result<(), LspError> {
+        let pglsp_path = self.file_path(&url)?;
+        let doc = self.document(&url)?;
+        if self.configuration_status().is_error() && !self.notified_broken_configuration() {
+            self.set_notified_broken_configuration();
+            self.client
+                    .show_message(MessageType::WARNING, "The configuration file has errors. Biome will report only parsing errors until the configuration is fixed.")
+                    .await;
+        }
+
+        let diagnostics: Vec<lsp_types::Diagnostic> = {
+            let result = self.workspace.pull_diagnostics(PullDiagnosticsParams {
+                path: pglsp_path.clone(),
+                max_diagnostics: u64::MAX,
+            })?;
+
+            tracing::trace!("biome diagnostics: {:#?}", result.diagnostics);
+
+            result
+                .diagnostics
+                .into_iter()
+                .filter_map(|d| {
+                    match utils::diagnostic_to_lsp(
+                        d,
+                        &url,
+                        &doc.line_index,
+                        self.position_encoding(),
+                        None,
+                    ) {
+                        Ok(diag) => Some(diag),
+                        Err(err) => {
+                            error!("failed to convert diagnostic to LSP: {err:?}");
+                            None
+                        }
+                    }
+                })
+                .collect()
+        };
+
+        tracing::Span::current().record("diagnostic_count", diagnostics.len());
+
+        self.client
+            .publish_diagnostics(url, diagnostics, Some(doc.version))
+            .await;
+
+        Ok(())
+    }
+
+    /// Updates diagnostics for every [`Document`] in this [`Session`]
+    pub(crate) async fn update_all_diagnostics(&self) {
+        let mut futures: FuturesUnordered<_> = self
+            .documents
+            .read()
+            .unwrap()
+            .keys()
+            .map(|url| self.update_diagnostics(url.clone()))
+            .collect();
+
+        while let Some(result) = futures.next().await {
+            if let Err(e) = result {
+                error!("Error while updating diagnostics: {}", e);
+            }
+        }
+    }
+
     /// Get a [`Document`] matching the provided [`lsp_types::Url`]
     ///
     /// If document does not exist, result is [WorkspaceError::NotFound]

crates/pg_workspace_new/src/workspace/server.rs

@@ -214,10 +214,16 @@ impl Workspace for WorkspaceServer {
     #[tracing::instrument(level = "trace", skip(self))]
     fn open_file(&self, params: OpenFileParams) -> Result<(), WorkspaceError> {
         tracing::info!("Opening file: {:?}", params.path);
-        self.documents.insert(
-            params.path.clone(),
-            Document::new(params.path, params.content, params.version),
-        );
+
+        let doc = Document::new(params.path.clone(), params.content, params.version);
+
+        doc.statements.iter().for_each(|s| {
+            let stmt = doc.statement(s);
+            self.tree_sitter.add_statement(&stmt);
+            self.pg_query.add_statement(&stmt);
+        });
+
+        self.documents.insert(params.path, doc);
 
         Ok(())
     }

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

@@ -63,6 +63,7 @@ impl Store<pg_query_ext::NodeEnum> for PgQueryStore {
         if let Ok(ast) = r {
             self.ast_db.insert(statement.ref_.clone(), Arc::new(ast));
         } else {
+            tracing::info!("adding diagnostics");
             self.diagnostics.insert(
                 statement.ref_.clone(),
                 SyntaxDiagnostic::from(r.unwrap_err()),

test.sql

@@ -4,6 +4,6 @@ select 14433313331333333333
 
 select * from test;
 
-alter table test drop column id;
+alter tqjable test drop column id;
 
 select lower();