chore: optimise cursor operations

Author: LynithDev

packages/engine/src/component.rs

@@ -25,7 +25,9 @@ pub trait ComponentErrors {
         let start_index = start.index() as usize;
         let end_index = end.index() as usize;
 
-        let source = &source_file.as_ref().1[start_index..end_index];
+        let code = &source_file.as_ref().1;
+
+        let source = &code[start_index..end_index.min(code.len())];
 
         Box::from((source_file.as_ref().0.clone(), source.to_string()))
     }

packages/engine/src/cursor.rs

@@ -1,88 +1,64 @@
-pub type CursorTuple = (u16, u16);
+use std::fmt::Debug;
 
-#[derive(Debug, Clone, Copy, Eq)]
-pub struct Cursor {
-    pub col: u16,
-    pub line: u16,
-    index: u32,
+#[derive(Clone, Copy, Eq)]
+pub struct Cursor(u16, u16, u32);
+
+impl Debug for Cursor {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Cursor({}:{}@{})", self.0, self.1, self.2)
+    }
+}
+
+impl PartialEq for Cursor {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0 && self.1 == other.1
+    }
 }
 
 impl Cursor {
     pub fn create() -> Self {
-        Self {
-            col: 1,
-            line: 1,
-            index: 0,
-        }
+        Self::from(1, 1)
     }
 
-    pub fn from(line: u16, col: u16) -> Self {
-        Self {
-            col,
-            line,
-            index: 0
-        }
+    pub fn from(col: u16, line: u16) -> Self {
+        Self::from_full(col, line, 0)
     }
 
     pub fn from_full(col: u16, line: u16, index: u32) -> Self {
-        Self {
-            col,
-            line,
-            index
-        }
-    }
-
-    /// Goes to the new line if needed, based on the character
-    pub fn next(&mut self, char: &char) {
-        if char.eq(&'\n') {
-            self.next_line();
-        } else {
-            self.next_col();
-        }
+        Self(col, line, index)
     }
 
-    /// Moves the cursor to the next column
+    /// Moves the cursor
     pub fn next_col(&mut self) {
-        self.col += 1;
-
-        self.index += 1;
+        self.1 += 1;
+        self.2 += 1;
     }
-    
-    /// Moves the cursor to the next line and resets the column to 0
-    pub fn next_line(&mut self) {
-        self.line += 1;
-        self.col = 1;
 
-        self.index += 1;
+    pub fn next_line(&mut self) {
+        self.0 += 1;
+        self.1 = 1;
+        self.2 += 1;
     }
 
-    /// Gets the index in the input file of the cursor
-    pub fn index(&self) -> u32 {
-        self.index
-    } 
-    
-    /// Resets the cursor back to line 1 column 1
+    /// Resets the cursor
     pub fn reset(&mut self) {
-        self.col = 1;
-        self.line = 1;
+        *self = Self::create();
     }
 
-    /// Returns a (line, col) tuple
-    pub fn to_tuple(&self) -> CursorTuple {
-        (self.line, self.col)
-    } 
-}
-
-impl PartialEq for Cursor {
-    fn eq(&self, other: &Self) -> bool {
-        self.col == other.col && self.line == other.line
+    /// Gets the line
+    pub fn line(&self) -> u16 {
+        self.0
     }
-}
 
-impl From<Cursor> for CursorTuple {
-    fn from(val: Cursor) -> Self {
-        val.to_tuple()
+    /// Gets the column
+    pub fn col(&self) -> u16 {
+        self.1
     }
+    
+    /// Gets the index in the input file of the cursor
+    pub fn index(&self) -> u32 {
+        self.2
+    } 
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -99,9 +75,9 @@ impl<T> WithCursor<T> {
 
     pub fn create_with(start: Cursor, end: Cursor, value: T) -> Self {
         Self {
-            value,
             start,
             end,
+            value,
         }
     }
 }

packages/engine/src/error.rs

@@ -49,14 +49,14 @@ where T: lang_macro::EnumVariantsTrait + ToString {
                 "{}{}{}{}{}",
                 path,
                 ":".black(),
-                self.start().line,
+                self.start().line(),
                 ":".black(),
-                self.start().col,
+                self.start().col(),
             ).bold()
         )?;
 
-        let lines = (self.end().line - self.start().line) + 1;
-        let max_line_len = self.end().line.to_string().len();
+        let lines = (self.end().line() - self.start().line()) + 1;
+        let max_line_len = self.end().line().to_string().len();
 
         writeln!(f,
             "   {} {}",
@@ -65,7 +65,7 @@ where T: lang_macro::EnumVariantsTrait + ToString {
         )?;
 
         for index in 0..lines {
-            let line = (self.start().line + index).to_string();
+            let line = (self.start().line() + index).to_string();
             let line_len = line.len();
 
             writeln!(f,

packages/engine/src/lexer/error.rs

@@ -15,7 +15,7 @@ pub enum LexerErrorKind {
     #[error("overflowing integer '{0}'")]
     IntegerOverflow(String),
     #[error("expected character '{expected}' but found {found:?}")]
-    UnexpectedCharacter { expected: String, found: Option<char> },
+    ExpectedCharacter { expected: String, found: Option<char> },
     #[error("unknown token")]
     UnknownToken
 }

packages/engine/src/lexer/mod.rs

@@ -82,23 +82,13 @@ impl<'a> Lexer<'a> {
             if let Some(char) = self.next() {
                 match self.scan_char(&char) {
                     Ok(Some((token_type, value))) => self.add_token(token_type, value, start),
-                    Err(err) => {
-                        self.errors.push(EngineErrorKind::LexerError(LexerError {
-                            #[cfg(feature = "cli")]
-                            source_file: self.get_source_sliced(start, self.cursor),
-                            start,
-                            end: self.cursor,
-                            kind: err,
-                        }));
-                    }
+                    Err(err) => self.add_error(start, err),
                     _ => {}
                 }
             }
         }
 
-        let start = self.cursor;
-        self.cursor.next_line();
-        self.add_token(LexerTokenKind::EOL, None, start);
+        self.add_token(LexerTokenKind::EOF, None, self.cursor);
 
         &self.tokens
     }
@@ -258,6 +248,20 @@ impl<'a> Lexer<'a> {
         });
     }
 
+    fn add_error(
+        &mut self,
+        start: Cursor,
+        err: LexerErrorKind
+    ) {
+        self.errors.push(EngineErrorKind::LexerError(LexerError {
+            #[cfg(feature = "cli")]
+            source_file: self.get_source_sliced(start, self.cursor),
+            start,
+            end: self.cursor,
+            kind: err,
+        }))
+    }
+
     /// Consumes a single-line comment (aka skips to the end of the line and returns nothing)
     fn consume_single_line_comment(&mut self) -> LexerResult<()> {
         self.eat_until(&['\n'], false);
@@ -280,7 +284,15 @@ impl<'a> Lexer<'a> {
     /// Attempts to return a [`TokenType::String`]
     fn consume_string(&mut self) -> LexerResult<(LexerTokenKind, Option<Box<LexerLiteral>>)> {
         let string = self.eat_until(&['"', '\n'], true).unwrap_or_default();
-        self.expect_char(&'"')?;
+        
+        if let Err(err) = self.expect_char(&'"') {
+            if let LexerErrorKind::ExpectedCharacter { found: Some(found), .. } = &err {
+                self.cursor_next(found);
+            }
+            
+            return Err(err);
+        }
+    
         Ok((
             LexerTokenKind::String,
             Some(Box::from(LexerLiteral::String(Box::from(string)))),
@@ -366,7 +378,7 @@ impl<'a> Lexer<'a> {
             }
 
             _ => {
-                return Err(LexerErrorKind::UnexpectedCharacter {
+                return Err(LexerErrorKind::ExpectedCharacter {
                     expected: "0..9".to_string(),
                     found: Some(char),
                 })
@@ -404,7 +416,7 @@ impl<'a> Lexer<'a> {
                     LexerErrorKind::IntegerOverflow(collector)
                 }
 
-                IntErrorKind::InvalidDigit => LexerErrorKind::UnexpectedCharacter {
+                IntErrorKind::InvalidDigit => LexerErrorKind::ExpectedCharacter {
                     expected: "0..9".to_string(),
                     found: None,
                 },
@@ -468,7 +480,7 @@ impl<'a> Lexer<'a> {
 
     fn expect_char(&mut self, expected: &char) -> LexerResult<char> {
         self.expect(expected)
-            .map_err(|found| LexerErrorKind::UnexpectedCharacter {
+            .map_err(|found| LexerErrorKind::ExpectedCharacter {
                 expected: expected.to_string(),
                 found,
             })
@@ -491,7 +503,11 @@ impl<'a> ComponentIter<'a, char, char, Chars<'a>> for Lexer<'a> {
         &mut self.chars
     }
 
-    fn cursor_next(&mut self, item: &char) {
-        self.cursor.next(item);
+    fn cursor_next(&mut self, char: &char) {
+        if char == &'\n' {
+            self.cursor.next_line();
+        } else {
+            self.cursor.next_col();
+        }
     }
 }

packages/engine/src/lexer/tokens.rs

@@ -106,6 +106,7 @@ pub enum LexerTokenKind {
     RangeInclusive,
     /// `\n`
     EOL,
+    EOF,
 
     Identifier,
     String,

packages/engine/src/parser/ast.rs

@@ -25,10 +25,10 @@ pub enum Expression {
 
 #[derive(lang_macro::EnumVariants, Debug, Clone, PartialEq, Eq)]
 pub enum Statement {
-    While(Box<(Expression, Block)>),
-    For(Box<(Variable, Expression, Block)>),
-    Return(Box<Option<Expression>>),
-    Expression(Box<Expression>),
+    While(Box<(WithCursor<Expression>, Block)>),
+    For(Box<(Variable, WithCursor<Expression>, Block)>),
+    Return(Box<Option<WithCursor<Expression>>>),
+    Expression(Box<WithCursor<Expression>>),
     Continue,
     Break,
     Variable(Box<Variable>),