[wasm] WebAssembly.instantiate has a pair-returning overload

test/mjsunit/wasm/js-api.js

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --expose-wasm --allow-natives-syntax
 
 if ((typeof drainJobQueue) != "function") {
   drainJobQueue = () => { %RunMicrotasks() };
 }
 
@@ skipping 124 matching lines @@
 assertEq(Module, moduleDesc.value);
 assertEq(Module.length, 1);
 assertEq(Module.name, "Module");
 assertErrorMessage(() => Module(), TypeError, /constructor without new is forbidden/);
 assertErrorMessage(() => new Module(), TypeError, /requires more than 0 arguments/);
 assertErrorMessage(() => new Module(undefined), TypeError, "first argument must be an ArrayBuffer or typed array object");
 assertErrorMessage(() => new Module(1), TypeError, "first argument must be an ArrayBuffer or typed array object");
 assertErrorMessage(() => new Module({}), TypeError, "first argument must be an ArrayBuffer or typed array object");
 assertErrorMessage(() => new Module(new Uint8Array()), CompileError, /failed to match magic number/);
 assertErrorMessage(() => new Module(new ArrayBuffer()), CompileError, /failed to match magic number/);
+assertErrorMessage(
+    () => new Module(importingModuleBinary, {'': {f: () => {}}}), TypeError,
+    /TODO error message/);
 assertEq(new Module(emptyModuleBinary) instanceof Module, true);
 assertEq(new Module(emptyModuleBinary.buffer) instanceof Module, true);
 
 // 'WebAssembly.Module.prototype' data property
 let moduleProtoDesc = Object.getOwnPropertyDescriptor(Module, 'prototype');
 assertEq(typeof moduleProtoDesc.value, "object");
 assertEq(moduleProtoDesc.writable, false);
 assertEq(moduleProtoDesc.enumerable, false);
 assertEq(moduleProtoDesc.configurable, false);
 
@@ skipping 447 matching lines @@
 assertInstantiateError([1], TypeError, /first argument must be a BufferSource/);
 assertInstantiateError([{}], TypeError, /first argument must be a BufferSource/);
 assertInstantiateError([new Uint8Array()], CompileError, /failed to match magic number/);
 assertInstantiateError([new ArrayBuffer()], CompileError, /failed to match magic number/);
 assertInstantiateError([new Uint8Array("hi!")], CompileError, /failed to match magic number/);
 assertInstantiateError([new ArrayBuffer("hi!")], CompileError, /failed to match magic number/);
 assertInstantiateError([importingModule], TypeError, /second argument must be an object/);
 assertInstantiateError([importingModule, null], TypeError, /second argument must be an object/);
 assertInstantiateError([importingModuleBinary, null], TypeError, /second argument must be an object/);
 assertInstantiateError([emptyModule, null], TypeError, /first argument must be a BufferSource/);
-assertInstantiateError([importingModule, {"":{f:()=>{}}}], TypeError, /first argument must be a BufferSource/);
 assertInstantiateError([importingModuleBinary, null], TypeError, /TODO: error messages?/);
 assertInstantiateError([importingModuleBinary, undefined], TypeError, /TODO: error messages?/);
 assertInstantiateError([importingModuleBinary, {}], LinkError, /TODO: error messages?/);
 assertInstantiateError([importingModuleBinary, {"":{g:()=>{}}}], LinkError, /TODO: error messages?/);
 assertInstantiateError([importingModuleBinary, {t:{f:()=>{}}}], LinkError, /TODO: error messages?/);
 assertInstantiateError([memoryImportingModuleBinary, null], TypeError, /TODO: error messages?/);
 assertInstantiateError([memoryImportingModuleBinary, undefined], TypeError, /TODO: error messages?/);
 assertInstantiateError([memoryImportingModuleBinary, {}], LinkError, /TODO: error messages?/);
 assertInstantiateError([memoryImportingModuleBinary, {"mod": {"my_memory": scratch_memory}}], LinkError, /TODO: error messages?/);
 assertInstantiateError([memoryImportingModuleBinary, {"": {"memory": scratch_memory}}], LinkError, /TODO: error messages?/);
 
-function assertInstantiateSuccess(module_bytes, imports) {
+function assertInstantiateSuccess(module_or_bytes, imports) {
   var result = null;
-  instantiate(module_bytes, imports).then(r => result = r).catch(e => print(e));
+  instantiate(module_or_bytes, imports)
+      .then(r => result = r)
+      .catch(e => print(e));
   drainJobQueue();
-  assertEq(result instanceof Instance, true);
+  if (module_or_bytes instanceof Module) {
+    assertEq(result instanceof Instance, true);
+  } else {
+    assertEq(result.module instanceof Module, true);

[rossberg, 2017/01/20 09:56:54]

Nit: Using assertTrue would make this less redundant.

[Mircea Trofin, 2017/01/20 16:29:53]

Done, and fixed everywhere else, too.

+    assertEq(result.instance instanceof Instance, true);
+  }
 }
+assertInstantiateSuccess(emptyModule);
 assertInstantiateSuccess(emptyModuleBinary);
 assertInstantiateSuccess(emptyModuleBinary.buffer);
+assertInstantiateSuccess(importingModule, {'': {f: () => {}}});
 assertInstantiateSuccess(importingModuleBinary, {"":{f:()=>{}}});
 assertInstantiateSuccess(importingModuleBinary.buffer, {"":{f:()=>{}}});
 assertInstantiateSuccess(memoryImportingModuleBinary, {"": {"my_memory": scratch_memory}});