Revert "Update GC proposal parsing (#55)"

This reverts commit 99c8f9c.

Author: alexcrichton

crates/wast/src/ast/expr.rs

@@ -117,7 +117,7 @@ impl<'a> ExpressionParser<'a> {
                         // If block/loop show up then we just need to be sure to
                         // push an `end` instruction whenever the `)` token is
                         // seen
-                        i @ Instruction::Block(_) | i @ Instruction::Loop(_) | i @ Instruction::Let(_) => {
+                        i @ Instruction::Block(_) | i @ Instruction::Loop(_) => {
                             self.instrs.push(i);
                             self.stack.push(Level::EndWith(Instruction::End(None)));
                         }
@@ -361,7 +361,6 @@ instructions! {
         CallRef : [0x14] : "call_ref",
         ReturnCallRef : [0x15] : "return_call_ref",
         FuncBind(ast::Index<'a>) : [0x16] : "func.bind",
-        Let(LetType<'a>) : [0x17] : "let",
 
         Drop : [0x1a] : "drop",
         Select(SelectTypes<'a>) : [] : "select",
@@ -425,19 +424,19 @@ instructions! {
         RefEq : [0xd5] : "ref.eq",
 
         // gc proposal: struct
-        StructNewWithRtt(ast::Index<'a>) : [0xfb, 0x01] : "struct.new_with_rtt",
-        StructNewDefaultWithRtt(ast::Index<'a>) : [0xfb, 0x02] : "struct.new_default_with_rtt",
+        StructNew(ast::Index<'a>) : [0xfb, 0x00] : "struct.new",
+        StructNewSub(ast::Index<'a>) : [0xfb, 0x01] : "struct.new_sub",
+        StructNewDefault(ast::Index<'a>) : [0xfb, 0x02] : "struct.new_default",
         StructGet(StructAccess<'a>) : [0xfb, 0x03] : "struct.get",
         StructGetS(StructAccess<'a>) : [0xfb, 0x04] : "struct.get_s",
         StructGetU(StructAccess<'a>) : [0xfb, 0x05] : "struct.get_u",
         StructSet(StructAccess<'a>) : [0xfb, 0x06] : "struct.set",
-
-        // gc proposal (moz specific, will be removed)
         StructNarrow(StructNarrow<'a>) : [0xfb, 0x07] : "struct.narrow",
 
         // gc proposal: array
-        ArrayNewWithRtt(ast::Index<'a>) : [0xfb, 0x11] : "array.new_with_rtt",
-        ArrayNewDefaultWithRtt(ast::Index<'a>) : [0xfb, 0x12] : "array.new_default_with_rtt",
+        ArrayNew(ast::Index<'a>) : [0xfb, 0x10] : "array.new",
+        ArrayNewSub(ast::Index<'a>) : [0xfb, 0x11] : "array.new_sub",
+        ArrayNewDefault(ast::Index<'a>) : [0xfb, 0x12] : "array.new_default",
         ArrayGet(ast::Index<'a>) : [0xfb, 0x13] : "array.get",
         ArrayGetS(ast::Index<'a>) : [0xfb, 0x14] : "array.get_s",
         ArrayGetU(ast::Index<'a>) : [0xfb, 0x15] : "array.get_u",
@@ -450,11 +449,11 @@ instructions! {
         I31GetU : [0xfb, 0x22] : "i31.get_u",
 
         // gc proposal, rtt/casting
-        RTTCanon(HeapType<'a>) : [0xfb, 0x30] : "rtt.canon",
-        RTTSub(RTTSub<'a>) : [0xfb, 0x31] : "rtt.sub",
-        RefTest(RefTest<'a>) : [0xfb, 0x40] : "ref.test",
-        RefCast(RefTest<'a>) : [0xfb, 0x41] : "ref.cast",
-        BrOnCast(BrOnCast<'a>) : [0xfb, 0x42] : "br_on_cast",
+        RTTGet(ast::Index<'a>) : [0xfb, 0x30] : "rtt.get",
+        RTTSub(ast::Index<'a>) : [0xfb, 0x31] : "rtt.sub",
+        RefTest : [0xfb, 0x40] : "ref.test",
+        RefCast : [0xfb, 0x41] : "ref.cast",
+        BrOnCast(ast::Index<'a>) : [0xfb, 0x42] : "br_on_cast",
 
         I32Const(i32) : [0x41] : "i32.const",
         I64Const(i64) : [0x42] : "i64.const",
@@ -912,23 +911,6 @@ impl<'a> Parse<'a> for BlockType<'a> {
     }
 }
 
-/// Extra information associated with the let instruction.
-#[derive(Debug)]
-#[allow(missing_docs)]
-pub struct LetType<'a> {
-    pub block: BlockType<'a>,
-    pub locals: Vec<ast::Local<'a>>,
-}
-
-impl<'a> Parse<'a> for LetType<'a> {
-    fn parse(parser: Parser<'a>) -> Result<Self> {
-        Ok(LetType {
-            block: parser.parse()?,
-            locals: ast::Local::parse_remainder(parser)?,
-        })
-    }
-}
-
 /// Extra information associated with the `br_table` instruction.
 #[allow(missing_docs)]
 #[derive(Debug)]
@@ -1382,55 +1364,3 @@ impl<'a> Parse<'a> for BrOnExn<'a> {
         Ok(BrOnExn { label, exn })
     }
 }
-
-/// Payload of the `br_on_cast` instruction
-#[derive(Debug)]
-#[allow(missing_docs)]
-pub struct BrOnCast<'a> {
-    pub label: ast::Index<'a>,
-    pub val: HeapType<'a>,
-    pub rtt: HeapType<'a>,
-}
-
-impl<'a> Parse<'a> for BrOnCast<'a> {
-    fn parse(parser: Parser<'a>) -> Result<Self> {
-        let label = parser.parse()?;
-        let val = parser.parse()?;
-        let rtt = parser.parse()?;
-        Ok(BrOnCast { label, val, rtt })
-    }
-}
-
-/// Payload of the `rtt.sub` instruction
-#[derive(Debug)]
-#[allow(missing_docs)]
-pub struct RTTSub<'a> {
-    pub depth: u32,
-    pub input_rtt: HeapType<'a>,
-    pub output_rtt: HeapType<'a>,
-}
-
-impl<'a> Parse<'a> for RTTSub<'a> {
-    fn parse(parser: Parser<'a>) -> Result<Self> {
-        let depth = parser.parse()?;
-        let input_rtt = parser.parse()?;
-        let output_rtt = parser.parse()?;
-        Ok(RTTSub { depth, input_rtt, output_rtt })
-    }
-}
-
-/// Payload of the `ref.test/cast` instruction
-#[derive(Debug)]
-#[allow(missing_docs)]
-pub struct RefTest<'a> {
-    pub val: HeapType<'a>,
-    pub rtt: HeapType<'a>,
-}
-
-impl<'a> Parse<'a> for RefTest<'a> {
-    fn parse(parser: Parser<'a>) -> Result<Self> {
-        let val = parser.parse()?;
-        let rtt = parser.parse()?;
-        Ok(RefTest { val, rtt })
-    }
-}

crates/wast/src/ast/func.rs

@@ -35,8 +35,14 @@ pub enum FuncKind<'a> {
 
     /// Almost all functions, those defined inline in a wasm module.
     Inline {
-        /// The list of locals, if any, for this function.
-        locals: Vec<Local<'a>>,
+        /// The list of locals, if any, for this function. Each local has an
+        /// optional identifier for name resolution and name for the custom
+        /// `name` section associated with it.
+        locals: Vec<(
+            Option<ast::Id<'a>>,
+            Option<ast::NameAnnotation<'a>>,
+            ast::ValType<'a>,
+        )>,
 
         /// The instructions of the function.
         expression: ast::Expression<'a>,
@@ -54,7 +60,24 @@ impl<'a> Parse<'a> for Func<'a> {
             (parser.parse()?, FuncKind::Import(import))
         } else {
             let ty = parser.parse()?;
-            let locals = Local::parse_remainder(parser)?;
+            let mut locals = Vec::new();
+            while parser.peek2::<kw::local>() {
+                parser.parens(|p| {
+                    p.parse::<kw::local>()?;
+                    if p.is_empty() {
+                        return Ok(());
+                    }
+                    let id: Option<_> = p.parse()?;
+                    let name: Option<_> = p.parse()?;
+                    let ty = p.parse()?;
+                    let parse_more = id.is_none() && name.is_none();
+                    locals.push((id, name, ty));
+                    while parse_more && !p.is_empty() {
+                        locals.push((None, None, p.parse()?));
+                    }
+                    Ok(())
+                })?;
+            }
             (
                 ty,
                 FuncKind::Inline {
@@ -74,42 +97,3 @@ impl<'a> Parse<'a> for Func<'a> {
         })
     }
 }
-
-/// A local for a `func` or `let` instruction.
-///
-/// Each local has an optional identifier for name resolution, an optional name
-/// for the custom `name` section, and a value type.
-#[derive(Debug)]
-pub struct Local<'a> {
-    /// An identifier that this local is resolved with (optionally) for name
-    /// resolution.
-    pub id: Option<ast::Id<'a>>,
-    /// An optional name for this local stored in the custom `name` section.
-    pub name: Option<ast::NameAnnotation<'a>>,
-    /// The value type of this local.
-    pub ty: ast::ValType<'a>,
-}
-
-impl<'a> Local<'a> {
-    pub(crate) fn parse_remainder(parser: Parser<'a>) -> Result<Vec<Local<'a>>> {
-        let mut locals = Vec::new();
-        while parser.peek2::<kw::local>() {
-            parser.parens(|p| {
-                p.parse::<kw::local>()?;
-                if p.is_empty() {
-                    return Ok(());
-                }
-                let id: Option<_> = p.parse()?;
-                let name: Option<_> = p.parse()?;
-                let ty = p.parse()?;
-                let parse_more = id.is_none() && name.is_none();
-                locals.push(Local { id, name, ty });
-                while parse_more && !p.is_empty() {
-                    locals.push(Local { id: None, name: None, ty: p.parse()? });
-                }
-                Ok(())
-            })?;
-        }
-        Ok(locals)
-    }
-}

crates/wast/src/ast/types.rs

@@ -10,8 +10,10 @@ pub enum ValType<'a> {
     F32,
     F64,
     V128,
+    I8,
+    I16,
     Ref(RefType<'a>),
-    Rtt(u32, ast::Index<'a>),
+    Rtt(ast::Index<'a>),
 }
 
 impl<'a> Parse<'a> for ValType<'a> {
@@ -32,14 +34,20 @@ impl<'a> Parse<'a> for ValType<'a> {
         } else if l.peek::<kw::v128>() {
             parser.parse::<kw::v128>()?;
             Ok(ValType::V128)
+        } else if l.peek::<kw::i8>() {
+            parser.parse::<kw::i8>()?;
+            Ok(ValType::I8)
+        } else if l.peek::<kw::i16>() {
+            parser.parse::<kw::i16>()?;
+            Ok(ValType::I16)
         } else if l.peek::<RefType>() {
             Ok(ValType::Ref(parser.parse()?))
         } else if l.peek::<ast::LParen>() {
             parser.parens(|p| {
                 let mut l = p.lookahead1();
                 if l.peek::<kw::rtt>() {
                     p.parse::<kw::rtt>()?;
-                    Ok(ValType::Rtt(p.parse()?, p.parse()?))
+                    Ok(ValType::Rtt(p.parse()?))
                 } else {
                     Err(l.error())
                 }
@@ -50,21 +58,6 @@ impl<'a> Parse<'a> for ValType<'a> {
     }
 }
 
-impl<'a> Peek for ValType<'a> {
-    fn peek(cursor: Cursor<'_>) -> bool {
-        kw::i32::peek(cursor) ||
-        kw::i64::peek(cursor) ||
-        kw::f32::peek(cursor) ||
-        kw::f64::peek(cursor) ||
-        kw::v128::peek(cursor) ||
-        (ast::LParen::peek(cursor) && kw::rtt::peek2(cursor)) ||
-        RefType::peek(cursor)
-    }
-    fn display() -> &'static str {
-        "valtype"
-    }
-}
-
 /// A heap type for a reference type
 #[allow(missing_docs)]
 #[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
@@ -245,32 +238,6 @@ impl<'a> Peek for RefType<'a> {
     }
 }
 
-/// The types of values that may be used in a struct or array.
-#[allow(missing_docs)]
-#[derive(Debug, PartialEq, Eq, Hash, Copy, Clone)]
-pub enum StorageType<'a> {
-    I8,
-    I16,
-    Val(ValType<'a>),
-}
-
-impl<'a> Parse<'a> for StorageType<'a> {
-    fn parse(parser: Parser<'a>) -> Result<Self> {
-        let mut l = parser.lookahead1();
-        if l.peek::<kw::i8>() {
-            parser.parse::<kw::i8>()?;
-            Ok(StorageType::I8)
-        } else if l.peek::<kw::i16>() {
-            parser.parse::<kw::i16>()?;
-            Ok(StorageType::I16)
-        } else if l.peek::<ValType>() {
-            Ok(StorageType::Val(parser.parse()?))
-        } else {
-            Err(l.error())
-        }
-    }
-}
-
 /// Type for a `global` in a wasm module
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub struct GlobalType<'a> {
@@ -502,8 +469,8 @@ pub struct StructField<'a> {
     pub id: Option<ast::Id<'a>>,
     /// Whether this field may be mutated or not.
     pub mutable: bool,
-    /// The storage type stored in this field.
-    pub ty: StorageType<'a>,
+    /// The value type stored in this field.
+    pub ty: ValType<'a>,
 }
 
 impl<'a> StructField<'a> {
@@ -516,7 +483,7 @@ impl<'a> StructField<'a> {
             })?;
             (ty, true)
         } else {
-            (parser.parse::<StorageType<'a>>()?, false)
+            (parser.parse::<ValType<'a>>()?, false)
         };
         Ok(StructField { id, mutable, ty })
     }
@@ -527,8 +494,8 @@ impl<'a> StructField<'a> {
 pub struct ArrayType<'a> {
     /// Whether this field may be mutated or not.
     pub mutable: bool,
-    /// The storage type stored in this field.
-    pub ty: StorageType<'a>,
+    /// The value type stored in this field.
+    pub ty: ValType<'a>,
 }
 
 impl<'a> Parse<'a> for ArrayType<'a> {
@@ -540,7 +507,7 @@ impl<'a> Parse<'a> for ArrayType<'a> {
             })?;
             (ty, true)
         } else {
-            (parser.parse::<StorageType<'a>>()?, false)
+            (parser.parse::<ValType<'a>>()?, false)
         };
         Ok(ArrayType { mutable, ty })
     }