work

src/parser/cursor/mod.rs

@@ -1,5 +1,4 @@
 use crate::io::{CompilerMsg, Span, Spanned};
-use std::iter::Peekable;
 
 mod lit;
 mod token;
@@ -8,37 +7,52 @@ pub use token::*;
 
 pub struct Cursor<'a> {
     pub span: Span,
-    tokens: Peekable<Tokens<'a>>,
+    next: Option<TokenInst>,
+    tokens: Tokens<'a>,
 }
 
 impl<'a> Cursor<'a> {
     pub fn new(text: &'a str, file: usize) -> Self {
-        Self {
+        let mut s = Self {
             span: Span {
                 start: 0,
                 end: 0,
                 file,
             },
-            tokens: Tokens::new(text, file).peekable(),
-        }
+            next: None,
+            tokens: Tokens::new(text, file),
+        };
+        s.next();
+        s
     }
 
     pub fn next(&mut self) -> Option<Token> {
-        self.tokens.next().map(|inst| {
+        let mut next = self.tokens.next();
+        std::mem::swap(&mut self.next, &mut next);
+        next.map(|inst| {
             self.span = inst.span;
             inst.inner
         })
     }
 
-    pub fn peek(&mut self) -> Option<&Token> {
-        self.tokens.peek().map(|inst| &inst.inner)
+    pub fn next_if(&mut self, token: Token) -> bool {
+        if self.peek().is_some_and(|t| *t == token) {
+            self.next();
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn peek(&self) -> Option<&Token> {
+        self.next.as_ref().map(|i| &i.inner)
     }
 
     pub fn expect_next(&mut self) -> Result<Token, CompilerMsg> {
         self.next().ok_or_else(CompilerMsg::unexpected_eof)
     }
 
-    pub fn expect_peek(&mut self) -> Result<&Token, CompilerMsg> {
+    pub fn expect_peek(&self) -> Result<&Token, CompilerMsg> {
         self.peek().ok_or_else(CompilerMsg::unexpected_eof)
     }
 
@@ -47,22 +61,16 @@ impl<'a> Cursor<'a> {
         if next == token {
             Ok(next)
         } else {
-            self.unexpected(next, &format!("'{token}'"))
+            self.unexpected(&next, &format!("'{token}'"))
         }
     }
 
-    pub fn unexpected<T>(&self, token: Token, expected: &str) -> Result<T, CompilerMsg> {
-        Err(CompilerMsg::unexpected_token(
-            Spanned {
-                inner: token,
-                span: self.span,
-            },
-            expected,
-        ))
+    pub fn unexpected<T>(&self, token: &Token, expected: &str) -> Result<T, CompilerMsg> {
+        Err(CompilerMsg::unexpected_token(token, self.span, expected))
     }
 
     pub fn peek_start(&mut self) -> usize {
-        self.tokens.peek().map(|i| i.span.start).unwrap_or(0)
+        self.next.as_ref().map(|i| i.span.start).unwrap_or(0)
     }
 
     pub fn cur_end(&mut self) -> usize {
@@ -75,10 +83,10 @@ impl<'a> Cursor<'a> {
 }
 
 impl CompilerMsg {
-    pub fn unexpected_token(inst: TokenInst, expected: &str) -> Self {
+    pub fn unexpected_token(token: &Token, span: Span, expected: &str) -> Self {
         Self {
-            spans: vec![inst.span],
-            msg: format!("Unexpected token '{}'; expected {expected}", inst.inner),
+            spans: vec![span],
+            msg: format!("Unexpected token '{}'; expected {expected}", token),
         }
     }