feat: pull diagnostics

Author: psteinroe

crates/pg_diagnostics_categories/src/categories.rs

@@ -25,5 +25,6 @@ define_categories! {
     "flags/invalid",
     "project",
     "internalError/panic",
+    "syntax",
     "dummy",
 }

crates/pg_workspace_new/src/workspace.rs

@@ -30,6 +30,22 @@ pub struct ChangeFileParams {
     pub changes: Vec<ChangeParams>,
 }
 
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct PullDiagnosticsParams {
+    pub path: PgLspPath,
+    // pub categories: RuleCategories,
+    pub max_diagnostics: u64,
+    // pub only: Vec<RuleSelector>,
+    // pub skip: Vec<RuleSelector>,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+pub struct PullDiagnosticsResult {
+    pub diagnostics: Vec<pg_diagnostics::serde::Diagnostic>,
+    pub errors: usize,
+    pub skipped_diagnostics: u64,
+}
+
 #[derive(Debug, serde::Serialize, serde::Deserialize)]
 pub struct ChangeParams {
     /// The range of the file that changed. If `None`, the whole file changed.
@@ -72,6 +88,12 @@ pub struct ServerInfo {
 }
 
 pub trait Workspace: Send + Sync + RefUnwindSafe {
+    /// Retrieves the list of diagnostics associated to a file
+    fn pull_diagnostics(
+        &self,
+        params: PullDiagnosticsParams,
+    ) -> Result<PullDiagnosticsResult, WorkspaceError>;
+
     /// Refresh the schema cache for this workspace
     fn refresh_schema_cache(&self) -> Result<(), WorkspaceError>;
 

crates/pg_workspace_new/src/workspace/client.rs

@@ -120,4 +120,11 @@ where
     fn refresh_schema_cache(&self) -> Result<(), WorkspaceError> {
         self.request("pglsp/refresh_schema_cache", ())
     }
+
+    fn pull_diagnostics(
+        &self,
+        params: super::PullDiagnosticsParams,
+    ) -> Result<super::PullDiagnosticsResult, WorkspaceError> {
+        self.request("pglsp/pull_diagnostics", params)
+    }
 }

crates/pg_workspace_new/src/workspace/server.rs

@@ -3,17 +3,20 @@ use std::{fs, future::Future, panic::RefUnwindSafe, path::Path, sync::RwLock};
 use change::StatementChange;
 use dashmap::{DashMap, DashSet};
 use document::{Document, StatementRef};
+use pg_diagnostics::{serde::Diagnostic as SDiagnostic, Diagnostic, DiagnosticExt, Severity};
 use pg_fs::{ConfigName, PgLspPath};
 use pg_query::PgQueryStore;
 use pg_schema_cache::SchemaCache;
 use sqlx::PgPool;
 use std::sync::LazyLock;
 use store::Store;
 use tokio::runtime::Runtime;
+use tracing::info;
 use tree_sitter::TreeSitterStore;
 
 use crate::{
     settings::{Settings, SettingsHandle, SettingsHandleMut},
+    workspace::PullDiagnosticsResult,
     WorkspaceError,
 };
 
@@ -291,6 +294,50 @@ impl Workspace for WorkspaceServer {
     fn is_path_ignored(&self, params: IsPathIgnoredParams) -> Result<bool, WorkspaceError> {
         Ok(self.is_ignored(params.pglsp_path.as_path()))
     }
+
+    fn pull_diagnostics(
+        &self,
+        params: super::PullDiagnosticsParams,
+    ) -> Result<super::PullDiagnosticsResult, WorkspaceError> {
+        // get all statements form the requested document and pull diagnostics out of every
+        // sourcece
+        let doc = self
+            .documents
+            .get(&params.path)
+            .ok_or(WorkspaceError::not_found())?;
+
+        let diagnostics: Vec<SDiagnostic> = doc
+            .statement_refs_with_ranges()
+            .iter()
+            .flat_map(|(stmt, r)| {
+                let mut stmt_diagnostics = vec![];
+
+                stmt_diagnostics.extend(self.pg_query.pull_diagnostics(stmt));
+
+                stmt_diagnostics
+                    .into_iter()
+                    .map(|d| {
+                        SDiagnostic::new(
+                            d.with_file_path(params.path.as_path().display().to_string())
+                                .with_file_span(r),
+                        )
+                    })
+                    .collect::<Vec<_>>()
+            })
+            .collect();
+
+        let errors = diagnostics
+            .iter()
+            .filter(|d| d.severity() == Severity::Error)
+            .count();
+
+        info!("Pulled {:?} diagnostic(s)", diagnostics.len());
+        Ok(PullDiagnosticsResult {
+            diagnostics,
+            errors,
+            skipped_diagnostics: 0,
+        })
+    }
 }
 
 /// Returns `true` if `path` is a directory or

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

@@ -74,6 +74,13 @@ impl Document {
             .collect()
     }
 
+    pub fn statement_refs_with_ranges(&self) -> Vec<(StatementRef, TextRange)> {
+        self.statements
+            .iter()
+            .map(|inner_ref| (self.statement_ref(inner_ref), inner_ref.1))
+            .collect()
+    }
+
     #[allow(dead_code)]
     /// Returns the statement ref at the given offset
     pub fn statement_ref_at_offset(&self, offset: &TextSize) -> Option<StatementRef> {

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

@@ -1,25 +1,56 @@
 use std::sync::Arc;
 
 use dashmap::DashMap;
+use pg_diagnostics::{serde::Diagnostic as SDiagnostic, Diagnostic, MessageAndDescription};
+use text_size::TextRange;
 
 use super::{
     change::ChangedStatement,
     document::{Statement, StatementRef},
     store::Store,
 };
 
+/// A specialized diagnostic for the libpg_query parser.
+///
+/// Parser diagnostics are always **errors**.
+#[derive(Clone, Debug, Diagnostic)]
+#[diagnostic(category = "syntax", severity = Error)]
+pub struct SyntaxDiagnostic {
+    /// The location where the error is occurred
+    #[location(span)]
+    span: Option<TextRange>,
+    #[message]
+    #[description]
+    pub message: MessageAndDescription,
+}
+
 pub struct PgQueryStore {
     ast_db: DashMap<StatementRef, Arc<pg_query_ext::NodeEnum>>,
-    native_diagnostics: DashMap<StatementRef, Arc<pg_query_ext::Error>>,
+    diagnostics: DashMap<StatementRef, pg_query_ext::Error>,
+}
+
+impl From<&pg_query_ext::Error> for SyntaxDiagnostic {
+    fn from(err: &pg_query_ext::Error) -> Self {
+        SyntaxDiagnostic {
+            span: None,
+            message: MessageAndDescription::from(err.to_string()),
+        }
+    }
 }
 
 impl PgQueryStore {
     pub fn new() -> PgQueryStore {
         PgQueryStore {
             ast_db: DashMap::new(),
-            native_diagnostics: DashMap::new(),
+            diagnostics: DashMap::new(),
         }
     }
+
+    pub fn pull_diagnostics(&self, ref_: &StatementRef) -> Vec<SDiagnostic> {
+        self.diagnostics.get(ref_).map_or_else(Vec::new, |err| {
+            vec![SDiagnostic::new(SyntaxDiagnostic::from(err.value()))]
+        })
+    }
 }
 
 impl Store<pg_query_ext::NodeEnum> for PgQueryStore {
@@ -32,14 +63,14 @@ impl Store<pg_query_ext::NodeEnum> for PgQueryStore {
         if let Ok(ast) = r {
             self.ast_db.insert(statement.ref_.clone(), Arc::new(ast));
         } else {
-            self.native_diagnostics
-                .insert(statement.ref_.clone(), Arc::new(r.unwrap_err()));
+            self.diagnostics
+                .insert(statement.ref_.clone(), r.unwrap_err());
         }
     }
 
     fn remove_statement(&self, statement: &StatementRef) {
         self.ast_db.remove(statement);
-        self.native_diagnostics.remove(statement);
+        self.diagnostics.remove(statement);
     }
 
     fn modify_statement(&self, change: &ChangedStatement) {

justfile

@@ -138,3 +138,8 @@ new-crate name:
 # dry-run-release *args='':
 #     knope release --dry-run {{args}}
 
+clear-branches:
+    git branch --merged | egrep -v "(^\\*|main)" | xargs git branch -d
+
+reset-git:
+    git checkout main && git pull && pnpm run clear-branches