Improved for loop

parser/src/ast.rs

@@ -164,7 +164,8 @@ pub enum Statement {
         body: Box<Statement>,
     },
     For {
-        pattern: Identifier,
+        mutable: bool,
+        pattern: Pattern,
         iterator: Expression,
         body: Box<Statement>,
     },

parser/src/grammar.pest

@@ -142,7 +142,7 @@ c_for_stmt = {
 }
 
 for_stmt = {
-    "for" ~ "(" ~ identifier ~ "in" ~ expr ~ ")" ~ statement
+    "for" ~ "(" ~ mutable? ~ pattern ~ "in" ~ expr ~ ")" ~ statement
 }
 
 match_item = { pattern ~ "=>" ~ block }

parser/src/lib.rs

@@ -365,7 +365,8 @@ impl From<pest::iterators::Pair<'_, Rule>> for Statement {
             },
 
             Rule::for_stmt => Statement::For {
-                pattern: Identifier::from(inner.next().unwrap()),
+                mutable: listen_rule(&mut inner, Rule::mutable),
+                pattern: Pattern::from(inner.next().unwrap()),
                 iterator: inner.next().unwrap().into(),
                 body: Box::new(Statement::from(inner.next().unwrap())),
             },

src/codegen.rs

@@ -541,12 +541,14 @@ impl ToRust for Statement {
             }
 
             Statement::For {
+                mutable,
                 pattern,
                 iterator,
                 body,
             } => {
                 cg.add_indentedln(&format!(
-                    "for {} in {}",
+                    "for {}{} in {}",
+                    get_mutable(*mutable),
                     pattern.get_rust(),
                     iterator.get_rust()
                 ));
@@ -590,15 +592,18 @@ impl ToRust for FunctionDecl {
 
 impl GetRust for VarDecl {
     fn get_rust(&self) -> String {
-        let mutability = if self.mutable { "mut " } else { "" };
-
         let ty = self
             .type_
             .as_ref()
             .map(|t| format!(": {}", t.get_rust()))
             .unwrap_or_default();
 
-        format!("{}{}{}", mutability, self.name.get_rust(), ty)
+        format!(
+            "{}{}{}",
+            get_mutable(self.mutable),
+            self.name.get_rust(),
+            ty
+        )
     }
 }
 
@@ -709,3 +714,7 @@ pub fn get_static_type_path(path: &Path) -> String {
 pub fn get_type_postfixes(postfixes: &[TypePostfix]) -> String {
     postfixes.iter().map(TypePostfix::get_rust).collect()
 }
+
+pub fn get_mutable(mutable: bool) -> String {
+    if mutable { "mut " } else { "" }.to_string()
+}