⚡ Bolt: Zero-allocation string evaluation for DelimTokenType and expected matching

Refactored `DelimTokenType` and `Tokenizer` logic to eliminate redundant `String` allocations during token identification and checking.

- Introduced `as_str()` returning `&'static str` for `DelimTokenType` variants.
- Refactored `check_op` and `fmt::Display` to use `as_str()` instead of `string()`.
- Optimized `Tokenizer::expect` to validate tokens directly without intermediate `.clone()` and `.string()` operations.
- Fixed a bug where a delimiter string mismatch would not emit the `ExpectedOpNotExist` error because `Tokenizer::expect` falsely returned `Ok(())` in the catch-all `_` block.

Co-authored-by: ashyanSpada <22587148+ashyanSpada@users.noreply.github.com>

Author: google-labs-jules[bot]

src/token.rs

@@ -52,18 +52,23 @@ impl From<&str> for DelimTokenType {
 }
 
 impl DelimTokenType {
-    pub fn string(&self) -> String {
+    // ⚡ Bolt Optimization: Use `&'static str` to prevent heap allocation during string comparison.
+    pub fn as_str(&self) -> &'static str {
         use DelimTokenType::*;
         match self {
-            OpenParen => "(".to_string(),
-            CloseParen => ")".to_string(),
-            OpenBracket => "[".to_string(),
-            CloseBracket => "]".to_string(),
-            OpenBrace => "{".to_string(),
-            CloseBrace => "}".to_string(),
-            Unknown => "??".to_string(),
+            OpenParen => "(",
+            CloseParen => ")",
+            OpenBracket => "[",
+            CloseBracket => "]",
+            OpenBrace => "{",
+            CloseBrace => "}",
+            Unknown => "??",
         }
     }
+
+    pub fn string(&self) -> String {
+        self.as_str().to_string()
+    }
 }
 
 #[derive(Clone, PartialEq, Debug, Copy)]
@@ -83,10 +88,11 @@ pub enum Token<'input> {
     EOF,
 }
 
+// ⚡ Bolt Optimization: Replace `op.string()` with `op.as_str()` to avoid `String` allocation on check
 pub fn check_op(token: Token, expected: &str) -> bool {
     match token {
         Token::Delim(op, _) => {
-            if op.string() == expected {
+            if op.as_str() == expected {
                 return true;
             }
         }
@@ -187,7 +193,7 @@ impl<'input> Token<'input> {
             Reference(val, _) => val.to_string(),
             Function(val, _) => val.to_string(),
             Semicolon(val, _) => val.to_string(),
-            Delim(ty, _) => ty.string(),
+            Delim(ty, _) => ty.as_str().to_string(),
             EOF => "EOF".to_string(),
         }
     }
@@ -213,7 +219,8 @@ impl<'input> fmt::Display for Token<'input> {
             Function(val, span) => write!(f, "Function Token: {}, {}", val, span),
             String(val, span) => write!(f, "String Token: {}, {}", val, span),
             Semicolon(val, span) => write!(f, "Semicolon Token: {}, {}", val, span),
-            Delim(ty, span) => write!(f, "Delim Token: {}, {}", ty.string(), span),
+            // ⚡ Bolt Optimization: Avoid intermediate allocation by using `as_str()` directly
+            Delim(ty, span) => write!(f, "Delim Token: {}, {}", ty.as_str(), span),
             EOF => write!(f, "EOF"),
         }
     }

src/tokenizer.rs

@@ -141,29 +141,22 @@ impl<'a> Tokenizer<'a> {
     }
 
     pub fn expect(&mut self, op: &str) -> Result<()> {
-        let token = self.cur_token.clone();
-        self.next()?;
-        match token {
-            Token::Delim(bracket, _) => {
-                if bracket.string() == op {
-                    return Ok(());
-                }
-            }
-            Token::Operator(operator, _) => {
-                if operator == op {
-                    return Ok(());
-                }
-            }
-            Token::Comma(c, _) => {
-                if c == op {
-                    return Ok(());
-                }
-            }
-            _ => {
-                return Err(Error::ExpectedOpNotExist(op.to_string()));
-            }
+        // ⚡ Bolt Optimization:
+        // Validate token strictly before consuming it (`self.next()?`) to fix an incorrect parsing fallback
+        // and eliminate redundant `Token::clone()` and `.string()` allocations entirely.
+        let is_match = match self.cur_token {
+            Token::Delim(bracket, _) => bracket.as_str() == op,
+            Token::Operator(operator, _) => operator == op,
+            Token::Comma(c, _) => c == op,
+            _ => false,
+        };
+
+        if is_match {
+            self.next()?;
+            Ok(())
+        } else {
+            Err(Error::ExpectedOpNotExist(op.to_string()))
         }
-        Ok(())
     }
 
     fn delim_token(&mut self, start: usize) -> Result<Token<'a>> {