[2] refactor: use more specific tree-sitter references and identifiers

crates/pgls_completions/src/providers/helper.rs

@@ -45,7 +45,7 @@ pub(crate) fn with_schema_or_alias(
     item_name: &str,
     schema_or_alias_name: Option<&str>,
 ) -> String {
-    let is_already_prefixed_with_schema_name = ctx.schema_or_alias_name.is_some();
+    let is_already_prefixed_with_schema_name = ctx.has_any_qualifier();
 
     let with_quotes = node_text_surrounded_by_quotes(ctx);
     let single_leading_quote = only_leading_quote(ctx);

crates/pgls_completions/src/relevance/filtering.rs

@@ -18,7 +18,7 @@ impl CompletionFilter<'_> {
     pub fn is_relevant(&self, ctx: &TreesitterContext) -> Option<()> {
         self.completable_context(ctx)?;
 
-        self.check_node_type(ctx)
+        self.check_specific_node_type(ctx)
             // we want to rely on treesitter more, so checking the clause is a fallback
             .or_else(|| self.check_clause(ctx))?;
 
@@ -70,6 +70,15 @@ impl CompletionFilter<'_> {
             }
         }
 
+        if ctx
+            .node_under_cursor
+            .as_ref()
+            .is_some_and(|n| n.kind() == "any_identifier")
+            && ctx.matches_ancestor_history(&["alias"])
+        {
+            return None;
+        }
+
         // No autocompletions if there are two identifiers without a separator.
         if ctx.node_under_cursor.as_ref().is_some_and(|node| {
             node.prev_sibling().is_some_and(|p| {
@@ -92,15 +101,79 @@ impl CompletionFilter<'_> {
         Some(())
     }
 
-    fn check_node_type(&self, ctx: &TreesitterContext) -> Option<()> {
+    fn check_specific_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")
+            "column_identifier" => matches!(self.data, CompletionRelevanceData::Column(_)),
+            "role_identifier" => matches!(self.data, CompletionRelevanceData::Role(_)),
+            "function_identifier" => matches!(self.data, CompletionRelevanceData::Function(_)),
+            "schema_identifier" => matches!(self.data, CompletionRelevanceData::Schema(_)),
+            "table_identifier" => matches!(self.data, CompletionRelevanceData::Table(_)),
+            "policy_identifier" => matches!(self.data, CompletionRelevanceData::Policy(_)),
+
+            "any_identifier" => {
+                if false || ctx.matches_ancestor_history(&["insert_values", "object_reference"]) {
+                    false
+                } else {
+                    match self.data {
+                        CompletionRelevanceData::Column(_) => {
+                            ctx.node_under_cursor_is_within_field_name(&[
+                                "object_reference_1of1",
+                                "object_reference_2of2",
+                                "object_reference_3of3",
+                                "column_reference_1of1",
+                                "column_reference_2of2",
+                                "column_reference_3of3",
+                            ]) && !ctx
+                                .node_under_cursor_is_within_field_name(&["binary_expr_right"])
+                                && !ctx.matches_ancestor_history(&[
+                                    "insert_values",
+                                    "object_reference",
+                                ])
+                        }
+
+                        CompletionRelevanceData::Schema(_) => ctx
+                            .node_under_cursor_is_within_field_name(&[
+                                "object_reference_1of1",
+                                "object_reference_1of2",
+                                "object_reference_1of3",
+                                "type_reference_1of1",
+                                "table_reference_1of1",
+                                "column_reference_1of1",
+                                "column_reference_1of2",
+                                "function_reference_1of1",
+                            ]),
+
+                        CompletionRelevanceData::Function(f) => {
+                            ctx.node_under_cursor_is_within_field_name(&[
+                                "object_reference_1of1",
+                                "object_reference_2of2",
+                                "function_reference_1of1",
+                            ]) && !(ctx.matches_ancestor_history(&[
+                                "check_or_using_clause",
+                                "binary_expression",
+                                "object_reference",
+                            ]) && matches!(f.kind, ProcKind::Aggregate))
+                        }
+
+                        CompletionRelevanceData::Table(_) => ctx
+                            .node_under_cursor_is_within_field_name(&[
+                                "object_reference_1of1",
+                                "object_reference_1of2",
+                                "object_reference_2of2",
+                                "object_reference_2of3",
+                                "table_reference_1of1",
+                                "column_reference_1of1",
+                                "column_reference_1of2",
+                                "column_reference_2of2",
+                            ]),
+
+                        _ => false,
+                    }
+                }
             }
+
             _ => false,
         };
 
@@ -216,7 +289,6 @@ impl CompletionFilter<'_> {
 
                     CompletionRelevanceData::Schema(_) => match clause {
                         WrappingClause::Select
-                        | WrappingClause::From
                         | WrappingClause::Join { .. }
                         | WrappingClause::Update
                         | WrappingClause::Delete => true,
@@ -225,7 +297,7 @@ impl CompletionFilter<'_> {
                             (ctx.matches_ancestor_history(&[
                                 "grantable_on_table",
                                 "object_reference",
-                            ]) && ctx.schema_or_alias_name.is_none())
+                            ]) && !ctx.has_any_qualifier())
                                 || ctx.matches_ancestor_history(&["grantable_on_all"])
                         }
 
@@ -308,18 +380,24 @@ impl CompletionFilter<'_> {
     }
 
     fn check_mentioned_schema_or_alias(&self, ctx: &TreesitterContext) -> Option<()> {
-        if ctx.schema_or_alias_name.is_none() {
-            return Some(());
-        }
-
-        let schema_or_alias = ctx.schema_or_alias_name.as_ref().unwrap().replace('"', "");
+        let tail_qualifier = match ctx.tail_qualifier_sanitized() {
+            Some(q) => q,
+            None => return Some(()), // no qualifier = this check passes
+        };
 
         let matches = match self.data {
-            CompletionRelevanceData::Table(table) => table.schema == schema_or_alias,
-            CompletionRelevanceData::Function(f) => f.schema == schema_or_alias,
-            CompletionRelevanceData::Column(col) => ctx
-                .get_mentioned_table_for_alias(&schema_or_alias)
-                .is_some_and(|t| t == &col.table_name),
+            CompletionRelevanceData::Table(table) => table.schema == tail_qualifier,
+            CompletionRelevanceData::Function(f) => f.schema == tail_qualifier,
+            CompletionRelevanceData::Column(col) => {
+                let table = ctx
+                    .get_mentioned_table_for_alias(&tail_qualifier)
+                    .unwrap_or(&tail_qualifier);
+
+                col.table_name == table.as_str()
+                    && ctx
+                        .head_qualifier_sanitized()
+                        .is_none_or(|schema| col.schema_name == schema.as_str())
+            }
 
             // we should never allow schema suggestions if there already was one.
             CompletionRelevanceData::Schema(_) => false,

crates/pgls_completions/src/relevance/scoring.rs

@@ -79,7 +79,7 @@ impl CompletionScore<'_> {
         };
 
         let has_mentioned_tables = ctx.has_any_mentioned_relations();
-        let has_mentioned_schema = ctx.schema_or_alias_name.is_some();
+        let has_qualifier = ctx.has_any_qualifier();
 
         self.score += match self.data {
             CompletionRelevanceData::Table(_) => match clause_type {
@@ -122,13 +122,13 @@ impl CompletionScore<'_> {
                 _ => -15,
             },
             CompletionRelevanceData::Schema(_) => match clause_type {
-                WrappingClause::From if !has_mentioned_schema => 15,
-                WrappingClause::Join { .. } if !has_mentioned_schema => 15,
-                WrappingClause::Update if !has_mentioned_schema => 15,
-                WrappingClause::Delete if !has_mentioned_schema => 15,
-                WrappingClause::AlterPolicy if !has_mentioned_schema => 15,
-                WrappingClause::DropPolicy if !has_mentioned_schema => 15,
-                WrappingClause::CreatePolicy if !has_mentioned_schema => 15,
+                WrappingClause::From if !has_qualifier => 15,
+                WrappingClause::Join { .. } if !has_qualifier => 15,
+                WrappingClause::Update if !has_qualifier => 15,
+                WrappingClause::Delete if !has_qualifier => 15,
+                WrappingClause::AlterPolicy if !has_qualifier => 15,
+                WrappingClause::DropPolicy if !has_qualifier => 15,
+                WrappingClause::CreatePolicy if !has_qualifier => 15,
                 _ => -50,
             },
             CompletionRelevanceData::Policy(_) => match clause_type {
@@ -149,15 +149,15 @@ impl CompletionScore<'_> {
             Some(wn) => wn,
         };
 
-        let has_mentioned_schema = ctx.schema_or_alias_name.is_some();
+        let has_qualifier = ctx.has_any_qualifier();
         let has_node_text = ctx
             .get_node_under_cursor_content()
             .is_some_and(|txt| !sanitization::is_sanitized_token(txt.as_str()));
 
         self.score += match self.data {
             CompletionRelevanceData::Table(_) => match wrapping_node {
-                WrappingNode::Relation if has_mentioned_schema => 15,
-                WrappingNode::Relation if !has_mentioned_schema => 10,
+                WrappingNode::Relation if has_qualifier => 15,
+                WrappingNode::Relation if !has_qualifier => 10,
                 WrappingNode::BinaryExpression => 5,
                 _ => -50,
             },
@@ -172,8 +172,8 @@ impl CompletionScore<'_> {
                 _ => -15,
             },
             CompletionRelevanceData::Schema(_) => match wrapping_node {
-                WrappingNode::Relation if !has_mentioned_schema && !has_node_text => 15,
-                WrappingNode::Relation if !has_mentioned_schema && has_node_text => 0,
+                WrappingNode::Relation if !has_qualifier && !has_node_text => 15,
+                WrappingNode::Relation if !has_qualifier && has_node_text => 0,
                 _ => -50,
             },
             CompletionRelevanceData::Policy(_) => 0,
@@ -191,17 +191,30 @@ impl CompletionScore<'_> {
     }
 
     fn check_matches_schema(&mut self, ctx: &TreesitterContext) {
-        let schema_name = match ctx.schema_or_alias_name.as_ref() {
-            None => return,
-            Some(n) => n.replace('"', ""),
+        let schema_from_qualifier = match self.data {
+            CompletionRelevanceData::Table(_) | CompletionRelevanceData::Function(_) => {
+                ctx.tail_qualifier_sanitized()
+            }
+
+            CompletionRelevanceData::Column(_) | CompletionRelevanceData::Policy(_) => {
+                ctx.head_qualifier_sanitized()
+            }
+
+            CompletionRelevanceData::Schema(_) | CompletionRelevanceData::Role(_) => None,
         };
 
+        if schema_from_qualifier.is_none() {
+            return;
+        }
+
+        let schema_from_qualifier = schema_from_qualifier.unwrap();
+
         let data_schema = match self.get_schema_name() {
             Some(s) => s,
             None => return,
         };
 
-        if schema_name == data_schema {
+        if schema_from_qualifier == data_schema {
             self.score += 25;
         } else {
             self.score -= 10;

crates/pgls_hover/src/hoverables/column.rs

@@ -74,12 +74,21 @@ impl ContextualPriority for Column {
         let mut score = 0.0;
 
         // high score if we match the specific alias or table being referenced in the cursor context
-        if let Some(table_or_alias) = ctx.schema_or_alias_name.as_ref() {
-            if table_or_alias.replace('"', "") == self.table_name.as_str() {
+
+        if let Some(table_or_alias) = ctx.tail_qualifier_sanitized() {
+            let table = ctx
+                .get_mentioned_table_for_alias(&table_or_alias)
+                .unwrap_or(&table_or_alias);
+
+            if table == self.table_name.as_str()
+                && ctx
+                    .head_qualifier_sanitized()
+                    .is_none_or(|s| self.schema_name == s.as_str())
+            {
                 score += 250.0;
-            } else if let Some(table_name) = ctx.get_mentioned_table_for_alias(table_or_alias) {
-                if table_name == self.table_name.as_str() {
-                    score += 250.0;
+
+                if ctx.head_qualifier_sanitized().is_some() {
+                    score += 50.0;
                 }
             }
         }