Merge pull request #766 from wado-lang/claude/fix-cross-module-types-WE3ky

Fix cross-module type identity and unify WirName

Author: gfx

wado-compiler/src/codegen/emit.rs

@@ -2251,7 +2251,7 @@ impl<'a> WirEmitter<'a> {
             for (i, func) in self.wir.functions.iter().enumerate() {
                 let wir_func_idx = crate::wir_build::DEFINED_FUNC_BASE + u32::try_from(i).unwrap();
                 if let Some(&wasm_idx) = self.func_index_map.get(&wir_func_idx) {
-                    name_map.append(wasm_idx, &func.name.display);
+                    name_map.append(wasm_idx, &func.name.fq);
                 }
             }
             names.functions(&name_map);

wado-compiler/src/monomorphize/call_rewrite.rs

@@ -119,6 +119,7 @@ impl Monomorphizer {
             if let Some(inferred_args) = effective_type_args {
                 let key = InstantiationKey {
                     name: qualified_func_name,
+                    module_source: func.module_source.clone(),
                     impl_type_args: vec![],
                     method_type_args: inferred_args,
                     method_info: original_method_info.clone(),
@@ -169,6 +170,7 @@ impl Monomorphizer {
                 for generic_method_name in names_to_try {
                     let key = InstantiationKey {
                         name: generic_method_name.clone(),
+                        module_source: func.module_source.clone(),
                         impl_type_args: monomorph.impl_type_args.clone(),
                         method_type_args: monomorph.method_type_args.clone(),
                         method_info: Some(info.clone()),
@@ -235,6 +237,7 @@ impl Monomorphizer {
             for (full_method_name, _tn) in &names_to_try {
                 let key = InstantiationKey {
                     name: full_method_name.clone(),
+                    module_source: method_func.module_source.clone(),
                     impl_type_args: vec![],
                     method_type_args: type_args.clone(),
                     method_info: None,
@@ -287,6 +290,7 @@ impl Monomorphizer {
                     for (generic_method_name, _tn) in &dg_names {
                         let combined_key = InstantiationKey {
                             name: generic_method_name.clone(),
+                            module_source: method_func.module_source.clone(),
                             impl_type_args: impl_type_args.clone(),
                             method_type_args: type_args.clone(),
                             method_info: None,
@@ -351,6 +355,7 @@ impl Monomorphizer {
                             Some(trait_name),
                             &method_name,
                         ),
+                        module_source: method_func.module_source.clone(),
                         impl_type_args: impl_type_args.clone(),
                         method_type_args: vec![],
                         method_info: None,
@@ -360,6 +365,7 @@ impl Monomorphizer {
                     MethodName::format_local(&base_struct, Some(trait_name), &method_name);
                 possible_keys.push(InstantiationKey {
                     name: trait_method_name,
+                    module_source: method_func.module_source.clone(),
                     impl_type_args: impl_type_args.clone(),
                     method_type_args: vec![],
                     method_info: None,
@@ -368,6 +374,7 @@ impl Monomorphizer {
             // Also try regular method format
             possible_keys.push(InstantiationKey {
                 name: MethodName::format_local(&base_struct, None, &method_name),
+                module_source: method_func.module_source.clone(),
                 impl_type_args,
                 method_type_args: vec![],
                 method_info: None,
@@ -404,6 +411,7 @@ impl Monomorphizer {
             {
                 let key = InstantiationKey {
                     name: mono.generic_name.clone(),
+                    module_source: method_func.module_source.clone(),
                     impl_type_args: mono.impl_type_args.clone(),
                     method_type_args: mono.method_type_args.clone(),
                     method_info: None,
@@ -462,6 +470,7 @@ impl Monomorphizer {
             {
                 let key = InstantiationKey {
                     name: generic_name.clone(),
+                    module_source: method_func.module_source.clone(),
                     impl_type_args: impl_type_args.clone(),
                     method_type_args: vec![],
                     method_info: None,

wado-compiler/src/monomorphize/func_inst.rs

@@ -190,6 +190,7 @@ impl Monomorphizer {
                 if !type_args.is_empty() && generic_functions.contains_key(&qualified_func_name) {
                     let key = InstantiationKey {
                         name: qualified_func_name.clone(),
+                        module_source: func.module_source.clone(),
                         impl_type_args: vec![],
                         method_type_args: type_args.clone(),
                         method_info: func.method_info.clone(),
@@ -214,6 +215,7 @@ impl Monomorphizer {
                         {
                             let key = InstantiationKey {
                                 name: qualified_func_name.clone(),
+                                module_source: func.module_source.clone(),
                                 impl_type_args: vec![],
                                 method_type_args: inferred,
                                 method_info: func.method_info.clone(),
@@ -267,6 +269,7 @@ impl Monomorphizer {
                                 let method_info = generic_func.method_info.clone();
                                 let key = InstantiationKey {
                                     name: generic_method_name,
+                                    module_source: func.module_source.clone(),
                                     impl_type_args: impl_type_args.clone(),
                                     method_type_args,
                                     method_info,
@@ -338,6 +341,7 @@ impl Monomorphizer {
                                     });
                                 let key = InstantiationKey {
                                     name: full_method_name.clone(),
+                                    module_source: method_func.module_source.clone(),
                                     impl_type_args: vec![],
                                     method_type_args: type_args.clone(),
                                     method_info: Some(method_info),
@@ -409,6 +413,7 @@ impl Monomorphizer {
                                             );
                                             let key = InstantiationKey {
                                                 name: generic_method_name.clone(),
+                                                module_source: method_func.module_source.clone(),
                                                 impl_type_args: impl_type_args.clone(),
                                                 method_type_args: type_args.clone(),
                                                 method_info: Some(method_info),
@@ -479,6 +484,7 @@ impl Monomorphizer {
                                 let method_info = generic_func.method_info.clone();
                                 let key = InstantiationKey {
                                     name: generic_method_name.clone(),
+                                    module_source: method_func.module_source.clone(),
                                     impl_type_args: impl_type_args.clone(),
                                     method_type_args: method_type_args_for_key,
                                     method_info,
@@ -540,6 +546,7 @@ impl Monomorphizer {
                                 let method_info = generic_func.method_info.clone();
                                 let key = InstantiationKey {
                                     name: generic_method_name.clone(),
+                                    module_source: method_func.module_source.clone(),
                                     impl_type_args: impl_type_args.clone(),
                                     method_type_args: method_type_args_for_key,
                                     method_info,
@@ -625,6 +632,7 @@ impl Monomorphizer {
                     };
                     let key = InstantiationKey {
                         name: mono.generic_name.clone(),
+                        module_source: method_func.module_source.clone(),
                         impl_type_args: impl_ta,
                         method_type_args: method_ta,
                         method_info,
@@ -677,6 +685,7 @@ impl Monomorphizer {
                             drop(generic_func);
                             let key = InstantiationKey {
                                 name: generic_name,
+                                module_source: method_func.module_source.clone(),
                                 impl_type_args,
                                 method_type_args: vec![],
                                 method_info,

wado-compiler/src/monomorphize/struct_inst.rs

@@ -17,26 +17,9 @@ impl Monomorphizer {
     ) -> Option<TirStruct> {
         let mangled_name = self.structs.instantiated.get(key)?.clone();
 
-        // Find the GenericInstance's module_source from the type table.
-        // Use the generic's original module (where it was defined) for the struct type,
-        // ensuring consistency across modules that share the same type table.
-        let struct_module_source = type_table
-            .iter_type_ids()
-            .find_map(|id| {
-                if let ResolvedType::GenericInstance {
-                    name,
-                    module_source,
-                    type_args,
-                } = type_table.get(id)
-                    && name == &key.name
-                    && type_args == &key.impl_type_args
-                {
-                    Some(module_source.clone())
-                } else {
-                    None
-                }
-            })
-            .unwrap_or_else(|| self.current_module_source.clone());
+        // Use module_source from the InstantiationKey, which carries
+        // the module where the generic struct was defined.
+        let struct_module_source = key.module_source.clone();
 
         // Register the concrete struct type in the type table BEFORE substituting field types.
         // This is critical for self-referential structs like:
@@ -53,9 +36,12 @@ impl Monomorphizer {
         // so that substitute_type can use it for self-references
         for id in type_table.iter_type_ids() {
             if let ResolvedType::GenericInstance {
-                name, type_args, ..
+                name,
+                module_source,
+                type_args,
             } = type_table.get(id)
                 && name == &key.name
+                && module_source == &key.module_source
                 && type_args == &key.impl_type_args
             {
                 self.structs.type_substitutions.insert(id, concrete_type_id);

wado-compiler/src/monomorphize/substitute.rs

@@ -136,7 +136,9 @@ impl Monomorphizer {
     ) {
         for id in type_table.iter_type_ids() {
             if let ResolvedType::GenericInstance {
-                name, type_args, ..
+                name,
+                module_source,
+                type_args,
             } = type_table.get(id)
             {
                 // Skip empty type_args (invalid generic instances)
@@ -164,6 +166,7 @@ impl Monomorphizer {
                 if all_concrete {
                     let key = crate::tir::InstantiationKey {
                         name: name.clone(),
+                        module_source: module_source.clone(),
                         impl_type_args: type_args.clone(),
                         method_type_args: vec![],
                         method_info: None, // Struct instantiation,

wado-compiler/src/name.rs

@@ -881,13 +881,7 @@ impl StructName {
 
 impl fmt::Display for StructName {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match &self.module_source {
-            ModuleSource::EntryPoint { .. } => write!(f, "{}", self.name),
-            ModuleSource::Core { name: module } => write!(f, "core/{}/{}", module, self.name),
-            ModuleSource::Wasi { interface } => write!(f, "wasi/{}/{}", interface, self.name),
-            ModuleSource::Local { path } => write!(f, "{}/{}", path, self.name),
-            ModuleSource::Remote { url } => write!(f, "{}/{}", url, self.name),
-        }
+        write!(f, "{}/{}", self.module_source, self.name)
     }
 }
 
@@ -1359,13 +1353,13 @@ mod tests {
     #[test]
     fn test_struct_name_from_strs() {
         let struct_name = StructName::from_strs(&["core", "internal"], "SomeType");
-        assert_eq!(struct_name.to_string(), "core/internal/SomeType");
+        assert_eq!(struct_name.to_string(), "core:internal/SomeType");
     }
 
     #[test]
     fn test_struct_name_empty_path() {
         let struct_name = StructName::from_path_and_name(&[], "Point");
-        assert_eq!(struct_name.to_string(), "Point");
+        assert_eq!(struct_name.to_string(), "<entry>/Point");
     }
 
     #[test]

wado-compiler/src/resolver.rs

@@ -265,23 +265,24 @@ impl<'a, H: CompilerHost> Resolver<'a, H> {
     /// Look up struct field info by (name, `module_source`).
     ///
     /// This is the correct way to look up struct fields — it disambiguates
-    /// structs with the same name from different modules. Falls back to the
-    /// module-local flat map when the requested `module_source` has no entry in
-    /// the global map (e.g. during early resolution before all modules are loaded).
+    /// The flat `struct_fields` map is a visibility-scoped projection of `all_struct_fields`,
+    /// containing only types visible to the current module (own definitions + explicit imports).
+    ///
+    /// `all_struct_fields` covers ALL modules and is needed for cross-module lookups where
+    /// the type wasn't explicitly imported (e.g., a struct returned by a function from another
+    /// module).
     fn lookup_struct_fields(
         &self,
         name: &str,
         module_source: &ModuleSource,
     ) -> Option<&StructFieldInfo> {
-        self.all_struct_fields
-            .get(module_source)
-            .and_then(|m| m.get(name))
+        self.struct_fields
+            .get(name)
+            .filter(|info| info.module_source == *module_source)
             .or_else(|| {
-                // Fallback: if all_struct_fields is not yet populated (early init),
-                // try the flat map but only if module_source matches.
-                self.struct_fields
-                    .get(name)
-                    .filter(|info| info.module_source == *module_source)
+                self.all_struct_fields
+                    .get(module_source)
+                    .and_then(|m| m.get(name))
             })
     }
 

wado-compiler/src/resolver/expr.rs

@@ -661,22 +661,10 @@ impl<H: CompilerHost> Resolver<'_, H> {
                 module_source,
                 ..
             } => {
-                // Use the flat struct_fields map first. When there's a name collision
-                // (the entry is from a different module), re-resolve fields from the
-                // source module to get the correct struct definition.
-                if let Some(struct_info) = self.struct_fields.get(&name) {
-                    if struct_info.module_source == module_source {
-                        for (index, (fname, ftype, _)) in struct_info.fields.iter().enumerate() {
-                            if fname == field_name {
-                                return (index as u32, *ftype);
-                            }
-                        }
-                    } else {
-                        // Name collision: re-resolve field type from the loaded module
-                        if let Some(ftype) =
-                            self.resolve_field_in_source_module(&name, field_name, &module_source)
-                        {
-                            return ftype;
+                if let Some(struct_info) = self.lookup_struct_fields(&name, &module_source) {
+                    for (index, (fname, ftype, _)) in struct_info.fields.iter().enumerate() {
+                        if fname == field_name {
+                            return (index as u32, *ftype);
                         }
                     }
                 }
@@ -715,7 +703,7 @@ impl<H: CompilerHost> Resolver<'_, H> {
                     return (0, TypeTable::UNKNOWN);
                 }
                 // Clone fields to avoid borrow issues
-                let fields_clone = self.struct_fields.get(&name).cloned();
+                let fields_clone = self.lookup_struct_fields(&name, &module_source).cloned();
                 if let Some(struct_info) = fields_clone {
                     for (index, (fname, ftype, _)) in struct_info.fields.iter().enumerate() {
                         if fname == field_name {
@@ -731,64 +719,6 @@ impl<H: CompilerHost> Resolver<'_, H> {
         (0, TypeTable::UNKNOWN)
     }
 
-    /// Resolve a struct field type from the source module where the struct is defined.
-    /// Used when the flat `struct_fields` map has a name collision (two modules define
-    /// a struct with the same name). This re-resolves the field type in the source
-    /// module's type context to get the correct result.
-    pub(super) fn resolve_field_in_source_module(
-        &mut self,
-        struct_name: &str,
-        field_name: &str,
-        module_source: &ModuleSource,
-    ) -> Option<(u32, TypeId)> {
-        // Pre-populate module type maps cache before borrowing loaded_modules
-        self.ensure_module_maps_cached(module_source);
-
-        let loaded_module = self.loaded_modules.get(module_source)?;
-        // Find the struct declaration in the loaded module
-        let struct_decl = loaded_module.items.iter().find_map(|item| {
-            if let Item::Struct(s) = item
-                && s.name == struct_name
-            {
-                Some(s)
-            } else {
-                None
-            }
-        })?;
-
-        // Swap to source module's type context using cached maps (O(1))
-        let mut cached = self
-            .module_type_maps_cache
-            .shift_remove(module_source)
-            .expect("cache populated by ensure_module_maps_cached");
-        std::mem::swap(&mut self.struct_fields, &mut cached.struct_fields);
-        std::mem::swap(&mut self.variant_cases, &mut cached.variant_cases);
-        std::mem::swap(&mut self.enum_cases, &mut cached.enum_cases);
-        std::mem::swap(&mut self.flags_cases, &mut cached.flags_cases);
-        std::mem::swap(&mut self.newtypes, &mut cached.newtypes);
-        std::mem::swap(&mut self.resource_types, &mut cached.resource_types);
-
-        // Find and resolve the field type
-        let result = struct_decl
-            .fields
-            .iter()
-            .enumerate()
-            .find(|(_, f)| f.name == field_name)
-            .map(|(index, f)| (index as u32, self.resolve_type(&f.ty)));
-
-        // Restore type maps and re-cache
-        std::mem::swap(&mut self.struct_fields, &mut cached.struct_fields);
-        std::mem::swap(&mut self.variant_cases, &mut cached.variant_cases);
-        std::mem::swap(&mut self.enum_cases, &mut cached.enum_cases);
-        std::mem::swap(&mut self.flags_cases, &mut cached.flags_cases);
-        std::mem::swap(&mut self.newtypes, &mut cached.newtypes);
-        std::mem::swap(&mut self.resource_types, &mut cached.resource_types);
-        self.module_type_maps_cache
-            .insert(module_source.clone(), cached);
-
-        result
-    }
-
     /// Check if a struct field is accessible from the current module.
     /// Non-pub fields are private to the module that defines them.
     fn check_field_visibility(&mut self, struct_type: TypeId, field_name: &str, span: Span) {
@@ -821,7 +751,7 @@ impl<H: CompilerHost> Resolver<'_, H> {
         }
 
         // Look up field visibility
-        if let Some(struct_info) = self.struct_fields.get(&struct_name) {
+        if let Some(struct_info) = self.lookup_struct_fields(&struct_name, &module_source) {
             for (fname, _, is_pub) in &struct_info.fields {
                 if fname == field_name && !is_pub {
                     let _ = self.logger.error(TypeError::TypeMismatch {