Working expr statements

mist-test/src/main.mist

@@ -1,3 +1,5 @@
 void main() {
+    i32 x;
+
     println!("hello, world");
 }

parser/src/ast/expr.rs

@@ -30,6 +30,7 @@ pub enum BinaryOp {
 pub enum Expression {
     Literal(Literal),
     Path(ExprPath),
+    Statement(Box<Statement>),
     Fix {
         initial: Box<Expression>,
         prefixes: Vec<Prefix>,

parser/src/ast/statement.rs

@@ -3,13 +3,11 @@ use serde::Serialize;
 use super::*;
 
 #[derive(Debug, Clone, Serialize, Default)]
-pub struct Block(pub Vec<Spanned<Statement>>);
+pub struct Block(pub Vec<Spanned<Expression>>);
 
 #[derive(Debug, Clone, Serialize)]
 pub enum Statement {
-    Expression(Expression),
     Block(Block),
-
     VarDecl(VarDeclStmt),
     Assign {
         target: Expression,

parser/src/grammar.pest

@@ -342,8 +342,8 @@ block = {
     "{" ~ (statement | unexpected_statement)* ~ "}"
 }
 
-statement = {
-    (expr | basic_stmt_left_recurse) ~ semicolon
+statement = _{
+    ((expr | basic_stmt_left_recurse) ~ semicolon)
 }
 
 // ------------------------------------------------------

parser/src/parser/common/expr.rs

@@ -117,6 +117,12 @@ 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 => ast_expr!(Expression::Statement(
+                pair.try_into().get_map(Box::new).map(Box::new)
+            )),
+            Rule::basic_stmt => ast_expr!(Expression::Statement(
+                pair.try_into().get_map(Box::new).map(Box::new)
+            )),
 
             _ => AstError::bug_unimplemented(pair),
         }

parser/src/parser/common/statement.rs

@@ -39,7 +39,7 @@ impl<'a> TryFrom<pest::iterators::Pair<'a, Rule>> for Statement {
         let mut inner = pair.clone().into_inner();
 
         match rule {
-            Rule::statement => Statement::try_from(inner.next().unwrap()),
+            Rule::statement | Rule::basic_stmt => Statement::try_from(inner.next().unwrap()),
 
             Rule::block => ast_expr!(Statement::Block(pair.try_into())),
 

src/codegen.rs

@@ -169,6 +169,12 @@ impl GetRust for Expression {
         match self {
             Expression::Path(path) => path.get_rust(),
             Expression::Literal(literal) => literal.get_rust(),
+            Expression::Statement(stmt) => {
+                let mut cg = RustCodegen::new();
+                cg.indent += 1;
+                stmt.to_rust(&mut cg);
+                cg.output
+            }
             Expression::Fix {
                 initial,
                 prefixes,
@@ -336,7 +342,7 @@ impl<T: ToRust> ToRust for Spanned<T> {
 impl ToRust for Block {
     fn to_rust(self, cg: &mut RustCodegen) {
         for stmt in self.0 {
-            stmt.to_rust(cg);
+            cg.add_indentedln(&(stmt.get_rust() + ";"));
         }
     }
 }
@@ -608,10 +614,6 @@ impl ToRust for TopLevelKind {
 impl ToRust for Statement {
     fn to_rust(self, cg: &mut RustCodegen) {
         match self {
-            Statement::Expression(expr) => {
-                cg.add_indentedln(&format!("{};", expr.get_rust()));
-            }
-
             Statement::Block(block) => {
                 cg.add_indentedln("{");
                 cg.indent += 1;