Add support for include to wit-smith (#2161)

* Test fuzzers with `cargo test --workspace`

* Add `include` to `wit-smith` generation

Updates the generator to generate `include` statements in worlds to help
fuzz the `include` directive.

* Pre-sort WIT worlds at rest, update printing

This commit moves a sort that previously happened during translation to
wasm to happening during general elaboration instead, meaning that
at-rest worlds are now pre-sorted in this order. Additionally printing
of WIT worlds was updated to manually respect this order where
interfaces are printed first, then types, then functions. As a result of
this change many test expectations have been updated to shuffle items
around.

The motivation for this commit is to fix fuzz failures about
round-tripping WIT documents through wasm. With `include` now supported
more test cases are showing up which stress new paths of when items are
added as they weren't tested before. This ensures that when throwing
`include` into the mix documents are still round-trip-able.

* Re-bless some tests

* Fix test build on Windows

Author: alexcrichton

Cargo.lock

@@ -65,6 +65,8 @@ rust-2024-incompatible-pat = 'warn'
 missing-unsafe-on-extern = 'warn'
 unsafe-op-in-unsafe-fn = 'warn'
 
+unexpected_cfgs = { level = 'warn', check-cfg = ['cfg(fuzzing)'] }
+
 [workspace.lints.clippy]
 # The default set of lints in Clippy is viewed as "too noisy" right now so
 # they're all turned off by default. Selective lints are then enabled below as

Cargo.toml

@@ -71,30 +71,8 @@ pub fn encode_world(resolve: &Resolve, world_id: WorldId) -> Result<ComponentTyp
     let world = &resolve.worlds[world_id];
     log::trace!("encoding world {}", world.name);
 
-    // This sort is similar in purpose to the sort below in
-    // `encode_instance`, but different in its sort. The purpose here is
-    // to ensure that when a document is either printed as WIT or
-    // encoded as wasm that decoding from those artifacts produces the
-    // same WIT package. Namely both encoding processes should encode
-    // things in the same order.
-    //
-    // When printing worlds in WIT freestanding function imports are
-    // printed first, then types. Resource functions are attached to
-    // types which means that they all come last. Sort all
-    // resource-related functions here to the back of the `imports` list
-    // while keeping everything else in front, using a stable sort to
-    // preserve preexisting ordering.
-    let mut imports = world.imports.iter().collect::<Vec<_>>();
-    imports.sort_by_key(|(_name, import)| match import {
-        WorldItem::Function(f) => match f.kind {
-            FunctionKind::Freestanding | FunctionKind::AsyncFreestanding => 0,
-            _ => 1,
-        },
-        _ => 0,
-    });
-
     // Encode the imports
-    for (name, import) in imports {
+    for (name, import) in world.imports.iter() {
         let name = resolve.name_world_key(name);
         log::trace!("encoding import {name}");
         let ty = match import {

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

@@ -383,12 +383,32 @@ impl<O: Output> WitPrinter<O> {
         Ok(())
     }
 
+    /// Prints the world `id` within `resolve`.
+    ///
+    /// This is a little tricky to preserve round-tripping that WIT wants. This
+    /// function inherently can't preserve ordering of imports because resource
+    /// functions aren't guaranteed to be all adjacent to the resource itself
+    /// they're attached to. That means that at the very least, when printing
+    /// resource functions, items may be printed out-of-order.
+    ///
+    /// To help solve this the printing here is kept in sync with WIT encoding
+    /// of worlds which is to print items in the order of:
+    ///
+    /// * Any imported interface. Ordering between interfaces is preserved.
+    /// * Any types, including resource functions on those types. Ordering
+    ///   between types is preserved.
+    /// * Any functions, which may refer to those types. Ordering between
+    ///   functions is preserved.
+    ///
+    /// This keeps things printed in a roughly topological fashion and makes
+    /// round-tripping a bit more reliable.
     fn print_world(&mut self, resolve: &Resolve, id: WorldId) -> Result<()> {
         let prev_items = mem::replace(&mut self.any_items, false);
         let world = &resolve.worlds[id];
         let pkgid = world.package.unwrap();
         let mut types = Vec::new();
         let mut resource_funcs = HashMap::new();
+        let mut function_imports_to_print = Vec::new();
         for (name, import) in world.imports.iter() {
             match import {
                 WorldItem::Type(t) => match name {
@@ -401,6 +421,8 @@ impl<O: Output> WitPrinter<O> {
                             resource_funcs.entry(id).or_insert(Vec::new()).push(f);
                             continue;
                         }
+                        function_imports_to_print.push((name, import));
+                        continue;
                     }
                     self.print_world_item(resolve, name, import, pkgid, "import")?;
                     // Don't put a blank line between imports, but count
@@ -416,6 +438,11 @@ impl<O: Output> WitPrinter<O> {
             types.into_iter(),
             &resource_funcs,
         )?;
+
+        for (name, import) in function_imports_to_print {
+            self.print_world_item(resolve, name, import, pkgid, "import")?;
+            self.any_items = true;
+        }
         if !world.exports.is_empty() {
             self.new_item();
         }

crates/wit-component/src/printing.rs

@@ -60,11 +60,10 @@ interface other-comment-forms {
 
 /// world docs
 world coverage-world {
-  /// world func import docs
-  import imp: func();
-
   /// world typedef docs
   type t = u32;
+  /// world func import docs
+  import imp: func();
 
   /// world func export docs
   export exp: func();

crates/wit-component/tests/interfaces/doc-comments/foo.wit.print

@@ -100,6 +100,20 @@
       (type (;0;)
         (component
           (type (;0;)
+            (instance
+              (export (;0;) "a" (type (sub resource)))
+              (type (;1;) (own 0))
+              (type (;2;) (func (result 1)))
+              (export (;0;) "[constructor]a" (func (type 2)))
+              (type (;3;) (func))
+              (export (;1;) "[static]a.b" (func (type 3)))
+              (type (;4;) (borrow 0))
+              (type (;5;) (func (param "self" 4)))
+              (export (;2;) "[method]a.c" (func (type 5)))
+            )
+          )
+          (import "anon" (instance (;0;) (type 0)))
+          (type (;1;)
             (instance
               (export (;0;) "bar" (type (sub resource)))
               (export (;1;) "t" (type (eq 0)))
@@ -117,14 +131,14 @@
               (export (;3;) "a" (func (type 9)))
             )
           )
-          (import "foo:bar/foo" (instance (;0;) (type 0)))
-          (alias export 0 "bar" (type (;1;)))
-          (alias export 0 "t" (type (;2;)))
-          (type (;3;)
+          (import "foo:bar/foo" (instance (;1;) (type 1)))
+          (alias export 1 "bar" (type (;2;)))
+          (alias export 1 "t" (type (;3;)))
+          (type (;4;)
             (instance
-              (alias outer 1 1 (type (;0;)))
+              (alias outer 1 2 (type (;0;)))
               (export (;1;) "bar" (type (eq 0)))
-              (alias outer 1 2 (type (;2;)))
+              (alias outer 1 3 (type (;2;)))
               (export (;3;) "t" (type (eq 2)))
               (type (;4;) (own 1))
               (type (;5;) (func (param "x" 4) (result 4)))
@@ -134,29 +148,15 @@
               (export (;1;) "b" (func (type 7)))
             )
           )
-          (import "foo:bar/baz" (instance (;1;) (type 3)))
-          (alias export 1 "bar" (type (;4;)))
-          (import "bar" (type (;5;) (eq 4)))
-          (import "a" (type (;6;) (sub resource)))
-          (type (;7;)
-            (instance
-              (export (;0;) "a" (type (sub resource)))
-              (type (;1;) (own 0))
-              (type (;2;) (func (result 1)))
-              (export (;0;) "[constructor]a" (func (type 2)))
-              (type (;3;) (func))
-              (export (;1;) "[static]a.b" (func (type 3)))
-              (type (;4;) (borrow 0))
-              (type (;5;) (func (param "self" 4)))
-              (export (;2;) "[method]a.c" (func (type 5)))
-            )
-          )
-          (import "anon" (instance (;2;) (type 7)))
-          (type (;8;) (own 6))
+          (import "foo:bar/baz" (instance (;2;) (type 4)))
+          (alias export 2 "bar" (type (;5;)))
+          (import "bar" (type (;6;) (eq 5)))
+          (import "a" (type (;7;) (sub resource)))
+          (type (;8;) (own 7))
           (type (;9;) (func (result 8)))
           (import "[constructor]a" (func (;0;) (type 9)))
           (export (;1;) "x" (func (type 9)))
-          (type (;10;) (own 5))
+          (type (;10;) (own 6))
           (type (;11;) (func (result 10)))
           (export (;2;) "y" (func (type 11)))
         )

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

@@ -50,15 +50,15 @@ interface implicit-own-handles2 {
 }
 
 world some-world {
-  import foo;
-  import baz;
   import anon: interface {
     resource a {
       constructor();
       b: static func();
       c: func();
     }
   }
+  import foo;
+  import baz;
   use baz.{bar};
 
   resource a {

crates/wit-component/tests/interfaces/resources.wit.print

@@ -3,15 +3,15 @@
     (component
       (type (;0;)
         (component
-          (type (;0;) (func))
-          (import "foo" (func (;0;) (type 0)))
-          (type (;1;) (func (param "arg" u32)))
-          (import "bar" (func (;1;) (type 1)))
-          (type (;2;)
+          (type (;0;)
             (instance)
           )
-          (import "some-interface" (instance (;0;) (type 2)))
-          (export (;2;) "foo2" (func (type 0)))
+          (import "some-interface" (instance (;0;) (type 0)))
+          (type (;1;) (func))
+          (import "foo" (func (;0;) (type 1)))
+          (type (;2;) (func (param "arg" u32)))
+          (import "bar" (func (;1;) (type 2)))
+          (export (;2;) "foo2" (func (type 1)))
           (type (;3;) (func (result u32)))
           (export (;3;) "bar2" (func (type 3)))
           (type (;4;)

crates/wit-component/tests/interfaces/world-top-level.wat

@@ -1,10 +1,10 @@
 package foo:foo;
 
 world foo {
-  import foo: func();
-  import bar: func(arg: u32);
   import some-interface: interface {
   }
+  import foo: func();
+  import bar: func(arg: u32);
 
   export foo2: func();
   export bar2: func() -> u32;

crates/wit-component/tests/interfaces/world-top-level.wit.print

@@ -5,20 +5,19 @@ interface import-me {
 }
 
 world simple {
-  import a: func(a: foo) -> bar;
-
   record foo {
     f: u8,
   }
 
   type bar = foo;
+  import a: func(a: foo) -> bar;
 
   export b: func(a: foo) -> bar;
 }
 world with-imports {
   import import-me;
-  import a: func(a: foo);
   use import-me.{foo};
+  import a: func(a: foo);
 
   export b: func(a: foo);
 }