Allow bare try blocks for exceptions (#289)

The exception handling spec now allows bare `try` blocks that
have no corresponding `catch` (or other) clauses following it.
These blocks are semantically equivalent to `block`.

Related spec PR:

  WebAssembly/exception-handling#157

Author: takikawa

crates/wasmparser/src/operators_validator.rs

@@ -677,9 +677,6 @@ impl OperatorValidator {
                         self.push_ctrl(FrameKind::Else, frame.block_type, resources)?;
                         frame = self.pop_ctrl(resources)?;
                     }
-                    FrameKind::Try => {
-                        bail_op_err!("expected catch block");
-                    }
                     _ => (),
                 }
 

crates/wast/src/ast/expr.rs

@@ -193,17 +193,12 @@ impl<'a> ExpressionParser<'a> {
                         self.instrs.push(Instruction::End(None));
                     }
 
-                    // Both `do` and `catch` are required in a `try` statement, so
-                    // we will signal those errors here. Otherwise, terminate with
+                    // The `do` clause is required in a `try` statement, so
+                    // we will signal that error here. Otherwise, terminate with
                     // an `end` or `delegate` instruction.
                     Level::Try(Try::Do(_)) => {
                         return Err(parser.error("previous `try` had no `do`"));
                     }
-                    Level::Try(Try::CatchOrDelegate) => {
-                        return Err(parser.error(
-                            "previous `try` had no `catch`, `catch_all`, or `delegate`",
-                        ));
-                    }
                     Level::Try(Try::Delegate) => {}
                     Level::Try(_) => {
                         self.instrs.push(Instruction::End(None));
@@ -372,7 +367,7 @@ impl<'a> ExpressionParser<'a> {
                     Paren::Right => return Ok(true),
                 }
             }
-            return Ok(false);
+            return Err(parser.error("expected a `catch`, `catch_all`, or `delegate`"));
         }
 
         if let Try::Catch = i {

tests/local/try.wast

@@ -1,5 +1,11 @@
 ;; --enable-exceptions
 
+(assert_malformed
+  (module quote
+    "(func (try))"
+  )
+  "previous `try` had no `do`")
+
 (assert_malformed
   (module quote
     "(func (try (catch $exn)))"
@@ -14,15 +20,15 @@
 
 (assert_malformed
   (module quote
-    "(func (try (do)))"
+    "(func (try (do) (unreachable)))"
   )
-  "previous `try` had no `catch`")
+  "expected a `catch`, `catch_all`, or `delegate`")
 
 (assert_malformed
   (module quote
-    "(func (try (do) (unreachable)))"
+    "(func (try (do) (catch_all) (unreachable)))"
   )
-  "previous `try` had no `catch`")
+  "too many payloads inside of `(try)`")
 
 (assert_malformed
   (module quote

tests/local/try.wat

@@ -3,6 +3,7 @@
 (module $m
   (type (func))
   (event $exn (type 0))
+  (func (try (do)))
   (func (try (do) (catch $exn)))
   (func (try (do) (catch $exn rethrow 0)))
   (func (try (do) (catch_all rethrow 0)))

tests/roundtrip.rs

@@ -280,6 +280,9 @@ impl TestState {
             // FIXME wabt doesn't print conflict or empty names in the same way
             // that we do.
             && !test.ends_with("local/names.wast")
+
+            // FIXME this can be removed once wabt support for catch-less try is merged
+            && !test.ends_with("local/try.wat")
         {
             if let Some(expected) = self.wasm2wat(contents)? {
                 self.string_compare(&string, &expected)