refactor: type replacement tracker supports shortening ranges

crates/pgt_hover/src/lib.rs

@@ -48,7 +48,7 @@ pub fn on_hover(params: OnHoverParams) -> Vec<String> {
                     .map(Hoverable::from)
                     .collect(),
 
-                hovered_node::NodeIdentification::SchemaAndTableAndName(_) => vec![],
+                _ => vec![],
             },
 
             HoveredNode::Column(node_identification) => match node_identification {
@@ -74,7 +74,7 @@ pub fn on_hover(params: OnHoverParams) -> Vec<String> {
                         .collect()
                 }
 
-                hovered_node::NodeIdentification::SchemaAndTableAndName(_) => vec![],
+                _ => vec![],
             },
 
             HoveredNode::Function(node_identification) => match node_identification {
@@ -92,7 +92,7 @@ pub fn on_hover(params: OnHoverParams) -> Vec<String> {
                     .map(Hoverable::from)
                     .collect(),
 
-                hovered_node::NodeIdentification::SchemaAndTableAndName(_) => vec![],
+                _ => vec![],
             },
 
             HoveredNode::Role(node_identification) => match node_identification {
@@ -103,8 +103,7 @@ pub fn on_hover(params: OnHoverParams) -> Vec<String> {
                     .map(Hoverable::from)
                     .collect(),
 
-                hovered_node::NodeIdentification::SchemaAndName(_) => vec![],
-                hovered_node::NodeIdentification::SchemaAndTableAndName(_) => vec![],
+                _ => vec![],
             },
 
             HoveredNode::Schema(node_identification) => match node_identification {

crates/pgt_text_size/src/size.rs

@@ -109,6 +109,13 @@ impl TryFrom<usize> for TextSize {
     }
 }
 
+impl From<TextSize> for isize {
+    #[inline]
+    fn from(value: TextSize) -> Self {
+        value.raw as isize
+    }
+}
+
 impl From<TextSize> for usize {
     #[inline]
     fn from(value: TextSize) -> Self {

crates/pgt_typecheck/src/typed_identifier.rs

@@ -55,11 +55,6 @@ pub fn apply_identifiers<'a>(
     for (range, type_, is_array) in replacements {
         let default_value = get_formatted_default_value(type_, is_array);
 
-        let range_size = range.end - range.start;
-
-        // if the default_value is shorter than "range", fill it up with spaces
-        let default_value = format!("{:<range_size$}", default_value);
-
         text_range_replacement_builder
             .replace_range(range.clone().try_into().unwrap(), &default_value);
     }
@@ -314,7 +309,7 @@ mod tests {
         assert_eq!(
             replacement.text(),
             // the numeric parameters are filled with 0;
-            "select 0      + 0                           + 0  + 0                   + 0               + 'critical'"
+            "select 0 + 0 + 0 + 0 + 0 + 'critical'"
         );
     }
 
@@ -363,8 +358,7 @@ mod tests {
 
         assert_eq!(
             replacement.text(),
-            // two spaces at the end because mail is longer than ''
-            r#"select id from auth.users where email_change_confirm_status = '00000000-0000-0000-0000-000000000000' and email = ''  ;"#
+            r#"select id from auth.users where email_change_confirm_status = '00000000-0000-0000-0000-000000000000' and email = '';"#
         );
     }
 }

crates/pgt_typecheck/tests/diagnostics.rs

@@ -1,70 +1,108 @@
-use pgt_console::{
-    fmt::{Formatter, HTML},
-    markup,
-};
-use pgt_diagnostics::PrintDiagnostic;
-use pgt_typecheck::{TypecheckParams, check_sql};
+use pgt_console::fmt::{Formatter, HTML};
+use pgt_diagnostics::Diagnostic;
+use pgt_typecheck::{IdentifierType, TypecheckParams, TypedIdentifier, check_sql};
 use sqlx::{Executor, PgPool};
+use std::fmt::Write;
 
-async fn test(name: &str, query: &str, setup: Option<&str>, test_db: &PgPool) {
-    if let Some(setup) = setup {
-        test_db
-            .execute(setup)
-            .await
-            .expect("Failed to setup test database");
-    }
+struct TestSetup<'a> {
+    name: &'a str,
+    query: &'a str,
+    setup: Option<&'a str>,
+    test_db: &'a PgPool,
+    typed_identifiers: Vec<TypedIdentifier>,
+}
 
-    let mut parser = tree_sitter::Parser::new();
-    parser
-        .set_language(&pgt_treesitter_grammar::LANGUAGE.into())
-        .expect("Error loading sql language");
-
-    let schema_cache = pgt_schema_cache::SchemaCache::load(test_db)
-        .await
-        .expect("Failed to load Schema Cache");
-
-    let root = pgt_query::parse(query)
-        .unwrap()
-        .into_root()
-        .expect("Failed to parse query");
-    let tree = parser.parse(query, None).unwrap();
-
-    let conn = &test_db;
-    let result = check_sql(TypecheckParams {
-        conn,
-        sql: query,
-        ast: &root,
-        tree: &tree,
-        schema_cache: &schema_cache,
-        search_path_patterns: vec![],
-        identifiers: vec![],
-    })
-    .await;
+impl<'a> TestSetup<'a> {
+    async fn test(self) {
+        if let Some(setup) = self.setup {
+            self.test_db
+                .execute(setup)
+                .await
+                .expect("Failed to setup test selfbase");
+        }
 
-    let mut content = vec![];
-    let mut writer = HTML::new(&mut content);
+        let mut parser = tree_sitter::Parser::new();
+        parser
+            .set_language(&pgt_treesitter_grammar::LANGUAGE.into())
+            .expect("Error loading sql language");
 
-    Formatter::new(&mut writer)
-        .write_markup(markup! {
-            {PrintDiagnostic::simple(&result.unwrap().unwrap())}
+        let schema_cache = pgt_schema_cache::SchemaCache::load(&self.test_db)
+            .await
+            .expect("Failed to load Schema Cache");
+
+        let root = pgt_query::parse(self.query)
+            .unwrap()
+            .into_root()
+            .expect("Failed to parse query");
+        let tree = parser.parse(self.query, None).unwrap();
+
+        let result = check_sql(TypecheckParams {
+            conn: self.test_db,
+            sql: self.query,
+            ast: &root,
+            tree: &tree,
+            schema_cache: &schema_cache,
+            identifiers: self.typed_identifiers,
+            search_path_patterns: vec![],
         })
-        .unwrap();
+        .await;
+
+        assert!(
+            result.is_ok(),
+            "Got Typechecking error: {}",
+            result.unwrap_err()
+        );
 
-    let content = String::from_utf8(content).unwrap();
+        let maybe_diagnostic = result.unwrap();
 
-    insta::with_settings!({
-        prepend_module_to_snapshot => false,
-    }, {
-        insta::assert_snapshot!(name, content);
-    });
+        let content = match maybe_diagnostic {
+            Some(d) => {
+                let mut result = String::new();
+
+                if let Some(span) = d.location().span {
+                    for (idx, c) in self.query.char_indices() {
+                        if pgt_text_size::TextSize::new(idx.try_into().unwrap()) == span.start() {
+                            result.push_str("~~~");
+                        }
+                        if pgt_text_size::TextSize::new(idx.try_into().unwrap()) == span.end() {
+                            result.push_str("~~~");
+                        }
+                        result.push(c);
+                    }
+                } else {
+                    result.push_str(self.query);
+                }
+
+                writeln!(&mut result).unwrap();
+                writeln!(&mut result).unwrap();
+
+                let mut msg_content = vec![];
+                let mut writer = HTML::new(&mut msg_content);
+                let mut formatter = Formatter::new(&mut writer);
+                d.message(&mut formatter).unwrap();
+
+                result.push_str(String::from_utf8(msg_content).unwrap().as_str());
+
+                result
+            }
+            None => String::from("No Diagnostic"),
+        };
+
+        insta::with_settings!({
+            prepend_module_to_snapshot => false,
+        }, {
+            insta::assert_snapshot!(self.name, content);
+
+        });
+    }
 }
 
 #[sqlx::test(migrator = "pgt_test_utils::MIGRATIONS")]
-async fn invalid_column(pool: PgPool) {
-    test(
-        "invalid_column",
-        "select id, unknown from contacts;",
-        Some(
+async fn invalid_column(test_db: PgPool) {
+    TestSetup {
+        name: "invalid_column",
+        query: "select id, unknown from contacts;",
+        setup: Some(
             r#"
         create table public.contacts (
             id serial primary key,
@@ -74,7 +112,66 @@ async fn invalid_column(pool: PgPool) {
         );
     "#,
         ),
-        &pool,
-    )
+        test_db: &test_db,
+        typed_identifiers: vec![],
+    }
+    .test()
+    .await;
+}
+
+#[sqlx::test(migrator = "pgt_test_utils::MIGRATIONS")]
+async fn invalid_type_in_function(test_db: PgPool) {
+    // create or replace function clean_up(uid uuid)
+    // returns void
+    // language sql
+    // as $$
+    //     delete from public.contacts where id = uid;
+    // $$;
+
+    let setup = r#"
+        create table public.contacts (
+            id serial primary key,
+            name text not null,
+            is_vegetarian bool default false,
+            middle_name varchar(255)
+        );
+    "#;
+
+    /* NOTE: The replaced type default value is *longer* than the param name. */
+    TestSetup {
+        name: "invalid_type_in_function_longer_default",
+        setup: Some(setup),
+        query: r#"delete from public.contacts where id = uid;"#,
+        test_db: &test_db,
+        typed_identifiers: vec![TypedIdentifier {
+            path: "clean_up".to_string(),
+            name: Some("uid".to_string()),
+            type_: IdentifierType {
+                schema: None,
+                name: "uuid".to_string(),
+                is_array: false,
+            },
+        }],
+    }
+    .test()
+    .await;
+
+    /* NOTE: The replaced type default value is *longer* than the param name. */
+    TestSetup {
+        name: "invalid_type_in_function_shorter_default",
+        setup: None,
+        query: r#"delete from public.contacts where id = contact_name;"#,
+        test_db: &test_db,
+        typed_identifiers: vec![TypedIdentifier {
+            path: "clean_up".to_string(),
+            name: Some("contact_name".to_string()),
+            type_: IdentifierType {
+                schema: None,
+                name: "text".to_string(),
+                is_array: false,
+            },
+        }],
+    }
+    .test()
     .await;
 }

crates/pgt_typecheck/tests/snapshots/invalid_column.snap

@@ -1,10 +1,7 @@
 ---
 source: crates/pgt_typecheck/tests/diagnostics.rs
-expression: normalized
-snapshot_kind: text
+expression: content
 ---
-typecheck ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+select id, ~~~unknown~~~ from contacts;
 
-  <strong><span style="color: Tomato;">✖</span></strong> <span style="color: Tomato;">column &quot;unknown&quot; does not exist</span>
-
-  <strong><span style="color: Tomato;">✖</span></strong> <span style="color: Tomato;">Error Code: </span><span style="color: Tomato;"><strong>42703</strong></span>
+column &quot;unknown&quot; does not exist

crates/pgt_typecheck/tests/snapshots/invalid_type_in_function_longer_default.snap

@@ -0,0 +1,7 @@
+---
+source: crates/pgt_typecheck/tests/diagnostics.rs
+expression: content
+---
+delete from public.contacts where id = ~~~uid~~~;
+
+invalid input syntax for type integer: "00000000-0000-0000-0000-000000000000"

crates/pgt_typecheck/tests/snapshots/invalid_type_in_function_shorter_default.snap

@@ -0,0 +1,7 @@
+---
+source: crates/pgt_typecheck/tests/diagnostics.rs
+expression: content
+---
+delete from public.contacts where id = ~~~contact_name~~~;
+
+invalid input syntax for type integer: ""