more comments

crates/wit-component/src/encoding/wit/v2.rs

@@ -229,8 +229,8 @@ impl InterfaceEncoder<'_> {
         Self::encode_instance_contents(self, interface)?;
         let iface = &self.resolve.interfaces[interface];
         let mut instance = self.pop_instance();
-        for (name, nest) in &iface.nested {
-            self.encode_nested(name, nest.id, &mut instance)?;
+        for nest in &iface.nested {
+            self.encode_nested(&self.interface_path(nest.id), nest.id, &mut instance)?;
         }
 
         let idx = self.outer.type_count();
@@ -240,6 +240,23 @@ impl InterfaceEncoder<'_> {
         Ok(idx)
     }
 
+    fn interface_path(&self, iface: InterfaceId) -> String {
+        let iface = &self.resolve.interfaces[iface];
+        let pkg_id = iface.package.unwrap();
+        let pkg = &self.resolve.packages[pkg_id];
+        if let Some(v) = &pkg.name.version {
+            format!(
+                "{}:{}/{}@{}",
+                pkg.name.namespace,
+                pkg.name.name,
+                iface.name.as_ref().unwrap(),
+                v.to_string()
+            )
+        } else {
+            format!("{}/{}", pkg.name.to_string(), iface.name.as_ref().unwrap())
+        }
+    }
+
     fn encode_nested<'a>(
         &mut self,
         name: &str,
@@ -251,9 +268,13 @@ impl InterfaceEncoder<'_> {
         let ty = instance.ty();
         let nested_instance = &mut inst.pop_instance();
         let iface = &self.resolve.interfaces[iface_id];
-        for (deep_name, deep_nest) in &iface.nested {
+        for deep_nest in &iface.nested {
             let mut inst = InterfaceEncoder::new(&self.resolve);
-            inst.encode_nested(deep_name, deep_nest.id, nested_instance)?;
+            inst.encode_nested(
+                &self.interface_path(deep_nest.id),
+                deep_nest.id,
+                nested_instance,
+            )?;
         }
         ty.instance(&nested_instance);
         instance.export(name, ComponentTypeRef::Instance(instance.type_count() - 1));

crates/wit-component/src/printing.rs

@@ -135,7 +135,7 @@ impl WitPrinter {
     fn print_interface(&mut self, resolve: &Resolve, id: InterfaceId) -> Result<()> {
         let prev_items = mem::replace(&mut self.any_items, false);
         let interface = &resolve.interfaces[id];
-        for (_, nest) in &interface.nested {
+        for nest in &interface.nested {
             self.print_stability(&nest.stability);
             self.print_docs(&nest.docs);
             self.output.push_str("nest ");

crates/wit-component/tests/interfaces/multi-package-nest.wat

@@ -0,0 +1,23 @@
+(component
+  (type (;0;)
+    (component
+      (type (;0;)
+        (instance
+          (type (;0;)
+            (instance
+              (type (;0;) string)
+              (export (;1;) "t" (type (eq 0)))
+            )
+          )
+          (export (;0;) "foo:other/i" (instance (type 0)))
+        )
+      )
+      (export (;0;) "foo:bar/i1" (instance (type 0)))
+    )
+  )
+  (export (;1;) "i1" (type 0))
+  (@custom "package-docs" "\00{}")
+  (@producers
+    (processed-by "wit-component" "$CARGO_PKG_VERSION")
+  )
+)

crates/wit-component/tests/interfaces/multi-package-nest.wit

@@ -0,0 +1,11 @@
+package foo:bar;
+
+package foo:other {
+  interface i {
+    type t = string;
+  }
+}
+
+interface i1 {
+  nest foo:other/i;
+}

crates/wit-component/tests/interfaces/multi-package-nest.wit.print

@@ -0,0 +1,6 @@
+package foo:bar;
+
+interface i1 {
+  nest foo:other/i;
+}
+

crates/wit-component/tests/interfaces/nested.wat

@@ -41,7 +41,7 @@
     )
   )
   (export (;1;) "something" (type 0))
-  (@custom "package-docs" "\01{\22interfaces\22:{\22something\22:{\22types\22:{\22my-record\22:{\22stability\22:{\22stable\22:{\22since\22:\221.0.0\22}}}},\22nested\22:{\22foo:nestee/[email protected]\22:{\22docs\22:{\22contents\22:\22nesting can be documented\22},\22stability\22:\22unknown\22},\22foo:nestee/[email protected]\22:{\22docs\22:{\22contents\22:null},\22stability\22:{\22stable\22:{\22since\22:\221.0.0\22}}}}}}}")
+  (@custom "package-docs" "\01{\22interfaces\22:{\22something\22:{\22types\22:{\22my-record\22:{\22stability\22:{\22stable\22:{\22since\22:\221.0.0\22}}}},\22nested\22:{\22things\22:{\22docs\22:{\22contents\22:\22nesting can be documented\22},\22stability\22:\22unknown\22},\22more\22:{\22docs\22:{\22contents\22:null},\22stability\22:{\22stable\22:{\22since\22:\221.0.0\22}}}}}}}")
   (@producers
     (processed-by "wit-component" "$CARGO_PKG_VERSION")
   )

crates/wit-parser/src/ast.rs

@@ -561,6 +561,23 @@ struct Nest<'a> {
     from: UsePath<'a>,
 }
 
+impl<'a> Nest<'a> {
+    fn parse(
+        tokens: &mut Tokenizer<'a>,
+        docs: Docs<'a>,
+        attributes: Vec<Attribute<'a>>,
+    ) -> Result<Self> {
+        tokens.eat(Token::Nest)?;
+        let path = UsePath::parse(tokens)?;
+        tokens.expect_semicolon()?;
+        Ok(Self {
+            docs,
+            attributes,
+            from: path,
+        })
+    }
+}
+
 struct Use<'a> {
     attributes: Vec<Attribute<'a>>,
     from: UsePath<'a>,
@@ -998,14 +1015,7 @@ impl<'a> InterfaceItem<'a> {
             }
             Some((_span, Token::Use)) => Use::parse(tokens, attributes).map(InterfaceItem::Use),
             Some((_span, Token::Nest)) => {
-                tokens.eat(Token::Nest)?;
-                let path = UsePath::parse(tokens)?;
-                tokens.expect_semicolon()?;
-                Ok(InterfaceItem::Nest(Nest {
-                    docs,
-                    attributes,
-                    from: path,
-                }))
+                Nest::parse(tokens, docs, attributes).map(InterfaceItem::Nest)
             }
             other => Err(err_expected(tokens, "`type`, `resource` or `func`", other).into()),
         }

crates/wit-parser/src/ast/resolve.rs

@@ -1,6 +1,5 @@
 use super::{ParamList, ResultList, WorldOrInterface};
 use crate::ast::toposort::toposort;
-use crate::ast::UsePath;
 use crate::*;
 use anyhow::bail;
 use std::collections::{HashMap, HashSet};
@@ -312,7 +311,7 @@ impl<'a> Resolver<'a> {
         });
         self.interfaces.alloc(Interface {
             name: None,
-            nested: IndexMap::new(),
+            nested: Vec::new(),
             types: IndexMap::new(),
             docs: Docs::default(),
             stability: Default::default(),
@@ -842,54 +841,16 @@ impl<'a> Resolver<'a> {
                 }
                 ast::InterfaceItem::TypeDef(_) => {}
                 ast::InterfaceItem::Nest(n) => {
-                    if let ast::Nest {
-                        from:
-                            UsePath::Package {
-                                id: package_id,
-                                name,
-                            },
-                        attributes,
-                        docs,
-                    } = n
-                    {
-                        let nest = self
-                            .foreign_deps
-                            .get(&PackageName {
-                                namespace: package_id.namespace.name.to_string(),
-                                name: package_id.name.name.to_string(),
-                                version: package_id.clone().version.map(|v| v.1),
-                            })
-                            .unwrap()
-                            .get(&name.name)
-                            .unwrap();
-                        let nested_id = if let AstItem::Interface(id) = nest {
-                            id
-                        } else {
-                            bail!("Expected interface item")
-                        };
-                        let stability = self.stability(attributes)?;
-                        let docs = self.docs(&docs);
-                        let full_name = if let Some(v) = &package_id.version {
-                            format!(
-                                "{}:{}/{}@{}",
-                                package_id.namespace.name,
-                                package_id.name.name,
-                                name.name,
-                                v.1.to_string()
-                            )
-                        } else {
-                            format!("{}/{}", package_id.package_name(), name.name)
-                        };
+                    let (item, name, span) = self.resolve_ast_item_path(&n.from)?;
+                    let nested_id = self.extract_iface_from_item(&item, &name, span)?;
 
-                        self.interfaces[interface_id].nested.insert(
-                            full_name.clone(),
-                            crate::Nest {
-                                id: *nested_id,
-                                docs,
-                                stability,
-                            },
-                        );
-                    }
+                    let stability = self.stability(&n.attributes)?;
+                    let docs = self.docs(&n.docs);
+                    self.interfaces[interface_id].nested.push(crate::Nest {
+                        id: nested_id,
+                        docs,
+                        stability,
+                    });
                 }
             }
         }