add add/sub assign operators

andogq · Aug 20, 2024 · f92a41e · f92a41e
1 parent 40d3f26
commit f92a41e
Show file tree

Hide file tree

Showing 4 changed files with 62 additions and 8 deletions.
diff --git a/src/main.rs b/src/main.rs
@@ -13,7 +13,7 @@ fn main() {
                     break;
                 }
 
-                count = count + 1;
+                count += 1;
 
                 let temp = a;
                 a = b;
@@ -39,13 +39,13 @@ fn main() {
                     break;
                 }
 
-                counter = counter + 1;
+                counter += 1;
 
                 if counter == 10 {
                     continue;
                 }
 
-                n = n + 1;
+                n += 1;
             }
 
             let result1 = fib1(n);

diff --git a/src/repr/token.rs b/src/repr/token.rs
@@ -26,6 +26,10 @@ pub enum Token {
      */
     #[token("=")]
     Eq,
+    #[token("+=")]
+    AddAssign,
+    #[token("-=")]
+    MinusAssign,
     #[token("->")]
     ThinArrow,
     #[token(":")]
@@ -117,6 +121,8 @@ impl Display for Token {
             Token::And => write!(f, "&&"),
             Token::Or => write!(f, "||"),
             Token::Eq => write!(f, "="),
+            Token::AddAssign => write!(f, "+="),
+            Token::MinusAssign => write!(f, "-="),
             Token::ThinArrow => write!(f, "->"),
             Token::Colon => write!(f, ":"),
             Token::SemiColon => write!(f, ";"),

diff --git a/src/stage/parse/expression/e_assign.rs b/src/stage/parse/expression/e_assign.rs
@@ -34,3 +34,48 @@ pub fn parse_assign(compiler: &mut Compiler, tokens: &mut Lexer<'_>) -> Result<A
         ty_info: None,
     })
 }
+
+pub fn parse_op_assign(
+    compiler: &mut Compiler,
+    tokens: &mut Lexer<'_>,
+) -> Result<Assign, ParseError> {
+    let (binding, binding_span) = match tokens.next_spanned().unwrap() {
+        (Token::Ident(ident), span) => (ident, span),
+        (token, _) => {
+            return Err(ParseError::ExpectedToken {
+                expected: Box::new(Token::Ident(String::new())),
+                found: Box::new(token),
+                reason: "assign must start with ident".to_string(),
+            });
+        }
+    };
+
+    let binding = compiler.symbols.get_or_intern(binding);
+
+    let operation = match tokens.next_token().unwrap() {
+        Token::AddAssign => InfixOperation::Plus,
+        Token::MinusAssign => InfixOperation::Minus,
+        token => {
+            return Err(ParseError::UnexpectedToken(token));
+        }
+    };
+
+    let right = parse_expression(compiler, tokens, Precedence::Lowest)?;
+
+    Ok(Assign {
+        span: binding_span.start..right.span().end,
+        binding,
+        value: Box::new(Expression::Infix(Infix {
+            span: right.span().start..right.span().end,
+            left: Box::new(Expression::Ident(Ident {
+                span: binding_span,
+                binding,
+                ty_info: None,
+            })),
+            operation,
+            right: Box::new(right),
+            ty_info: None,
+        })),
+        ty_info: None,
+    })
+}
diff --git a/src/stage/parse/expression/mod.rs b/src/stage/parse/expression/mod.rs
@@ -1,6 +1,6 @@
 use std::iter;
 
-use e_assign::parse_assign;
+use e_assign::{parse_assign, parse_op_assign};
 use e_loop::parse_loop;
 
 use super::*;
@@ -40,10 +40,13 @@ impl Precedence {
 fn parse_prefix(compiler: &mut Compiler, tokens: &mut Lexer<'_>) -> Result<Expression, ParseError> {
     match tokens.peek_token().unwrap().clone() {
         Token::Integer(_) => Ok(Expression::Integer(parse_integer(compiler, tokens)?)),
-        Token::Ident(_) if matches!(tokens.double_peek_token(), Some(Token::Eq)) => {
-            Ok(Expression::Assign(parse_assign(compiler, tokens)?))
-        }
-        Token::Ident(_) => Ok(Expression::Ident(parse_ident(compiler, tokens)?)),
+        Token::Ident(_) => match tokens.double_peek_token().unwrap() {
+            Token::Eq => Ok(Expression::Assign(parse_assign(compiler, tokens)?)),
+            Token::AddAssign | Token::MinusAssign => {
+                Ok(Expression::Assign(parse_op_assign(compiler, tokens)?))
+            }
+            _ => Ok(Expression::Ident(parse_ident(compiler, tokens)?)),
+        },
         Token::True => Ok(Expression::Boolean(parse_boolean(compiler, tokens)?)),
         Token::False => Ok(Expression::Boolean(parse_boolean(compiler, tokens)?)),
         Token::LeftBrace => Ok(Expression::Block(parse_block(compiler, tokens)?)),