feat: hover on types (#557)

Author: juleswritescode

crates/pgt_completions/src/relevance/filtering.rs

@@ -163,7 +163,7 @@ impl CompletionFilter<'_> {
  // only autocomplete left side of binary expression
  WrappingClause::Where => {
  ctx.before_cursor_matches_kind(&["keyword_and", "keyword_where"])
- || (ctx.before_cursor_matches_kind(&["."])
+ || (ctx.before_cursor_matches_kind(&["field_qualifier"])
  && ctx.matches_ancestor_history(&["field"]))
  }
 

crates/pgt_hover/src/hoverables/column.rs

@@ -1,20 +1,28 @@
 use std::fmt::Write;
 
-use pgt_schema_cache::Column;
+use pgt_schema_cache::{Column, SchemaCache};
 use pgt_treesitter::TreesitterContext;
 
 use crate::{contextual_priority::ContextualPriority, to_markdown::ToHoverMarkdown};
 
 impl ToHoverMarkdown for pgt_schema_cache::Column {
- fn hover_headline<W: Write>(&self, writer: &mut W) -> Result<(), std::fmt::Error> {
+ fn hover_headline<W: Write>(
+ &self,
+ writer: &mut W,
+ _schema_cache: &SchemaCache,
+ ) -> Result<(), std::fmt::Error> {
  write!(
  writer,
  "`{}.{}.{}`",
  self.schema_name, self.table_name, self.name
  )
  }
 
- fn hover_body<W: Write>(&self, writer: &mut W) -> Result<bool, std::fmt::Error> {
+ fn hover_body<W: Write>(
+ &self,
+ writer: &mut W,
+ _schema_cache: &SchemaCache,
+ ) -> Result<bool, std::fmt::Error> {
  if let Some(comment) = &self.comment {
  write!(writer, "Comment: '{}'", comment)?;
  writeln!(writer)?;
@@ -46,7 +54,11 @@ impl ToHoverMarkdown for pgt_schema_cache::Column {
  Ok(true)
  }
 
- fn hover_footer<W: Write>(&self, writer: &mut W) -> Result<bool, std::fmt::Error> {
+ fn hover_footer<W: Write>(
+ &self,
+ writer: &mut W,
+ _schema_cache: &SchemaCache,
+ ) -> Result<bool, std::fmt::Error> {
  if let Some(default) = &self.default_expr {
  writeln!(writer)?;
  write!(writer, "Default: {}", default)?;

crates/pgt_hover/src/hoverables/function.rs

@@ -1,6 +1,6 @@
 use std::fmt::Write;
 
-use pgt_schema_cache::Function;
+use pgt_schema_cache::{Function, SchemaCache};
 use pgt_treesitter::TreesitterContext;
 
 use crate::{contextual_priority::ContextualPriority, to_markdown::ToHoverMarkdown};
@@ -10,7 +10,11 @@ impl ToHoverMarkdown for Function {
  "sql"
  }
 
- fn hover_headline<W: Write>(&self, writer: &mut W) -> Result<(), std::fmt::Error> {
+ fn hover_headline<W: Write>(
+ &self,
+ writer: &mut W,
+ _schema_cache: &SchemaCache,
+ ) -> Result<(), std::fmt::Error> {
  write!(writer, "`{}.{}", self.schema, self.name)?;
 
  if let Some(args) = &self.argument_types {
@@ -28,7 +32,11 @@ impl ToHoverMarkdown for Function {
  Ok(())
  }
 
- fn hover_body<W: Write>(&self, writer: &mut W) -> Result<bool, std::fmt::Error> {
+ fn hover_body<W: Write>(
+ &self,
+ writer: &mut W,
+ _schema_cache: &SchemaCache,
+ ) -> Result<bool, std::fmt::Error> {
  let kind_text = match self.kind {
  pgt_schema_cache::ProcKind::Function => "Function",
  pgt_schema_cache::ProcKind::Procedure => "Procedure",
@@ -55,7 +63,11 @@ impl ToHoverMarkdown for Function {
  Ok(true)
  }
 
- fn hover_footer<W: Write>(&self, writer: &mut W) -> Result<bool, std::fmt::Error> {
+ fn hover_footer<W: Write>(
+ &self,
+ writer: &mut W,
+ _schema_cache: &SchemaCache,
+ ) -> Result<bool, std::fmt::Error> {
  if let Some(def) = self.definition.as_ref() {
  /*
  * We don't want to show 250 lines of functions to the user.

crates/pgt_hover/src/hoverables/mod.rs

@@ -1,7 +1,10 @@
+use pgt_schema_cache::SchemaCache;
+
 use crate::{contextual_priority::ContextualPriority, to_markdown::ToHoverMarkdown};
 
 mod column;
 mod function;
+mod postgres_type;
 mod role;
 mod schema;
 mod table;
@@ -16,6 +19,7 @@ pub enum Hoverable<'a> {
  Function(&'a pgt_schema_cache::Function),
  Role(&'a pgt_schema_cache::Role),
  Schema(&'a pgt_schema_cache::Schema),
+ PostgresType(&'a pgt_schema_cache::PostgresType),
 }
 
 impl<'a> From<&'a pgt_schema_cache::Schema> for Hoverable<'a> {
@@ -48,6 +52,12 @@ impl<'a> From<&'a pgt_schema_cache::Role> for Hoverable<'a> {
  }
 }
 
+impl<'a> From<&'a pgt_schema_cache::PostgresType> for Hoverable<'a> {
+ fn from(value: &'a pgt_schema_cache::PostgresType) -> Self {
+ Hoverable::PostgresType(value)
+ }
+}
+
 impl ContextualPriority for Hoverable<'_> {
  fn relevance_score(&self, ctx: &pgt_treesitter::TreesitterContext) -> f32 {
  match self {
@@ -56,38 +66,76 @@ impl ContextualPriority for Hoverable<'_> {
  Hoverable::Function(function) => function.relevance_score(ctx),
  Hoverable::Role(role) => role.relevance_score(ctx),
  Hoverable::Schema(schema) => schema.relevance_score(ctx),
+ Hoverable::PostgresType(type_) => type_.relevance_score(ctx),
  }
  }
 }
 
 impl ToHoverMarkdown for Hoverable<'_> {
- fn hover_headline<W: std::fmt::Write>(&self, writer: &mut W) -> Result<(), std::fmt::Error> {
+ fn hover_headline<W: std::fmt::Write>(
+ &self,
+ writer: &mut W,
+ schema_cache: &SchemaCache,
+ ) -> Result<(), std::fmt::Error> {
  match self {
- Hoverable::Table(table) => ToHoverMarkdown::hover_headline(*table, writer),
- Hoverable::Column(column) => ToHoverMarkdown::hover_headline(*column, writer),
- Hoverable::Function(function) => ToHoverMarkdown::hover_headline(*function, writer),
- Hoverable::Role(role) => ToHoverMarkdown::hover_headline(*role, writer),
- Hoverable::Schema(schema) => ToHoverMarkdown::hover_headline(*schema, writer),
+ Hoverable::Table(table) => {
+ ToHoverMarkdown::hover_headline(*table, writer, schema_cache)
+ }
+ Hoverable::Column(column) => {
+ ToHoverMarkdown::hover_headline(*column, writer, schema_cache)
+ }
+ Hoverable::Function(function) => {
+ ToHoverMarkdown::hover_headline(*function, writer, schema_cache)
+ }
+ Hoverable::Role(role) => ToHoverMarkdown::hover_headline(*role, writer, schema_cache),
+ Hoverable::Schema(schema) => {
+ ToHoverMarkdown::hover_headline(*schema, writer, schema_cache)
+ }
+ Hoverable::PostgresType(type_) => {
+ ToHoverMarkdown::hover_headline(*type_, writer, schema_cache)
+ }
  }
  }
 
- fn hover_body<W: std::fmt::Write>(&self, writer: &mut W) -> Result<bool, std::fmt::Error> {
+ fn hover_body<W: std::fmt::Write>(
+ &self,
+ writer: &mut W,
+ schema_cache: &SchemaCache,
+ ) -> Result<bool, std::fmt::Error> {
  match self {
- Hoverable::Table(table) => ToHoverMarkdown::hover_body(*table, writer),
- Hoverable::Column(column) => ToHoverMarkdown::hover_body(*column, writer),
- Hoverable::Function(function) => ToHoverMarkdown::hover_body(*function, writer),
- Hoverable::Role(role) => ToHoverMarkdown::hover_body(*role, writer),
- Hoverable::Schema(schema) => ToHoverMarkdown::hover_body(*schema, writer),
+ Hoverable::Table(table) => ToHoverMarkdown::hover_body(*table, writer, schema_cache),
+ Hoverable::Column(column) => ToHoverMarkdown::hover_body(*column, writer, schema_cache),
+ Hoverable::Function(function) => {
+ ToHoverMarkdown::hover_body(*function, writer, schema_cache)
+ }
+ Hoverable::Role(role) => ToHoverMarkdown::hover_body(*role, writer, schema_cache),
+ Hoverable::Schema(schema) => ToHoverMarkdown::hover_body(*schema, writer, schema_cache),
+ Hoverable::PostgresType(type_) => {
+ ToHoverMarkdown::hover_body(*type_, writer, schema_cache)
+ }
  }
  }
 
- fn hover_footer<W: std::fmt::Write>(&self, writer: &mut W) -> Result<bool, std::fmt::Error> {
+ fn hover_footer<W: std::fmt::Write>(
+ &self,
+ writer: &mut W,
+ schema_cache: &SchemaCache,
+ ) -> Result<bool, std::fmt::Error> {
  match self {
- Hoverable::Table(table) => ToHoverMarkdown::hover_footer(*table, writer),
- Hoverable::Column(column) => ToHoverMarkdown::hover_footer(*column, writer),
- Hoverable::Function(function) => ToHoverMarkdown::hover_footer(*function, writer),
- Hoverable::Role(role) => ToHoverMarkdown::hover_footer(*role, writer),
- Hoverable::Schema(schema) => ToHoverMarkdown::hover_footer(*schema, writer),
+ Hoverable::Table(table) => ToHoverMarkdown::hover_footer(*table, writer, schema_cache),
+ Hoverable::Column(column) => {
+ ToHoverMarkdown::hover_footer(*column, writer, schema_cache)
+ }
+ Hoverable::Function(function) => {
+ ToHoverMarkdown::hover_footer(*function, writer, schema_cache)
+ }
+ Hoverable::Role(role) => ToHoverMarkdown::hover_footer(*role, writer, schema_cache),
+ Hoverable::Schema(schema) => {
+ ToHoverMarkdown::hover_footer(*schema, writer, schema_cache)
+ }
+ Hoverable::PostgresType(type_) => {
+ ToHoverMarkdown::hover_footer(*type_, writer, schema_cache)
+ }
  }
  }
 
@@ -98,6 +146,7 @@ impl ToHoverMarkdown for Hoverable<'_> {
  Hoverable::Function(function) => function.body_markdown_type(),
  Hoverable::Role(role) => role.body_markdown_type(),
  Hoverable::Schema(schema) => schema.body_markdown_type(),
+ Hoverable::PostgresType(type_) => type_.body_markdown_type(),
  }
  }
 
@@ -108,6 +157,7 @@ impl ToHoverMarkdown for Hoverable<'_> {
  Hoverable::Function(function) => function.footer_markdown_type(),
  Hoverable::Role(role) => role.footer_markdown_type(),
  Hoverable::Schema(schema) => schema.footer_markdown_type(),
+ Hoverable::PostgresType(type_) => type_.footer_markdown_type(),
  }
  }
 }

crates/pgt_hover/src/hoverables/postgres_type.rs

@@ -0,0 +1,101 @@
+use std::fmt::Write;
+
+use pgt_schema_cache::{PostgresType, SchemaCache};
+use pgt_treesitter::TreesitterContext;
+
+use crate::{contextual_priority::ContextualPriority, to_markdown::ToHoverMarkdown};
+
+impl ToHoverMarkdown for PostgresType {
+ fn hover_headline<W: Write>(
+ &self,
+ writer: &mut W,
+ _schema_cache: &SchemaCache,
+ ) -> Result<(), std::fmt::Error> {
+ write!(writer, "`{}.{}` (Custom Type)", self.schema, self.name)?;
+ Ok(())
+ }
+
+ fn hover_body<W: Write>(
+ &self,
+ writer: &mut W,
+ schema_cache: &SchemaCache,
+ ) -> Result<bool, std::fmt::Error> {
+ if let Some(comment) = &self.comment {
+ write!(writer, "Comment: '{}'", comment)?;
+ writeln!(writer)?;
+ writeln!(writer)?;
+ }
+
+ if !self.attributes.attrs.is_empty() {
+ write!(writer, "Attributes:")?;
+ writeln!(writer)?;
+
+ for attribute in &self.attributes.attrs {
+ write!(writer, "- {}", attribute.name)?;
+
+ if let Some(type_info) = schema_cache.find_type_by_id(attribute.type_id) {
+ write!(writer, ": ")?;
+
+ if type_info.schema != "pg_catalog" {
+ write!(writer, "{}.", type_info.schema)?;
+ }
+
+ write!(writer, "{}", type_info.name)?;
+ } else {
+ write!(writer, " (type_id: {})", attribute.type_id)?;
+ }
+
+ writeln!(writer)?;
+ }
+
+ writeln!(writer)?;
+ }
+
+ if !self.enums.values.is_empty() {
+ write!(writer, "Enum Permutations:")?;
+ writeln!(writer)?;
+
+ for kind in &self.enums.values {
+ write!(writer, "- {}", kind)?;
+ writeln!(writer)?;
+ }
+
+ writeln!(writer)?;
+ }
+
+ Ok(true)
+ }
+
+ fn hover_footer<W: Write>(
+ &self,
+ writer: &mut W,
+ _schema_cache: &SchemaCache,
+ ) -> Result<bool, std::fmt::Error> {
+ writeln!(writer)?;
+ Ok(true)
+ }
+}
+
+impl ContextualPriority for PostgresType {
+ // there are no schemas with duplicate names.
+ fn relevance_score(&self, ctx: &TreesitterContext) -> f32 {
+ let mut score = 0.0;
+
+ if ctx
+ .get_mentioned_relations(&Some(self.schema.clone()))
+ .is_some()
+ {
+ score += 100.0;
+ }
+
+ if ctx.get_mentioned_relations(&None).is_some() && self.schema == "public" {
+ score += 100.0;
+ }
+
+ if self.schema == "public" && score == 0.0 {
+ score += 10.0;
+ }
+
+ score
+ }
+}

crates/pgt_hover/src/hoverables/role.rs

@@ -1,18 +1,26 @@
 use std::fmt::Write;
 
-use pgt_schema_cache::Role;
+use pgt_schema_cache::{Role, SchemaCache};
 use pgt_treesitter::TreesitterContext;
 
 use crate::{contextual_priority::ContextualPriority, to_markdown::ToHoverMarkdown};
 
 impl ToHoverMarkdown for pgt_schema_cache::Role {
- fn hover_headline<W: Write>(&self, writer: &mut W) -> Result<(), std::fmt::Error> {
+ fn hover_headline<W: Write>(
+ &self,
+ writer: &mut W,
+ _schema_cache: &SchemaCache,
+ ) -> Result<(), std::fmt::Error> {
  write!(writer, "`{}`", self.name)?;
 
  Ok(())
  }
 
- fn hover_body<W: Write>(&self, writer: &mut W) -> Result<bool, std::fmt::Error> {
+ fn hover_body<W: Write>(
+ &self,
+ writer: &mut W,
+ _schema_cache: &SchemaCache,
+ ) -> Result<bool, std::fmt::Error> {
  if let Some(comm) = self.comment.as_ref() {
  write!(writer, "Comment: '{}'", comm)?;
  writeln!(writer)?;
@@ -81,7 +89,11 @@ impl ToHoverMarkdown for pgt_schema_cache::Role {
  Ok(true)
  }
 
- fn hover_footer<W: Write>(&self, _writer: &mut W) -> Result<bool, std::fmt::Error> {
+ fn hover_footer<W: Write>(
+ &self,
+ _writer: &mut W,
+ _schema_cache: &SchemaCache,
+ ) -> Result<bool, std::fmt::Error> {
  Ok(false)
  }
 }