Improved operator support

Robert-M-Lucas · Jun 8, 2024 · ad80498 · ad80498
1 parent b573fba
commit ad80498
Show file tree

Hide file tree

Showing 17 changed files with 180 additions and 94 deletions.
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
diff --git a/build/out.asm b/build/out.asm
@@ -2,60 +2,34 @@
 
     section .text
 
-_2:
-    push rbp
-    mov rbp, rsp
-    
-    mov rax, qword [rbp+16]
-    mov qword [rbp-16], rax
-    mov rax, qword [rbp+24]
-    mov qword [rbp-24], rax
-    mov rax, qword [rbp-16]
-    add rax, qword [rbp-24]
-    mov qword [rbp-8], rax
-    mov qword [rbp-32], 1
-    mov rax, qword [rbp-8]
-    add rax, qword [rbp-32]
-    mov qword [rbp+32], rax
-    leave
-    ret
-
 main:
     push rbp
     mov rbp, rsp
     
-    mov qword [rbp-16], 3
-    mov qword [rbp-24], 2
-    mov rax, qword [rbp-16]
-    mov qword [rbp-48], rax
+    mov qword [rbp-8], -12
+    mov rax, qword [rbp-8]
+    mov qword [rbp-24], rax
     mov rax, qword [rbp-24]
-    mov qword [rbp-56], rax
-    sub rsp, 56
+    mov qword [rbp-40], rax
+    sub rsp, 40
     call _1
-    add rsp, 56
-    mov rax, qword [rbp-40]
-    mov qword [rbp-8], rax
-	mov rax, qword [rbp-8]
+    add rsp, 40
+    mov rax, qword [rbp-32]
+    mov qword [rbp-16], rax
+	mov rax, qword [rbp-16]
 	leave
 	ret
 
 _1:
     push rbp
     mov rbp, rsp
     
+    mov qword [rbp-8], 0
     mov rax, qword [rbp+16]
-    mov qword [rbp-8], rax
-    mov rax, qword [rbp+24]
     mov qword [rbp-16], rax
     mov rax, qword [rbp-8]
-    mov qword [rbp-40], rax
-    mov rax, qword [rbp-16]
-    mov qword [rbp-48], rax
-    sub rsp, 48
-    call _2
-    add rsp, 48
-    mov rax, qword [rbp-32]
-    mov qword [rbp+32], rax
+    sub rax, qword [rbp-16]
+    mov qword [rbp+24], rax
     leave
     ret
 
diff --git a/build/out.o b/build/out.o
diff --git a/build/out.out b/build/out.out
diff --git a/main.why b/main.why
@@ -1,14 +1,11 @@
 impl int {
-    fn sub(lhs: int, rhs: int) -> int {
-        return lhs == rhs;
-    }
-
-    fn eq(lhs: int, rhs: int) -> int {
-        return (lhs + rhs) + 1;
+    fn p_sub(self) -> Self {
+        return 0 - self;
     }
 }
 
 fn main() -> int {
-    return 3 - 2;
+    let x: int = -12;
+    return -x;
 }
 
diff --git a/src/root/builtin/int/add.rs b/src/root/builtin/int/add.rs
@@ -22,6 +22,7 @@ impl BuiltinInlineFunction for IntAdd {
 
     fn signature(&self) -> FunctionSignature {
         FunctionSignature::new_inline_builtin(
+            true,
             &[("lhs", IntType::id().immediate()), ("rhs", IntType::id().immediate())],
             Some(IntType::id().immediate())
         )

diff --git a/src/root/builtin/int/mod.rs b/src/root/builtin/int/mod.rs
@@ -1,8 +1,10 @@
 mod add;
+mod sub;
 
 use b_box::b;
 use unique_type_id::UniqueTypeId;
 use crate::root::builtin::int::add::IntAdd;
+use crate::root::builtin::int::sub::IntSub;
 use crate::root::errors::WErr;
 use crate::root::name_resolver::name_resolvers::GlobalDefinitionTable;
 use crate::root::parser::parse_function::parse_literal::{LiteralToken, LiteralTokens};
@@ -12,6 +14,7 @@ use crate::root::shared::types::Type;
 pub fn register_int(global_table: &mut GlobalDefinitionTable) {
     global_table.register_builtin_type(b!(IntType));
     global_table.register_inline_function(&IntAdd);
+    global_table.register_inline_function(&IntSub);
 }
 
 #[derive(UniqueTypeId)]

diff --git a/src/root/builtin/int/sub.rs b/src/root/builtin/int/sub.rs
@@ -0,0 +1,46 @@
+use unique_type_id::UniqueTypeId;
+use crate::root::builtin::{BuiltinInlineFunction, InlineFunctionGenerator};
+use crate::root::builtin::int::IntType;
+use crate::root::errors::WErr;
+use crate::root::name_resolver::name_resolvers::NameResult::Function;
+use crate::root::name_resolver::resolve_function_signatures::FunctionSignature;
+
+use crate::root::shared::common::{FunctionID, Indirection, LocalAddress, TypeID, TypeRef};
+
+#[derive(UniqueTypeId)]
+#[UniqueTypeIdType = "u16"]
+pub struct IntSub;
+
+impl BuiltinInlineFunction for IntSub {
+    fn id(&self) -> FunctionID {
+        FunctionID(-(IntSub::unique_type_id().0 as isize) - 1)
+    }
+
+    fn name(&self) -> &'static str {
+        "sub"
+    }
+
+    fn signature(&self) -> FunctionSignature {
+        FunctionSignature::new_inline_builtin(
+            true,
+            &[("lhs", IntType::id().immediate()), ("rhs", IntType::id().immediate())],
+            Some(IntType::id().immediate())
+        )
+    }
+
+    fn inline(&self) -> InlineFunctionGenerator {
+        |args: &[LocalAddress], return_into: Option<LocalAddress>| -> String {
+            let lhs = args[0];
+            let rhs = args[1];
+            let return_into = return_into.unwrap();
+            format!(
+"    mov rax, qword {lhs}
+    sub rax, qword {rhs}
+    mov qword {return_into}, rax")
+        }
+    }
+
+    fn parent_type(&self) -> Option<TypeID> {
+        Some(IntType::id())
+    }
+}
diff --git a/src/root/compiler/compile_evaluable.rs b/src/root/compiler/compile_evaluable.rs
@@ -90,22 +90,16 @@ pub fn compile_evaluable_into(
             t.instantiate_from_literal(target.local_address(), literal)?
         }
         EvaluableTokens::InfixOperator(lhs, op, rhs) => {
-            // if op.is_prefix_opt_t() {
-            //     return Err(WErr::n(EvalErrs::FoundPrefixNotInfixOp(op.operator().to_str().to_string()), op.location().clone()));
-            // }
-
             let mut code = String::new();
 
-            // let (mut code, lhs) = compile_evaluable(fid, lhs, local_variables, global_table, function_calls)?;
             let lhs_type = compile_evaluable_type_only(fid, lhs, local_variables, global_table, function_calls)?;
-            // code += "\n";
             let op_fn = global_table.get_operator_function(*lhs_type.type_id(), op, PrefixOrInfixEx::Infix)?;
             let signature = global_table.get_function_signature(op_fn);
 
             if signature.args().len() != 2 {
                 return Err(
                     WErr::n(
-                        EvalErrs::OpWrongArgumentCount(
+                        EvalErrs::InfixOpWrongArgumentCount(
                             op.operator().to_str().to_string(),
                             global_table.get_type(*lhs_type.type_id()).name().to_string(),
                             op.operator().get_method_name(PrefixOrInfixEx::Infix).unwrap(),
@@ -127,18 +121,50 @@ pub fn compile_evaluable_into(
                 }
             }
 
-            // let rhs_type_target = signature.args()[1].1.clone();
-            // let rhs_box = global_table.add_local_variable_unnamed_base(rhs_type_target, local_variables);
-            // code += &compile_evaluable_into(fid, rhs, rhs_box.clone(), local_variables, global_table, function_calls)?;
-            // code += "\n";
-
             let (c, _) = call_function(fid, op_fn, &[Left(lhs), Left(rhs)], Some(target), global_table, local_variables, function_calls)?;
 
             code += &c;
 
             code
         },
-        EvaluableTokens::PrefixOperator(_, _) => todo!(),
+        EvaluableTokens::PrefixOperator(op, lhs) => {
+            let mut code = String::new();
+
+            let lhs_type = compile_evaluable_type_only(fid, lhs, local_variables, global_table, function_calls)?;
+            let op_fn = global_table.get_operator_function(*lhs_type.type_id(), op, PrefixOrInfixEx::Prefix)?;
+            let signature = global_table.get_function_signature(op_fn);
+
+            if signature.args().len() != 1 {
+                return Err(
+                    WErr::n(
+                        EvalErrs::InfixOpWrongArgumentCount(
+                            op.operator().to_str().to_string(),
+                            global_table.get_type(*lhs_type.type_id()).name().to_string(),
+                            op.operator().get_method_name(PrefixOrInfixEx::Prefix).unwrap(),
+                            signature.args().len()
+                        ),
+                        op.location().clone()
+                    )
+                );
+            }
+
+            match signature.return_type() {
+                None => {
+                    return Err(WErr::n(OpNoReturn(global_table.get_type_name(target.type_ref())), op.location().clone()))
+                }
+                Some(rt) => {
+                    if rt != target.type_ref() {
+                        return Err(WErr::n(OpWrongReturnType(global_table.get_type_name(target.type_ref()), global_table.get_type_name(rt)), op.location().clone()))
+                    }
+                }
+            }
+
+            let (c, _) = call_function(fid, op_fn, &[Left(lhs)], Some(target), global_table, local_variables, function_calls)?;
+
+            code += &c;
+
+            code
+        },
         EvaluableTokens::DynamicAccess(_, _) => todo!(), // Accessed methods must be called
         EvaluableTokens::StaticAccess(_, n) => return Err(WErr::n(NRErrors::CannotFindConstantAttribute(n.name().clone()), n.location().clone())), // Accessed methods must be called
         EvaluableTokens::FunctionCall(inner, args) => {