refactor, terminate by semicolons

Author: juleswritescode

crates/pgt_text_size/src/range.rs

@@ -281,6 +281,24 @@ impl TextRange {
         })
     }
 
+    /// Expand the range's end by the given offset.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use pgt_text_size::*;
+    /// assert_eq!(
+    ///     TextRange::new(2.into(), 4.into()).checked_expand_end(16.into()).unwrap(),
+    ///     TextRange::new(2.into(), 20.into()),
+    /// );
+    /// ```
+    #[inline]
+    pub fn checked_expand_end(self, offset: TextSize) -> Option<TextRange> {
+        Some(TextRange {
+            start: self.start,
+            end: self.end.checked_add(offset)?,
+        })
+    }
     /// Subtract an offset from this range.
     ///
     /// Note that this is not appropriate for changing where a `TextRange` is

crates/pgt_workspace/src/workspace/server.rs

@@ -541,61 +541,57 @@ impl Workspace for WorkspaceServer {
             .ok_or(WorkspaceError::not_found())?;
 
         let count = doc.statement_count();
+        // no arms no cookies
+        if count == 0 {
+            return Ok(CompletionsResult::default());
+        }
 
-        let maybe_statement = if count == 0 {
-            None
-        } else if count == 1 {
+        /*
+         * We allow an offset of two for the statement:
+         *
+         * select * from | <-- we want to suggest items for the next token.
+         *
+         * However, if the current statement is terminated by a semicolon, we don't apply any
+         * offset.
+         *
+         * select * from users; | <-- no autocompletions here.
+         */
+        let matches_expanding_range =
+            |stmt_id: StatementId, range: &TextRange, position: TextSize| {
+                let measuring_range = if doc.is_terminated_by_semicolon(stmt_id).unwrap() {
+                    *range
+                } else {
+                    range.checked_expand_end(2.into()).unwrap_or(*range)
+                };
+                measuring_range.contains(position)
+            };
+
+        let maybe_statement = if count == 1 {
             let (stmt, range, txt) = doc.iter_statements_with_text_and_range().next().unwrap();
-            let expanded_range = TextRange::new(
-                range.start(),
-                range
-                    .end()
-                    .checked_add(TextSize::new(2))
-                    .unwrap_or(range.end()),
-            );
-            if expanded_range.contains(params.position) {
+            if matches_expanding_range(stmt.id, range, params.position) {
                 Some((stmt, range, txt))
             } else {
                 None
             }
         } else {
-            let mut stmts = doc.iter_statements_with_text_and_range().tuple_windows();
-            stmts.find(|((_, rcurrent, _), (_, rnext, _))| {
             /*
-             * We allow an offset of two for the statement:
-             *
-             * (| is the user's cursor.)
-             *
-             * select * from | <-- we want to suggest items for the next token.
+             * If we have multiple statements, we want to make sure that we do not overlap
+             * with the next one.
              *
+             * select 1 |select 1;
              */
-            let expanded_range = TextRange::new(
-                rcurrent.start(),
-                rcurrent
-                    .end()
-                    .checked_add(TextSize::new(2))
-                    .unwrap_or(rcurrent.end()),
-            );
-            let is_within_range = expanded_range.contains(params.position);
-
-            /*
-             * However, we do not allow this if the there the offset overlaps
-             * with an adjacent statement:
-             *
-             * select 1; |select 1;
-             */
-            let overlaps_next = !rnext.contains(params.position);
-
-
-            tracing::warn!("Current range {:?}, next range {:?}, position: {:?}, contains range: {}, overlaps :{}", rcurrent, rnext, params.position, is_within_range, overlaps_next);
-
-            is_within_range && !overlaps_next
-
-        }).map(|(t1,_t2)| t1)
+            let mut stmts = doc.iter_statements_with_text_and_range().tuple_windows();
+            stmts
+                .find(|((current_stmt, rcurrent, _), (_, rnext, _))| {
+                    let overlaps_next = rnext.contains(params.position);
+                    matches_expanding_range(current_stmt.id, &rcurrent, params.position)
+                        && !overlaps_next
+                })
+                .map(|t| t.0)
         };
 
         let (statement, stmt_range, text) = match maybe_statement {
-            Some(tuple) => tuple,
+            Some(it) => it,
             None => {
                 tracing::debug!("No matching statement found for completion.");
                 return Ok(CompletionsResult::default());

crates/pgt_workspace/src/workspace/server/document.rs

@@ -117,6 +117,16 @@ impl Document {
                 stmt.to_owned()
             })
     }
+
+    pub fn is_terminated_by_semicolon(&self, stmt_id: StatementId) -> Option<bool> {
+        self.positions
+            .iter()
+            .find(|pos| pos.0 == stmt_id)
+            .map(|(_, range)| {
+                let final_char = self.content.chars().nth(range.end().into());
+                final_char == Some(';')
+            })
+    }
 }
 
 pub(crate) struct IdGenerator {