Add handle value to Wave syntax

crates/wasm-wave/src/ast.rs

@@ -227,6 +227,7 @@ impl Node {
             WasmTypeKind::Option => self.to_wasm_option(ty, src)?,
             WasmTypeKind::Result => self.to_wasm_result(ty, src)?,
             WasmTypeKind::Flags => self.to_wasm_flags(ty, src)?,
+            WasmTypeKind::Handle => self.to_wasm_handle(ty, src)?,
             other => {
                 return Err(
                     self.wasm_value_error(WasmValueError::UnsupportedType(other.to_string()))
@@ -352,6 +353,17 @@ impl Node {
         V::make_option(ty, value).map_err(|err| self.wasm_value_error(err))
     }
 
+    fn to_wasm_handle<V: WasmValue>(&self, _ty: &V::Type, src: &str) -> Result<V, ParserError> {
+        self.ensure_type(NodeType::Handle)?;
+        match self.children.as_slice() {
+            [label] => {
+                let label = label.as_label(src)?;
+                Ok(V::make_handle(label.into()))
+            }
+            _ => Err(self.error(ParserErrorKind::InvalidType)),
+        }
+    }
+
     fn to_wasm_result<V: WasmValue>(&self, ty: &V::Type, src: &str) -> Result<V, ParserError> {
         let (ok_type, err_type) = ty.result_types().unwrap();
         let value = match self.ty {
@@ -470,4 +482,7 @@ pub enum NodeType {
     /// Flags
     /// Child nodes are flag Labels.
     Flags,
+    /// Handle
+    /// Child node is a opaque label.
+    Handle,
 }

crates/wasm-wave/src/lex.rs

@@ -12,7 +12,8 @@ pub type Lexer<'source> = logos::Lexer<'source, Token>;
 #[logos(error = Option<Span>)]
 #[logos(skip r"[ \t\n\r]+")]
 #[logos(skip r"//[^\n]*")]
-#[logos(subpattern label_word = r"[a-z][a-z0-9]*|[A-Z][A-Z0-9]*")]
+#[logos(subpattern first_label_word = r"[a-z][a-z0-9]*|[A-Z][A-Z0-9]*")]
+#[logos(subpattern label_word = r"[a-z0-9]+|[A-Z0-9]+")]
 #[logos(subpattern char_escape = r#"\\['"tnr\\]|\\u\{[0-9a-fA-F]{1,6}\}"#)]
 pub enum Token {
     /// The `{` symbol
@@ -40,6 +41,10 @@ pub enum Token {
     #[token(":")]
     Colon,
 
+    /// The `#` symbol
+    #[token("#")]
+    Sharp,
+
     /// The `,` symbol
     #[token(",")]
     Comma,
@@ -50,7 +55,7 @@ pub enum Token {
     Number,
 
     /// A label or keyword
-    #[regex(r"%?(?&label_word)(-(?&label_word))*")]
+    #[regex(r"%?(?&first_label_word)(-(?&label_word))*")]
     LabelOrKeyword,
 
     /// A char literal

crates/wasm-wave/src/parser.rs

@@ -81,6 +81,7 @@ impl<'source> Parser<'source> {
             Token::ParenOpen => self.parse_tuple()?,
             Token::BracketOpen => self.parse_list()?,
             Token::BraceOpen => self.parse_record_or_flags()?,
+            Token::Sharp => self.parse_handle()?,
             Token::LabelOrKeyword => match Keyword::decode(self.slice()) {
                 Some(Keyword::True) => self.leaf_node(NodeType::BoolTrue),
                 Some(Keyword::False) => self.leaf_node(NodeType::BoolFalse),
@@ -99,6 +100,13 @@ impl<'source> Parser<'source> {
         })
     }
 
+    fn parse_handle(&mut self) -> Result<Node, ParserError> {
+        let start = self.span().start;
+        self.advance()?;
+        let label = self.parse_label()?;
+        Ok(Node::new(NodeType::Handle, start..self.span().end, [label]))
+    }
+
     fn parse_tuple(&mut self) -> Result<Node, ParserError> {
         let start = self.span().start;
         let children = self.parse_comma_separated_nodes(Token::ParenClose)?;
@@ -485,6 +493,20 @@ mod tests {
         );
     }
 
+    #[test]
+    fn parse_resource() {
+        let ty = Type::handle("test_resource");
+        assert_eq!(
+            parse_value("#http-body-42", &ty),
+            Value::make_handle("http-body-42".into())
+        );
+        let ty = Type::handle("resource");
+        assert_eq!(
+            parse_value("#borrow-http-body", &ty),
+            Value::make_handle("borrow-http-body".into())
+        );
+    }
+
     #[test]
     fn parse_record_reordering() {
         let ty = Type::record([("red", Type::S32), ("green", Type::CHAR)]).unwrap();

crates/wasm-wave/src/untyped.rs

@@ -184,6 +184,7 @@ fn fmt_node(f: &mut impl std::fmt::Write, node: &Node, src: &str) -> std::fmt::R
             }
             f.write_char('}')
         }
+        Handle => todo!(),
     }
 }