Soft returning refactor

crates/codegen/src/expr.rs

@@ -103,7 +103,7 @@ impl GenRust for Expression {
         if ensure_semicolon {
             ctx.expr_ensure_semicolon = true;
 
-            if !self.is_block() {
+            if !self.is_soft_return() {
                 cg.add(";");
             }
         }

crates/codegen/src/lib.rs

@@ -94,6 +94,13 @@ impl RustCodegen {
             }
         }
     }
+
+    pub fn ensure_brackets_body(&mut self, ctx: &mut Context, expr: &StatementBody) {
+        match expr {
+            StatementBody::Statement(expr) => self.ensure_brackets_expr(ctx, expr),
+            StatementBody::Expression(expr) => self.ensure_brackets_expr(ctx, expr),
+        }
+    }
 }
 
 impl GenRust for Attribute {

crates/codegen/src/statement.rs

@@ -26,6 +26,18 @@ impl GenRust for Block {
     }
 }
 
+impl GenRust for StatementBody {
+    fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
+        match self {
+            Self::Expression(expr) => expr.gen_rust(ctx, cg),
+            Self::Statement(stmt) => {
+                stmt.gen_rust(ctx, cg);
+                cg.add(";");
+            }
+        }
+    }
+}
+
 impl GenRust for Statement {
     fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen) {
         match self {
@@ -76,18 +88,18 @@ impl GenRust for Statement {
                 cg.add("if ");
                 initial.condition.gen_rust(ctx, cg);
                 cg.add(" ");
-                cg.ensure_brackets_expr(ctx, &initial.body);
+                cg.ensure_brackets_body(ctx, &initial.body);
 
                 for else_if_branch in else_if {
                     cg.add("else if");
                     else_if_branch.condition.gen_rust(ctx, cg);
                     cg.add(" ");
-                    cg.ensure_brackets_expr(ctx, &else_if_branch.body);
+                    cg.ensure_brackets_body(ctx, &else_if_branch.body);
                 }
 
                 if let Some(else_br) = else_branch {
                     cg.add(" else ");
-                    cg.ensure_brackets_expr(ctx, else_br);
+                    cg.ensure_brackets_body(ctx, else_br);
                 }
             }
 
@@ -95,12 +107,12 @@ impl GenRust for Statement {
                 cg.add("while ");
                 condition.gen_rust(ctx, cg);
                 cg.add(" ");
-                cg.ensure_brackets_expr(ctx, body);
+                cg.ensure_brackets_body(ctx, body);
             }
 
             Statement::Loop(body) => {
                 cg.add("loop ");
-                cg.ensure_brackets_expr(ctx, body);
+                cg.ensure_brackets_body(ctx, body);
             }
 
             Statement::CStyleFor {
@@ -156,7 +168,7 @@ impl GenRust for Statement {
                 pattern.gen_rust(ctx, cg);
                 cg.add(" in ");
                 iterator.gen_rust(ctx, cg);
-                cg.ensure_brackets_expr(ctx, body);
+                cg.ensure_brackets_body(ctx, body);
             }
 
             Statement::Return(expr) => {

crates/parser/src/ast/expr.rs

@@ -84,9 +84,9 @@ pub enum Generic {
 }
 
 impl Expression {
-    pub fn is_block(&self) -> bool {
+    pub fn is_soft_return(&self) -> bool {
         if let Expression::Statement(stmt) = self {
-            stmt.is_block()
+            stmt.is_soft_return()
         } else {
             false
         }

crates/parser/src/ast/statement.rs

@@ -10,7 +10,7 @@ pub struct Block(
 
 #[derive(Debug, Clone, Serialize)]
 pub enum StatementBody {
-    Statement(Box<Statement>),
+    Statement(Expression),
     Expression(Expression),
 }
 
@@ -64,12 +64,12 @@ pub struct StatementBranch {
 }
 
 impl Statement {
-    pub fn is_block(&self) -> bool {
+    pub fn is_soft_return(&self) -> bool {
         match self {
             Self::Block(_) | Self::Match(_, _) => true,
-            Self::While(branch) => branch.body.is_block(),
+            Self::While(branch) => branch.body.is_soft_return(),
             Self::For { body, .. } | Self::Loop(body) | Self::CStyleFor { body, .. } => {
-                body.is_block()
+                body.is_soft_return()
             }
             Self::If {
                 initial,
@@ -78,13 +78,13 @@ impl Statement {
             } => {
                 else_branch
                     .as_ref()
-                    .map(|v| v.is_block())
+                    .map(|v| v.is_soft_return())
                     .unwrap_or_default()
                     || else_if
                         .last()
-                        .map(|b| b.body.is_block())
+                        .map(|b| b.body.is_soft_return())
                         .unwrap_or_default()
-                    || initial.body.is_block()
+                    || initial.body.is_soft_return()
             }
             _ => false,
         }
@@ -92,10 +92,10 @@ impl Statement {
 }
 
 impl StatementBody {
-    pub fn is_block(&self) -> bool {
+    pub fn is_soft_return(&self) -> bool {
         match self {
-            Self::Expression(_) => false,
+            Self::Expression(_) => true,
-            _ => true,
+            _ => false,
         }
     }
 }

crates/parser/src/parser/common/expr.rs

@@ -13,7 +13,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Expression {
 
     fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result<Self, Self::Error> {
         let rule = pair.as_rule();
-        let inner = pair.clone().into_inner();
+        let mut inner = pair.clone().into_inner();
 
         match rule {
             Rule::expr => {
@@ -79,6 +79,15 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Expression {
             Rule::static_path => ast_expr!(Expression::Path(pair.try_into())),
             Rule::literal => ast_expr!(Expression::Literal(pair.try_into())),
             Rule::expr_path => ast_expr!(Expression::Path(pair.try_into())),
+            Rule::statement_wrapper => {
+                let i = inner.next().unwrap();
+                match i.as_rule() {
+                    Rule::expr => i.try_into(),
+                    _ => ast_expr!(Expression::Statement(
+                        i.try_into().get_map(Box::new).map(Box::new)
+                    )),
+                }
+            }
             Rule::statement | Rule::basic_stmt | Rule::control_flow => ast_expr!(
                 Expression::Statement(pair.try_into().get_map(Box::new).map(Box::new))
             ),

crates/parser/src/parser/common/statement.rs

@@ -29,7 +29,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for StatementBody {
 
             match i.as_rule() {
                 Rule::expr => ast_expr!(StatementBody::Expression(i.try_into())),
-                Rule::statement_wrapper => ast_expr!(StatementBody::Statement(i.try_into().map(Box::new).get_map(Box::new))),
+                Rule::statement_wrapper => ast_expr!(StatementBody::Statement(i.try_into())),
                 _ => AstError::bug_unimplemented(i),
             }
         })

mist-test/src/main.mist

@@ -13,4 +13,16 @@ void main() {
 
 void do_stuff() {
     vec!(1, 2, 3).into_iter().map(Option<i32> |var v| {Some(v)}).collect::<Vec<_>>();
+
+    if (43=69) testing1();    
+}
+
+i32 testing1() {
+
+    i32 v = if (0 == 0) {
+        0
+    } else {
+        1
+    };
+    v
 }