Gather trait impls from the argument type module when handling trait operator calls.

tritao · tritao · commit 9bfc436ba9db · 2025-09-04T10:22:13.000+01:00
Fixes #7330.
diff --git a/sway-core/src/language/call_path.rs b/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.
     ///
diff --git a/sway-core/src/language/ty/expression/expression_variant.rs b/sway-core/src/language/ty/expression/expression_variant.rs
@@ -873,6 +873,7 @@ impl ReplaceDecls for TyExpressionVariant {
                                 method.return_type.type_id(),
                                 &arguments_types,
                                 None,
+                                false
                             )?;
                             method = (*decl_engine.get(&implementing_type_method_ref)).clone();
                         }
diff --git a/sway-core/src/semantic_analysis/ast_node/declaration/abi.rs b/sway-core/src/semantic_analysis/ast_node/declaration/abi.rs
@@ -114,6 +114,7 @@ impl ty::TyAbiDecl {
                             ctx.type_annotation(),
                             &[],
                             None,
+                            false,
                         ) {
                             let superabi_impl_method =
                                 ctx.engines.de().get_function(&superabi_impl_method_ref);
@@ -280,6 +281,7 @@ impl ty::TyAbiDecl {
                                 ctx.type_annotation(),
                                 &[],
                                 None,
+                                false,
                             ) {
                                 let superabi_method =
                                     ctx.engines.de().get_function(&superabi_method_ref);
@@ -354,6 +356,7 @@ impl ty::TyAbiDecl {
                             ctx.type_annotation(),
                             &[],
                             None,
+                            false,
                         ) {
                             let superabi_impl_method =
                                 ctx.engines.de().get_function(&superabi_impl_method_ref);
diff --git a/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_application.rs b/sway-core/src/semantic_analysis/ast_node/expression/typed_expression/method_application.rs
@@ -934,6 +934,7 @@ pub(crate) fn resolve_method_name(
                 ctx.type_annotation(),
                 arguments_types,
                 None,
+                false,
             )?;
 
             (decl_ref, type_id)
@@ -978,6 +979,7 @@ pub(crate) fn resolve_method_name(
                 ctx.type_annotation(),
                 arguments_types,
                 None,
+                true
             )?;
 
             (decl_ref, type_id)
@@ -1001,6 +1003,7 @@ pub(crate) fn resolve_method_name(
                 ctx.type_annotation(),
                 arguments_types,
                 None,
+                false,
             )?;
 
             (decl_ref, type_id)
@@ -1025,6 +1028,7 @@ pub(crate) fn resolve_method_name(
                 ctx.type_annotation(),
                 arguments_types,
                 Some(*as_trait),
+                false,
             )?;
 
             (decl_ref, type_id)
diff --git a/sway-core/src/semantic_analysis/type_check_context.rs b/sway-core/src/semantic_analysis/type_check_context.rs
@@ -2,6 +2,7 @@
 use std::collections::{btree_map::Entry, BTreeMap, HashSet};
 
 use crate::{
+    ast_elements::type_argument::GenericTypeArgument,
     decl_engine::{DeclEngineGet, DeclRefFunction, MaterializeConstGenerics},
     engine_threading::*,
     language::{
@@ -11,7 +12,7 @@ use crate::{
     },
     monomorphization::{monomorphize_with_modpath, MonomorphizeHelper},
     namespace::{
-        IsExtendingExistingImpl, IsImplSelf, ModulePath, ResolvedDeclaration,
+        IsExtendingExistingImpl, IsImplSelf, Module, ModulePath, ResolvedDeclaration,
         ResolvedTraitImplItem, TraitMap,
     },
     semantic_analysis::{
@@ -735,6 +736,7 @@ impl<'a> TypeCheckContext<'a> {
         type_id: TypeId,
         item_prefix: &ModulePath,
         item_name: &Ident,
+        from_trait: bool,
     ) -> Result<Vec<ty::TyTraitItem>, ErrorEmitted> {
         let type_engine = self.engines.te();
 
@@ -796,6 +798,19 @@ impl<'a> TypeCheckContext<'a> {
             &mut filter_item,
         );
 
+        // grab the items from where the argument type is declared
+        if from_trait {
+            let type_module = self.get_namespace_module_from_type_id(type_id);
+            if let Ok(type_module) = type_module {
+                TraitMap::find_items_and_trait_key_for_type(
+                    type_module,
+                    self.engines,
+                    type_id,
+                    &mut filter_item,
+                );
+            }
+        }
+
         if item_prefix != self.namespace().current_mod_path.as_slice() {
             // grab the module where the type itself is declared
             let type_module = self
@@ -814,6 +829,35 @@ impl<'a> TypeCheckContext<'a> {
         Ok(matching_item_decl_refs)
     }
 
+    fn get_namespace_module_from_type_id(&self, type_id: TypeId) -> Result<&Module, ErrorEmitted> {
+        let type_info = self.engines().te().get(type_id);
+        if type_info.is_alias() {
+            if let TypeInfo::Alias { ty, .. } = &*type_info {
+                if let Some(GenericTypeArgument { type_id, .. }) = ty.as_type_argument() {
+                    return self.get_namespace_module_from_type_id(*type_id);
+                }
+            }
+        }
+
+        let handler = Handler::default();
+        let call_path = match *type_info {
+            // TypeInfo::UntypedEnum(parsed_decl_id) => Some(self.engines().pe().get_struct(&parsed_decl_id).call_path),
+            // TypeInfo::UntypedStruct(parsed_decl_id) => todo!(),
+            TypeInfo::Enum(decl_id) => self.engines().de().get_enum(&decl_id).call_path.clone(),
+            TypeInfo::Struct(decl_id) => self.engines().de().get_struct(&decl_id).call_path.clone(),
+            _ => {
+                return Err(handler.emit_err(CompileError::Internal(
+                    "No call path for type id",
+                    Span::dummy(),
+                )))
+            }
+        };
+
+        let call_path = call_path.rshift();
+        self.namespace()
+            .require_module_from_absolute_path(&handler, &call_path.as_vec_ident())
+    }
+
     #[inline]
     fn default_numeric_if_needed(
         &self,
@@ -851,11 +895,13 @@ impl<'a> TypeCheckContext<'a> {
         method_prefix: &ModulePath,
         method_name: &Ident,
         annotation_type: TypeId,
+        from_trait: bool,
     ) -> Result<Vec<ty::TyTraitItem>, ErrorEmitted> {
         let type_engine = self.engines.te();
 
         // Start with items for the concrete type.
-        let mut items = self.find_items_for_type(handler, type_id, method_prefix, method_name)?;
+        let mut items =
+            self.find_items_for_type(handler, type_id, method_prefix, method_name, from_trait)?;
 
         // Consider items from supersets indicated by the annotation return type.
         if !matches!(&*type_engine.get(annotation_type), TypeInfo::Unknown)
@@ -873,6 +919,7 @@ impl<'a> TypeCheckContext<'a> {
                         inner,
                         method_prefix,
                         method_name,
+                        from_trait,
                     )?);
                 }
             }
@@ -1258,6 +1305,7 @@ impl<'a> TypeCheckContext<'a> {
         annotation_type: TypeId,
         arguments_types: &[TypeId],
         as_trait: Option<TypeId>,
+        from_trait: bool,
     ) -> Result<DeclRefFunction, ErrorEmitted> {
         let type_engine = self.engines.te();
 
@@ -1269,6 +1317,7 @@ impl<'a> TypeCheckContext<'a> {
             method_prefix,
             method_name,
             annotation_type,
+            from_trait,
         )?;
 
         let matching_method_decl_refs = self.items_to_method_refs(matching_items);
diff --git a/sway-core/src/type_system/info.rs b/sway-core/src/type_system/info.rs
@@ -1342,6 +1342,10 @@ impl TypeInfo {
         matches!(self, TypeInfo::Array(_, _))
     }
 
+    pub fn is_alias(&self) -> bool {
+        matches!(self, TypeInfo::Alias { .. })
+    }
+
     pub fn is_contract(&self) -> bool {
         matches!(self, TypeInfo::Contract)
     }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/trait_map_use_impl_in_scope/Forc.lock b/test/src/e2e_vm_tests/test_programs/should_pass/trait_map_use_impl_in_scope/Forc.lock
@@ -0,0 +1,8 @@
+[[package]]
+name = "std"
+source = "path+from-root-AA6134FC2B337767"
+
+[[package]]
+name = "trait_map_use_impl_in_scope"
+source = "member"
+dependencies = ["std"]
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/trait_map_use_impl_in_scope/Forc.toml b/test/src/e2e_vm_tests/test_programs/should_pass/trait_map_use_impl_in_scope/Forc.toml
@@ -0,0 +1,8 @@
+[project]
+name = "trait_map_use_impl_in_scope"
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+
+[dependencies]
+std = { path = "../../../../../../sway-lib-std" }
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/trait_map_use_impl_in_scope/src/main.sw b/test/src/e2e_vm_tests/test_programs/should_pass/trait_map_use_impl_in_scope/src/main.sw
@@ -0,0 +1,9 @@
+script;
+
+use std::time::Time;
+// use std::time::*;
+
+pub fn main() {
+    let duration = Time::now().duration_since(Time::from(0)).unwrap();
+    let _ = duration + duration;
+}
diff --git a/test/src/e2e_vm_tests/test_programs/should_pass/trait_map_use_impl_in_scope/test.toml b/test/src/e2e_vm_tests/test_programs/should_pass/trait_map_use_impl_in_scope/test.toml
@@ -0,0 +1,2 @@
+category = "compile"
+expected_warnings = 0

Original file line number	Diff line number	Diff line change
`@@ -873,6 +873,7 @@ impl ReplaceDecls for TyExpressionVariant {`
`873`	`873`	`method.return_type.type_id(),`
`874`	`874`	`&arguments_types,`
`875`	`875`	`None,`
	`876`	`+ false`
`876`	`877`	`)?;`
`877`	`878`	`method = (*decl_engine.get(&implementing_type_method_ref)).clone();`
`878`	`879`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1342,6 +1342,10 @@ impl TypeInfo {`
`1342`	`1342`	`matches!(self, TypeInfo::Array(_, _))`
`1343`	`1343`	`}`
`1344`	`1344`
	`1345`	`+ pub fn is_alias(&self) -> bool {`
	`1346`	`+ matches!(self, TypeInfo::Alias { .. })`
	`1347`	`+ }`
	`1348`	`+`
`1345`	`1349`	`pub fn is_contract(&self) -> bool {`
`1346`	`1350`	`matches!(self, TypeInfo::Contract)`
`1347`	`1351`	`}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+category = "compile"`
	`2`	`+expected_warnings = 0`