Added support for inferring trait implementations for callees with polymorphic #[using] implementation parameters (and even for traits with associated types)

Author: IsaacShelton

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

@@ -73,6 +73,8 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
             assert!(self.input.advance().is_static_member());
             assert!(self.input.advance().is_open_paren());
 
+            self.ignore_newlines();
+
             while !self.input.peek_is_or_eof(TokenKind::CloseParen) {
                 if using.len() > starting_args_len {
                     self.parse_token(

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

@@ -4,7 +4,7 @@ use crate::{
     resolve::{
         error::ResolveError,
         expr::{static_member::resolve_impl_mention_from_type, ResolveExprCtx},
-        PolyCatalog, PolyValue,
+        MatchTypesError, PolyCatalog, PolyValue,
     },
     source_files::{source::Sourced, Source},
 };
@@ -177,36 +177,31 @@ fn try_register_specified_impl(
         ));
     }
 
-    if param_generic_trait.args.len() != arg_concrete_trait.args.len() {
-        return Err(ResolveError::other(
-            "Mismatching number of arguments expected for trait implementation",
-            target_param.source,
-        ));
-    }
-
-    for (pattern, concrete) in param_generic_trait
-        .args
-        .iter()
-        .zip(arg_concrete_trait.args.iter())
-    {
-        match catalog.match_type(ctx, pattern, concrete) {
-            Ok(()) => {}
-            Err(_) => {
-                return Err(ResolveError::other(
-                    format!(
-                        "Implementation of '{}' cannot be used for '{}'",
-                        arg_concrete_trait.display(ctx.asg),
-                        param_generic_trait.display(ctx.asg)
-                    ),
-                    impl_arg_source,
-                ));
-            }
+    match catalog.match_types(
+        ctx,
+        param_generic_trait.args.as_slice(),
+        arg_concrete_trait.args.as_slice(),
+    ) {
+        Ok(()) => {}
+        Err(MatchTypesError::LengthMismatch) => {
+            return Err(ResolveError::other(
+                "Mismatching number of arguments expected for trait implementation",
+                target_param.source,
+            ));
+        }
+        Err(MatchTypesError::Incongruent(_) | MatchTypesError::NoMatch(_)) => {
+            return Err(ResolveError::other(
+                format!(
+                    "Implementation of '{}' cannot be used for '{}'",
+                    arg_concrete_trait.display(&ctx.asg),
+                    param_generic_trait.display(&ctx.asg),
+                ),
+                impl_arg_source,
+            ));
         }
     }
 
-    // TODO: PERFORMANCE: We shouldn't need to clone this
-    let recipe = catalog.clone().bake();
-    let param_concrete_trait = recipe.resolve_trait(param_generic_trait)?;
+    let param_concrete_trait = catalog.resolver().resolve_trait(param_generic_trait)?;
 
     if *arg_concrete_trait != param_concrete_trait {
         return Err(ResolveError::other(

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

@@ -79,7 +79,6 @@ pub fn call_callee(
     for using in call.using.iter() {
         resolve_impl_arg(ctx, &mut callee, using, &mut used_names, &mut catalog)?;
     }
-    callee.recipe = catalog.bake();
 
     let function = ctx.asg.funcs.get(callee.func_ref).unwrap();
     let num_required = function.params.required.len();
@@ -98,16 +97,24 @@ pub fn call_callee(
 
         // NOTE: PERFORMANCE: TODO: This could probably be optimized
         let from_env = caller.impl_params.params.iter().filter(|(_, param_trait)| {
-            callee
-                .recipe
+            if catalog
+                .match_types(ctx, &expected_trait.args, &param_trait.args)
+                .is_err()
+            {
+                return false;
+            }
+
+            catalog
+                .resolver()
                 .resolve_trait(expected_trait)
-                .map_or(false, |expected_trait| **param_trait == expected_trait)
+                .map_or(false, |expected_trait| {
+                    param_trait.trait_ref == expected_trait.trait_ref
+                })
         });
 
         match from_env.exactly_one() {
             Ok((param_name, _)) => {
-                if callee
-                    .recipe
+                if catalog
                     .polymorphs
                     .insert(expected_name.into(), PolyValue::PolyImpl(param_name.into()))
                     .is_some()
@@ -146,6 +153,8 @@ pub fn call_callee(
     // We shouldn't use used_names after this, since we know all names were satisfied
     drop(used_names);
 
+    callee.recipe = catalog.bake();
+
     for (i, arg) in args.iter_mut().enumerate() {
         let function = ctx.asg.funcs.get(callee.func_ref).unwrap();
 

Diff for: src/resolve/polymorph.rs

@@ -105,7 +105,34 @@ impl Display for PolymorphErrorKind {
 }
 
 impl PolyRecipe {
-    pub fn resolve_type<'a>(&self, ty: &asg::Type) -> Result<asg::Type, PolymorphError> {
+    pub fn resolver<'a>(&'a self) -> PolyRecipeResolver<'a> {
+        PolyRecipeResolver {
+            polymorphs: &self.polymorphs,
+        }
+    }
+
+    pub fn resolve_type(&self, ty: &asg::Type) -> Result<asg::Type, PolymorphError> {
+        self.resolver().resolve_type(ty)
+    }
+
+    pub fn resolve_impl(&self, name: &str, source: Source) -> Result<asg::ImplRef, PolymorphError> {
+        self.resolver().resolve_impl(name, source)
+    }
+
+    pub fn resolve_trait(
+        &self,
+        generic_trait: &GenericTraitRef,
+    ) -> Result<GenericTraitRef, PolymorphError> {
+        self.resolver().resolve_trait(generic_trait)
+    }
+}
+
+pub struct PolyRecipeResolver<'a> {
+    polymorphs: &'a IndexMap<String, PolyValue>,
+}
+
+impl<'a> PolyRecipeResolver<'a> {
+    pub fn resolve_type(&self, ty: &asg::Type) -> Result<asg::Type, PolymorphError> {
         let polymorphs = &self.polymorphs;
 
         Ok(match &ty.kind {
@@ -218,6 +245,12 @@ impl PolyCatalog {
         }
     }
 
+    pub fn resolver<'a>(&'a self) -> PolyRecipeResolver<'a> {
+        PolyRecipeResolver {
+            polymorphs: &self.polymorphs,
+        }
+    }
+
     pub fn bake(self) -> PolyRecipe {
         PolyRecipe {
             polymorphs: self.polymorphs,
@@ -314,6 +347,37 @@ impl PolyCatalog {
         }
     }
 
+    pub fn match_types<'a>(
+        &'a mut self,
+        ctx: &ResolveExprCtx,
+        pattern_types: &'a [Type],
+        concrete_types: &'a [Type],
+    ) -> Result<(), MatchTypesError<'a>> {
+        if concrete_types.len() != pattern_types.len() {
+            return Err(MatchTypesError::LengthMismatch);
+        }
+
+        for (pattern, concrete) in pattern_types.iter().zip(concrete_types.iter()) {
+            match self.match_type(ctx, pattern, concrete) {
+                Ok(()) => {}
+                Err(None) => {
+                    return Err(MatchTypesError::NoMatch(TypePatternAttempt {
+                        pattern,
+                        concrete,
+                    }))
+                }
+                Err(Some(PolyCatalogInsertError::Incongruent)) => {
+                    return Err(MatchTypesError::Incongruent(TypePatternAttempt {
+                        pattern,
+                        concrete,
+                    }));
+                }
+            }
+        }
+
+        Ok(())
+    }
+
     pub fn put_type(&mut self, name: &str, new_type: &Type) -> Result<(), PolyCatalogInsertError> {
         if let Some(existing) = self.polymorphs.get_mut(name) {
             match existing {
@@ -338,3 +402,16 @@ impl PolyCatalog {
         self.polymorphs.get(name)
     }
 }
+
+#[derive(Clone, Debug)]
+pub struct TypePatternAttempt<'a> {
+    pub pattern: &'a Type,
+    pub concrete: &'a Type,
+}
+
+#[derive(Clone, Debug)]
+pub enum MatchTypesError<'a> {
+    LengthMismatch,
+    NoMatch(TypePatternAttempt<'a>),
+    Incongruent(TypePatternAttempt<'a>),
+}