Add function calls to IR Generator

src/compiler/ir_generator.rs

@@ -220,7 +220,31 @@ fn visit_ast_node<'source>(
 
             symbols.get("unit").clone()
         }
-        FunCall(_, _) => todo!(),
+        FunCall(name, expressions) => {
+            let fn_var = symbols.get(name).clone();
+            let Type::Func(_, result_type) = types.get(&fn_var).unwrap().clone() else {
+                panic!("Function call does not have entry in types table!");
+            };
+
+            let mut args = Vec::new();
+            for expression in expressions {
+                args.push(visit_ast_node(
+                    expression,
+                    types,
+                    symbols,
+                    instructions,
+                    labels,
+                ));
+            }
+            let result_var = add_var(&result_type, types);
+
+            instructions.push(IrInstruction::new(
+                ast.loc,
+                Call(fn_var, args, result_var.clone()),
+            ));
+
+            result_var
+        }
         Block(expressions) => {
             let mut result_var = symbols.get("unit").clone();
             for expression in expressions {

src/compiler/symtab.rs

@@ -49,6 +49,9 @@ impl<'source> SymTab<'source, Type> {
     pub fn new_type_table() -> SymTab<'source, Type> {
         use Type::*;
         let globals = HashMap::from([
+            ("print_bool", Func(vec![Bool], Box::new(Unit))),
+            ("print_int", Func(vec![Int], Box::new(Unit))),
+            ("read_int", Func(vec![], Box::new(Int))),
             ("+", Func(vec![Int, Int], Box::new(Int))),
             ("*", Func(vec![Int, Int], Box::new(Int))),
             ("-", Func(vec![Int, Int], Box::new(Int))),

src/compiler/type_checker.rs

@@ -122,8 +122,8 @@ fn get_type<'source>(ast: &mut AstNode<'source>, symbols: &mut SymTab<'source, T
         }
         FunCall(name, args) => {
             let mut arg_types = Vec::new();
-            for mut arg in args {
-                arg_types.push(type_check(&mut arg, symbols));
+            for arg in args {
+                arg_types.push(type_check(arg, symbols));
             }
 
             let Type::Func(sig_arg_types, sig_ret_type) = symbols.get(name) else {