Continued working on ability to call functions with implementation polymorphs and being able to use polymorphic implementation parameters within functions

Author: IsaacShelton

Diff for: src/asg/generic_trait_ref.rs

@@ -1,7 +1,51 @@
-use super::{TraitRef, Type};
+use super::{Asg, TraitRef, Type};
+use std::fmt::Display;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct GenericTraitRef {
     pub trait_ref: TraitRef,
     pub args: Vec<Type>,
 }
+
+impl GenericTraitRef {
+    pub fn display<'a>(&'a self, asg: &'a Asg) -> DisplayGenericTraitRef<'a> {
+        DisplayGenericTraitRef {
+            generic_trait: self,
+            asg,
+        }
+    }
+}
+
+pub struct DisplayGenericTraitRef<'a> {
+    generic_trait: &'a GenericTraitRef,
+    asg: &'a Asg<'a>,
+}
+
+impl<'a> Display for DisplayGenericTraitRef<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let trait_decl = self
+            .asg
+            .traits
+            .get(self.generic_trait.trait_ref)
+            .expect("referenced trait to exist");
+
+        write!(f, "{}", trait_decl.human_name.0)?;
+
+        if self.generic_trait.args.is_empty() {
+            return Ok(());
+        }
+
+        write!(f, "<")?;
+
+        for (i, ty) in self.generic_trait.args.iter().enumerate() {
+            if i != 0 {
+                write!(f, ", ")?;
+            }
+
+            write!(f, "{}", ty)?;
+        }
+
+        write!(f, ">")?;
+        Ok(())
+    }
+}

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

@@ -167,8 +167,8 @@ pub fn lower_expr(
                     PolyValue::Expr(_) => {
                         todo!("compile-time expression parameters are not supported when calling generic functions yet")
                     }
-                    PolyValue::Impl(_) => {
-                        eprintln!("warning: implementation polymorphs are not propogated yet when calling from functions that have them");
+                    PolyValue::Impl(impl_ref) => {
+                        polymorphs.insert(name.clone(), PolyValue::Impl(*impl_ref));
                     }
                 }
             }

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

@@ -6,7 +6,8 @@ use crate::{
     resolve::{
         conform::{conform_expr, to_default::conform_expr_to_default, ConformMode, Perform},
         error::{ResolveError, ResolveErrorKind},
-        Initialized,
+        expr::static_member::resolve_impl_mention_from_type,
+        Initialized, PolyValue,
     },
     source_files::Source,
 };
@@ -64,13 +65,70 @@ pub fn resolve_call_expr(
 pub fn call_callee(
     ctx: &mut ResolveExprCtx,
     call: &ast::Call,
-    callee: Callee,
+    mut callee: Callee,
     mut args: Vec<TypedExpr>,
     source: Source,
 ) -> Result<TypedExpr, ResolveError> {
+    for impl_arg in call.using.iter() {
+        let (impl_ref, impl_poly_catalog) = resolve_impl_mention_from_type(ctx, impl_arg)?;
+
+        let imp = ctx
+            .asg
+            .impls
+            .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();
+        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,
+                ));
+            }
+
+            dbg!(&arg_concrete_trait);
+            dbg!(&param_concrete_trait);
+
+            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()`
+        // ...
+    }
+
     let function = ctx.asg.funcs.get(callee.function).unwrap();
     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!");
+    }
+
     for (i, arg) in args.iter_mut().enumerate() {
         let function = ctx.asg.funcs.get(callee.function).unwrap();
 

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

@@ -1,6 +1,6 @@
 use super::{call::call_callee, resolve_expr, ResolveExprCtx, ResolveExprMode};
 use crate::{
-    asg::{self, PolyCall, PolyCallee, TypeKind, TypedExpr},
+    asg::{self, ImplRef, PolyCall, PolyCallee, TypeKind, TypedExpr},
     ast::{self, StaticMemberCall, StaticMemberValue, TypeArg},
     name::Name,
     resolve::{
@@ -13,6 +13,7 @@ use crate::{
         initialized::Initialized,
         PolyCatalog, PolyRecipe,
     },
+    source_files::Source,
 };
 use indexmap::IndexMap;
 use itertools::Itertools;
@@ -70,62 +71,52 @@ pub fn resolve_static_member_call(
     }
 }
 
-pub fn resolve_static_member_call_named(
+pub fn resolve_impl_mention_from_type<'a>(
+    ctx: &mut ResolveExprCtx,
+    ty: &ast::Type,
+) -> Result<(ImplRef, PolyCatalog), ResolveError> {
+    let ast::TypeKind::Named(name, type_args) = &ty.kind else {
+        return Err(ResolveError::other(
+            "Expected implementation name",
+            ty.source,
+        ));
+    };
+
+    resolve_impl_mention(ctx, name, type_args, ty.source)
+}
+
+pub fn resolve_impl_mention(
     ctx: &mut ResolveExprCtx,
-    static_member_call: &StaticMemberCall,
     impl_name: &Name,
     impl_args: &[TypeArg],
-) -> Result<TypedExpr, ResolveError> {
-    let StaticMemberCall {
-        subject: _,
-        call,
-        call_source,
-        source,
-    } = &static_member_call;
-
+    source: Source,
+) -> Result<(ImplRef, PolyCatalog), ResolveError> {
     let Some(impl_name) = impl_name.as_plain_str() else {
-        return Err(ResolveError::other("Invalid implementation name", *source));
+        return Err(ResolveError::other("Invalid implementation name", source));
     };
 
     let impl_ref = ctx
         .impls_in_modules
         .get(&ctx.module_fs_node_id)
         .and_then(|impls| impls.get(impl_name));
 
-    let mut args = Vec::with_capacity(call.args.len());
-    for arg in call.args.iter() {
-        args.push(resolve_expr(
-            ctx,
-            arg,
-            None,
-            Initialized::Require,
-            ResolveExprMode::RequireValue,
-        )?);
-    }
-
     let Some(imp) = impl_ref.and_then(|found| ctx.asg.impls.get(*found)) else {
         return Err(ResolveError::other(
             "Undefined trait implementation",
-            *source,
+            source,
         ));
     };
 
+    // Guaranteed to be valid now
+    let impl_ref = impl_ref.unwrap();
+
     if imp.name_params.len() != impl_args.len() {
         return Err(ResolveError::other(
             "Wrong number of arguments for implementation",
-            *source,
+            source,
         ));
     }
 
-    let target = &imp.target;
-
-    let Some(callee_name) = call.name.as_plain_str() else {
-        return Err(ResolveError::other(
-            "Implementation does not have namespaced functions",
-            *call_source,
-        ));
-    };
-
     let mut catalog = PolyCatalog::default();
 
     for (name, arg) in imp.name_params.keys().zip(impl_args) {
@@ -144,9 +135,56 @@ pub fn resolve_static_member_call_named(
         }
     }
 
-    let mut only_match = imp.body.get(callee_name).into_iter().flat_map(|func_ref| {
-        FuncHaystack::fits(ctx, *func_ref, &args, Some(catalog.clone()), *call_source)
-    });
+    Ok((*impl_ref, catalog))
+}
+
+pub fn resolve_static_member_call_named(
+    ctx: &mut ResolveExprCtx,
+    static_member_call: &StaticMemberCall,
+    impl_name: &Name,
+    impl_args: &[TypeArg],
+) -> Result<TypedExpr, ResolveError> {
+    let StaticMemberCall {
+        subject: _,
+        call,
+        call_source,
+        source: _,
+    } = &static_member_call;
+
+    let mut args = Vec::with_capacity(call.args.len());
+    for arg in call.args.iter() {
+        args.push(resolve_expr(
+            ctx,
+            arg,
+            None,
+            Initialized::Require,
+            ResolveExprMode::RequireValue,
+        )?);
+    }
+
+    let (impl_ref, catalog) =
+        resolve_impl_mention(ctx, impl_name, impl_args, static_member_call.source)?;
+
+    let Some(callee_name) = call.name.as_plain_str() else {
+        return Err(ResolveError::other(
+            "Implementation does not have namespaced functions",
+            *call_source,
+        ));
+    };
+    let imp = ctx
+        .asg
+        .impls
+        .get(impl_ref)
+        .expect("referenced impl to exist");
+
+    let mut only_match = imp
+        .body
+        .get(callee_name)
+        .into_iter()
+        .copied()
+        .flat_map(|func_ref| {
+            FuncHaystack::fits(ctx, func_ref, &args, Some(catalog.clone()), *call_source)
+        });
 
     let callee = only_match.next().ok_or_else(|| {
         ResolveErrorKind::FailedToFindFunction {

Diff for: src/resolve/polymorph.rs

@@ -1,11 +1,12 @@
 use super::expr::ResolveExprCtx;
 use crate::{
-    asg::{self, Type},
+    asg::{self, GenericTraitRef, Type},
     source_files::Source,
 };
 use core::hash::Hash;
 use derive_more::IsVariant;
 use indexmap::IndexMap;
+use itertools::Itertools;
 use std::fmt::Display;
 
 // TODO: We probably want this to store some kind of internal hash
@@ -41,8 +42,11 @@ impl Display for PolyRecipe {
                 PolyValue::Expr(_) => {
                     todo!("mangle name for polymorphic function with expr polymorph")
                 }
-                PolyValue::Impl(_) => {
-                    todo!("mangle name for polymorphic implementation with impl polymorph")
+                PolyValue::Impl(impl_ref) => {
+                    eprintln!(
+                        "warning: name mangling for functions called with impl params is ad-hoc"
+                    );
+                    write!(f, "{:?}", impl_ref)?;
                 }
             }
 
@@ -152,6 +156,20 @@ impl PolyRecipe {
         }
         .map_err(|err| err.at(source))
     }
+
+    pub fn resolve_trait(
+        &self,
+        generic_trait: &GenericTraitRef,
+    ) -> Result<GenericTraitRef, PolymorphError> {
+        Ok(GenericTraitRef {
+            trait_ref: generic_trait.trait_ref,
+            args: generic_trait
+                .args
+                .iter()
+                .map(|ty| self.resolve_type(ty))
+                .try_collect()?,
+        })
+    }
 }
 
 impl Hash for PolyRecipe {