Support for Wast table initialisation syntactic sugar with typeful references

crates/wast/src/core/table.rs

@@ -64,12 +64,12 @@ impl<'a> Parse<'a> for Table<'a> {
             let elem = parser.parse()?;
             let payload = parser.parens(|p| {
                 p.parse::<kw::elem>()?;
-                let ty = if parser.peek::<LParen>() {
-                    Some(elem)
-                } else {
-                    None
+                let ty = match elem {
+                    rt @ RefType { heap: HeapType::Index(_), .. } => Some(rt),
+                    elem if parser.peek::<LParen>() => Some(elem),
+                    _ => None,
                 };
-                ElemPayload::parse_tail(parser, ty)
+                Ok(ElemPayload::parse_tail(parser, ty)?)
             })?;
             TableKind::Inline { elem, payload }
         } else if l.peek::<u32>() {
@@ -203,39 +203,65 @@ impl<'a> Parse<'a> for ElemPayload<'a> {
 
 impl<'a> ElemPayload<'a> {
     fn parse_tail(parser: Parser<'a>, ty: Option<RefType<'a>>) -> Result<Self> {
-        let (must_use_indices, ty) = match ty {
+
+        // We are in the middle of parsing an element
+        // (elem XXXX indices/expressions)
+        //       ^^^^
+        //       | we are here. We use the provided context `ty` + parser lookahead to learn which
+        //         abbreviation notation we are currently parsing.
+        match ty {
             None => {
+                // case: "XXXX" is "func", we expect to parse a list
+                // of untyped function references indices.
                 parser.parse::<Option<kw::func>>()?;
-                (true, RefType::func())
+                let mut elems = Vec::new();
+                while !parser.is_empty() {
+                    elems.push(parser.parse()?);
+                }
+                Ok(ElemPayload::Indices(elems))
             }
-            Some(ty) => (false, ty),
-        };
-        if let HeapType::Func = ty.heap {
-            if must_use_indices || parser.peek::<Index<'_>>() {
+            Some(RefType { heap: HeapType::Func, .. }) if parser.peek::<Index<'_>>() => {
+                // case: "XXXX" is the empty string. The context tells
+                // us to expect a list of untyped function references.
                 let mut elems = Vec::new();
                 while !parser.is_empty() {
                     elems.push(parser.parse()?);
                 }
-                return Ok(ElemPayload::Indices(elems));
+                Ok(ElemPayload::Indices(elems))
             }
-        }
-        let mut exprs = Vec::new();
-        while !parser.is_empty() {
-            let expr = parser.parens(|parser| {
-                if parser.peek::<kw::item>() {
-                    parser.parse::<kw::item>()?;
-                    parser.parse()
-                } else {
-                    // Without `item` this is "sugar" for a single-instruction
-                    // expression.
-                    let insn = parser.parse()?;
-                    Ok(Expression {
-                        instrs: [insn].into(),
-                    })
+            Some(ty @ RefType { heap: HeapType::Index(_), .. }) if parser.peek::<Index<'_>>() => {
+                // case: "XXXX" is the empty string. The context tells
+                // us to expect a list of typeful function references.
+                let mut instrs = Vec::new();
+                while !parser.is_empty() {
+                    instrs.push(Instruction::RefFunc(parser.parse()?));
                 }
-            })?;
-            exprs.push(expr);
+                Ok(ElemPayload::Exprs {
+                    ty,
+                    exprs: vec![Expression { instrs:instrs.into() }] })
+            }
+            Some(ty) => {
+                // default case: "XXXX" is the empty string. We expect
+                // to parse a list of constant expressions.
+                let mut exprs = Vec::new();
+                while !parser.is_empty() {
+                    let expr = parser.parens(|parser| {
+                        if parser.peek::<kw::item>() {
+                            parser.parse::<kw::item>()?;
+                            parser.parse()
+                        } else {
+                            // Without `item` this is "sugar" for a single-instruction
+                            // expression.
+                            let insn = parser.parse()?;
+                            Ok(Expression {
+                                instrs: [insn].into(),
+                            })
+                        }
+                    })?;
+                    exprs.push(expr);
+                }
+                Ok(ElemPayload::Exprs { exprs, ty })
+            }
         }
-        Ok(ElemPayload::Exprs { exprs, ty })
     }
 }

tests/roundtrip.rs

@@ -291,20 +291,7 @@ impl TestState {
     fn test_wast_directive(&self, test: &Path, directive: WastDirective, idx: usize) -> Result<()> {
         // Only test parsing and encoding of modules which wasmparser doesn't
         // support test (basically just test `wast`, nothing else)
-        let skip_verify = test.iter().any(|t| t == "gc")
-            // This specific test contains a module along the lines of:
-            //
-            //  (module
-            //   (type $t (func))
-            //   (func $tf)
-            //   (table $t (ref null $t) (elem $tf))
-            //  )
-            //
-            // which doesn't currently validate since the injected element
-            // segment has a type of `funcref` which isn't compatible with the
-            // table's type. The spec interpreter thinks this should validate,
-            // however, and I'm not entirely sure why.
-            || test.ends_with("function-references/br_table.wast");
+        let skip_verify = test.iter().any(|t| t == "gc");
 
         match directive {
             WastDirective::Wat(mut module) => {