fire: Add handling of builtin arithmetic operations

fire/Cargo.toml

@@ -15,3 +15,4 @@ name_resolve = { path = "../name_resolve" }
 typecheck = { path = "../typecheck" }
 xparser = { path = "../xparser" }
 location = { path = "../location" }
+builtins = { path = "../builtins" }

fire/src/lib.rs

@@ -16,6 +16,8 @@ use instance::Instance;
 use fir::{Fir, Kind, Node, OriginIdx, RefIdx};
 use flatten::FlattenData;
 
+mod outside;
+
 // Emit a fatal error from the [`Fire`].
 // macro_rules! fire_fatal {
 //     ($fmt:literal $($args:tt),*) => {
@@ -57,7 +59,7 @@ impl Interpret for Fir<FlattenData<'_>> {
 }
 
 /// It's called [`GarbajKollector`] because this way you have "jk" in the middle of the word :)
-struct GarbaJKollector(HashMap<OriginIdx, Instance>);
+pub struct GarbaJKollector(HashMap<OriginIdx, Instance>);
 
 // FIXME: Add documentation for all methods
 impl GarbaJKollector {
@@ -118,38 +120,6 @@ impl<'ast, 'fir> Fire<'ast, 'fir> {
         &self.fir.nodes[&resolved]
     }
 
-    // TODO: Move outside of the impl block?
-    fn perform_extern_call(
-        &self,
-        node: &Node<FlattenData<'_>>,
-        args: &[RefIdx],
-    ) -> Option<Instance> {
-        let ast = node.data.ast.node();
-        let name = match &ast.node {
-            ast::Node::Function {
-                decl: ast::Declaration { name, .. },
-                ..
-            } => name,
-            other => {
-                dbg!(other);
-                unreachable!()
-            }
-        };
-
-        if name.access() == "println" {
-            args.iter().for_each(|arg| {
-                let value = self.gc.lookup(&arg.expect_resolved()).unwrap();
-                if let Instance::String(s) = value {
-                    println!("{s}");
-                } else {
-                    unreachable!("typecheck didn't catch this error. this is an interpreter bug.");
-                }
-            })
-        }
-
-        None
-    }
-
     #[must_use]
     fn fire_block(
         &mut self,
@@ -215,7 +185,7 @@ impl<'ast, 'fir> Fire<'ast, 'fir> {
         // FIXME: We need to add bindings here between the function's variables and the arguments given to the call
         match block {
             None => {
-                let result = self.perform_extern_call(def, args);
+                let result = outside::perform_call(&self.gc, def, args);
                 if let Some(instance) = result {
                     self.gc.allocate(node.origin, instance);
                 }
@@ -413,20 +383,25 @@ impl<'ast, 'fir> Fire<'ast, 'fir> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use builtins::AppendAstBuiltins;
     use flatten::FlattenAst;
     use name_resolve::NameResolve;
     use typecheck::TypeCheck;
 
     macro_rules! ast {
         ($($toks:tt)*) => {
-            xparser::ast!(
-                type char;
-                type bool;
-                type int;
-                type float;
-                type string;
-                $($toks)*
-            )
+            {
+                let ast = xparser::ast!(
+                    type char;
+                    type bool;
+                    type int;
+                    type float;
+                    type string;
+                    $($toks)*
+                );
+
+                ast.append_builtins().unwrap()
+            }
         }
     }
 
@@ -597,4 +572,12 @@ mod tests {
         let result = fir!(ast).interpret();
         assert_eq!(result, Some(Instance::from("one")));
     }
+
+    #[test]
+    fn arithmetic() {
+        let ast = ast! { 14 * 2 };
+
+        let result = fir!(ast).interpret();
+        assert_eq!(result, Some(Instance::from(28)));
+    }
 }

fire/src/outside.rs

@@ -0,0 +1,104 @@
+//! This module takes care of performing calls to extern functions. Extern functions will
+//! either be builtins, or C functions defined in a dynamic library loaded with the `link_with`
+//! builtin.
+
+use fir::{Node, RefIdx};
+use flatten::FlattenData;
+
+use crate::instance::Instance;
+use crate::GarbaJKollector;
+
+// TODO: Factor this with `ast_builtins`?
+static ARITHMETIC_BUILTINS: &[&'static str] = &["+", "-", "*", "/"];
+
+enum Arithmetic {
+    Add,
+    Sub,
+    Mul,
+    Div,
+}
+
+impl From<&str> for Arithmetic {
+    fn from(s: &str) -> Self {
+        match s {
+            "+" => Arithmetic::Add,
+            "-" => Arithmetic::Sub,
+            "*" => Arithmetic::Mul,
+            "/" => Arithmetic::Div,
+            _ => unreachable!("this is an interpreter error."),
+        }
+    }
+}
+
+pub fn perform_call(
+    // FIXME: This should probably take a context, correct? &self?
+    gc: &GarbaJKollector,
+    node: &Node<FlattenData<'_>>,
+    args: &[RefIdx],
+) -> Option<Instance> {
+    let ast = node.data.ast.node();
+    let name = match &ast.node {
+        ast::Node::Function {
+            decl: ast::Declaration { name, .. },
+            ..
+        } => name,
+        other => {
+            dbg!(other);
+            unreachable!()
+        }
+    };
+
+    if ARITHMETIC_BUILTINS.contains(&name.access()) {
+        return Some(arithmetic_builtin_call(
+            gc,
+            args,
+            Arithmetic::from(name.access()),
+        ));
+    }
+
+    if name.access() == "println" {
+        args.iter().for_each(|arg| {
+            let value = gc.lookup(&arg.expect_resolved()).unwrap();
+            if let Instance::String(s) = value {
+                println!("{s}");
+            } else {
+                unreachable!("typecheck didn't catch this error. this is an interpreter bug.");
+            }
+        })
+    }
+
+    None
+}
+
+fn int_op(lhs: &i64, rhs: &i64, op: Arithmetic) -> Instance {
+    let res = match op {
+        Arithmetic::Add => lhs + rhs,
+        Arithmetic::Sub => lhs - rhs,
+        Arithmetic::Mul => lhs * rhs,
+        Arithmetic::Div => lhs / rhs,
+    };
+
+    Instance::Int(res)
+}
+
+fn float_op(lhs: &f64, rhs: &f64, op: Arithmetic) -> Instance {
+    let res = match op {
+        Arithmetic::Add => lhs + rhs,
+        Arithmetic::Sub => lhs - rhs,
+        Arithmetic::Mul => lhs * rhs,
+        Arithmetic::Div => lhs / rhs,
+    };
+
+    Instance::Float(res)
+}
+
+fn arithmetic_builtin_call(gc: &GarbaJKollector, args: &[RefIdx], op: Arithmetic) -> Instance {
+    let lhs = gc.lookup(&args[0].expect_resolved()).unwrap();
+    let rhs = gc.lookup(&args[1].expect_resolved()).unwrap();
+
+    match (lhs, rhs) {
+        (Instance::Int(l), Instance::Int(r)) => int_op(l, r, op),
+        (Instance::Float(l), Instance::Float(r)) => float_op(l, r, op),
+        _ => unreachable!("fuck me"),
+    }
+}