progress

Author: psteinroe

crates/pgt_plpgsql_check/src/diagnostics.rs

@@ -137,7 +137,15 @@ pub fn create_diagnostics_from_check_result(
 }
 
 fn resolve_span(issue: &PlpgSqlCheckIssue, fn_body: &str, offset: usize) -> Option<TextRange> {
-    let stmt = issue.statement.as_ref()?;
+    let stmt = match issue.statement.as_ref() {
+        Some(s) => s,
+        None => {
+            return Some(TextRange::new(
+                (offset as u32).into(),
+                ((offset + fn_body.len()) as u32).into(),
+            ));
+        }
+    };
 
     let line_number = stmt
         .line_number

crates/pgt_workspace/src/workspace/server.rs

@@ -511,6 +511,8 @@ impl Workspace for WorkspaceServer {
                                 .await
                                 .unwrap_or_else(|_| vec![]);
 
+                                println!("{:#?}", plpgsql_check_results);
+
                                 for d in plpgsql_check_results {
                                     let r = d.span.map(|span| span + range.start());
                                     diagnostics.push(
@@ -571,6 +573,8 @@ impl Workspace for WorkspaceServer {
                 analysable_stmts.push(node);
             }
             if let Some(diag) = diagnostic {
+                println!("{:?}", diag);
+                println!("{:?}", diagnostics);
                 // ignore the syntax error if we already have more specialized diagnostics for the
                 // same statement.
                 // this is important for create function statements, where we might already have detailed
@@ -579,7 +583,7 @@ impl Workspace for WorkspaceServer {
                     d.location().span.is_some_and(|async_loc| {
                         diag.location()
                             .span
-                            .is_some_and(|syntax_loc| syntax_loc.contains(async_loc))
+                            .is_some_and(|syntax_loc| syntax_loc.contains_range(async_loc))
                     })
                 }) {
                     continue;

crates/pgt_workspace/src/workspace/server.tests.rs

@@ -8,7 +8,7 @@ use pgt_configuration::{
 use pgt_diagnostics::Diagnostic;
 use pgt_fs::PgTPath;
 use pgt_text_size::TextRange;
-use sqlx::PgPool;
+use sqlx::{Executor, PgPool};
 
 use crate::{
     Workspace, WorkspaceError,
@@ -206,3 +206,73 @@ async fn correctly_ignores_files() {
 
     assert!(execute_statement_result.is_ok_and(|res| res == ExecuteStatementResult::default()));
 }
+
+#[sqlx::test(migrator = "pgt_test_utils::MIGRATIONS")]
+async fn test_dedupe_diagnostics(test_db: PgPool) {
+    let mut conf = PartialConfiguration::init();
+    conf.merge_with(PartialConfiguration {
+        db: Some(PartialDatabaseConfiguration {
+            database: Some(
+                test_db
+                    .connect_options()
+                    .get_database()
+                    .unwrap()
+                    .to_string(),
+            ),
+            ..Default::default()
+        }),
+        ..Default::default()
+    });
+
+    let workspace = get_test_workspace(Some(conf)).expect("Unable to create test workspace");
+
+    let path = PgTPath::new("test.sql");
+
+    let setup_sql = "CREATE EXTENSION IF NOT EXISTS plpgsql_check;";
+    test_db.execute(setup_sql).await.expect("setup sql failed");
+
+    let content = r#"
+        CREATE OR REPLACE FUNCTION public.f1()
+        RETURNS void
+        LANGUAGE plpgsql
+        AS $function$
+        decare r text;
+        BEGIN
+            select '1' into into r;
+        END;
+        $function$;
+    "#;
+
+    workspace
+        .open_file(OpenFileParams {
+            path: path.clone(),
+            content: content.into(),
+            version: 1,
+        })
+        .expect("Unable to open test file");
+
+    let diagnostics = workspace
+        .pull_diagnostics(crate::workspace::PullDiagnosticsParams {
+            path: path.clone(),
+            categories: RuleCategories::all(),
+            max_diagnostics: 100,
+            only: vec![],
+            skip: vec![],
+        })
+        .expect("Unable to pull diagnostics")
+        .diagnostics;
+
+    assert_eq!(diagnostics.len(), 1, "Expected one diagnostic");
+
+    let diagnostic = &diagnostics[0];
+
+    assert_eq!(
+        diagnostic.category().map(|c| c.name()),
+        Some("plpgsql_check")
+    );
+
+    assert_eq!(
+        diagnostic.location().span,
+        Some(TextRange::new(115.into(), 210.into()))
+    );
+}