chore: cleanup parser

Author: psteinroe

crates/pg_statement_splitter/src/parser.rs

@@ -1,18 +1,6 @@
-use std::cmp::min;
-
 use pg_lexer::{SyntaxKind, Token, TokenType, WHITESPACE_TOKENS};
-use text_size::{TextRange, TextSize};
-
-use crate::syntax_error::SyntaxError;
 
-/// Main parser that exposes the `cstree` api, and collects errors and statements
 pub struct Parser {
-    /// The ranges of the statements
-    ranges: Vec<(usize, usize)>,
-    /// The syntax errors accumulated during parsing
-    errors: Vec<SyntaxError>,
-    /// The start of the current statement, if any
-    current_stmt_start: Option<usize>,
     /// The tokens to parse
     pub tokens: Vec<Token>,
     /// The current position in the token stream
@@ -23,62 +11,16 @@ pub struct Parser {
     eof_token: Token,
 }
 
-/// Result of Building
-#[derive(Debug)]
-pub struct Parse {
-    /// The ranges of the errors
-    pub ranges: Vec<TextRange>,
-    /// The syntax errors accumulated during parsing
-    pub errors: Vec<SyntaxError>,
-}
-
 impl Parser {
     pub fn new(tokens: Vec<Token>) -> Self {
         Self {
             eof_token: Token::eof(usize::from(tokens.last().unwrap().span.end())),
-            ranges: Vec::new(),
-            errors: Vec::new(),
-            current_stmt_start: None,
             tokens,
             pos: 0,
             whitespace_token_buffer: None,
         }
     }
 
-    pub fn finish(self) -> Parse {
-        Parse {
-            ranges: self
-                .ranges
-                .iter()
-                .map(|(start, end)| {
-                    let from = self.tokens.get(*start);
-                    let to = self.tokens.get(end - 1);
-                    // get text range from token range
-                    let text_start = from.unwrap().span.start();
-                    let text_end = to.unwrap().span.end();
-
-                    TextRange::new(
-                        TextSize::try_from(text_start).unwrap(),
-                        TextSize::try_from(text_end).unwrap(),
-                    )
-                })
-                .collect(),
-            errors: self.errors,
-        }
-    }
-
-    /// collects an SyntaxError with an `error` message at `pos`
-    pub fn error_at_pos(&mut self, error: String, pos: usize) {
-        self.errors.push(SyntaxError::new_at_offset(
-            error,
-            self.tokens
-                .get(min(self.tokens.len() - 1, pos))
-                .unwrap()
-                .span
-                .start(),
-        ));
-    }
-
     /// applies token and advances
     pub fn advance(&mut self) {
         assert!(!self.eof());
@@ -203,25 +145,4 @@ impl Parser {
     pub fn at(&self, kind: SyntaxKind) -> bool {
         self.nth(0, false).kind == kind
     }
-
-    pub fn expect(&mut self, kind: SyntaxKind) {
-        if self.eat(kind) {
-            return;
-        }
-        if self.whitespace_token_buffer.is_some() {
-            self.error_at_pos(
-                format!(
-                    "Expected {:#?}, found {:#?}",
-                    kind,
-                    self.tokens[self.whitespace_token_buffer.unwrap()].kind
-                ),
-                self.whitespace_token_buffer.unwrap(),
-            );
-        } else {
-            self.error_at_pos(
-                format!("Expected {:#?}, found {:#?}", kind, self.nth(0, false)),
-                self.pos + 1,
-            );
-        }
-    }
 }