From 63cc20107cfaedae8a83cce58070314f7ab9e41f Mon Sep 17 00:00:00 2001 From: Selimaj Dev Date: Sun, 24 May 2026 13:20:08 +0200 Subject: [PATCH] Soft returning refactor --- crates/codegen/src/expr.rs | 2 +- crates/codegen/src/lib.rs | 7 ++++++ crates/codegen/src/statement.rs | 24 +++++++++++++++----- crates/parser/src/ast/expr.rs | 4 ++-- crates/parser/src/ast/statement.rs | 20 ++++++++-------- crates/parser/src/parser/common/expr.rs | 11 ++++++++- crates/parser/src/parser/common/statement.rs | 2 +- mist-test/src/main.mist | 12 ++++++++++ 8 files changed, 61 insertions(+), 21 deletions(-) diff --git a/crates/codegen/src/expr.rs b/crates/codegen/src/expr.rs index c6fa873..0eddd32 100644 --- a/crates/codegen/src/expr.rs +++ b/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(";"); } } diff --git a/crates/codegen/src/lib.rs b/crates/codegen/src/lib.rs index 220cde2..951f928 100644 --- a/crates/codegen/src/lib.rs +++ b/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 { diff --git a/crates/codegen/src/statement.rs b/crates/codegen/src/statement.rs index 8f16fcb..f98bc0e 100644 --- a/crates/codegen/src/statement.rs +++ b/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) => { diff --git a/crates/parser/src/ast/expr.rs b/crates/parser/src/ast/expr.rs index 1c6eb6b..c3cc4de 100644 --- a/crates/parser/src/ast/expr.rs +++ b/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 } diff --git a/crates/parser/src/ast/statement.rs b/crates/parser/src/ast/statement.rs index 361a434..e7fbc21 100644 --- a/crates/parser/src/ast/statement.rs +++ b/crates/parser/src/ast/statement.rs @@ -10,7 +10,7 @@ pub struct Block( #[derive(Debug, Clone, Serialize)] pub enum StatementBody { - Statement(Box), + 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, - _ => true, + Self::Expression(_) => true, + _ => false, } } } diff --git a/crates/parser/src/parser/common/expr.rs b/crates/parser/src/parser/common/expr.rs index feb1e24..2bd9c67 100644 --- a/crates/parser/src/parser/common/expr.rs +++ b/crates/parser/src/parser/common/expr.rs @@ -13,7 +13,7 @@ impl<'a> TryFrom> for Expression { fn try_from(pair: pest::iterators::Pair<'a, Rule>) -> Result { 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> 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)) ), diff --git a/crates/parser/src/parser/common/statement.rs b/crates/parser/src/parser/common/statement.rs index 5fc632f..3f2db09 100644 --- a/crates/parser/src/parser/common/statement.rs +++ b/crates/parser/src/parser/common/statement.rs @@ -29,7 +29,7 @@ impl<'a> TryFrom> 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), } }) diff --git a/mist-test/src/main.mist b/mist-test/src/main.mist index d0e58d0..47de144 100644 --- a/mist-test/src/main.mist +++ b/mist-test/src/main.mist @@ -13,4 +13,16 @@ void main() { void do_stuff() { vec!(1, 2, 3).into_iter().map(Option |var v| {Some(v)}).collect::>(); + + if (43=69) testing1(); +} + +i32 testing1() { + + i32 v = if (0 == 0) { + 0 + } else { + 1 + }; + v }