Improved error messages for calling functions without specifying the required implementation arguments or with non-existent target implementation parameters specified

Author: IsaacShelton

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

@@ -9,6 +9,6 @@ pub struct Call {
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
 pub struct Callee {
-    pub function: FuncRef,
+    pub func_ref: FuncRef,
     pub recipe: PolyRecipe,
 }

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

@@ -2,6 +2,7 @@ use super::Expr;
 use crate::{
     ast::{Type, TypeArg},
     name::Name,
+    source_files::source::Sourced,
 };
 
 #[derive(Clone, Debug)]
@@ -15,6 +16,6 @@ pub struct Call {
 
 #[derive(Clone, Debug)]
 pub struct Using {
-    pub name: Option<String>,
+    pub name: Option<Sourced<String>>,
     pub ty: Type,
 }

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

@@ -23,7 +23,7 @@ pub fn lower_expr_call(
         expr,
         function,
         asg,
-        call.callee.function,
+        call.callee.func_ref,
         &call.callee.recipe,
         call.args.as_slice(),
     )

Diff for: src/parser/parse_annotation.rs

@@ -19,8 +19,9 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         let mut annotations = Vec::with_capacity(2);
 
         loop {
-            let (annotation_name, source) =
-                self.parse_identifier_keep_location(Some("for annotation name"))?;
+            let (annotation_name, source) = self
+                .parse_identifier_keep_location(Some("for annotation name"))?
+                .tuple();
 
             let annotation = match annotation_name.as_str() {
                 "foreign" => AnnotationKind::Foreign,

Diff for: src/parser/parse_expr/primary/call.rs

@@ -84,7 +84,9 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
 
                 let name = (self.input.peek().is_identifier()
                     && self.input.peek_nth(1).could_start_type())
-                .then(|| self.parse_identifier(Some("for implementation parameter name")))
+                .then(|| {
+                    self.parse_identifier_keep_location(Some("for implementation parameter name"))
+                })
                 .transpose()?;
 
                 using.push(Using {

Diff for: src/parser/parse_global_variable.rs

@@ -32,8 +32,9 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
             }
         }
 
-        let (name, source) =
-            self.parse_identifier_keep_location(Some("for name of global variable"))?;
+        let (name, source) = self
+            .parse_identifier_keep_location(Some("for name of global variable"))?
+            .tuple();
 
         // Better error message for trying to call functions at global scope
         if self.input.peek_is(TokenKind::OpenParen) {

Diff for: src/parser/parse_stmt/parse_declaration.rs

@@ -7,7 +7,9 @@ use crate::{
 
 impl<'a, I: Inflow<Token>> Parser<'a, I> {
     pub fn parse_declaration(&mut self) -> Result<Stmt, ParseError> {
-        let (name, source) = self.parse_identifier_keep_location(Some("for variable name"))?;
+        let (name, source) = self
+            .parse_identifier_keep_location(Some("for variable name"))?
+            .tuple();
 
         let variable_type = self.parse_type(None::<&str>, Some("for variable"))?;
 

Diff for: src/parser/parse_util.rs

@@ -5,7 +5,7 @@ use super::{
 use crate::{
     inflow::Inflow,
     name::Name,
-    source_files::Source,
+    source_files::{source::Sourced, Source},
     token::{Token, TokenKind},
 };
 use std::borrow::Borrow;
@@ -30,17 +30,20 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         &mut self,
         for_reason: Option<impl ToString>,
     ) -> Result<String, ParseError> {
-        Ok(self.parse_identifier_keep_location(for_reason)?.0)
+        Ok(self
+            .parse_identifier_keep_location(for_reason)?
+            .inner()
+            .into())
     }
 
     pub fn parse_identifier_keep_location(
         &mut self,
         for_reason: Option<impl ToString>,
-    ) -> Result<(String, Source), ParseError> {
+    ) -> Result<Sourced<String>, ParseError> {
         let token = self.input.advance();
 
         if let TokenKind::Identifier(identifier) = &token.kind {
-            Ok((identifier.into(), token.source))
+            Ok(Sourced::new(identifier.into(), token.source))
         } else {
             Err(ParseError::expected("identifier", for_reason, token))
         }

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

@@ -1,19 +1,18 @@
 use crate::{
-    asg::{Callee, GenericTraitRef},
+    asg::{self, Callee, GenericTraitRef, ImplParams},
     ast::{self, Using},
     resolve::{
         error::ResolveError,
         expr::{static_member::resolve_impl_mention_from_type, ResolveExprCtx},
         PolyValue,
     },
-    source_files::Source,
+    source_files::{source::Sourced, Source},
 };
 use std::collections::HashSet;
 
 pub fn resolve_impl_arg(
     ctx: &mut ResolveExprCtx,
     callee: &mut Callee,
-    source: Source,
     using: &Using,
     used_names: &mut HashSet<String>,
 ) -> Result<(), ResolveError> {
@@ -22,7 +21,7 @@ pub fn resolve_impl_arg(
     if let ast::TypeKind::Polymorph(polymorph, args_to_polymorph) = &impl_arg.kind {
         resolve_polymorph_impl_arg(ctx, callee, using, polymorph, args_to_polymorph, used_names)
     } else {
-        resolve_concrete_impl_arg(ctx, callee, using, impl_arg, source, used_names)
+        resolve_concrete_impl_arg(ctx, callee, using, impl_arg, used_names)
     }
 }
 
@@ -31,7 +30,6 @@ fn resolve_concrete_impl_arg(
     callee: &mut Callee,
     using: &Using,
     impl_arg: &ast::Type,
-    call_source: Source,
     used_names: &mut HashSet<String>,
 ) -> Result<(), ResolveError> {
     let impl_arg_source = using.ty.source;
@@ -44,51 +42,18 @@ fn resolve_concrete_impl_arg(
         .expect("referenced impl to exist");
 
     let arg_concrete_trait = impl_poly_catalog.bake().resolve_trait(&imp.target)?;
-
-    let function = ctx.asg.funcs.get(callee.function).unwrap();
-
-    let target_poly_impl_name = match &using.name {
-        Some(name) => name,
-        None => function
-            .impl_params
-            .params
-            .iter()
-            .filter(|(param_name, param)| {
-                param.trait_ref == arg_concrete_trait.trait_ref && !used_names.contains(*param_name)
-            })
-            .map(|(param_name, _)| param_name)
-            .next()
-            .ok_or_else(|| {
-                ResolveError::other(
-                    format!(
-                        "Excess implementation of trait '{}' is not used by callee",
-                        arg_concrete_trait.display(&ctx.asg)
-                    ),
-                    impl_arg.source,
-                )
-            })?,
-    }
-    .clone();
-
-    let Some(param_generic_trait) = function.impl_params.params.get(&target_poly_impl_name) else {
-        return Err(ResolveError::other(
-            format!(
-                "Callee does not have implementation parameter '${}'",
-                target_poly_impl_name
-            ),
-            call_source,
-        ));
-    };
+    let callee_func = ctx.asg.funcs.get(callee.func_ref).unwrap();
 
     try_register_specified_impl(
         ctx,
         callee,
-        target_poly_impl_name,
+        callee_func,
+        using,
         impl_arg_source,
         used_names,
         PolyValue::Impl(impl_ref),
         &arg_concrete_trait,
-        &param_generic_trait,
+        &callee_func.impl_params,
     )
 }
 
@@ -101,7 +66,7 @@ fn resolve_polymorph_impl_arg(
     used_names: &mut HashSet<String>,
 ) -> Result<(), ResolveError> {
     let impl_arg_source = using.ty.source;
-    let callee_func = ctx.asg.funcs.get(callee.function).unwrap();
+    let callee_func = ctx.asg.funcs.get(callee.func_ref).unwrap();
 
     if !args_to_polymorph.is_empty() {
         return Err(ResolveError::other(
@@ -130,69 +95,75 @@ fn resolve_polymorph_impl_arg(
         ));
     };
 
-    let target_poly_impl_name = match &using.name {
-        Some(name) => name,
-        None => callee_func
-            .impl_params
-            .params
-            .iter()
-            .filter(|(param_name, param)| {
-                param.trait_ref == arg_concrete_trait.trait_ref && !used_names.contains(*param_name)
-            })
-            .map(|(param_name, _)| param_name)
-            .next()
-            .ok_or_else(|| {
-                ResolveError::other(
-                    format!(
-                        "Excess implementation of trait '{}' is not used by callee",
-                        arg_concrete_trait.display(&ctx.asg)
-                    ),
-                    impl_arg_source,
-                )
-            })?,
-    }
-    .clone();
-
-    let Some(param_generic_trait) = callee_func.impl_params.params.get(&target_poly_impl_name)
-    else {
-        return Err(ResolveError::other(
-            format!(
-                "Callee does not have implementation parameter '${}'",
-                target_poly_impl_name
-            ),
-            impl_arg_source,
-        ));
-    };
-
     try_register_specified_impl(
         ctx,
         callee,
-        target_poly_impl_name,
+        callee_func,
+        using,
         impl_arg_source,
         used_names,
         PolyValue::PolyImpl(polymorph.into()),
         arg_concrete_trait,
-        param_generic_trait,
+        &callee_func.impl_params,
     )
 }
 
 fn try_register_specified_impl(
     ctx: &ResolveExprCtx,
     callee: &mut Callee,
-    target_poly_impl_name: String,
+    callee_func: &asg::Func,
+    using: &Using,
     impl_arg_source: Source,
     used_names: &mut HashSet<String>,
     poly_value: PolyValue,
     arg_concrete_trait: &GenericTraitRef,
-    param_generic_trait: &GenericTraitRef,
+    impl_params: &ImplParams,
 ) -> Result<(), ResolveError> {
-    if !used_names.insert(target_poly_impl_name.clone()) {
+    let target_poly_impl = match &using.name {
+        Some(name_and_source) => name_and_source.as_ref(),
+        None => Sourced::new(
+            callee_func
+                .impl_params
+                .params
+                .iter()
+                .filter(|(param_name, param)| {
+                    param.trait_ref == arg_concrete_trait.trait_ref
+                        && !used_names.contains(*param_name)
+                })
+                .map(|(param_name, _)| param_name)
+                .next()
+                .ok_or_else(|| {
+                    ResolveError::other(
+                        format!(
+                            "Excess implementation of trait '{}' is not used by callee",
+                            arg_concrete_trait.display(&ctx.asg)
+                        ),
+                        impl_arg_source,
+                    )
+                })?,
+            impl_arg_source,
+        ),
+    }
+    .clone();
+
+    let Some(param_generic_trait) = impl_params.params.get(target_poly_impl.inner().as_str())
+    else {
+        return Err(ResolveError::other(
+            format!(
+                "No implementation parameter named '${}' exists on callee",
+                target_poly_impl.inner()
+            ),
+            target_poly_impl.source,
+        ));
+    };
+
+    if !used_names.insert(target_poly_impl.inner().to_string()) {
         return Err(ResolveError::other(
             format!(
                 "Implementation for '${}' was already specified",
-                target_poly_impl_name
+                target_poly_impl.inner()
             ),
-            impl_arg_source,
+            target_poly_impl.source,
         ));
     }
 
@@ -212,15 +183,15 @@ fn try_register_specified_impl(
     callee
         .recipe
         .polymorphs
-        .insert(target_poly_impl_name.clone(), poly_value)
+        .insert(target_poly_impl.inner().to_string(), poly_value)
         .is_some()
         .then(|| {
             ResolveError::other(
                 format!(
                     "Multiple implementations were specified for implementation parameter '${}'",
-                    target_poly_impl_name
+                    target_poly_impl.inner()
                 ),
-                impl_arg_source,
+                target_poly_impl.source,
             )
         })
         .map_or(Ok(()), Err)

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

@@ -74,17 +74,30 @@ pub fn call_callee(
     let mut used_names = HashSet::new();
 
     for using in call.using.iter() {
-        resolve_impl_arg(ctx, &mut callee, source, using, &mut used_names)?;
+        resolve_impl_arg(ctx, &mut callee, using, &mut used_names)?;
     }
 
-    let function = ctx.asg.funcs.get(callee.function).unwrap();
+    let function = ctx.asg.funcs.get(callee.func_ref).unwrap();
     let num_required = function.params.required.len();
 
+    for (expected_name, expected_trait) in function.impl_params.params.iter() {
+        if !used_names.contains(expected_name) {
+            return Err(ResolveError::other(
+                format!(
+                    "Missing '${} {}' trait implementation required by function call",
+                    expected_name,
+                    expected_trait.display(&ctx.asg),
+                ),
+                source,
+            ));
+        }
+    }
+
     for (i, arg) in args.iter_mut().enumerate() {
-        let function = ctx.asg.funcs.get(callee.function).unwrap();
+        let function = ctx.asg.funcs.get(callee.func_ref).unwrap();
 
         let preferred_type =
-            (i < num_required).then_some(PreferredType::of_parameter(callee.function, i));
+            (i < num_required).then_some(PreferredType::of_parameter(callee.func_ref, i));
 
         if preferred_type.map_or(false, |ty| ty.view(&ctx.asg).kind.contains_polymorph()) {
             *arg = conform_expr_to_default::<Perform>(&*arg, ctx.c_integer_assumptions())

Diff for: src/resolve/func_haystack.rs

@@ -147,7 +147,7 @@ impl FuncHaystack {
         }
 
         Some(Callee {
-            function: func_ref,
+            func_ref,
             recipe: catalog.bake(),
         })
     }