Test traps from start function; check JS Error classes

ml-proto/README.md

@@ -275,6 +275,7 @@ assertion:
   ( assert_malformed <module> <failure> )    ;; assert module cannot be decoded with given failure string
   ( assert_invalid <module> <failure> )      ;; assert module is invalid with given failure string
   ( assert_unlinkable <module> <failure> )   ;; assert module fails to link
+  ( assert_trap <module> <failure> )         ;; assert module traps on instantiation
 
 meta:
   ( script <name>? <script> )                ;; name a subscript

ml-proto/host/arrange.ml

@@ -413,6 +413,8 @@ let assertion mode ass =
     Node ("assert_invalid", [definition mode None def; Atom (string re)])
   | AssertUnlinkable (def, re) ->
     Node ("assert_unlinkable", [definition mode None def; Atom (string re)])
+  | AssertUninstantiable (def, re) ->
+    Node ("assert_trap", [definition mode None def; Atom (string re)])
   | AssertReturn (act, lits) ->
     Node ("assert_return", action act :: List.map literal lits)
   | AssertReturnNaN act ->

ml-proto/host/js.ml

@@ -38,23 +38,39 @@ let prefix =
   "}\n" ^
   "\n" ^
   "function assert_malformed(bytes) {\n" ^
-  "  try { module(bytes) } catch (e) { return }\n" ^
+  "  try { module(bytes) } catch (e) {\n" ^
+  "    if (e instanceof WebAssembly.CompileError) return;\n" ^
+  "  }\n" ^
   "  throw new Error(\"Wasm decoding failure expected\");\n" ^
   "}\n" ^
   "\n" ^
   "function assert_invalid(bytes) {\n" ^
-  "  try { module(bytes) } catch (e) { return }\n" ^
+  "  try { module(bytes) } catch (e) {\n" ^
+  "    if (e instanceof WebAssembly.CompileError) return;\n" ^
+  "  }\n" ^
   "  throw new Error(\"Wasm validation failure expected\");\n" ^
   "}\n" ^
   "\n" ^
   "function assert_unlinkable(bytes) {\n" ^
   "  let mod = module(bytes);\n" ^
-  "  try { new WebAssembly.Instance(mod, registry) } catch (e) { return }\n" ^
+  "  try { new WebAssembly.Instance(mod, registry) } catch (e) {\n" ^
+  "    if (e instanceof TypeError) return;\n" ^
+  "  }\n" ^
   "  throw new Error(\"Wasm linking failure expected\");\n" ^
   "}\n" ^
   "\n" ^
+  "function assert_uninstantiable(bytes) {\n" ^
+  "  let mod = module(bytes);\n" ^
+  "  try { new WebAssembly.Instance(mod, registry) } catch (e) {\n" ^
+  "    if (e instanceof WebAssembly.RuntimeError) return;\n" ^
+  "  }\n" ^
+  "  throw new Error(\"Wasm trap expected\");\n" ^
+  "}\n" ^
+  "\n" ^
   "function assert_trap(action) {\n" ^
-  "  try { action() } catch (e) { return }\n" ^
+  "  try { action() } catch (e) {\n" ^
+  "    if (e instanceof WebAssembly.RuntimeError) return;\n" ^
+  "  }\n" ^
   "  throw new Error(\"Wasm trap expected\");\n" ^
   "}\n" ^
   "\n" ^
@@ -259,6 +275,8 @@ let of_assertion mods ass =
     "assert_invalid(" ^ of_definition def ^ ");"
   | AssertUnlinkable (def, _) ->
     "assert_unlinkable(" ^ of_definition def ^ ");"
+  | AssertUninstantiable (def, _) ->
+    "assert_uninstantiable(" ^ of_definition def ^ ");"
   | AssertReturn (act, lits) ->
     of_return_assertion mods act
       (fun act_js ->

ml-proto/host/parser.mly

@@ -693,6 +693,8 @@ assertion :
     { AssertInvalid (snd $3, $4) @@ at () }
   | LPAR ASSERT_UNLINKABLE module_ TEXT RPAR
     { AssertUnlinkable (snd $3, $4) @@ at () }
+  | LPAR ASSERT_TRAP module_ TEXT RPAR
+    { AssertUninstantiable (snd $3, $4) @@ at () }
   | LPAR ASSERT_RETURN action const_list RPAR { AssertReturn ($3, $4) @@ at () }
   | LPAR ASSERT_RETURN_NAN action RPAR { AssertReturnNaN $3 @@ at () }
   | LPAR ASSERT_TRAP action TEXT RPAR { AssertTrap ($3, $4) @@ at () }

ml-proto/host/run.ml

@@ -305,6 +305,24 @@ let run_assertion ass =
       Assert.error ass.at "expected linking error"
     )
 
+  | AssertUninstantiable (def, re) ->
+    trace "Asserting trap...";
+    let m = run_definition def in
+    if not !Flags.unchecked then Check.check_module m;
+    (match
+      let imports = Import.link m in
+      ignore (Eval.init m imports)
+    with
+    | exception Eval.Trap (_, msg) ->
+      if not (Str.string_match (Str.regexp re) msg 0) then begin
+        print_endline ("Result: \"" ^ msg ^ "\"");
+        print_endline ("Expect: \"" ^ re ^ "\"");
+        Assert.error ass.at "wrong instantiation trap"
+      end
+    | _ ->
+      Assert.error ass.at "expected instaniation trap"
+    )
+
   | AssertReturn (act, es) ->
     trace ("Asserting return...");
     let got_vs = run_action act in

ml-proto/host/script.ml

@@ -15,6 +15,7 @@ and assertion' =
   | AssertMalformed of definition * string
   | AssertInvalid of definition * string
   | AssertUnlinkable of definition * string
+  | AssertUninstantiable of definition * string
   | AssertReturn of action * Ast.literal list
   | AssertReturnNaN of action
   | AssertTrap of action * string

ml-proto/test/start.wast

@@ -86,3 +86,8 @@
   (func $main (call $print_i32 (i32.const 2)))
   (start $main)
 )
+
+(assert_trap
+  (module (func $main (unreachable)) (start $main))
+  "unreachable"
+)