Implement let statement resolution.

This commit implements let-statement resolution, which includes:

* Resolution of new expressions.
* Resolution of access expressions.

The resolution of new expressions is complicated as it has to perform type
checks for the instantiation arguments; the logic of which is in the newly
implemented `SubtypeChecker`, which operates solely off of WAC type information.

Resolution now stores resolved "items" that have information attached about
where they were sourced from (i.e. an import statement, an instantiation,
etc.).

Type information has been refactored (again, sorry) to hopefully make more
sense and appear better in error messages.

Additionally, the grammar was updated to support named instantiation arguments
by identifier (and not just by strings).

Error reporting has also been cleaned up to remove duplicated information.

To support testing, a default `wat` feature allows for parsing component
dependencies from local `wat` files.

The CLI now supports passing the paths to known package dependencies (via the
`--dep` option).

Author: peterhuene

Cargo.lock

@@ -29,23 +29,28 @@ owo-colors = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 
+[features]
+default = []
+wat = ["wac-parser/wat"]
+
 [workspace.dependencies]
-wac-parser = { path = "crates/wac-parser" }
+wac-parser = { path = "crates/wac-parser", default-features = false }
 wit-parser = "0.12.1"
-wasmparser = "0.113.3"
+wasmparser = "0.115.0"
 wit-component = "0.16.0"
 anyhow = "1.0.75"
-clap = { version = "4.4.3", features = ["derive"] }
-pest = "2.7.3"
-pest_derive = "2.7.3"
+clap = { version = "4.4.6", features = ["derive"] }
+pest = "2.7.4"
+pest_derive = "2.7.4"
 from-pest = "0.3.2"
 pest-ast = "0.3.4"
-semver = "1.0.18"
+semver = "1.0.20"
 pretty_env_logger = "0.5.0"
 log = "0.4.20"
-tokio = { version = "1.32.0", default-features = false, features = ["macros", "rt-multi-thread"] }
+tokio = { version = "1.33.0", default-features = false, features = ["macros", "rt-multi-thread"] }
 owo-colors = "3.5.0"
-indexmap = { version = "2.0.0", features = ["serde"] }
+indexmap = { version = "2.0.2", features = ["serde"] }
 id-arena = "2.2.1"
-serde = { version = "1.0.188", features = ["derive"] }
+serde = { version = "1.0.189", features = ["derive"] }
 serde_json = "1.0.107"
+wat = "1.0.77"

Cargo.toml

@@ -24,6 +24,10 @@ serde = { workspace = true }
 wasmparser = { workspace = true }
 wit-parser = { workspace = true }
 wit-component = { workspace = true }
+wat = { workspace = true, optional = true }
+
+[features]
+default = ["wat"]
 
 [dev-dependencies]
 pretty_assertions = "1.4.0"

crates/wac-parser/Cargo.toml

@@ -43,11 +43,10 @@ where
 }
 
 /// Creates a new error with the given message, file path, and span.
-pub fn new_error_with_span(msg: impl fmt::Display, path: &Path, span: Span) -> anyhow::Error {
-    let msg = msg.to_string();
+pub fn new_error_with_span(path: &Path, span: Span, msg: impl fmt::Display) -> anyhow::Error {
     let mut e = Error::new_from_span(
         ErrorVariant::CustomError::<Rule> {
-            message: msg.clone(),
+            message: msg.to_string(),
         },
         span,
     );
@@ -56,7 +55,15 @@ pub fn new_error_with_span(msg: impl fmt::Display, path: &Path, span: Span) -> a
         e = e.with_path(path)
     }
 
-    anyhow!(e).context(msg)
+    let (line, column) = match e.line_col {
+        pest::error::LineColLocation::Pos((l, c)) => (l, c),
+        pest::error::LineColLocation::Span((l, c), _) => (l, c),
+    };
+
+    anyhow!(format!(
+        "{path}:{line}:{column}: {msg}\n\n{e}",
+        path = path.display()
+    ))
 }
 
 /// Used to indent output when displaying AST nodes.

crates/wac-parser/src/ast.rs

@@ -103,8 +103,8 @@ mod test {
 
         roundtrip::<ExportStatement>(
             Rule::ExportStatement,
-            "export new foo:bar { foo, bar: (new baz:qux {...}), baz: foo[\"baz\"].qux };",
-            "export new foo:bar {\n  foo,\n  bar: (new baz:qux { ... }),\n  baz: foo[\"baz\"].qux,\n};",
+            "export new foo:bar { foo, \"bar\": (new baz:qux {...}), \"baz\": foo[\"baz\"].qux };",
+            "export new foo:bar {\n  foo,\n  \"bar\": (new baz:qux { ... }),\n  \"baz\": foo[\"baz\"].qux,\n};",
         )
         .unwrap();
     }

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

@@ -8,6 +8,7 @@ use super::{
     AstDisplay, Ident, Indenter, PackageName,
 };
 use crate::parser::Rule;
+use pest::Span;
 use pest_ast::FromPest;
 use serde::Serialize;
 use std::fmt;
@@ -172,8 +173,8 @@ display!(InstantiationArgument);
 #[pest_ast(rule(Rule::NamedInstantiationArgument))]
 #[serde(rename_all = "camelCase")]
 pub struct NamedInstantiationArgument<'a> {
-    /// The identifier in the argument.
-    pub id: Ident<'a>,
+    /// The name of the argument.
+    pub name: InstantiationArgumentName<'a>,
     /// The colon in the argument.
     pub colon: Colon<'a>,
     /// The expression in the argument.
@@ -182,13 +183,46 @@ pub struct NamedInstantiationArgument<'a> {
 
 impl AstDisplay for NamedInstantiationArgument<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, indenter: &mut Indenter) -> fmt::Result {
-        write!(f, "{id}{colon} ", id = self.id, colon = self.colon)?;
+        self.name.fmt(f, indenter)?;
+        write!(f, "{colon} ", colon = self.colon)?;
         self.expr.fmt(f, indenter)
     }
 }
 
 display!(NamedInstantiationArgument);
 
+/// Represents the argument name in an instantiation argument in the AST.
+#[derive(Debug, Clone, Serialize, FromPest)]
+#[pest_ast(rule(Rule::InstantiationArgumentName))]
+#[serde(rename_all = "camelCase")]
+pub enum InstantiationArgumentName<'a> {
+    /// The argument name is an identifier.
+    Ident(Ident<'a>),
+    /// The argument name is a string.
+    String(super::String<'a>),
+}
+
+impl<'a> InstantiationArgumentName<'a> {
+    /// Gets the span of the instantiation argument name.
+    pub fn span(&self) -> Span<'a> {
+        match self {
+            InstantiationArgumentName::Ident(ident) => ident.0,
+            InstantiationArgumentName::String(string) => string.0,
+        }
+    }
+}
+
+impl AstDisplay for InstantiationArgumentName<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>, _indenter: &mut Indenter) -> fmt::Result {
+        match self {
+            InstantiationArgumentName::Ident(ident) => ident.fmt(f, _indenter),
+            InstantiationArgumentName::String(string) => string.fmt(f, _indenter),
+        }
+    }
+}
+
+display!(InstantiationArgumentName);
+
 /// Represents a nested expression in the AST.
 #[derive(Debug, Clone, Serialize, FromPest)]
 #[pest_ast(rule(Rule::NestedExpr))]
@@ -223,11 +257,21 @@ pub enum PostfixExpr<'a> {
     NamedAccess(NamedAccessExpr<'a>),
 }
 
+impl<'a> PostfixExpr<'a> {
+    /// Gets the span of the postfix expression.
+    pub fn span(&self) -> pest::Span<'a> {
+        match self {
+            PostfixExpr::Access(access) => access.span(),
+            PostfixExpr::NamedAccess(access) => access.span(),
+        }
+    }
+}
+
 impl AstDisplay for PostfixExpr<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, indenter: &mut Indenter) -> fmt::Result {
         match self {
             PostfixExpr::Access(access) => access.fmt(f, indenter),
-            PostfixExpr::NamedAccess(named_access) => named_access.fmt(f, indenter),
+            PostfixExpr::NamedAccess(access) => access.fmt(f, indenter),
         }
     }
 }
@@ -245,6 +289,13 @@ pub struct AccessExpr<'a> {
     pub id: Ident<'a>,
 }
 
+impl<'a> AccessExpr<'a> {
+    /// Gets the span of the access expression.
+    pub fn span(&self) -> Span<'a> {
+        Span::new(self.dot.0.get_input(), self.dot.0.start(), self.id.0.end()).unwrap()
+    }
+}
+
 impl AstDisplay for AccessExpr<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, _indenter: &mut Indenter) -> fmt::Result {
         write!(f, "{dot}{id}", dot = self.dot, id = self.id)
@@ -266,6 +317,18 @@ pub struct NamedAccessExpr<'a> {
     pub close: CloseBracket<'a>,
 }
 
+impl<'a> NamedAccessExpr<'a> {
+    /// Gets the span of the access expression.
+    pub fn span(&self) -> Span<'a> {
+        Span::new(
+            self.open.0.get_input(),
+            self.open.0.start(),
+            self.close.0.end(),
+        )
+        .unwrap()
+    }
+}
+
 impl AstDisplay for NamedAccessExpr<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>, _indenter: &mut Indenter) -> fmt::Result {
         write!(
@@ -303,8 +366,8 @@ mod test {
 
         roundtrip::<Expr>(
             Rule::Expr,
-            "new foo:bar { foo, bar: (new baz:qux {...}), baz: foo[\"baz\"].qux }",
-            "new foo:bar {\n  foo,\n  bar: (new baz:qux { ... }),\n  baz: foo[\"baz\"].qux,\n}",
+            "new foo:bar { foo, \"bar\": (new baz:qux {...}), \"baz\": foo[\"baz\"].qux }",
+            "new foo:bar {\n  foo,\n  \"bar\": (new baz:qux { ... }),\n  \"baz\": foo[\"baz\"].qux,\n}",
         )
         .unwrap();
     }

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

@@ -77,8 +77,8 @@ mod test {
 
         roundtrip::<LetStatement>(
             Rule::LetStatement,
-            "let x = new foo:bar { foo, bar: (new baz:qux {...}), baz: foo[\"baz\"].qux };",
-            "let x = new foo:bar {\n  foo,\n  bar: (new baz:qux { ... }),\n  baz: foo[\"baz\"].qux,\n};",
+            "let x = new foo:bar { foo, \"bar\": (new baz:qux {...}), \"baz\": foo[\"baz\"].qux };",
+            "let x = new foo:bar {\n  foo,\n  \"bar\": (new baz:qux { ... }),\n  \"baz\": foo[\"baz\"].qux,\n};",
         )
         .unwrap();
     }

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

@@ -101,6 +101,7 @@ mod pest {
                 Self::NewExprBody => "new expression body",
                 Self::InstantiationArgument => "instantiation argument",
                 Self::NamedInstantiationArgument => "named instantiation argument",
+                Self::InstantiationArgumentName => "instantiation argument name",
                 Self::NestedExpr => "nested expression",
                 Self::PostfixExpr => "postfix expression",
                 Self::AccessExpr => "access expression",