Initialize a test suite for wit-encoder (bytecodealliance#1626)

* change `wit-encoder` indent to 2

* test empty `Result`s in `wit-encoder`

* import wit test files for `wit-encoder`

* use external wit test file for `functions.rs` test

* add `empty` test

* add `wit-encoder` overlap tests

* fix more existing tests

* Add `include` capabilities to `wit-encoder`

* tidy up

* rebase on main

* check in `.gitattributes` to normalize line endings

Rebasing brok

* remove additional wit files

* inline tests

Author: yoshuawuyts

.gitattributes

@@ -1,2 +1,3 @@
+* text=auto
 *.waves text eol=lf
 *.out text eol=lf

Cargo.lock

@@ -84,6 +84,7 @@ bitflags = "2.5.0"
 hashbrown = { version = "0.14.3", default-features = false, features = ['ahash'] }
 ahash = { version = "0.8.11", default-features = false }
 termcolor = "1.2.0"
+indoc = "2.0.5"
 
 wasm-compose = { version = "0.211.1", path = "crates/wasm-compose" }
 wasm-encoder = { version = "0.211.1", path = "crates/wasm-encoder" }

Cargo.toml

@@ -13,3 +13,6 @@ workspace = true
 [dependencies]
 semver = { workspace = true }
 pretty_assertions = { workspace = true }
+
+[dev-dependencies]
+indoc = { workspace = true }

crates/wit-encoder/Cargo.toml

@@ -108,7 +108,7 @@ where
 impl Results {
     // For the common case of an empty results list.
     pub fn empty() -> Results {
-        Results::Named(Default::default())
+        Results::Named(Params::empty())
     }
 
     pub fn anon(type_: Type) -> Results {
@@ -166,3 +166,14 @@ impl StandaloneFunc {
         self.docs = docs.map(|d| d.into());
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::Results;
+
+    #[test]
+    fn is_empty() {
+        let res = Results::empty();
+        assert!(res.is_empty());
+    }
+}

crates/wit-encoder/src/function.rs

@@ -0,0 +1,26 @@
+use std::fmt;
+
+use crate::{Ident, Render};
+
+/// Enable the union of a world with another world
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Include {
+    use_path: Ident,
+    include_names_list: Vec<String>,
+}
+
+impl Include {
+    pub fn new(use_path: impl Into<Ident>) -> Self {
+        Self {
+            use_path: use_path.into(),
+            include_names_list: vec![],
+        }
+    }
+}
+
+impl Render for Include {
+    fn render(&self, f: &mut fmt::Formatter<'_>, opts: &crate::RenderOpts) -> fmt::Result {
+        write!(f, "{}include {};\n", opts.spaces(), self.use_path)?;
+        Ok(())
+    }
+}

crates/wit-encoder/src/include.rs

@@ -8,6 +8,7 @@ mod enum_;
 mod flags;
 mod function;
 mod ident;
+mod include;
 mod interface;
 mod package;
 mod record;
@@ -24,6 +25,7 @@ pub use enum_::*;
 pub use flags::*;
 pub use function::*;
 pub use ident::*;
+pub use include::*;
 pub use interface::*;
 pub use package::*;
 pub use record::*;

crates/wit-encoder/src/lib.rs

@@ -41,16 +41,21 @@ impl Package {
 impl Render for Package {
     fn render(&self, f: &mut fmt::Formatter<'_>, opts: &RenderOpts) -> fmt::Result {
         write!(f, "{}package {};\n", opts.spaces(), self.name)?;
-        write!(f, "\n")?;
         for item in &self.items {
+            write!(f, "\n")?;
             match item {
                 PackageItem::Interface(interface) => {
                     if let Some(docs) = &interface.docs {
                         docs.render(f, opts)?;
                     }
-                    write!(f, "{}interface {} {{\n", opts.spaces(), interface.name)?;
-                    interface.items.render(f, &opts.indent())?;
-                    write!(f, "{}}}\n", opts.spaces())?;
+                    write!(f, "{}interface {} {{", opts.spaces(), interface.name)?;
+                    if !interface.items.is_empty() {
+                        write!(f, "\n")?;
+                        interface.items.render(f, &opts.indent())?;
+                        write!(f, "{}}}\n", opts.spaces())?;
+                    } else {
+                        write!(f, "}}\n")?;
+                    }
                 }
                 PackageItem::World(world) => {
                     world.render(f, opts)?;

crates/wit-encoder/src/package.rs

@@ -11,7 +11,7 @@ pub struct RenderOpts {
 impl Default for RenderOpts {
     fn default() -> Self {
         Self {
-            indent_width: 4,
+            indent_width: 2,
             ident_count: 0,
         }
     }

crates/wit-encoder/src/render.rs

@@ -317,8 +317,11 @@ impl Render for TypeDef {
                 if let Some(docs) = &self.docs {
                     docs.render(f, opts)?;
                 }
-                write!(f, "{}record {} {{\n", opts.spaces(), self.name)?;
-                for field in &record.fields {
+                write!(f, "{}record {} {{", opts.spaces(), self.name)?;
+                for (index, field) in record.fields.iter().enumerate() {
+                    if index == 0 {
+                        write!(f, "\n")?;
+                    }
                     let opts = opts.indent();
                     if let Some(docs) = &field.docs {
                         docs.render(f, &opts)?;

crates/wit-encoder/src/ty.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use crate::{ident::Ident, Docs, Interface, Render, RenderOpts, StandaloneFunc};
+use crate::{ident::Ident, Docs, Include, Interface, Render, RenderOpts, StandaloneFunc};
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct World {
@@ -52,6 +52,9 @@ impl World {
     pub fn function_export(&mut self, value: StandaloneFunc) {
         self.item(WorldItem::function_export(value));
     }
+    pub fn include(&mut self, value: impl Into<Ident>) {
+        self.item(WorldItem::include(value));
+    }
 
     /// Set the documentation
     pub fn docs(&mut self, docs: Option<impl Into<Docs>>) {
@@ -88,18 +91,28 @@ impl Render for World {
                         docs.render(f, opts)?;
                     }
                     import(f, opts)?;
-                    write!(f, "{}: interface {{\n", interface.name)?;
-                    interface.items.render(f, &opts.indent())?;
-                    write!(f, "{}}}\n", opts.spaces())?;
+                    write!(f, "{}: interface {{", interface.name)?;
+                    if !interface.items.is_empty() {
+                        write!(f, "\n")?;
+                        interface.items.render(f, &opts.indent())?;
+                        write!(f, "{}}}\n", opts.spaces())?;
+                    } else {
+                        write!(f, "}}\n")?;
+                    }
                 }
                 WorldItem::InlineInterfaceExport(interface) => {
                     if let Some(docs) = &interface.docs {
                         docs.render(f, opts)?;
                     }
                     export(f, opts)?;
-                    write!(f, "{}: interface {{\n", interface.name)?;
-                    interface.items.render(f, &opts.indent())?;
-                    write!(f, "{}}}\n", opts.spaces())?;
+                    write!(f, "{}: interface {{", interface.name)?;
+                    if !interface.items.is_empty() {
+                        write!(f, "\n")?;
+                        interface.items.render(f, &opts.indent())?;
+                        write!(f, "{}}}\n", opts.spaces())?;
+                    } else {
+                        write!(f, "}}\n")?;
+                    }
                 }
                 WorldItem::NamedInterfaceImport(interface) => {
                     if let Some(docs) = &interface.docs {
@@ -129,6 +142,7 @@ impl Render for World {
                     export(f, opts)?;
                     render_function(f, opts, function)?;
                 }
+                WorldItem::Include(include) => include.render(f, opts)?,
             }
         }
         let opts = &opts.outdent();
@@ -156,6 +170,9 @@ pub enum WorldItem {
 
     /// A function is being directly exported from this world.
     FunctionExport(StandaloneFunc),
+
+    /// Include type
+    Include(Include),
 }
 
 impl WorldItem {
@@ -177,6 +194,9 @@ impl WorldItem {
     pub fn function_export(value: StandaloneFunc) -> Self {
         Self::FunctionExport(value)
     }
+    pub fn include(value: impl Into<Ident>) -> Self {
+        Self::Include(Include::new(value))
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]

crates/wit-encoder/src/world.rs

@@ -0,0 +1,12 @@
+use pretty_assertions::assert_eq;
+use wit_encoder::{Package, PackageName};
+
+const PACKAGE: &str = indoc::indoc! {"
+    package foo:empty;
+"};
+
+#[test]
+fn concrete_types() {
+    let package = Package::new(PackageName::new("foo", "empty", None));
+    assert_eq!(package.to_string(), PACKAGE);
+}

crates/wit-encoder/tests/empty.rs

@@ -1,88 +1,88 @@
 use pretty_assertions::assert_eq;
-use wit_encoder::{Params, Result_, Results, StandaloneFunc, Type};
+use wit_encoder::{
+    Interface, Package, PackageName, Params, Result_, Results, StandaloneFunc, Type,
+};
 
-const PACKAGE: &str = "package foo:functions;
+const PACKAGE: &str = indoc::indoc! {"
+    package foo:functions;
 
-interface functions {
-    f1: func();
-    f2: func(a: u32);
-    f3: func() -> u32;
-    /// this is a documentation comment
-    /// for the f4 function
-    f4: func() -> tuple<u32, u32>;
-    f5: func(a: f32, b: f32) -> tuple<u32, u32>;
-    f6: func(a: option<u32>) -> result<u32, f32>;
-    f7: func() -> (u: u32, f: f32);
-    f8: func() -> (u: u32);
-    f9: func() -> result<f32>;
-    f10: func() -> result<_, f32>;
-    f11: func() -> result;
-}
-";
+    interface functions {
+      f1: func();
+      f2: func(a: u32);
+      f4: func() -> u32;
+      f6: func() -> tuple<u32, u32>;
+      f7: func(a: f32, b: f32) -> tuple<u32, u32>;
+      f8: func(a: option<u32>) -> result<u32, f32>;
+      f9: func() -> (u: u32, f: f32);
+      f10: func() -> (u: u32);
+      f11: func() -> result<f32>;
+      f12: func() -> result<_, f32>;
+      f13: func() -> result;
+    }
+"};
 
 #[test]
-fn smoke() {
-    let name = wit_encoder::PackageName::new("foo", "functions", None);
-    let mut package = wit_encoder::Package::new(name);
+fn concrete_types() {
+    let name = PackageName::new("foo", "functions", None);
+    let mut package = Package::new(name);
 
     package.interface({
-        let mut interface = wit_encoder::Interface::new("functions");
+        let mut interface = Interface::new("functions");
         interface.function(StandaloneFunc::new("f1"));
         interface.function({
             let mut func = StandaloneFunc::new("f2");
             func.params(Params::from_iter([("a", Type::U32)]));
             func
         });
         interface.function({
-            let mut func = StandaloneFunc::new("f3");
-            func.results(Type::U32);
+            let mut func = StandaloneFunc::new("f4");
+            func.results(Results::anon(Type::U32));
             func
         });
         interface.function({
-            let mut func = StandaloneFunc::new("f4");
-            func.results(Type::tuple(vec![Type::U32, Type::U32]));
-            func.docs(Some("this is a documentation comment\nfor the f4 function"));
+            let mut func = StandaloneFunc::new("f6");
+            func.results(Results::anon(Type::tuple(vec![Type::U32, Type::U32])));
             func
         });
         interface.function({
-            let mut func = StandaloneFunc::new("f5");
+            let mut func = StandaloneFunc::new("f7");
             func.params(Params::from_iter([("a", Type::F32), ("b", Type::F32)]));
             func.results(Type::tuple(vec![Type::U32, Type::U32]));
             func
         });
         interface.function({
-            let mut func = StandaloneFunc::new("f6");
+            let mut func = StandaloneFunc::new("f8");
             func.params(Params::from_iter([("a", Type::option(Type::U32))]));
             func.results(Type::result(Result_::both(Type::U32, Type::F32)));
             func
         });
         interface.function({
-            let mut func = StandaloneFunc::new("f7");
+            let mut func = StandaloneFunc::new("f9");
             func.results(Results::named(vec![("u", Type::U32), ("f", Type::F32)]));
             func
         });
         interface.function({
-            let mut func = StandaloneFunc::new("f8");
+            let mut func = StandaloneFunc::new("f10");
             func.results(Results::named(vec![("u", Type::U32)]));
             func
         });
         interface.function({
-            let mut func = StandaloneFunc::new("f9");
+            let mut func = StandaloneFunc::new("f11");
             func.results(Type::result(Result_::ok(Type::F32)));
             func
         });
         interface.function({
-            let mut func = StandaloneFunc::new("f10");
+            let mut func = StandaloneFunc::new("f12");
             func.results(Type::result(Result_::err(Type::F32)));
             func
         });
         interface.function({
-            let mut func = StandaloneFunc::new("f11");
+            let mut func = StandaloneFunc::new("f13");
             func.results(Type::result(Result_::empty()));
             func
         });
         interface
     });
 
-    assert_eq!(PACKAGE, package.to_string());
+    assert_eq!(package.to_string(), PACKAGE);
 }

crates/wit-encoder/tests/functions.rs

@@ -0,0 +1,23 @@
+use pretty_assertions::assert_eq;
+use wit_encoder::{Package, PackageName, StandaloneFunc, World};
+
+const PACKAGE: &str = indoc::indoc! {"
+    package foo:foo;
+    
+    world foo {
+      import a: func();
+      export a: func();
+    }
+"};
+
+#[test]
+fn concrete_types() {
+    let mut package = Package::new(PackageName::new("foo", "foo", None));
+
+    let mut world = World::new("foo");
+    world.function_import(StandaloneFunc::new("a"));
+    world.function_export(StandaloneFunc::new("a"));
+    package.world(world);
+
+    assert_eq!(package.to_string(), PACKAGE);
+}

crates/wit-encoder/tests/import-export-overlap1.rs

@@ -0,0 +1,23 @@
+use pretty_assertions::assert_eq;
+use wit_encoder::{Interface, Package, PackageName, StandaloneFunc, World};
+
+const PACKAGE: &str = indoc::indoc! {"
+    package foo:foo;
+
+    world foo {
+      import a: func();
+      export a: interface {}
+    }
+"};
+
+#[test]
+fn concrete_types() {
+    let mut package = Package::new(PackageName::new("foo", "foo", None));
+
+    let mut world = World::new("foo");
+    world.function_import(StandaloneFunc::new("a"));
+    world.inline_interface_export(Interface::new("a"));
+    package.world(world);
+
+    assert_eq!(package.to_string(), PACKAGE);
+}

crates/wit-encoder/tests/import-export-overlap2.rs

@@ -0,0 +1,42 @@
+use pretty_assertions::assert_eq;
+use wit_encoder::{Interface, Package, PackageName, World};
+
+const PACKAGE: &str = indoc::indoc! {"
+    package foo:foo;
+
+    interface a {}
+
+    interface b {}
+
+    world bar {
+      import a;
+      export b;
+    }
+
+    world foo {
+      include bar;
+      include bar;
+      include bar;
+    }
+"};
+
+#[test]
+fn concrete_types() {
+    let mut package = Package::new(PackageName::new("foo", "foo", None));
+
+    package.interface(Interface::new("a"));
+    package.interface(Interface::new("b"));
+
+    let mut world = World::new("bar");
+    world.named_interface_import("a");
+    world.named_interface_export("b");
+    package.world(world);
+
+    let mut world = World::new("foo");
+    world.include("bar");
+    world.include("bar");
+    world.include("bar");
+    package.world(world);
+
+    assert_eq!(package.to_string(), PACKAGE);
+}

crates/wit-encoder/tests/include-reps.rs

@@ -3,109 +3,109 @@ use wit_encoder::{
     Field, Flag, Params, ResourceFunc, Result_, Results, Type, TypeDef, TypeDefKind, VariantCase,
 };
 
-const PACKAGE: &str = "package wit-encoder:tests;
+const PACKAGE: &str = indoc::indoc! {"
+    package wit-encoder:tests;
 
-/// interface documentation
-interface type-defs {
-    type t1 = u8;
-    type t2 = u16;
-    type t3 = u32;
-    type t4 = u64;
-    type t5 = s8;
-    type t6 = s16;
-    type t7 = s32;
-    type t8 = s64;
-    type t9a = f32;
-    type t9b = f32;
-    type t10a = f64;
-    type t10b = f64;
-    type t11 = char;
-    type t12 = list<char>;
-    type t13 = string;
-    type t14 = option<u32>;
-    type t15 = result<u32, u32>;
-    type t16 = result<_, u32>;
-    type t17 = result<u32>;
-    /// this is a documentation comment
-    type t18 = result;
-    record t20 {
-    }
-    record t21 {
+    /// interface documentation
+    interface type-defs {
+      type t1 = u8;
+      type t2 = u16;
+      type t3 = u32;
+      type t4 = u64;
+      type t5 = s8;
+      type t6 = s16;
+      type t7 = s32;
+      type t8 = s64;
+      type t9a = f32;
+      type t9b = f32;
+      type t10a = f64;
+      type t10b = f64;
+      type t11 = char;
+      type t12 = list<char>;
+      type t13 = string;
+      type t14 = option<u32>;
+      type t15 = result<u32, u32>;
+      type t16 = result<_, u32>;
+      type t17 = result<u32>;
+      /// this is a documentation comment
+      type t18 = result;
+      record t20 {  }
+      record t21 {
         a: u32,
-    }
-    record t22 {
+      }
+      record t22 {
         a: u32,
-    }
-    record t23 {
+      }
+      record t23 {
         a: u32,
         b: u64,
-    }
-    record t24 {
+      }
+      record t24 {
         a: u32,
         b: u64,
-    }
-    record t25 {
+      }
+      record t25 {
         x: u32,
-    }
-    record %record {
+      }
+      record %record {
         a: u32,
-    }
-    type t26 = tuple<>;
-    type t27 = tuple<u32>;
-    type t29 = tuple<u32, u64>;
-    flags t30 {
-    }
-    flags t31 {
+      }
+      type t26 = tuple<>;
+      type t27 = tuple<u32>;
+      type t29 = tuple<u32, u64>;
+      flags t30 {
+      }
+      flags t31 {
         /// option a
         a,
         /// option b
         b,
         /// option c
         c,
-    }
-    flags t32 {
+      }
+      flags t32 {
         a,
         b,
         c,
-    }
-    variant t33 {
+      }
+      variant t33 {
         a,
-    }
-    variant t34 {
+      }
+      variant t34 {
         a,
         b,
-    }
-    variant t35 {
+      }
+      variant t35 {
         a,
         b,
-    }
-    variant t36 {
+      }
+      variant t36 {
         a,
         b(u32),
-    }
-    variant t37 {
+      }
+      variant t37 {
         a,
         b(option<u32>),
-    }
-    enum t41 {
+      }
+      enum t41 {
         a,
         b,
         c,
-    }
-    enum t42 {
+      }
+      enum t42 {
         a,
         b,
         c,
-    }
-    type t43 = bool;
-    type t44 = string;
-    type t45 = list<list<list<t32>>>;
-    type t46 = t44;
-    type foo = bar;
-    type bar = u32;
-    resource t50 {
-    }
-    resource t51 {
+      }
+      type t43 = bool;
+      type t44 = string;
+      type t45 = list<list<list<t32>>>;
+      type t46 = t44;
+      type foo = bar;
+      type bar = u32;
+      resource t50 {
+      }
+      resource t51 {
         /// create a new t51
         constructor(a: u32);
         /// set a
@@ -114,9 +114,9 @@ interface type-defs {
         get-a: func() -> u32;
         /// do b
         b: static func();
+      }
     }
-}
-";
+"};
 
 #[test]
 fn types() {

crates/wit-encoder/tests/type_defs.rs

@@ -1,22 +1,23 @@
 use pretty_assertions::assert_eq;
 use wit_encoder::{Interface, StandaloneFunc, Type};
 
-const PACKAGE: &str = "package foo:functions;
+const PACKAGE: &str = indoc::indoc! {"
+    package foo:functions;
 
-interface error-reporter {
-}
-world %world {
-    /// inline interface
-    export example: interface {
+    interface error-reporter {}
+
+    world %world {
+      /// inline interface
+      export example: interface {
         /// func docs
         do-nothing: func();
+      }
+      /// scan stuff
+      export scan: func() -> list<u8>;
+      import error-reporter;
+      import print: func(s: string);
     }
-    /// scan stuff
-    export scan: func() -> list<u8>;
-    import error-reporter;
-    import print: func(s: string);
-}
-";
+"};
 
 #[test]
 fn worlds() {