added if expression

- kos codegen not yet updated

Author: DigitalCodeCrafter

src/ast_interpreter.rs

@@ -115,6 +115,15 @@ fn eval_expr<'a>(expr: &Expr<'a>, env: &Env<'a>) -> Result<Value, EvalError> {
             tail_expr.as_ref().map(|expr| eval_expr(expr, &inner_env)).unwrap_or(Ok(Value::Unit))
         }
 
+        ExprKind::If { cond, then_branch, else_brach } => {
+            let result = eval_expr(cond, env)?;
+            match result {
+                Value::Bool(true) => eval_expr(then_branch, env),
+                Value::Bool(false) => else_brach.as_ref().map(|b| eval_expr(b, env)).unwrap_or(Ok(Value::Unit)),
+                _ => return Err(EvalError::InvalidType(result, Value::Bool(false), expr.span))
+            }
+        }
+
         ExprKind::Error(_) => Err(EvalError::InvalidExpression(expr.span)),
     }
 }

src/backend/kerboscript.rs

@@ -95,6 +95,9 @@ impl KosEmitter {
         self.emit_indent();
         match term {
             Terminator::Goto(_) => todo!("Some good way to handle this too."),
+
+            Terminator::Branch(_, _, _) => todo!("Some good way to handle this... "),
+
             Terminator::Return(op) => {
                 self.emit("return ");
                 self.emit_operand(op);

src/grammar.ebnf

@@ -22,6 +22,7 @@ nud = Number
     | "-", Expression
     | "(", Expression, ")"
     | "{", { Statement }, "}"
+    | "if", Expression, Block, [ "else", Block ]
     ;
 
 led = "==", Expression

src/mir/lowerer.rs

@@ -120,6 +120,42 @@ impl MirBuilder<'_> {
                 }
             }
 
+            t::ExprKind::If { cond, then_branch, else_branch: Some(else_branch) } => {
+                let cond_place = Place { local: self.new_local(expr.ty.clone()), projection: Vec::new() };
+                self.lower_expr(cond_place.clone(), *cond);
+                let then_block = self.new_block();
+                let else_block = self.new_block();
+                let join_block = self.new_block();
+                self.set_terminator(Terminator::Branch(Operand::Move(cond_place), then_block, else_block));
+
+                self.switch_block(then_block);
+                self.lower_expr(dest.clone(), *then_branch);
+                self.set_terminator(Terminator::Goto(join_block));
+
+                self.switch_block(else_block);
+                self.lower_expr(dest, *else_branch);
+                self.set_terminator(Terminator::Goto(join_block));
+
+                self.switch_block(join_block);
+                return;
+            }
+
+            t::ExprKind::If { cond, then_branch, else_branch: None } => {
+                let cond_place = Place { local: self.new_local(expr.ty.clone()), projection: Vec::new() };
+                self.lower_expr(cond_place.clone(), *cond);
+                let then_block = self.new_block();
+                let join_block = self.new_block();
+                self.set_terminator(Terminator::Branch(Operand::Move(cond_place), then_block, join_block));
+
+                self.switch_block(then_block);
+                let fresh = Place { local: self.new_local(then_branch.ty.clone()), projection: Vec::new() };
+                self.lower_expr(fresh, *then_branch);
+                self.set_terminator(Terminator::Goto(join_block));
+                
+                self.switch_block(join_block);
+                RValue::Use(Operand::Const(Const::Unit))
+            }
+
             t::ExprKind::Error(_) => RValue::Poison,
         };
 
@@ -138,6 +174,22 @@ impl MirBuilder<'_> {
         let block = &mut self.blocks[self.current_block.0 as usize];
         block.instrs.push(instr);
     }
+
+    fn set_terminator(&mut self, terminator: Terminator) {
+        let block = &mut self.blocks[self.current_block.0 as usize];
+        block.terminator = terminator;
+    }
+
+    fn switch_block(&mut self, block: BlockId) {
+        assert!((block.0 as usize) < self.blocks.len(), "[Lowerer] Internal error: switched to non-existing block");
+        self.current_block = block;
+    }
+
+    fn new_block(&mut self) -> BlockId {
+        let id = BlockId(self.blocks.len() as u32);
+        self.blocks.push(Block { instrs: vec![], terminator: Terminator::Unreachable });
+        id
+    }
 }
 
 

src/mir/mir.rs

@@ -21,6 +21,7 @@ pub struct Block {
 #[derive(Debug, PartialEq)]
 pub enum Terminator {
     Goto(BlockId),
+    Branch(Operand, BlockId, BlockId),
     Return(Operand),
     Unreachable,
 }

src/mir/passes/const_prop.rs

@@ -67,6 +67,7 @@ fn prop_in_terminator(const_map: &HashMap<LocalId, Const>, term: &mut Terminator
     match term {
         Terminator::Goto(_) => {},
         Terminator::Return(op) => prop_in_operand(const_map, op),
+        Terminator::Branch(op, _, _) => prop_in_operand(const_map, op),
         Terminator::Unreachable => {},
     }
 }

src/mir/passes/copy_prop.rs

@@ -66,6 +66,7 @@ fn prop_in_terminator(copy_map: &HashMap<LocalId, LocalId>, term: &mut Terminato
     match term {
         Terminator::Goto(_) => {},
         Terminator::Return(op) => prop_in_operand(copy_map, op),
+        Terminator::Branch(op, _, _) => prop_in_operand(copy_map, op),
         Terminator::Unreachable => {},
     }
 }

src/mir/passes/dead_local_elim.rs

@@ -1,5 +1,5 @@
 use std::collections::HashSet;
-use crate::mir::{Block, DebugKind, Instr, LocalId, Operand, Place, RValue, passes::Pass};
+use crate::mir::{Block, DebugKind, Instr, LocalId, Operand, Place, RValue, Terminator, passes::Pass};
 
 
 pub struct DeadLocalElim;
@@ -44,6 +44,7 @@ fn find_live_in_block(used: &mut HashSet<LocalId>, block: &Block) {
             }
         }
     }
+    find_live_in_term(used, &block.terminator);
 }
 
 fn find_live_in_rval(used: &mut HashSet<LocalId>, rval: &RValue) {
@@ -58,6 +59,15 @@ fn find_live_in_rval(used: &mut HashSet<LocalId>, rval: &RValue) {
     }
 }
 
+fn find_live_in_term(used: &mut HashSet<LocalId>, term: &Terminator) {
+    match term {
+        Terminator::Goto(_) => {},
+        Terminator::Return(op) => find_live_in_op(used, op),
+        Terminator::Branch(op, _, _) => find_live_in_op(used, op),
+        Terminator::Unreachable => {},
+    }
+}
+
 fn find_live_in_op(used: &mut HashSet<LocalId>, op: &Operand) {
     match op {
         Operand::Copy(place) |
@@ -85,6 +95,7 @@ fn remap_in_block(remap: &[Option<LocalId>], block: &mut Block) {
             }
         }
     });
+    remap_in_term(remap, &mut block.terminator);
 }
 
 fn remap_in_rval(remap: &[Option<LocalId>], rval: &mut RValue) {
@@ -99,6 +110,15 @@ fn remap_in_rval(remap: &[Option<LocalId>], rval: &mut RValue) {
     }
 }
 
+fn remap_in_term(remap: &[Option<LocalId>], term: &mut Terminator) {
+    match term {
+        Terminator::Goto(_) => {},
+        Terminator::Return(op) => remap_in_op(remap, op),
+        Terminator::Branch(op, _, _) => remap_in_op(remap, op),
+        Terminator::Unreachable => {},
+    }
+}
+
 fn remap_in_op(remap: &[Option<LocalId>], op: &mut Operand) {
     match op {
         Operand::Copy(place) |

src/mir/pretty.rs

@@ -76,6 +76,7 @@ pub fn format_instr(i: &Instr) -> String {
 pub fn format_terminator(t: &Terminator) -> String {
     match t {
         Terminator::Goto(b) => format!("goto block{}", b.index()),
+        Terminator::Branch(op, then_block, else_block) => format!("branch {} [then -> block{}, else -> block{}]", format_operand(op), then_block.index(), else_block.index()),
         Terminator::Return(op) => format!("return {}", format_operand(op)),
         Terminator::Unreachable => "unreachable".to_string(),
     }

src/mir/verifier.rs

@@ -86,6 +86,11 @@ impl IRVerifier<'_> {
         match term {
             Terminator::Goto(id) => self.verify_block_id(*id),
             Terminator::Return(op) => self.verify_operand(op),
+            Terminator::Branch(op, then_block, else_block) => {
+                self.verify_operand(op);
+                self.verify_block_id(*then_block);
+                self.verify_block_id(*else_block);
+            }
             Terminator::Unreachable => {}
         }
     }