fix: make it work

Author: psteinroe

crates/parser/src/parser.rs

@@ -14,6 +14,7 @@ pub struct Parser {
     curr_depth: i32,
     errors: Vec<SyntaxError>,
     stmts: Vec<RawStmt>,
+    is_parsing_erronous_node: bool,
 }
 
 #[derive(Debug)]
@@ -26,27 +27,33 @@ pub struct Parse {
 /// Main parser that controls the cst building process, and collects errors and statements
 impl Parser {
     pub fn close_until_depth(&mut self, depth: i32) {
-        while self.curr_depth >= depth {
-            self.inner.finish_node();
+        while self.curr_depth >= depth && depth > 0 {
+            self.finish_node();
             self.curr_depth -= 1;
         }
     }
 
     /// start a new node of `SyntaxKind` at `depth`
     /// handles closing previous nodes if necessary
     /// and consumes token buffer before starting new node
-    pub fn start_node(&mut self, kind: SyntaxKind, depth: &i32) {
+    ///
+    /// if `SyntaxKind` is `SyntaxKind::AnyStatement`, sets `is_parsing_erronous_node` to true
+    pub fn start_node(&mut self, kind: SyntaxKind, depth: i32) {
         // close until target depth
-        self.close_until_depth(*depth);
+        self.close_until_depth(depth);
 
         self.consume_token_buffer();
 
-        self.curr_depth = *depth;
+        self.curr_depth = depth;
         self.inner.start_node(kind);
+        if kind == SyntaxKind::AnyStatement {
+            self.is_parsing_erronous_node = true;
+        }
     }
 
     pub fn finish_node(&mut self) {
         self.inner.finish_node();
+        self.is_parsing_erronous_node = false;
     }
 
     /// Drains the token buffer and applies all tokens
@@ -58,10 +65,16 @@ impl Parser {
 
     /// applies token based on its `SyntaxKindType`
     /// if `SyntaxKindType::Close`, closes all nodes until depth 1
-    /// if `SyntaxKindType::Follow`, add token to buffer and wait until next node to apply token at
-    /// same depth
+    /// if `SyntaxKindType::Follow`, add token to buffer and wait until next node to apply token at same depth
     /// otherwise, applies token immediately
+    ///
+    /// if `is_parsing_erronous_node` is true, applies token immediately
     pub fn token(&mut self, kind: SyntaxKind, text: &str) {
+        if self.is_parsing_erronous_node {
+            self.inner.token(kind, text);
+            return;
+        }
+
         match kind.get_type() {
             Some(SyntaxKindType::Close) => {
                 // move up to depth 2 and consume buffered tokens before applying closing token

crates/parser/src/source_file.rs

@@ -26,7 +26,7 @@ impl Parser {
     pub fn parse_source_file(&mut self, text: &str) {
         let mut lexer = SourceFileToken::lexer(text);
 
-        self.start_node(SyntaxKind::SourceFile, &0);
+        self.start_node(SyntaxKind::SourceFile, 0);
         while let Some(token) = lexer.next() {
             match token {
                 Ok(token) => {
@@ -77,4 +77,30 @@ mod tests {
         assert_eq!(lex.next(), Some(Ok(SourceFileToken::Statement)));
         assert_eq!(lex.slice(), "select id,username from contact\n\nselect id,name\nfrom contact -- test inline comment\nwhere id = '123';");
     }
+
+    #[test]
+    fn test_source_file_parser() {
+        let input = "select id, name from users where id = '1224';
+
+select select;
+
+
+
+
+
+select 1;
+
+";
+
+        let mut parser = Parser::default();
+        println!("input {:?}", input);
+        parser.parse_source_file(input);
+        let parsed = parser.finish();
+
+        dbg!(parsed.errors);
+
+        dbg!(&parsed.cst);
+
+        assert_eq!(parsed.cst.text(), input);
+    }
 }

crates/parser/src/statement.rs

@@ -103,6 +103,7 @@ impl StatementToken {
 
 impl Parser {
     pub fn parse_statement(&mut self, text: &str, at_offset: Option<u32>) {
+        println!("#### parse_statement: {}", text);
         let offset = at_offset.unwrap_or(0);
         let range = TextRange::new(
             TextSize::from(offset),
@@ -116,6 +117,7 @@ impl Parser {
                 Vec::new().into_iter().peekable()
             }
         };
+        println!("pg_query_tokens: {:?}", pg_query_tokens);
 
         let parsed = pg_query::parse(text);
         let proto;
@@ -137,14 +139,18 @@ impl Parser {
                 Vec::new().into_iter().peekable()
             }
         };
+        println!("pg_query_nodes: {:?}", pg_query_nodes);
 
         let mut lexer = StatementToken::lexer(&text);
 
         // parse root node if no syntax errors
         if pg_query_nodes.peek().is_some() {
             let (node, depth, _) = pg_query_nodes.next().unwrap();
             self.stmt(node.to_enum(), range);
-            self.start_node(SyntaxKind::from_pg_query_node(&node), &depth);
+            self.start_node(SyntaxKind::from_pg_query_node(&node), depth);
+        } else {
+            // fallback to generic node as root
+            self.start_node(SyntaxKind::AnyStatement, 1);
         }
 
         while let Some(token) = lexer.next() {
@@ -160,7 +166,7 @@ impl Parser {
                         } else {
                             // node is within span
                             let (node, depth, _) = pg_query_nodes.next().unwrap();
-                            self.start_node(SyntaxKind::from_pg_query_node(&node), &depth);
+                            self.start_node(SyntaxKind::from_pg_query_node(&node), depth);
                         }
                     }
 
@@ -249,6 +255,21 @@ mod tests {
         parser.parse_statement(input, None);
         let parsed = parser.finish();
 
+        dbg!(&parsed.cst);
+
+        assert_eq!(parsed.cst.text(), input);
+    }
+
+    #[test]
+    fn test_invalid_statement() {
+        let input = "select select;";
+
+        let mut parser = Parser::default();
+        parser.parse_statement(input, None);
+        let parsed = parser.finish();
+
+        dbg!(&parsed.cst);
+
         assert_eq!(parsed.cst.text(), input);
     }
 }