Consolidate Bolt PRs: optimize Value Display, Token comparisons, and tokenizer allocations

Agent-Logs-Url: https://github.com/ashyanSpada/expression_engine_rs/sessions/ca3024b8-72f8-4ddf-aa61-9c26416668e9

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

Author: Copilot

src/token.rs

@@ -52,18 +52,22 @@ impl From<&str> for DelimTokenType {
 }
 
 impl DelimTokenType {
-    pub fn string(&self) -> String {
+    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)]
@@ -85,19 +89,10 @@ pub enum Token<'input> {
 
 pub fn check_op(token: Token, expected: &str) -> bool {
     match token {
-        Token::Delim(op, _) => {
-            if op.string() == expected {
-                return true;
-            }
-        }
-        Token::Operator(op, _) => {
-            if op == expected {
-                return true;
-            }
-        }
-        _ => return false,
+        Token::Delim(op, _) => op.as_str() == expected,
+        Token::Operator(op, _) => op == expected,
+        _ => false,
     }
-    return false;
 }
 
 impl<'input> Token<'input> {
@@ -213,7 +208,7 @@ 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),
+            Delim(ty, span) => write!(f, "Delim Token: {}, {}", ty.as_str(), span),
             EOF => write!(f, "EOF"),
         }
     }

src/tokenizer.rs

@@ -58,7 +58,7 @@ impl<'a> Tokenizer<'a> {
         loop {
             match self.peek_one() {
                 Some((_, _ch)) => {
-                    if keyword::is_op(&(self.input[start..self.current() + 1].to_string())) {
+                    if keyword::is_op(&self.input[start..self.current() + 1]) {
                         self.next_one();
                     } else {
                         break;
@@ -145,7 +145,7 @@ impl<'a> Tokenizer<'a> {
         self.next()?;
         match token {
             Token::Delim(bracket, _) => {
-                if bracket.string() == op {
+                if bracket.as_str() == op {
                     return Ok(());
                 }
             }

src/value.rs

@@ -17,25 +17,23 @@ pub enum Value {
 impl fmt::Display for Value {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::String(val) => write!(f, "value string: {}", val.clone()),
-            Self::Number(val) => write!(f, "value number: {}", val.clone()),
-            Self::Bool(val) => write!(f, "value bool: {}", val.clone()),
+            Self::String(val) => write!(f, "value string: {}", val),
+            Self::Number(val) => write!(f, "value number: {}", val),
+            Self::Bool(val) => write!(f, "value bool: {}", val),
             Self::List(values) => {
-                let mut s = String::from("[");
+                write!(f, "value list: [")?;
                 for value in values {
-                    s.push_str(format!("{},", value.clone()).as_str());
+                    write!(f, "{},", value)?;
                 }
-                s.push_str("]");
-                write!(f, "value list: {}", s)
+                write!(f, "]")
             }
             Self::Map(m) => {
-                let mut s = String::from("{");
+                write!(f, "value map: {{")?;
                 for (k, v) in m {
-                    s.push_str(format!("key: {},", k.clone()).as_str());
-                    s.push_str(format!("value: {}; ", v.clone()).as_str());
+                    write!(f, "key: {},", k)?;
+                    write!(f, "value: {}; ", v)?;
                 }
-                s.push_str("}");
-                write!(f, "value map: {}", s)
+                write!(f, "}}")
             }
             Self::None => write!(f, "None"),
         }