Improve method resolution for trait method name bindings (#7364)

## Description

This PR improves method resolution for trait method name bindings, like
this following example:

```sway
script;

use std::time::Time;

pub fn main() {
    let duration = Time::now().duration_since(Time::from(0)).unwrap();
    let _ = duration + duration;
}
```

This fix is implemented in [Gather trait impls from the argument type
module when handling trait operator
calls.](8610000).

A general refactor was also done for associated method resolution
functions:

[Refactor
TypeCheckContext::find_method_for_type.](ace60ce)

[Refactor
resolve_method_name.](9d97d46)

Closes #7330.

## Checklist

- [x] I have linked to any relevant issues.
- [x] I have commented my code, particularly in hard-to-understand
areas.
- [x] I have updated the documentation where relevant (API docs, the
reference, and the Sway book).
- [ ] If my change requires substantial documentation changes, I have
[requested support from the DevRel
team](https://github.com/FuelLabs/devrel-requests/issues/new/choose)
- [x] I have added tests that prove my fix is effective or that my
feature works.
- [x] I have added (or requested a maintainer to add) the necessary
`Breaking*` or `New Feature` labels where relevant.
- [x] I have done my best to ensure that my PR adheres to [the Fuel Labs
Code Review
Standards](https://github.com/FuelLabs/rfcs/blob/master/text/code-standards/external-contributors.md).
- [x] I have requested a review from the relevant team or maintainers.

---------

Co-authored-by: IGI-111 <igi-111@protonmail.com>

Author: tritao

sway-core/src/language/call_path.rs

@@ -375,6 +375,13 @@ impl CallPath {
             .collect::<Vec<_>>()
     }
 
+    pub fn as_vec_ident(&self) -> Vec<Ident> {
+        self.as_vec_string()
+            .iter()
+            .map(|s| Ident::new_no_span(s.clone()))
+            .collect::<Vec<_>>()
+    }
+
     /// Create a full [CallPath] from a given [Ident] and the [Namespace] in which the [Ident] is
     /// declared.
     ///

sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_application.rs

@@ -900,65 +900,58 @@ fn unify_arguments_and_parameters(
 pub(crate) fn resolve_method_name(
     handler: &Handler,
     mut ctx: TypeCheckContext,
-    method_name: &TypeBinding<MethodName>,
+    method_name_binding: &TypeBinding<MethodName>,
     arguments_types: &[TypeId],
 ) -> Result<(DeclRefFunction, TypeId), ErrorEmitted> {
     ctx.engines
         .obs()
-        .raise_on_before_method_resolution(&ctx, method_name, arguments_types);
+        .raise_on_before_method_resolution(&ctx, method_name_binding, arguments_types);
 
     let type_engine = ctx.engines.te();
     let engines = ctx.engines();
 
-    // retrieve the function declaration using the components of the method name
-    let (decl_ref, type_id) = match &method_name.inner {
+    // Helper: first argument type or an unknown placeholder.
+    let first_arg_or_unknown = || {
+        arguments_types
+            .first()
+            .cloned()
+            .unwrap_or_else(|| type_engine.new_unknown())
+    };
+
+    let (type_id, module_path, method_ident) = match &method_name_binding.inner {
         MethodName::FromType {
             call_path_binding,
             method_name,
         } => {
-            // type check the call path
             let type_id = call_path_binding
                 .type_check_with_type_info(handler, &mut ctx)
                 .unwrap_or_else(|err| type_engine.id_of_error_recovery(err));
 
-            // find the module that the symbol is in
-            let type_info_prefix = &call_path_binding
+            let type_info_path = call_path_binding
                 .inner
-                .to_fullpath(engines, ctx.namespace())
-                .prefixes;
+                .to_fullpath(engines, ctx.namespace());
+            let module_path = type_info_path.prefixes.clone();
             ctx.namespace()
-                .require_module_from_absolute_path(handler, type_info_prefix)?;
+                .require_module_from_absolute_path(handler, &module_path)?;
 
-            // find the method
-            let decl_ref = ctx.find_method_for_type(
-                handler,
-                type_id,
-                type_info_prefix,
-                method_name,
-                ctx.type_annotation(),
-                arguments_types,
-                None,
-            )?;
-
-            (decl_ref, type_id)
+            (type_id, module_path, method_name)
         }
+
         MethodName::FromTrait { call_path } => {
-            // find the module that the symbol is in
-            let module_path = match call_path.callpath_type {
+            let module_path: Vec<_> = match call_path.callpath_type {
                 CallPathType::RelativeToPackageRoot => {
                     let mut path = vec![ctx.namespace().current_package_name().clone()];
-                    for ident in call_path.prefixes.iter() {
-                        path.push(ident.clone())
-                    }
+                    path.extend(call_path.prefixes.iter().cloned());
                     path
                 }
                 CallPathType::Full => call_path.prefixes.clone(),
                 CallPathType::Ambiguous => {
+                    let first = call_path.prefixes.first().expect("prefixes is non-empty");
                     if ctx
                         .namespace()
                         .current_module()
                         .submodules()
-                        .contains_key(call_path.prefixes.first().unwrap().as_str())
+                        .contains_key(first.as_str())
                     {
                         ctx.namespace().prepend_module_path(&call_path.prefixes)
                     } else {
@@ -967,77 +960,38 @@ pub(crate) fn resolve_method_name(
                 }
             };
 
-            // find the type of the first argument
-            let type_id = arguments_types
-                .first()
-                .cloned()
-                .unwrap_or_else(|| type_engine.new_unknown());
-
-            // find the method
-            let decl_ref = ctx.find_method_for_type(
-                handler,
-                type_id,
-                &module_path,
-                &call_path.suffix,
-                ctx.type_annotation(),
-                arguments_types,
-                None,
-            )?;
-
-            (decl_ref, type_id)
+            let type_id = first_arg_or_unknown();
+            (type_id, module_path, &call_path.suffix)
         }
-        MethodName::FromModule { method_name } => {
-            // find the module that the symbol is in
-            let module_path = ctx.namespace().current_mod_path();
 
-            // find the type of the first argument
-            let type_id = arguments_types
-                .first()
-                .cloned()
-                .unwrap_or_else(|| type_engine.new_unknown());
-
-            // find the method
-            let decl_ref = ctx.find_method_for_type(
-                handler,
-                type_id,
-                module_path.as_slice(),
-                method_name,
-                ctx.type_annotation(),
-                arguments_types,
-                None,
-            )?;
-
-            (decl_ref, type_id)
+        MethodName::FromModule { method_name } => {
+            let module_path = ctx.namespace().current_mod_path().to_vec();
+            let type_id = first_arg_or_unknown();
+            (type_id, module_path, method_name)
         }
+
         MethodName::FromQualifiedPathRoot {
-            ty,
-            as_trait,
-            method_name,
+            ty, method_name, ..
         } => {
-            // type check the call path
             let type_id = ty.type_id();
-
-            // find the module that the symbol is in
-            let module_path = ctx.namespace().current_mod_path();
-
-            // find the method
-            let decl_ref = ctx.find_method_for_type(
-                handler,
-                type_id,
-                module_path,
-                method_name,
-                ctx.type_annotation(),
-                arguments_types,
-                Some(*as_trait),
-            )?;
-
-            (decl_ref, type_id)
+            let module_path = ctx.namespace().current_mod_path().to_vec();
+            (type_id, module_path, method_name)
         }
     };
 
+    let decl_ref = ctx.find_method_for_type(
+        handler,
+        type_id,
+        module_path.as_slice(),
+        method_ident,
+        ctx.type_annotation(),
+        arguments_types,
+        Some(&method_name_binding.inner),
+    )?;
+
     ctx.engines.obs().raise_on_after_method_resolution(
         &ctx,
-        method_name,
+        method_name_binding,
         arguments_types,
         decl_ref.clone(),
         type_id,