Added named implementation parameters for functions

Author: IsaacShelton

src/ast/expr/call.rs

@@ -10,5 +10,11 @@ pub struct Call {
     pub args: Vec<Expr>,
     pub expected_to_return: Option<Type>,
     pub generics: Vec<TypeArg>,
-    pub using: Vec<Type>,
+    pub using: Vec<Using>,
+}
+
+#[derive(Clone, Debug)]
+pub struct Using {
+    pub name: String,
+    pub ty: Type,
 }

src/interpreter/mod.rs

@@ -94,9 +94,9 @@ impl<'a, S: SyscallHandler> Interpreter<'a, S> {
                     break value;
                 }
                 ir::Instr::Call(call) => {
-                    let mut arguments = Vec::with_capacity(call.arguments.len());
+                    let mut arguments = Vec::with_capacity(call.args.len());
 
-                    for argument in call.arguments.iter() {
+                    for argument in call.args.iter() {
                         arguments.push(self.eval(&registers, argument));
                     }
 

src/ir/mod.rs

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

src/llvm_backend/functions/block.rs

@@ -795,8 +795,8 @@ unsafe fn emit_call(
 
     let function_value = skeleton.function;
 
-    let mut arguments = call
-        .arguments
+    let mut args = call
+        .args
         .iter()
         .enumerate()
         .map(|(i, argument)| {
@@ -830,7 +830,7 @@ unsafe fn emit_call(
 
         // If we're using variadic arguments, then we have to re-generate the ABI
         // function signature for the way we're calling it
-        let abi_function_approximation = (abi_function.parameter_types.len() < arguments.len())
+        let abi_function_approximation = (abi_function.parameter_types.len() < args.len())
             .then(|| {
                 ABIFunction::new(
                     ctx,
@@ -845,10 +845,7 @@ unsafe fn emit_call(
             .unwrap_or(Cow::Borrowed(abi_function));
 
         // After generating the function signature, we should have ABI parameter information for each argument
-        assert_eq!(
-            abi_function_approximation.parameter_types.len(),
-            arguments.len()
-        );
+        assert_eq!(abi_function_approximation.parameter_types.len(), args.len());
 
         // NOTE: We shouldn't need inalloca, since we intend to target
         // only x86_64 Windows GNU on Windows, as opposed to older MSVC ABIs.
@@ -914,7 +911,7 @@ unsafe fn emit_call(
         let saved_stack_pointer = builder.save_stack_pointer(ctx);
 
         for (argument, argument_type, abi_param, param_mapping) in zip4(
-            arguments.iter().copied(),
+            args.iter().copied(),
             argument_types_iter,
             abi_function_approximation.parameter_types.iter(),
             params_mapping.params().iter(),
@@ -1140,8 +1137,8 @@ unsafe fn emit_call(
             builder.get(),
             function_type,
             function_value,
-            arguments.as_mut_ptr(),
-            arguments.len().try_into().unwrap(),
+            args.as_mut_ptr(),
+            args.len().try_into().unwrap(),
             cstr!("").as_ptr(),
         ))
     }

src/lower/expr/mod.rs

@@ -183,7 +183,7 @@ pub fn lower_expr(
 
             Ok(builder.push(ir::Instr::Call(ir::Call {
                 func: function,
-                arguments: args,
+                args,
                 unpromoted_variadic_arg_types: variadic_arg_types,
             })))
         }
@@ -554,7 +554,7 @@ pub fn lower_expr(
             let func_ref = imp
                 .body
                 .get(&poly_call.callee.member)
-                .expect("expected impl body function refereneced by poly call to exist");
+                .expect("expected impl body function referenced by poly call to exist");
 
             let callee = asg
                 .funcs
@@ -602,7 +602,7 @@ pub fn lower_expr(
 
             Ok(builder.push(ir::Instr::Call(ir::Call {
                 func: function,
-                arguments: args,
+                args,
                 unpromoted_variadic_arg_types: variadic_arg_types,
             })))
         }

src/parser/parse_expr/primary/call.rs

@@ -1,6 +1,6 @@
 use super::Parser;
 use crate::{
-    ast::{Call, Expr, ExprKind, TypeArg},
+    ast::{Call, Expr, ExprKind, TypeArg, Using},
     inflow::Inflow,
     name::Name,
     parser::error::ParseError,
@@ -82,7 +82,12 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
                     self.ignore_newlines();
                 }
 
-                using.push(self.parse_type(Some("implementation"), Some("for implementation"))?);
+                let name = self.parse_identifier(Some("for implementation parameter name"))?;
+
+                using.push(Using {
+                    name,
+                    ty: self.parse_type(Some("implementation"), Some("for implementation"))?,
+                });
                 self.ignore_newlines();
             }
 

src/resolve/expr/call.rs

@@ -69,7 +69,8 @@ pub fn call_callee(
     mut args: Vec<TypedExpr>,
     source: Source,
 ) -> Result<TypedExpr, ResolveError> {
-    for impl_arg in call.using.iter() {
+    for impl_using in call.using.iter() {
+        let impl_arg = &impl_using.ty;
         let (impl_ref, impl_poly_catalog) = resolve_impl_mention_from_type(ctx, impl_arg)?;
 
         let imp = ctx
@@ -81,34 +82,41 @@ pub fn call_callee(
         let arg_concrete_trait = impl_poly_catalog.bake().resolve_trait(&imp.target)?;
 
         let function = ctx.asg.funcs.get(callee.function).unwrap();
-        for (poly_impl_name, param_generic_trait) in function.impl_params.params.iter() {
-            let param_concrete_trait = callee.recipe.resolve_trait(param_generic_trait)?;
-
-            if arg_concrete_trait != param_concrete_trait {
-                return Err(ResolveError::other(
-                    format!(
-                        "Implementation of {} cannot be used for {}",
-                        arg_concrete_trait.display(ctx.asg),
-                        param_concrete_trait.display(ctx.asg)
-                    ),
-                    impl_arg.source,
-                ));
-            }
 
-            if callee
-                .recipe
-                .polymorphs
-                .insert(poly_impl_name.into(), PolyValue::Impl(impl_ref))
-                .is_some()
-            {
-                return Err(ResolveError::other(
-                    format!(
-                        "Multiple implementations were specified for implementation parameter '${}'",
-                        poly_impl_name
-                    ),
-                    impl_arg.source,
-                ));
-            }
+        let poly_impl_name = &impl_using.name;
+
+        let Some(param_generic_trait) = function.impl_params.params.get(&impl_using.name) else {
+            return Err(ResolveError::other(
+                format!("Unknown implementation argument '${}'", poly_impl_name),
+                source,
+            ));
+        };
+
+        let param_concrete_trait = callee.recipe.resolve_trait(param_generic_trait)?;
+
+        if arg_concrete_trait != param_concrete_trait {
+            return Err(ResolveError::other(
+                format!(
+                    "Implementation of {} cannot be used for {}",
+                    arg_concrete_trait.display(ctx.asg),
+                    param_concrete_trait.display(ctx.asg)
+                ),
+                impl_arg.source,
+            ));
+        }
+        if callee
+            .recipe
+            .polymorphs
+            .insert(poly_impl_name.into(), PolyValue::Impl(impl_ref))
+            .is_some()
+        {
+            return Err(ResolveError::other(
+                format!(
+                    "Multiple implementations were specified for implementation parameter '${}'",
+                    poly_impl_name
+                ),
+                impl_arg.source,
+            ));
         }
 
         // NOTE: We will need to populate the callee's poly recipe with `callee.recipe.polymorphs.insert()`