Implement component encoding.

This giant commit implements encoding of resolved WAC documents, effectively
enabling component composition.

Changes to the grammar:

* resource methods no longer accept references to function types (WIT compat).

Changes to the AST:

* The AST printer moved into the `ast` module.
* Fixed `or` not printing correctly for printing lookahead failures.
* Fixed segment spans in a package path not being calculated correctly.
* Types now store their span; used in new resolution diagnostics.

Changes to resolution:

* The majority of the resolution logic has been refactored out into an `ast`
  submodule.
* A check was added to ensure function result types do not contain a borrow.
* There is now a package arena so that instantiations (and implicit imports)
  can keep track of the originating package for better diagnostic messages.
* The value type enum was refactored such that borrows and owns of resources
  don't need allocations in the types arena (unless aliased with `type foo =
  borrow<x>`).
* The `Item` struct and `ItemSource` enum were merged into a single `Item`
  enum.
* Support for aliasing resources was added (e.g. `type r2 = r;`).
* The `Resource` type no longer stores a collection of related methods as this
  *greatly* complicated merging of implicit imports; now resource methods are
  exported/imported directly in the exports/imports of an interface/world.
* Consequently, merging of implicitly imported instances is now correctly
  implemented.
* Subtype checking relating to resources has been improved so that the
  `ResourceMap` is no longer required.
* Scope rules now better align with WIT; an interface or world may no longer
  reference top-level types.
* Decoding binary packages now properly resolves resources and "used" types in
  interface and world definitions.

Implementation of encoding:

* Encoding of WIT subset of the grammar should match that of the existing WIT
  tooling; may be round-tripped with `wasm-tools component wit`.
* Encoding of imports, instantiations, and exports should enable the output of
  actual WebAssembly compositions.

CLI changes:

* The `parse` command has been split into three different commands:

  * The `parse` command that outputs a JSON formatted AST.
  * The `resolve` command that outputs a JSON formatted resolved document.
  * The `encode` command that outputs with text or binary WebAssembly.

Author: peterhuene

Cargo.lock

@@ -19,7 +19,7 @@ keywords = ["webassembly", "wasm", "components", "component-model"]
 repository = "https://github.com/bytecodealliance/wac"
 
 [dependencies]
-wac-parser = { workspace = true }
+wac-parser = { workspace = true, default-features = false}
 anyhow = { workspace = true }
 clap = { workspace = true }
 pretty_env_logger = { workspace = true }
@@ -28,6 +28,9 @@ tokio = { workspace = true }
 owo-colors = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
+wat = { workspace = true }
+wasmparser = { workspace = true }
+wasmprinter = { workspace = true }
 
 [features]
 default = []
@@ -38,6 +41,9 @@ wac-parser = { path = "crates/wac-parser", default-features = false }
 wit-parser = "0.13.0"
 wasmparser = "0.116.1"
 wit-component = "0.18.0"
+wasm-encoder = "0.36.2"
+wasmprinter = "0.2.72"
+wasm-metadata = "0.10.11"
 anyhow = "1.0.75"
 clap = { version = "4.4.7", features = ["derive"] }
 semver = { version = "1.0.20", features = ["serde"] }

Cargo.toml

@@ -46,7 +46,7 @@ item-type-decl      ::= resource-decl | type-decl
 resource-decl       ::= 'resource' id '{' resource-item* '}'
 resource-item       ::= constructor | method
 constructor         ::= 'constructor' param-list
-method              ::= id ':' 'static'? func-type-ref
+method              ::= id ':' 'static'? func-type
 variant-decl        ::= 'variant' id '{' variant-cases '}'
 variant-cases       ::= variant-case (',' variant-case)* ','?
 variant-case        ::= id ('(' type ')')?

README.md

@@ -21,6 +21,8 @@ serde = { workspace = true }
 wasmparser = { workspace = true }
 wit-parser = { workspace = true }
 wit-component = { workspace = true }
+wasm-encoder = { workspace = true }
+wasm-metadata = { workspace = true }
 wat = { workspace = true, optional = true }
 owo-colors = { workspace = true }
 
@@ -32,6 +34,7 @@ pretty_assertions = "1.4.0"
 pretty_env_logger = { workspace = true }
 rayon = "1.8.0"
 serde_json = { workspace = true }
+wasmprinter = { workspace = true }
 
 [[test]]
 name = "parser"
@@ -40,3 +43,7 @@ harness = false
 [[test]]
 name = "resolution"
 harness = false
+
+[[test]]
+name = "encoding"
+harness = false

crates/wac-parser/Cargo.toml

@@ -11,11 +11,13 @@ mod export;
 mod expr;
 mod import;
 mod r#let;
+mod printer;
 mod r#type;
 
 pub use export::*;
 pub use expr::*;
 pub use import::*;
+pub use printer::*;
 pub use r#let::*;
 pub use r#type::*;
 
@@ -43,7 +45,7 @@ impl fmt::Display for Expected<'_> {
                 write!(f, ", ")?;
             }
 
-            if i == self.expected.len() - 1 && self.count <= self.expected.len() {
+            if i == self.count - 1 {
                 write!(f, "or ")?;
             }
 
@@ -306,7 +308,7 @@ macro_rules! display {
     ($name:ident, $method:ident) => {
         impl std::fmt::Display for $name<'_> {
             fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-                let mut printer = crate::printer::DocumentPrinter::new(f, None);
+                let mut printer = crate::ast::DocumentPrinter::new(f, None);
                 printer.$method(self)
             }
         }

crates/wac-parser/src/ast.rs

@@ -98,7 +98,7 @@ impl<'a> PackagePath<'a> {
     /// Iterates over the segments of the package path.
     pub fn segment_spans<'b>(&'b self) -> impl Iterator<Item = (&'a str, Span<'a>)> + 'b {
         self.segments.split('/').map(|s| {
-            let start = s.as_ptr() as usize - self.name.as_ptr() as usize;
+            let start = self.span.start + s.as_ptr() as usize - self.name.as_ptr() as usize;
             let end = start + s.len();
             (s, Span::from_span(self.span.source(), &(start..end)))
         })

crates/wac-parser/src/ast/import.rs

@@ -140,20 +140,20 @@ impl<W: Write> DocumentPrinter<W> {
     /// Prints the given type.
     pub fn ty(&mut self, ty: &Type) -> std::fmt::Result {
         match ty {
-            Type::U8 => write!(self.writer, "u8"),
-            Type::S8 => write!(self.writer, "s8"),
-            Type::U16 => write!(self.writer, "u16"),
-            Type::S16 => write!(self.writer, "s16"),
-            Type::U32 => write!(self.writer, "u32"),
-            Type::S32 => write!(self.writer, "s32"),
-            Type::U64 => write!(self.writer, "u64"),
-            Type::S64 => write!(self.writer, "s64"),
-            Type::Float32 => write!(self.writer, "float32"),
-            Type::Float64 => write!(self.writer, "float64"),
-            Type::Char => write!(self.writer, "char"),
-            Type::Bool => write!(self.writer, "bool"),
-            Type::String => write!(self.writer, "string"),
-            Type::Tuple(types) => {
+            Type::U8(_) => write!(self.writer, "u8"),
+            Type::S8(_) => write!(self.writer, "s8"),
+            Type::U16(_) => write!(self.writer, "u16"),
+            Type::S16(_) => write!(self.writer, "s16"),
+            Type::U32(_) => write!(self.writer, "u32"),
+            Type::S32(_) => write!(self.writer, "s32"),
+            Type::U64(_) => write!(self.writer, "u64"),
+            Type::S64(_) => write!(self.writer, "s64"),
+            Type::Float32(_) => write!(self.writer, "float32"),
+            Type::Float64(_) => write!(self.writer, "float64"),
+            Type::Char(_) => write!(self.writer, "char"),
+            Type::Bool(_) => write!(self.writer, "bool"),
+            Type::String(_) => write!(self.writer, "string"),
+            Type::Tuple(types, _) => {
                 write!(self.writer, "tuple<")?;
                 for (i, ty) in types.iter().enumerate() {
                     if i > 0 {
@@ -165,17 +165,17 @@ impl<W: Write> DocumentPrinter<W> {
 
                 write!(self.writer, ">")
             }
-            Type::List(ty) => {
+            Type::List(ty, _) => {
                 write!(self.writer, "list<")?;
                 self.ty(ty)?;
                 write!(self.writer, ">")
             }
-            Type::Option(ty) => {
+            Type::Option(ty, _) => {
                 write!(self.writer, "option<")?;
                 self.ty(ty)?;
                 write!(self.writer, ">")
             }
-            Type::Result { ok, err } => match (ok, err) {
+            Type::Result { ok, err, .. } => match (ok, err) {
                 (None, None) => write!(self.writer, "result"),
                 (None, Some(err)) => {
                     write!(self.writer, "result<_, ")?;
@@ -195,7 +195,7 @@ impl<W: Write> DocumentPrinter<W> {
                     write!(self.writer, ">")
                 }
             },
-            Type::Borrow(id) => {
+            Type::Borrow(id, _) => {
                 write!(self.writer, "borrow<{id}>", id = id.span.as_str())
             }
             Type::Ident(id) => write!(self.writer, "{id}", id = id.span.as_str()),
@@ -323,7 +323,7 @@ impl<W: Write> DocumentPrinter<W> {
             write!(self.writer, "static ")?;
         }
 
-        self.func_type_ref(&method.ty)?;
+        self.func_type(&method.ty)?;
         write!(self.writer, ";")
     }