Finished adding basic support for calling functions with polymorphic trait implementations

Author: IsaacShelton

Diff for: src/asg/expr/call.rs

@@ -4,7 +4,7 @@ use crate::{asg::FuncRef, resolve::PolyRecipe};
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct Call {
     pub callee: Callee,
-    pub arguments: Vec<TypedExpr>,
+    pub args: Vec<TypedExpr>,
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]

Diff for: src/asg/expr/poly_call.rs

@@ -1,4 +1,5 @@
 use super::TypedExpr;
+use crate::resolve::PolyRecipe;
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct PolyCall {
@@ -10,4 +11,5 @@ pub struct PolyCall {
 pub struct PolyCallee {
     pub polymorph: String,
     pub member: String,
+    pub recipe: PolyRecipe,
 }

Diff for: src/ir/mod.rs

@@ -205,7 +205,7 @@ impl BinaryOperands {
 pub struct Call {
     pub func: FuncRef,
     pub arguments: Box<[Value]>,
-    pub unpromoted_variadic_argument_types: Box<[Type]>,
+    pub unpromoted_variadic_arg_types: Box<[Type]>,
 }
 
 #[derive(Clone, Debug)]

Diff for: src/llvm_backend/functions/block.rs

@@ -814,7 +814,7 @@ unsafe fn emit_call(
         let abi_function = skeleton.abi_function.as_ref().expect("abi function");
 
         let variadic_argument_types = call
-            .unpromoted_variadic_argument_types
+            .unpromoted_variadic_arg_types
             .iter()
             .map(|argument_type| {
                 promote_variadic_argument_type(builder, &ctx.ir_module.target, argument_type)

Diff for: src/lower/expr/mod.rs

@@ -140,15 +140,15 @@ pub fn lower_expr(
                 .get(call.callee.function)
                 .expect("referenced function to exist");
 
-            let arguments = call
-                .arguments
+            let args = call
+                .args
                 .iter()
-                .map(|argument| lower_expr(builder, ir_module, &argument.expr, function, asg))
+                .map(|arg| lower_expr(builder, ir_module, &arg.expr, function, asg))
                 .collect::<Result<Box<[_]>, _>>()?;
 
-            let variadic_argument_types = call.arguments[callee.params.required.len()..]
+            let variadic_arg_types = call.args[callee.params.required.len()..]
                 .iter()
-                .map(|argument| lower_type(ir_module, &builder.unpoly(&argument.ty)?, asg))
+                .map(|arg| lower_type(ir_module, &builder.unpoly(&arg.ty)?, asg))
                 .collect::<Result<Box<[_]>, _>>()?;
 
             // NOTE: We have to resolve our own polymorphs in the mapping
@@ -183,8 +183,8 @@ pub fn lower_expr(
 
             Ok(builder.push(ir::Instr::Call(ir::Call {
                 func: function,
-                arguments,
-                unpromoted_variadic_argument_types: variadic_argument_types,
+                arguments: args,
+                unpromoted_variadic_arg_types: variadic_arg_types,
             })))
         }
         ExprKind::Variable(variable) => {
@@ -551,9 +551,60 @@ pub fn lower_expr(
 
             let imp = asg.impls.get(impl_ref).expect("referenced impl to exist");
 
-            dbg!(poly_call);
-            dbg!(imp);
-            todo!("lowering poly calls is not implemented yet!");
+            let func_ref = imp
+                .body
+                .get(&poly_call.callee.member)
+                .expect("expected impl body function refereneced by poly call to exist");
+
+            let callee = asg
+                .funcs
+                .get(*func_ref)
+                .expect("referenced function to exist");
+
+            let args = poly_call
+                .args
+                .iter()
+                .map(|arg| lower_expr(builder, ir_module, &arg.expr, function, asg))
+                .collect::<Result<Box<[_]>, _>>()?;
+
+            let variadic_arg_types = poly_call.args[callee.params.required.len()..]
+                .iter()
+                .map(|arg| lower_type(ir_module, &builder.unpoly(&arg.ty)?, asg))
+                .collect::<Result<Box<[_]>, _>>()?;
+
+            // NOTE: We have to resolve our own polymorphs in the mapping
+            let mut polymorphs = IndexMap::<String, PolyValue>::new();
+
+            for (name, value) in poly_call.callee.recipe.polymorphs.iter() {
+                match value {
+                    PolyValue::Type(ty) => {
+                        polymorphs.insert(
+                            name.clone(),
+                            PolyValue::Type(
+                                Borrow::<asg::Type>::borrow(&builder.unpoly(&ty)?.0).clone(),
+                            ),
+                        );
+                    }
+                    PolyValue::Expr(_) => {
+                        todo!("compile-time expression parameters are not supported when calling generic functions yet")
+                    }
+                    PolyValue::Impl(impl_ref) => {
+                        polymorphs.insert(name.clone(), PolyValue::Impl(*impl_ref));
+                    }
+                }
+            }
+
+            let recipe = PolyRecipe { polymorphs };
+
+            let function = ir_module.funcs.translate(*func_ref, &recipe, || {
+                lower_func_head(ir_module, *func_ref, &recipe, asg)
+            })?;
+
+            Ok(builder.push(ir::Instr::Call(ir::Call {
+                func: function,
+                arguments: args,
+                unpromoted_variadic_arg_types: variadic_arg_types,
+            })))
         }
     }
 }

Diff for: src/resolve/expr/call.rs

@@ -78,9 +78,6 @@ pub fn call_callee(
             .get(impl_ref)
             .expect("referenced impl to exist");
 
-        dbg!(&callee.recipe);
-        dbg!(&imp.target);
-
         let arg_concrete_trait = impl_poly_catalog.bake().resolve_trait(&imp.target)?;
 
         let function = ctx.asg.funcs.get(callee.function).unwrap();
@@ -98,9 +95,6 @@ pub fn call_callee(
                 ));
             }
 
-            dbg!(&arg_concrete_trait);
-            dbg!(&param_concrete_trait);
-
             if callee
                 .recipe
                 .polymorphs
@@ -125,8 +119,7 @@ pub fn call_callee(
     let num_required = function.params.required.len();
 
     if !function.impl_params.params.is_empty() {
-        dbg!(&function.impl_params);
-        eprintln!("warning: calling functions with implementation parameters is not fully implemented yet!");
+        eprintln!("warning: calling functions with implementation parameters is not fully implemented yet! (more that one implementation parameter is not supported yet)");
     }
 
     for (i, arg) in args.iter_mut().enumerate() {
@@ -188,10 +181,7 @@ pub fn call_callee(
     Ok(TypedExpr::new(
         return_type,
         asg::Expr::new(
-            asg::ExprKind::Call(Box::new(asg::Call {
-                callee,
-                arguments: args,
-            })),
+            asg::ExprKind::Call(Box::new(asg::Call { callee, args })),
             source,
         ),
     ))

Diff for: src/resolve/expr/static_member.rs

@@ -343,6 +343,7 @@ pub fn resolve_static_member_call_polymorph(
             callee: PolyCallee {
                 polymorph: polymorph.into(),
                 member,
+                recipe: catalog.bake(),
             },
             args,
         }))