intermediary

Author: juleswritescode

crates/pgls_completions/src/providers/keywords.rs

@@ -409,9 +409,12 @@ mod tests {
     use pgls_test_utils::QueryWithCursorPosition;
     use sqlx::PgPool;
 
-    use crate::test_helper::{
-        CompletionAssertion, TestCompletionsCase, TestCompletionsSuite, assert_complete_results,
-        assert_no_complete_results,
+    use crate::{
+        CompletionItemKind,
+        test_helper::{
+            CompletionAssertion, TestCompletionsCase, TestCompletionsSuite,
+            assert_complete_results, assert_no_complete_results,
+        },
     };
 
     #[sqlx::test]
@@ -490,6 +493,28 @@ mod tests {
         .await;
     }
 
+    #[sqlx::test]
+    async fn completes_columsn_after_select(pool: PgPool) {
+        let setup = r#"
+            create table public.users (
+                id serial primary key,
+                email varchar(255)
+            );
+        "#;
+
+        let query = format!("select {}", QueryWithCursorPosition::cursor_marker());
+
+        assert_complete_results(
+            query.as_str(),
+            vec![CompletionAssertion::KindNotExists(
+                CompletionItemKind::Keyword,
+            )],
+            Some(setup),
+            &pool,
+        )
+        .await;
+    }
+
     #[sqlx::test]
     async fn completes_after_from_clause(pool: PgPool) {
         let setup = r#"

crates/pgls_completions/src/relevance/filtering.rs

@@ -1,3 +1,4 @@
+use async_std::task::current;
 use pgls_schema_cache::ProcKind;
 use pgls_treesitter::{
     context::{TreesitterContext, WrappingClause, WrappingNode},
@@ -496,12 +497,6 @@ impl CompletionFilter<'_> {
             start_position,
         });
 
-        let (clause_to_investigate, clause_completed) = if ctx.node_under_cursor.kind() != "ERROR" {
-            (ctx.current_clause, ctx.current_clause_completed)
-        } else {
-            (ctx.previous_clause, ctx.previous_clause_completed)
-        };
-
         if tree.root_node().has_error() {
             return None;
         } else if ctx.previous_clause.is_some_and(|n| n.kind() == "ERROR") {
@@ -510,6 +505,12 @@ impl CompletionFilter<'_> {
             return Some(());
         }
 
+        let (clause_to_investigate, clause_completed) = if ctx.node_under_cursor.kind() != "ERROR" {
+            (ctx.current_clause, ctx.current_clause_completed)
+        } else {
+            (ctx.previous_clause, ctx.previous_clause_completed)
+        };
+
         if clause_to_investigate.is_none() {
             if keyword.starts_statement {
                 return Some(());
@@ -529,15 +530,22 @@ impl CompletionFilter<'_> {
                     && Some(current_parent.start_byte())
                         == clause_to_investigate.map(|n| n.start_byte())
                 {
+                    println!("does not change the clause");
                     return Some(());
                 }
             }
         }
 
-        // will allow those nodes that fully exchange the cluase
+        // will allow those nodes that fully exchange the clause
         if let Some(current_node) = goto_node_at_position(&tree, start_byte) {
             // replacing the start byte means full exchanging
             if Some(current_node.start_byte()) == clause_to_investigate.map(|n| n.start_byte()) {
+                println!("fully exchange the clause.");
+                println!("current_node {}", current_node.kind());
+                println!(
+                    "investigated {}",
+                    clause_to_investigate.map(|n| n.kind()).unwrap_or("here")
+                );
                 return Some(());
             }
         }

crates/pgls_treesitter/src/context/mod.rs

@@ -171,6 +171,10 @@ impl<'a> TreesitterContext<'a> {
         ctx.check_previous_clause_completed();
         ctx.check_current_clause_completed();
 
+        println!("{:#?}", ctx);
+        println!("{:#?}", ctx.previous_clause);
+        println!("{:#?}", ctx.current_clause);
+
         ctx
     }
 
@@ -427,9 +431,17 @@ impl<'a> TreesitterContext<'a> {
     fn check_current_clause_completed(&mut self) {
         if let Some(closest_parent) = helper::goto_closest_parent_clause(self.node_under_cursor) {
             self.current_clause = Some(closest_parent);
-            self.current_clause_completed = closest_parent
-                .child_by_field_name("end")
-                .is_some_and(|child| child != self.node_under_cursor)
+            self.current_clause_completed =
+                closest_parent
+                    .child_by_field_name("end")
+                    .is_some_and(|child| {
+                        let is_node_under_cursor = child == self.node_under_cursor;
+                        let matches_node_under_cursor_range = child.start_byte()
+                            == self.node_under_cursor.start_byte()
+                            && child.end_byte() == self.node_under_cursor.end_byte();
+
+                        !is_node_under_cursor && !matches_node_under_cursor_range
+                    })
         };
     }
 
@@ -439,7 +451,14 @@ impl<'a> TreesitterContext<'a> {
                 self.previous_clause = Some(closest_parent);
                 self.previous_clause_completed = closest_parent
                     .child_by_field_name("end")
-                    .is_some_and(|child| child != self.node_under_cursor)
+                    .is_some_and(|child| {
+                        let is_node_under_cursor = child == self.node_under_cursor;
+                        let matches_node_under_cursor_range = child.start_byte()
+                            == self.node_under_cursor.start_byte()
+                            && child.end_byte() == self.node_under_cursor.end_byte();
+
+                        !is_node_under_cursor && !matches_node_under_cursor_range
+                    })
             }
         };
     }