Implemented basic automatic passing of trait implementations for function calls when which trait implementation should be used is unambiguous

Author: IsaacShelton

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

@@ -8,7 +8,7 @@ use crate::{
     resolve::{
         conform::{conform_expr, to_default::conform_expr_to_default, ConformMode, Perform},
         error::{ResolveError, ResolveErrorKind},
-        Initialized,
+        Initialized, PolyValue,
     },
     source_files::Source,
 };
@@ -81,18 +81,65 @@ pub fn call_callee(
     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,
-            ));
+        if used_names.contains(expected_name) {
+            continue;
+        }
+
+        // NOTE: PERFORMANCE: TODO: This could probably be optimized
+        if let Some(caller) = ctx
+            .func_ref
+            .map(|caller_func_ref| ctx.asg.funcs.get(caller_func_ref).unwrap())
+        {
+            let from_env = caller.impl_params.params.iter().filter(|(_, param_trait)| {
+                callee
+                    .recipe
+                    .resolve_trait(expected_trait)
+                    .map_or(false, |expected_trait| **param_trait == expected_trait)
+            });
+
+            match from_env.exactly_one() {
+                Ok((param_name, _)) => {
+                    if callee
+                        .recipe
+                        .polymorphs
+                        .insert(expected_name.into(), PolyValue::PolyImpl(param_name.into()))
+                        .is_some()
+                    {
+                        return Err(ResolveError::other(
+                        format!(
+                            "Could not automatically supply trait implementation for '${} {}' required by function call, since the polymorph is already in use",
+                            expected_name,
+                            expected_trait.display(&ctx.asg),
+                        ),
+                        source,
+                    ));
+                    }
+                }
+                Err(mut non_unique) => {
+                    return Err(ResolveError::other(
+                        if non_unique.next().is_some() {
+                            format!(
+                            "Ambiguous trait implementation for '${} {}' required by function call, please specify manually",
+                            expected_name,
+                            expected_trait.display(&ctx.asg),
+                        )
+                        } else {
+                            format!(
+                                "Missing '${} {}' trait implementation required by function call",
+                                expected_name,
+                                expected_trait.display(&ctx.asg),
+                            )
+                        },
+                        source,
+                    ));
+                }
+            }
         }
     }
 
+    // We shouldn't use used_names after this, since we know all names were satisfied
+    drop(used_names);
+
     for (i, arg) in args.iter_mut().enumerate() {
         let function = ctx.asg.funcs.get(callee.func_ref).unwrap();