Add importize method to Resolve

A new method `importize` is added to the Resolve. This is to allow to
mutate the Resolve to state where it would resemble what a consuming
component would expect to see during composition.

Signed-off-by: karthik2804 <[email protected]>

crates/wit-parser/src/resolve.rs

@@ -926,6 +926,56 @@ package {name} is defined in two different locations:\n\
         Some(self.id_of_name(interface.package.unwrap(), interface.name.as_ref()?))
     }
 
+    pub fn importize(&mut self, world_id: WorldId) {
+        let exports = &self.worlds[world_id].exports.clone();
+        // Make a copy of the imports as we will wholesale clear the imports in the world being importized
+        let ref_imports = mem::take(&mut self.worlds[world_id].imports);
+
+        let mut temp = Vec::new();
+
+        for (key, item) in exports.clone() {
+            match key {
+                WorldKey::Name(_) => {
+                    temp.push((key, item));
+                }
+                WorldKey::Interface(id) => self.resolve_interface_deps(id, world_id, &ref_imports),
+            }
+        }
+        let world = &mut self.worlds[world_id];
+        world.imports.append(&mut world.exports);
+
+        for (key, item) in ref_imports {
+            if let WorldItem::Type(_) = item {
+                world.imports.insert(key, item);
+            }
+        }
+
+        for (key, item) in temp {
+            world.imports.insert(key, item);
+        }
+
+        world.exports.clear();
+    }
+
+    fn resolve_interface_deps(
+        &mut self,
+        interface_id: InterfaceId,
+        world_id: WorldId,
+        ref_imports: &IndexMap<WorldKey, WorldItem>,
+    ) {
+        let direct_deps = self.interface_direct_deps(interface_id).collect::<Vec<_>>();
+        for dep_id in direct_deps {
+            let world_key = WorldKey::Interface(dep_id);
+            let world_item = ref_imports.get(&world_key).unwrap();
+
+            let world = &mut self.worlds[world_id];
+            if !world.imports.contains_key(&world_key) {
+                world.imports.insert(world_key, world_item.clone());
+                self.resolve_interface_deps(dep_id, world_id, ref_imports);
+            }
+        }
+    }
+
     /// Returns the ID of the specified `name` within the `pkg`.
     pub fn id_of_name(&self, pkg: PackageId, name: &str) -> String {
         let package = &self.packages[pkg];

src/bin/wasm-tools/component.rs

@@ -499,6 +499,16 @@ pub struct WitOpts {
     )]
     json: bool,
 
+    /// Importize the WIT document by removing the imports and
+    ///  moving the exports of a component to be its imports.
+    #[clap(
+        long,
+        conflicts_with = "wasm",
+        conflicts_with = "wat",
+        conflicts_with = "json"
+    )]
+    importize: bool,
+
     /// Features to enable when parsing the `wit` option.
     ///
     /// This flag enables the `@unstable` feature in WIT documents where the
@@ -621,7 +631,13 @@ impl WitOpts {
     fn emit_wit(&self, decoded: &DecodedWasm) -> Result<()> {
         assert!(!self.wasm && !self.wat);
 
-        let resolve = decoded.resolve();
+        let mut resolve = decoded.resolve().clone();
+
+        let main = decoded.package();
+        if self.importize {
+            let world_id = resolve.select_world(main, None)?;
+            resolve.importize(world_id)
+        }
 
         let mut printer = WitPrinter::default();
         printer.emit_docs(!self.no_docs);
@@ -647,7 +663,7 @@ impl WitOpts {
                 let main = decoded.package();
                 for (id, pkg) in resolve.packages.iter() {
                     let is_main = id == main;
-                    let output = printer.print(resolve, id, &[])?;
+                    let output = printer.print(&resolve, id, &[])?;
                     let out_dir = if is_main {
                         dir.clone()
                     } else {
@@ -685,8 +701,9 @@ impl WitOpts {
                 self.output.output(
                     &self.general,
                     Output::Wit {
-                        wit: &decoded,
                         printer,
+                        resolve: &resolve,
+                        package: main,
                     },
                 )?;
             }

src/lib.rs

@@ -147,7 +147,8 @@ pub struct OutputArg {
 pub enum Output<'a> {
     #[cfg(feature = "component")]
     Wit {
-        wit: &'a wit_component::DecodedWasm,
+        resolve: &'a wit_parser::Resolve,
+        package: wit_parser::PackageId,
         printer: wit_component::WitPrinter,
     },
     Wasm(&'a [u8]),
@@ -236,15 +237,18 @@ impl OutputArg {
             }
             Output::Json(s) => self.output_str(s),
             #[cfg(feature = "component")]
-            Output::Wit { wit, mut printer } => {
-                let resolve = wit.resolve();
+            Output::Wit {
+                mut printer,
+                resolve,
+                package,
+            } => {
                 let ids = resolve
                     .packages
                     .iter()
                     .map(|(id, _)| id)
-                    .filter(|id| *id != wit.package())
+                    .filter(|id| *id != package)
                     .collect::<Vec<_>>();
-                let output = printer.print(resolve, wit.package(), &ids)?;
+                let output = printer.print(resolve, package, &ids)?;
                 self.output_str(&output)
             }
         }

tests/cli/importize-component.wit

@@ -0,0 +1,37 @@
+// RUN: component embed --world foo --dummy % | component wit --importize
+
+package importize:importize;
+
+interface t {
+    resource r;
+}
+interface bar {
+    use t.{r};
+    record foo {
+      x: string
+    }
+    importize: func(name: r);
+}
+
+interface qux {
+   use bar.{foo};
+   blah: func(boo: foo);
+}
+
+interface something-else-dep {
+    type t = u32;
+} 
+
+world foo {
+    export qux;
+    export foo: func();
+    type s = u32;
+    export bar: func() -> s;
+    export something: interface {
+        foo: func();
+    }
+    export something-else: interface {
+        use something-else-dep.{t};
+        bar: func() -> t;
+    }
+}

tests/cli/importize-component.wit.stdout

@@ -0,0 +1,60 @@
+package root:root;
+
+world root {
+  import importize:importize/bar;
+  import importize:importize/t;
+  import foo: func();
+  import bar: func() -> s;
+  import importize:importize/qux;
+  import something: interface {
+    foo: func();
+  }
+  import something-else: interface {
+    use something-else-dep.{t};
+
+    bar: func() -> t;
+  }
+
+  type s = u32;
+}
+package importize:importize {
+  interface t {
+    resource r;
+  }
+  interface bar {
+    use t.{r};
+
+    record foo {
+      x: string,
+    }
+
+    importize: func(name: r);
+  }
+  interface something-else-dep {
+    type t = u32;
+  }
+  interface qux {
+    use bar.{foo};
+
+    blah: func(boo: foo);
+  }
+  world foo {
+    import t;
+    import bar;
+    import something-else-dep;
+
+    type s = u32;
+
+    export foo: func();
+    export bar: func() -> s;
+    export qux;
+    export something: interface {
+      foo: func();
+    }
+    export something-else: interface {
+      use something-else-dep.{t};
+
+      bar: func() -> t;
+    }
+  }
+}