[3] refactor: remove custom NodeUnderCursor

crates/pgt_completions/src/relevance/filtering.rs

@@ -1,5 +1,5 @@
 use pgt_schema_cache::ProcKind;
-use pgt_treesitter::context::{NodeUnderCursor, TreesitterContext, WrappingClause, WrappingNode};
+use pgt_treesitter::context::{TreesitterContext, WrappingClause, WrappingNode};
 
 use super::CompletionRelevanceData;
 
@@ -17,7 +17,11 @@ impl<'a> From<CompletionRelevanceData<'a>> for CompletionFilter<'a> {
 impl CompletionFilter<'_> {
     pub fn is_relevant(&self, ctx: &TreesitterContext) -> Option<()> {
         self.completable_context(ctx)?;
-        self.check_clause(ctx)?;
+
+        self.check_node_type(ctx)
+            // we want to rely on treesitter more, so checking the clause is a fallback
+            .or_else(|| self.check_clause(ctx))?;
+
         self.check_invocation(ctx)?;
         self.check_mentioned_schema_or_alias(ctx)?;
 
@@ -67,30 +71,42 @@ impl CompletionFilter<'_> {
         }
 
         // No autocompletions if there are two identifiers without a separator.
-        if ctx.node_under_cursor.as_ref().is_some_and(|n| match n {
-            NodeUnderCursor::TsNode(node) => node.prev_sibling().is_some_and(|p| {
-                (p.kind() == "identifier" || p.kind() == "object_reference")
-                    && n.kind() == "identifier"
-            }),
-            NodeUnderCursor::CustomNode { .. } => false,
+        if ctx.node_under_cursor.as_ref().is_some_and(|node| {
+            node.prev_sibling().is_some_and(|p| {
+                (p.kind() == "any_identifier" || p.kind() == "object_reference")
+                    && node.kind() == "any_identifier"
+            })
         }) {
             return None;
         }
 
         // no completions if we're right after an asterisk:
         // `select * {}`
-        if ctx.node_under_cursor.as_ref().is_some_and(|n| match n {
-            NodeUnderCursor::TsNode(node) => node
-                .prev_sibling()
-                .is_some_and(|p| (p.kind() == "all_fields") && n.kind() == "identifier"),
-            NodeUnderCursor::CustomNode { .. } => false,
+        if ctx.node_under_cursor.as_ref().is_some_and(|node| {
+            node.prev_sibling()
+                .is_some_and(|p| (p.kind() == "all_fields") && node.kind() == "any_identifier")
         }) {
             return None;
         }
 
         Some(())
     }
 
+    fn check_node_type(&self, ctx: &TreesitterContext) -> Option<()> {
+        let kind = ctx.node_under_cursor.as_ref().map(|n| n.kind())?;
+
+        let is_allowed = match kind {
+            "column_identifier" => {
+                matches!(self.data, CompletionRelevanceData::Column(_))
+                    && !ctx.matches_ancestor_history(&["insert_values", "field"])
+                    && !ctx.node_under_cursor_is_within_field_name("binary_expr_right")
+            }
+            _ => false,
+        };
+
+        if is_allowed { Some(()) } else { None }
+    }
+
     fn check_clause(&self, ctx: &TreesitterContext) -> Option<()> {
         ctx.wrapping_clause_type
             .as_ref()
@@ -257,7 +273,7 @@ impl CompletionFilter<'_> {
                         WrappingClause::RevokeStatement | WrappingClause::GrantStatement => {
                             ctx.matches_ancestor_history(&["role_specification"])
                                 || ctx.node_under_cursor.as_ref().is_some_and(|k| {
-                                    k.kind() == "identifier"
+                                    k.kind() == "any_identifier"
                                         && ctx.before_cursor_matches_kind(&[
                                             "keyword_grant",
                                             "keyword_revoke",

crates/pgt_hover/src/hovered_node.rs

@@ -32,7 +32,7 @@ impl HoveredNode {
         let under_cursor = ctx.node_under_cursor.as_ref()?;
 
         match under_cursor.kind() {
-            "identifier"
+            "any_identifier"
                 if ctx.matches_ancestor_history(&["relation", "object_reference"])
                     || ctx
                         .matches_ancestor_history(&["grantable_on_table", "object_reference"]) =>
@@ -52,7 +52,7 @@ impl HoveredNode {
                 }
             }
 
-            "identifier"
+            "any_identifier"
                 if ctx.matches_ancestor_history(&["object_reference"])
                     && ctx.wrapping_clause_type.as_ref().is_some_and(|clause| {
                         matches!(
@@ -73,7 +73,7 @@ impl HoveredNode {
                 }
             }
 
-            "identifier" if ctx.matches_ancestor_history(&["field"]) => {
+            "column_identifier" => {
                 if let Some(table_or_alias) = ctx.schema_or_alias_name.as_ref() {
                     Some(HoveredNode::Column(NodeIdentification::SchemaAndName((
                         table_or_alias.clone(),
@@ -84,7 +84,9 @@ impl HoveredNode {
                 }
             }
 
-            "identifier" if ctx.matches_ancestor_history(&["invocation", "object_reference"]) => {
+            "any_identifier"
+                if ctx.matches_ancestor_history(&["invocation", "object_reference"]) =>
+            {
                 if let Some(schema) = ctx.schema_or_alias_name.as_ref() {
                     Some(HoveredNode::Function(NodeIdentification::SchemaAndName((
                         schema.clone(),
@@ -97,7 +99,7 @@ impl HoveredNode {
                 }
             }
 
-            "identifier"
+            "any_identifier"
                 if ctx.matches_one_of_ancestors(&[
                     "alter_role",
                     "policy_to_role",
@@ -110,7 +112,7 @@ impl HoveredNode {
                 Some(HoveredNode::Role(NodeIdentification::Name(node_content)))
             }
 
-            "identifier"
+            "any_identifier"
                 if (
                     // hover over custom type in `create table` or `returns`
                     (ctx.matches_ancestor_history(&["type", "object_reference"])