Compound assign statement

mist-test/src/app.mist

@@ -46,7 +46,7 @@ pub class Application {
     void tick(self mut*) {
         self.logger.info("tick");
 
-        self.ticks = self.ticks + 1;
+        self.ticks += 1;
 
         var task = task::create_task("background-job");
 

parser/src/ast.rs

@@ -181,7 +181,15 @@ pub enum Statement {
     Block(Block),
 
     VarDecl(VarDeclStmt),
-    VarAssign(VarAssignStmt),
+    Assign {
+        target: Expression,
+        value: Expression,
+    },
+    CompoundAssign {
+        target: Expression,
+        compound: String,
+        value: Expression,
+    },
     If {
         initial: StatementBranch,
         else_if: Vec<StatementBranch>,

parser/src/grammar.pest

@@ -314,6 +314,7 @@ statement = _{
     expr_stmt
   | match_stmt
   | assign_statement
+  | compound_assign_statement
   | if_stmt
   | while_stmt
   | c_for_stmt
@@ -353,6 +354,22 @@ assign_statement = {
     expr ~ "=" ~ expr ~ semicolon
 }
 
+compound_assign = {
+    "+="
+  | "-="
+  | "/="
+  | "%="
+  | "&="
+  | "|="
+  | "^="
+  | "<<="
+  | ">>="
+}
+
+compound_assign_statement = {
+    expr ~ compound_assign ~ expr ~ semicolon
+}
+
 // ------------------------------------------------------
 // CONDITIONALS
 // ------------------------------------------------------

parser/src/parser/common/statement.rs

@@ -88,13 +88,10 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Statement {
                 body: inner.next().unwrap().try_into().map(Box::new),
             }),
 
-            Rule::assign_statement => ast_expr!(VarAssignStmt {
+            Rule::assign_statement => ast_expr!(Statement::Assign {
                 target: inner.next().unwrap().try_into(),
                 value: inner.next().unwrap().try_into(),
-            })
-            .map(Statement::VarAssign)
-            .get_map(Statement::VarAssign),
-
+            }),
             Rule::match_stmt => ast_expr!(Statement::Match(
                 inner.next().unwrap().try_into(),
                 inner
@@ -108,6 +105,15 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Statement {
                     .collect::<AstResult<'a, Vec<_>>>(),
             )),
 
+            Rule::compound_assign_statement => {
+                ast_expr!(Statement::CompoundAssign {
+                    target: inner.next().unwrap().try_into(),
+                    compound: Ok(inner.next().unwrap().as_str().trim().to_string())
+                        as AstResult<'_, String>,
+                    value: inner.next().unwrap().try_into(),
+                })
+            }
+
             Rule::unexpected_statement => {
                 return Err(AstError {
                     span: pair.as_span(),

src/codegen.rs

@@ -545,10 +545,23 @@ impl ToRust for Statement {
                 cg.add_indentedln(&format!("let {}{};", decl.get_rust(), init));
             }
 
-            Statement::VarAssign(VarAssignStmt { target, value }) => {
+            Statement::Assign { target, value } => {
                 cg.add_indentedln(&format!("{} = {};", target.get_rust(), value.get_rust(),));
             }
 
+            Statement::CompoundAssign {
+                target,
+                compound,
+                value,
+            } => {
+                cg.add_indentedln(&format!(
+                    "{} {} {};",
+                    target.get_rust(),
+                    compound,
+                    value.get_rust(),
+                ));
+            }
+
             Statement::Match(expr, match_items) => {
                 cg.add_indentedln(&format!("match {} {{", expr.get_rust()));
                 cg.indent += 1;