Rewriting statements

parser/src/grammar.pest

@@ -11,9 +11,9 @@ boolean    =  { "true" | "false" }
 string_lit =  { "\"" ~ inner_str ~ "\"" }
 inner_str  = @{ (!"\"" ~ ANY)* }
 
-export     = { "public" }
-mutable    = { "mut" }
-var_decl_1 = { type_expr ~ mutable? ~ identifier }
+export   = { "public" }
+mutable  = { "mut" }
+var_decl = { type_expr ~ mutable? ~ identifier }
 
 // ================= TOP LEVEL =================
 
@@ -24,7 +24,7 @@ import = { "import" ~ string_lit ~ ";" }
 field_list = { field ~ ("," ~ field)* ~ ","? }
 field      = { export? ~ type_expr ~ identifier }
 
-param_list = { var_decl_1 ~ ("," ~ var_decl_1)* ~ ","? }
+param_list = { var_decl ~ ("," ~ var_decl)* ~ ","? }
 
 struct_decl = {
     export? ~ "struct" ~ identifier ~ "{" ~ field_list? ~ "}"
@@ -61,7 +61,7 @@ break_stmt = { "break" ~ ";" }
 
 continue_stmt = { "continue" ~ ";" }
 
-var_decl_statement = { var_decl_1 ~ ";" }
+var_decl_statement = { var_decl ~ ("=" ~ expr)? ~ ";" }
 
 if_stmt = {
     "if" ~ "(" ~ expr ~ ")" ~ statement ~ ("else" ~ statement)?

parser/src/lib.rs

@@ -17,6 +17,8 @@ pub type ParseError = pest::error::Error<Rule>;
 pub fn parse(source: &str) -> Result<Vec<TopLevel>, ParseError> {
     let mut pairs = MistParser::parse(Rule::program, source)?;
 
+    println!("{pairs:#?}");
+
     let mut statements = vec![];
 
     for pair in pairs.next().unwrap().into_inner() {
@@ -180,15 +182,18 @@ impl From<pest::iterators::Pair<'_, Rule>> for Statement {
 
             Rule::block => Statement::Block(Block::from(pair.into_inner().next().unwrap())),
 
-            Rule::var_decl => {
+            Rule::var_decl_statement => {
                 let mut inner = pair.into_inner();
 
-                let type_ = inner.next().map(TypeExpr::try_from).unwrap().ok();
-                let name = inner.next().unwrap().as_str().to_string();
+                let mut var_decl = inner.next().unwrap().into_inner();
+
+                let type_ = var_decl.next().map(TypeExpr::try_from).unwrap().ok();
+                let name = var_decl.next().unwrap().as_str().to_string();
                 let init = inner.next().map(Expression::from);
+                let mutable = inner.next().is_some();
 
                 Statement::VarDecl {
-                    mutable: false,
+                    mutable,
                     name: name.as_str().to_string(),
                     init,
                     type_,
@@ -234,49 +239,6 @@ impl From<pest::iterators::Pair<'_, Rule>> for Statement {
                 }
             }
 
-            Rule::for_stmt => {
-                let mut inner = pair.into_inner();
-
-                let init = inner
-                    .next()
-                    .map(|p| match p.as_rule() {
-                        Rule::var_decl => {
-                            let mut it = p.into_inner();
-
-                            let name = it.next().unwrap().as_str().to_string();
-                            let init_expr = it
-                                .next()
-                                .map(|e| Expression::from(e.into_inner().next().unwrap()));
-
-                            (false, name, init_expr)
-                        }
-                        _ => unimplemented!(
-                            "For loop init parsing not implemented yet: {:?}",
-                            p.as_rule()
-                        ),
-                    })
-                    .unwrap();
-
-                let condition = inner.next().map(Expression::from);
-                let update = inner.next().map(parse_var_assign_no_semicolon);
-                let body = Statement::from(inner.next().unwrap());
-
-                Statement::For {
-                    init,
-                    condition,
-                    update: update.map(Box::new),
-                    body: Box::new(body),
-                }
-            }
-
-            Rule::var_assign => {
-                let mut inner = pair.into_inner();
-                let target = Expression::from(inner.next().unwrap());
-                let value = Expression::from(inner.next().unwrap());
-
-                Statement::VarAssign { target, value }
-            }
-
             _ => unimplemented!(
                 "Statement parsing not implemented yet: {:?}",
                 pair.as_rule()