rename

Author: juleswritescode

crates/pgt_statement_splitter/src/splitter.rs

@@ -8,7 +8,7 @@ pub use common::source;
 use pgt_lexer::{Lexed, SyntaxKind};
 use pgt_text_size::TextRange;
 
-use crate::splitter::common::SplitterException;
+use crate::splitter::common::ReachedEOFException;
 
 pub struct SplitResult {
     pub ranges: Vec<TextRange>,
@@ -105,7 +105,7 @@ impl<'a> Splitter<'a> {
         self.lexed.kind(self.current_pos)
     }
 
-    fn eat(&mut self, kind: SyntaxKind) -> Result<bool, SplitterException> {
+    fn eat(&mut self, kind: SyntaxKind) -> Result<bool, ReachedEOFException> {
         if self.current() == kind {
             self.advance()?;
             Ok(true)
@@ -121,9 +121,9 @@ impl<'a> Splitter<'a> {
     /// Advances the parser to the next relevant token and returns it.
     ///
     /// NOTE: This will skip trivia tokens.
-    fn advance(&mut self) -> Result<SyntaxKind, SplitterException> {
+    fn advance(&mut self) -> Result<SyntaxKind, ReachedEOFException> {
         if self.current() == SyntaxKind::EOF {
-            return Err(SplitterException);
+            return Err(ReachedEOFException);
         }
 
         let pos = (self.current_pos + 1..self.lexed.len())
@@ -171,7 +171,7 @@ impl<'a> Splitter<'a> {
 
     /// Will advance if the `kind` matches the current token.
     /// Otherwise, will add a diagnostic to the internal `errors`.
-    fn expect(&mut self, kind: SyntaxKind) -> Result<(), SplitterException> {
+    fn expect(&mut self, kind: SyntaxKind) -> Result<(), ReachedEOFException> {
         if self.current() == kind {
             self.advance()?;
         } else {

crates/pgt_statement_splitter/src/splitter/common.rs

@@ -11,18 +11,17 @@ use super::{
 };
 
 #[derive(Debug)]
-pub struct SplitterException;
+pub struct ReachedEOFException;
 
-impl std::fmt::Display for SplitterException {
+impl std::fmt::Display for ReachedEOFException {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        // todo
-        write!(f, "SplitterException")
+        write!(f, "ReachedEOFException")
     }
 }
 
-impl Error for SplitterException {}
+impl Error for ReachedEOFException {}
 
-pub fn source(p: &mut Splitter) -> Result<(), SplitterException> {
+pub fn source(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     loop {
         match p.current() {
             SyntaxKind::EOF => {
@@ -43,7 +42,7 @@ pub fn source(p: &mut Splitter) -> Result<(), SplitterException> {
     Ok(())
 }
 
-pub(crate) fn statement(p: &mut Splitter) -> Result<(), SplitterException> {
+pub(crate) fn statement(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     p.start_stmt();
 
     // Currently, Err means that we reached EOF.
@@ -65,7 +64,7 @@ pub(crate) fn statement(p: &mut Splitter) -> Result<(), SplitterException> {
     Ok(())
 }
 
-pub(crate) fn begin_end(p: &mut Splitter) -> Result<(), SplitterException> {
+pub(crate) fn begin_end(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     p.expect(SyntaxKind::BEGIN_KW)?;
 
     let mut depth = 1;
@@ -94,7 +93,7 @@ pub(crate) fn begin_end(p: &mut Splitter) -> Result<(), SplitterException> {
     Ok(())
 }
 
-pub(crate) fn parenthesis(p: &mut Splitter) -> Result<(), SplitterException> {
+pub(crate) fn parenthesis(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     p.expect(SyntaxKind::L_PAREN)?;
 
     let mut depth = 1;
@@ -123,7 +122,7 @@ pub(crate) fn parenthesis(p: &mut Splitter) -> Result<(), SplitterException> {
     Ok(())
 }
 
-pub(crate) fn plpgsql_command(p: &mut Splitter) -> Result<(), SplitterException> {
+pub(crate) fn plpgsql_command(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     p.expect(SyntaxKind::BACKSLASH)?;
 
     loop {
@@ -143,7 +142,7 @@ pub(crate) fn plpgsql_command(p: &mut Splitter) -> Result<(), SplitterException>
     Ok(())
 }
 
-pub(crate) fn case(p: &mut Splitter) -> Result<(), SplitterException> {
+pub(crate) fn case(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     p.expect(SyntaxKind::CASE_KW)?;
 
     loop {
@@ -161,7 +160,7 @@ pub(crate) fn case(p: &mut Splitter) -> Result<(), SplitterException> {
     Ok(())
 }
 
-pub(crate) fn unknown(p: &mut Splitter, exclude: &[SyntaxKind]) -> Result<(), SplitterException> {
+pub(crate) fn unknown(p: &mut Splitter, exclude: &[SyntaxKind]) -> Result<(), ReachedEOFException> {
     loop {
         match p.current() {
             SyntaxKind::SEMICOLON => {

crates/pgt_statement_splitter/src/splitter/ddl.rs

@@ -1,16 +1,16 @@
 use pgt_lexer::SyntaxKind;
 
-use crate::splitter::common::SplitterException;
+use crate::splitter::common::ReachedEOFException;
 
 use super::{Splitter, common::unknown};
 
-pub(crate) fn create(p: &mut Splitter) -> Result<(), SplitterException> {
+pub(crate) fn create(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     p.expect(SyntaxKind::CREATE_KW)?;
 
     unknown(p, &[SyntaxKind::WITH_KW])
 }
 
-pub(crate) fn alter(p: &mut Splitter) -> Result<(), SplitterException> {
+pub(crate) fn alter(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     p.expect(SyntaxKind::ALTER_KW)?;
 
     unknown(p, &[SyntaxKind::ALTER_KW])

crates/pgt_statement_splitter/src/splitter/dml.rs

@@ -1,13 +1,13 @@
 use pgt_lexer::SyntaxKind;
 
-use crate::splitter::common::SplitterException;
+use crate::splitter::common::ReachedEOFException;
 
 use super::{
     Splitter,
     common::{parenthesis, unknown},
 };
 
-pub(crate) fn cte(p: &mut Splitter) -> Result<(), SplitterException> {
+pub(crate) fn cte(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     p.expect(SyntaxKind::WITH_KW)?;
     p.eat(SyntaxKind::RECURSIVE_KW)?;
 
@@ -36,26 +36,26 @@ pub(crate) fn cte(p: &mut Splitter) -> Result<(), SplitterException> {
     Ok(())
 }
 
-pub(crate) fn select(p: &mut Splitter) -> Result<(), SplitterException> {
+pub(crate) fn select(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     p.expect(SyntaxKind::SELECT_KW)?;
 
     unknown(p, &[])
 }
 
-pub(crate) fn insert(p: &mut Splitter) -> Result<(), SplitterException> {
+pub(crate) fn insert(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     p.expect(SyntaxKind::INSERT_KW)?;
     p.expect(SyntaxKind::INTO_KW)?;
 
     unknown(p, &[SyntaxKind::SELECT_KW])
 }
 
-pub(crate) fn update(p: &mut Splitter) -> Result<(), SplitterException> {
+pub(crate) fn update(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     p.expect(SyntaxKind::UPDATE_KW)?;
 
     unknown(p, &[])
 }
 
-pub(crate) fn delete(p: &mut Splitter) -> Result<(), SplitterException> {
+pub(crate) fn delete(p: &mut Splitter) -> Result<(), ReachedEOFException> {
     p.expect(SyntaxKind::DELETE_KW)?;
     p.expect(SyntaxKind::FROM_KW)?;