Implement package resolution.

This commit implements a file system package resolver that will load foreign
packages from either a binary-encoded wasm file or a directory containing WIT
files.

The package is parsed and the wasmparser types converted to the WAC
representation, allowing the resolution of package references from already
implemented AST resolution:

* import statements
* use statements in an interface or world.
* world include statements.
* world item statements.

The `as` clause in use statements is also implemented as part of these changes.

The type system has also been refactored to remove the lifetime annotations.

Author: peterhuene

Cargo.lock

@@ -1,11 +1,19 @@
 [package]
 name = "wac"
+description = "A tool for encoding and decoding WebAssembly compositions."
+version = { workspace = true }
+edition = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+categories = { workspace = true }
+keywords = { workspace = true }
+repository = { workspace = true }
+
+[workspace.package]
 version = "0.1.0"
 edition = "2021"
 authors = ["Peter Huene <peter@huene.dev>"]
-description = "A tool for encoding and decoding WebAssembly compositions."
 license = "Apache-2.0 WITH LLVM-exception"
-documentation = "https://docs.rs/wac"
 categories = ["wasm"]
 keywords = ["webassembly", "wasm", "components", "component-model"]
 repository = "https://github.com/bytecodealliance/wac"
@@ -23,6 +31,9 @@ serde_json = { workspace = true }
 
 [workspace.dependencies]
 wac-parser = { path = "crates/wac-parser" }
+wit-parser = "0.12.1"
+wasmparser = "0.113.3"
+wit-component = "0.16.0"
 anyhow = "1.0.75"
 clap = { version = "4.4.3", features = ["derive"] }
 pest = "2.7.3"

Cargo.toml

@@ -1,14 +1,13 @@
 [package]
 name = "wac-parser"
-version = "0.1.0"
-edition = "2021"
-authors = ["Peter Huene <peter@huene.dev>"]
 description = "A library for encoding and decoding WebAssembly compositions."
-license = "Apache-2.0 WITH LLVM-exception"
-documentation = "https://docs.rs/wac-parser"
-categories = ["wasm"]
-keywords = ["webassembly", "wasm", "components", "component-model"]
-repository = "https://github.com/bytecodealliance/wac"
+version = { workspace = true }
+edition = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+categories = { workspace = true }
+keywords = { workspace = true }
+repository = { workspace = true }
 
 [dependencies]
 anyhow = { workspace = true }
@@ -22,6 +21,9 @@ log = { workspace = true }
 indexmap = { workspace = true }
 id-arena = { workspace = true }
 serde = { workspace = true }
+wasmparser = { workspace = true }
+wit-parser = { workspace = true }
+wit-component = { workspace = true }
 
 [dev-dependencies]
 pretty_assertions = "1.4.0"

crates/wac-parser/Cargo.toml

@@ -109,35 +109,50 @@ display!(WithClause);
 pub struct PackagePath<'a> {
     /// The name of the package.
     pub name: PackageName<'a>,
-    /// The path into the package.
-    pub path: Vec<(Slash<'a>, Ident<'a>)>,
-    /// The version of the package.
+    /// The path segments.
+    pub segments: Vec<(Slash<'a>, Ident<'a>)>,
+    /// The optional version of the package.
     pub version: Option<(At<'a>, PackageVersion<'a>)>,
 }
 
 impl PackagePath<'_> {
     /// Calculates the span of the package path.
     pub fn span(&self) -> Span {
-        let span = self.name.parts.first().unwrap().0;
+        let span = self.name.span();
         let end = if let Some((_, version)) = &self.version {
             version.0.end()
-        } else if let Some((_, path)) = self.path.last() {
-            path.0.end()
         } else {
-            span.end()
+            self.segments.last().unwrap().1 .0.end()
         };
 
         Span::new(span.get_input(), span.start(), end).unwrap()
     }
+
+    /// Returns the string representation of the package path.
+    pub fn as_str(&self) -> &str {
+        self.span().as_str()
+    }
+
+    /// Gets the span of just the path segments.
+    pub fn segments_span(&self) -> Span {
+        let (_, first) = self.segments.first().unwrap();
+        let (_, last) = self.segments.last().unwrap();
+        Span::new(first.0.get_input(), first.0.start(), last.0.end()).unwrap()
+    }
+
+    /// Gets the path segments as a string.
+    pub fn segments(&self) -> &str {
+        self.segments_span().as_str()
+    }
 }
 
 impl AstDisplay for PackagePath<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, indenter: &mut Indenter) -> fmt::Result {
         self.name.fmt(f, indenter)?;
 
-        for (slash, part) in &self.path {
+        for (slash, segment) in &self.segments {
             write!(f, "{slash}")?;
-            part.fmt(f, indenter)?;
+            segment.fmt(f, indenter)?;
         }
 
         if let Some((at, version)) = &self.version {
@@ -160,6 +175,20 @@ pub struct PackageName<'a> {
     pub parts: Vec<Ident<'a>>,
 }
 
+impl PackageName<'_> {
+    /// Gets the span of the package name.
+    pub fn span(&self) -> Span {
+        let span = self.parts.first().unwrap().0;
+        let end = self.parts.last().map(|i| i.0.end()).unwrap();
+        Span::new(span.get_input(), span.start(), end).unwrap()
+    }
+
+    /// Gets the package name as a string.
+    pub fn as_str(&self) -> &str {
+        self.span().as_str()
+    }
+}
+
 impl AstDisplay for PackageName<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, indenter: &mut Indenter) -> fmt::Result {
         for (i, part) in self.parts.iter().enumerate() {

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

@@ -14,7 +14,7 @@ use crate::parser::Rule;
 use pest::Span;
 use pest_ast::FromPest;
 use serde::Serialize;
-use std::{borrow::Cow, fmt};
+use std::fmt;
 
 /// Represents a type statement in the AST.
 #[derive(Debug, Clone, Serialize, FromPest)]
@@ -1142,7 +1142,7 @@ pub struct UseItems<'a> {
     /// The opening brace of the statement.
     pub open: OpenBrace<'a>,
     /// The items being used.
-    pub list: Vec<Ident<'a>>,
+    pub list: Vec<UseItem<'a>>,
     /// The closing brace of the use items.
     pub close: CloseBrace<'a>,
 }
@@ -1166,6 +1166,51 @@ impl AstDisplay for UseItems<'_> {
 
 display!(UseItems);
 
+/// Represents an item being used in a use statement in the AST.
+#[derive(Debug, Clone, Serialize, FromPest)]
+#[pest_ast(rule(Rule::UseItem))]
+#[serde(rename_all = "camelCase")]
+pub struct UseItem<'a> {
+    /// The identifier of the item.
+    pub id: Ident<'a>,
+    /// The optional as clause of the item.
+    pub as_clause: std::option::Option<UseAsClause<'a>>,
+}
+
+impl AstDisplay for UseItem<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>, indenter: &mut Indenter) -> fmt::Result {
+        self.id.fmt(f, indenter)?;
+
+        if let Some(as_clause) = &self.as_clause {
+            write!(f, " {as_clause}")?;
+        }
+
+        Ok(())
+    }
+}
+
+display!(UseItem);
+
+/// Represents an as clause in a use statement in the AST.
+#[derive(Debug, Clone, Serialize, FromPest)]
+#[pest_ast(rule(Rule::UseAsClause))]
+#[serde(rename_all = "camelCase")]
+pub struct UseAsClause<'a> {
+    /// The `as` keyword.
+    pub keyword: As<'a>,
+    /// The identifier of the as clause.
+    pub id: Ident<'a>,
+}
+
+impl AstDisplay for UseAsClause<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>, indenter: &mut Indenter) -> fmt::Result {
+        write!(f, "{keyword} ", keyword = self.keyword)?;
+        self.id.fmt(f, indenter)
+    }
+}
+
+display!(UseAsClause);
+
 /// Represents a use path in the AST.
 #[derive(Debug, Clone, Serialize, FromPest)]
 #[pest_ast(rule(Rule::UsePath))]
@@ -1524,11 +1569,11 @@ pub enum WorldRef<'a> {
 }
 
 impl<'a> WorldRef<'a> {
-    /// Gets the full name of the world ref.
-    pub fn name(&self) -> Cow<'a, str> {
+    /// Gets the name of the world being referred to.
+    pub fn name(&self) -> &str {
         match self {
-            Self::Ident(id) => Cow::Borrowed(id.as_str()),
-            Self::Path(path) => Cow::Owned(path.to_string()),
+            Self::Ident(id) => id.as_str(),
+            Self::Path(path) => path.as_str(),
         }
     }
 

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

@@ -70,6 +70,8 @@ mod pest {
 
                 Self::UseStatement => "use statement",
                 Self::UseItems => "use items",
+                Self::UseItem => "use item",
+                Self::UseAsClause => "use as clause",
                 Self::UsePath => "use path",
 
                 Self::InterfaceBody => "interface body",