kewl

crates/pgt_typecheck/src/diagnostics.rs

@@ -2,9 +2,11 @@ use std::io;
 
 use pgt_console::markup;
 use pgt_diagnostics::{Advices, Diagnostic, LogCategory, MessageAndDescription, Severity, Visit};
-use pgt_text_size::{TextRange, TextRangeReplacement, TextSize};
+use pgt_text_size::{TextRange, TextSize};
 use sqlx::postgres::{PgDatabaseError, PgSeverity};
 
+use crate::{IdentifierType, TypedReplacement};
+
 /// A specialized diagnostic for the typechecker.
 ///
 /// Type diagnostics are always **errors**.
@@ -94,18 +96,50 @@ impl Advices for TypecheckAdvices {
  }
 }
 
+/// Finds the original type at the given position in the adjusted text
+fn find_type_at_position(
+ adjusted_position: TextSize,
+ type_info: &[(TextRange, IdentifierType)],
+) -> Option<&IdentifierType> {
+ type_info
+ .iter()
+ .find(|(range, _)| range.contains(adjusted_position))
+ .map(|(_, type_)| type_)
+}
+
+/// Rewrites error messages to show the original type name instead of the replaced literal value
+fn rewrite_error_message(original_message: &str, identifier_type: &IdentifierType) -> String {
+ // pattern: invalid input syntax for type X: "literal_value"
+ // we want to replace "literal_value" with the type name
+
+ if let Some(colon_pos) = original_message.rfind(": ") {
+ let before_value = &original_message[..colon_pos];
+
+ // build the type name, including schema if present
+ let type_name = if let Some(schema) = &identifier_type.schema {
+ format!("{}.{}", schema, identifier_type.name)
+ } else {
+ identifier_type.name.clone()
+ };
+
+ format!("{}: {}", before_value, type_name)
+ } else {
+ original_message.to_string()
+ }
+}
+
 pub(crate) fn create_type_error(
  pg_err: &PgDatabaseError,
  ts: &tree_sitter::Tree,
- txt_replacement: TextRangeReplacement,
+ typed_replacement: TypedReplacement,
 ) -> TypecheckDiagnostic {
  let position = pg_err.position().and_then(|pos| match pos {
  sqlx::postgres::PgErrorPosition::Original(pos) => Some(pos - 1),
  _ => None,
  });
 
  let range = position.and_then(|pos| {
- let adjusted = txt_replacement.to_original_position(TextSize::new(pos.try_into().unwrap()));
+ let adjusted = typed_replacement.replacement.to_original_position(TextSize::new(pos.try_into().unwrap()));
 
  ts.root_node()
  .named_descendant_for_byte_range(adjusted.into(), adjusted.into())
@@ -128,8 +162,20 @@ pub(crate) fn create_type_error(
  PgSeverity::Log => Severity::Information,
  };
 
+ // check if the error position corresponds to a replaced parameter
+ let message = if let Some(pos) = position {
+ let adjusted_pos = TextSize::new(pos.try_into().unwrap());
+ if let Some(original_type) = find_type_at_position(adjusted_pos, &typed_replacement.type_info) {
+ rewrite_error_message(pg_err.message(), original_type)
+ } else {
+ pg_err.to_string()
+ }
+ } else {
+ pg_err.to_string()
+ };
+
  TypecheckDiagnostic {
- message: pg_err.to_string().into(),
+ message: message.into(),
  severity,
  span: range,
  advices: TypecheckAdvices {

crates/pgt_typecheck/src/lib.rs

@@ -10,7 +10,7 @@ use sqlx::postgres::PgDatabaseError;
 pub use sqlx::postgres::PgSeverity;
 use sqlx::{Executor, PgPool};
 use typed_identifier::apply_identifiers;
-pub use typed_identifier::{IdentifierType, TypedIdentifier};
+pub use typed_identifier::{IdentifierType, TypedIdentifier, TypedReplacement};
 
 #[derive(Debug)]
 pub struct TypecheckParams<'a> {
@@ -48,7 +48,7 @@ pub async fn check_sql(
  // each typecheck operation.
  conn.close_on_drop();
 
- let replacement = apply_identifiers(
+ let typed_replacement = apply_identifiers(
  params.identifiers,
  params.schema_cache,
  params.tree,
@@ -68,13 +68,13 @@ pub async fn check_sql(
  conn.execute(&*search_path_query).await?;
  }
 
- let res = conn.prepare(replacement.text()).await;
+ let res = conn.prepare(typed_replacement.replacement.text()).await;
 
  match res {
  Ok(_) => Ok(None),
  Err(sqlx::Error::Database(err)) => {
  let pg_err = err.downcast_ref::<PgDatabaseError>();
- Ok(Some(create_type_error(pg_err, params.tree, replacement)))
+ Ok(Some(create_type_error(pg_err, params.tree, typed_replacement)))
  }
  Err(err) => Err(err),
  }

crates/pgt_typecheck/src/typed_identifier.rs

@@ -1,5 +1,5 @@
 use pgt_schema_cache::PostgresType;
-use pgt_text_size::{TextRangeReplacement, TextRangeReplacementBuilder};
+use pgt_text_size::{TextRange, TextRangeReplacement, TextRangeReplacementBuilder};
 use pgt_treesitter::queries::{ParameterMatch, TreeSitterQueriesExecutor};
 
 /// It is used to replace parameters within the SQL string.
@@ -21,13 +21,20 @@ pub struct IdentifierType {
  pub is_array: bool,
 }
 
+/// Contains the text replacement along with metadata about which ranges correspond to which types.
+#[derive(Debug)]
+pub struct TypedReplacement {
+ pub replacement: TextRangeReplacement,
+ pub type_info: Vec<(TextRange, IdentifierType)>,
+}
+
 /// Applies the identifiers to the SQL string by replacing them with their default values.
 pub fn apply_identifiers<'a>(
  identifiers: Vec<TypedIdentifier>,
  schema_cache: &'a pgt_schema_cache::SchemaCache,
  cst: &'a tree_sitter::Tree,
  sql: &'a str,
-) -> TextRangeReplacement {
+) -> TypedReplacement {
  let mut executor = TreeSitterQueriesExecutor::new(cst.root_node(), sql);
 
  executor.add_query_results::<ParameterMatch>();
@@ -46,20 +53,26 @@ pub fn apply_identifiers<'a>(
  // Resolve the type based on whether we're accessing a field of a composite type
  let type_ = resolve_type(identifier, position, &parts, schema_cache)?;
 
- Some((m.get_byte_range(), type_, identifier.type_.is_array))
+ Some((m.get_byte_range(), type_, identifier.type_.clone()))
  })
  .collect();
 
  let mut text_range_replacement_builder = TextRangeReplacementBuilder::new(sql);
+ let mut type_info = vec![];
 
- for (range, type_, is_array) in replacements {
- let default_value = get_formatted_default_value(type_, is_array);
+ for (range, type_, original_type) in replacements {
+ let default_value = get_formatted_default_value(type_, original_type.is_array);
 
  text_range_replacement_builder
  .replace_range(range.clone().try_into().unwrap(), &default_value);
+
+ type_info.push((range.try_into().unwrap(), original_type));
  }
 
- text_range_replacement_builder.build()
+ TypedReplacement {
+ replacement: text_range_replacement_builder.build(),
+ type_info,
+ }
 }
 
 /// Format the default value based on the type and whether it's an array
@@ -307,7 +320,7 @@ mod tests {
  let replacement = super::apply_identifiers(identifiers, &schema_cache, &tree, input);
 
  assert_eq!(
- replacement.text(),
+ replacement.replacement.text(),
  // the numeric parameters are filled with 0;
  "select 0 + 0 + 0 + 0 + 0 + 'critical'"
  );
@@ -357,7 +370,7 @@ mod tests {
  let replacement = super::apply_identifiers(identifiers, &schema_cache, &tree, input);
 
  assert_eq!(
- replacement.text(),
+ replacement.replacement.text(),
  r#"select id from auth.users where email_change_confirm_status = '00000000-0000-0000-0000-000000000000' and email = '';"#
  );
  }

crates/pgt_typecheck/tests/snapshots/invalid_type_in_function_longer_default.snap

@@ -4,4 +4,4 @@ expression: content
 ---
 delete from public.contacts where id = ~~~uid~~~;
 
-invalid input syntax for type integer: "00000000-0000-0000-0000-000000000000"
+invalid input syntax for type integer: uuid

crates/pgt_typecheck/tests/snapshots/invalid_type_in_function_shorter_default.snap

@@ -4,4 +4,4 @@ expression: content
 ---
 delete from public.contacts where id = ~~~contact_name~~~;
 
-invalid input syntax for type integer: ""
+invalid input syntax for type integer: text