Adjust TypeCheckContext::find_method_for_tyoe

Author: ironcev

sway-core/src/semantic_analysis/type_check_context.rs

@@ -7,7 +7,7 @@ use crate::{
     engine_threading::*,
     language::{
         parsed::{MethodName, TreeType},
-        ty::{self, TyDecl, TyExpression},
+        ty::{self, TyDecl, TyExpression, TyFunctionDisplay},
         CallPath, QualifiedCallPath, Visibility,
     },
     monomorphization::{monomorphize_with_modpath, MonomorphizeHelper},
@@ -23,6 +23,7 @@ use crate::{
     EnforceTypeArguments, SubstTypesContext, TraitConstraint, TypeParameter, TypeSubstMap,
     UnifyCheck,
 };
+use itertools::Itertools;
 use sway_error::{
     error::CompileError,
     handler::{ErrorEmitted, Handler},
@@ -915,10 +916,10 @@ impl<'a> TypeCheckContext<'a> {
             // While collecting unifications we don't decay numeric and will ignore this error.
             if self.collecting_unifications {
                 return Err(handler.emit_err(CompileError::MethodNotFound {
-                    method: method_name.clone().as_str().to_string(),
+                    called_method: method_name.into(),
+                    expected_signature: method_name.clone().as_str().to_string(),
                     type_name: self.engines.help_out(type_id).to_string(),
-                    matching_method_strings: vec![],
-                    span: method_name.span(),
+                    matching_methods: vec![],
                 }));
             }
             type_engine.decay_numeric(handler, self.engines, type_id, &method_name.span())?;
@@ -1515,7 +1516,7 @@ impl<'a> TypeCheckContext<'a> {
                 continue;
             }
 
-            let key: GroupingKey = (impl_trait.decl_id, method.implementing_for_typeid);
+            let key: GroupingKey = (impl_trait.decl_id, method.implementing_for);
 
             // Prefer the method that is type-check finalized when conflicting.
             match trait_methods.get_mut(&key) {
@@ -1603,7 +1604,7 @@ impl<'a> TypeCheckContext<'a> {
                 let mut exact = vec![];
                 for r in trait_methods.values() {
                     let m = decl_engine.get_function(r);
-                    if let Some(impl_for) = m.implementing_for_typeid {
+                    if let Some(impl_for) = m.implementing_for {
                         if eq_check.with_unify_ref_mut(false).check(impl_for, type_id) {
                             exact.push(r.clone());
                         }
@@ -1647,41 +1648,36 @@ impl<'a> TypeCheckContext<'a> {
     }
 
     #[inline]
-    fn format_candidate_summaries_for_error(&self, decl_refs: &[DeclRefFunction]) -> Vec<String> {
-        let de = self.engines.de();
+    fn format_candidate_summaries_for_error(engines: &Engines, decl_refs: &[DeclRefFunction]) -> Vec<String> {
+        let de = engines.de();
+        let fn_display = TyFunctionDisplay::full().without_self_param_type();
 
-        let mut out: Vec<String> = decl_refs
+        let mut out = decl_refs
             .iter()
             .map(|r| {
                 let m = de.get_function(r);
-                let params = m
-                    .parameters
-                    .iter()
-                    .map(|p| self.engines.help_out(p.type_argument.type_id()).to_string())
-                    .collect::<Vec<_>>()
-                    .join(", ");
-                let ret = self.engines.help_out(m.return_type.type_id());
-                let in_impl = if let Some(for_ty) = m.implementing_for_typeid {
-                    format!(" in {}", self.engines.help_out(for_ty))
-                } else {
-                    String::new()
-                };
-                format!("{}({}) -> {}{}", m.name.as_str(), params, ret, in_impl)
+                fn_display.display(&m, engines)
             })
-            .collect();
+            .collect_vec();
 
         out.sort();
         out
     }
 
     /// Given a `method_name` and a `type_id`, find that method on that type in the namespace.
-    /// `annotation_type` is the expected method return type. Requires `argument_types` because:
+    ///
+    /// `annotation_type` is the expected method return type.
+    ///
+    /// Requires `argument_types` because:
     /// - standard operations like +, <=, etc. are called like "std::ops::<operation>" and the
     ///   actual self type of the trait implementation is determined by the passed argument type.
     /// - we can have several implementations of generic traits for different types, that can
     ///   result in a method of a same name, but with different type arguments.
     ///
     /// This function will emit a [CompileError::MethodNotFound] if the method is not found.
+    ///
+    /// Note that _method_ here means **any function associated to a type**, with or without
+    /// the `self` argument.
     #[allow(clippy::too_many_arguments)]
     pub(crate) fn find_method_for_type(
         &self,
@@ -1714,7 +1710,7 @@ impl<'a> TypeCheckContext<'a> {
             annotation_type,
         );
 
-        let mut matching_method_strings = HashSet::<String>::new();
+        let mut matching_methods = Vec::<String>::new();
 
         let mut qualified_call_path: Option<QualifiedCallPath> = None;
 
@@ -1758,8 +1754,8 @@ impl<'a> TypeCheckContext<'a> {
             }
         } else {
             // No signature-compatible candidates.
-            matching_method_strings
-                .extend(self.format_candidate_summaries_for_error(&matching_method_decl_refs));
+            matching_methods
+                .append(&mut Self::format_candidate_summaries_for_error(self.engines, &matching_method_decl_refs));
         }
 
         // Forward an ErrorRecovery from the first argument if present.
@@ -1782,7 +1778,8 @@ impl<'a> TypeCheckContext<'a> {
 
         // Final: MethodNotFound with formatted signature and candidates.
         Err(handler.emit_err(CompileError::MethodNotFound {
-            method: format!(
+            called_method: method_ident.into(),
+            expected_signature: format!(
                 "{}({}){}",
                 method_ident.clone(),
                 arguments_types
@@ -1800,8 +1797,7 @@ impl<'a> TypeCheckContext<'a> {
                 }
             ),
             type_name,
-            matching_method_strings: matching_method_strings.iter().cloned().collect::<Vec<_>>(),
-            span: method_ident.span(),
+            matching_methods,
         }))
     }