[wasm] JS-API: enable WebAssembly.instantiate tests; fix LinkError

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 23 matching lines @@
     .exportAs("f");
   return new Int8Array(builder.toBuffer());
 })();
 
 let importingModuleBinary = (() => {
   var builder = new WasmModuleBuilder();
   builder.addImport("", "f", kSig_i_v);
   return new Int8Array(builder.toBuffer());
 })();
 
+let memoryImportingModuleBinary = (() => {
+  var builder = new WasmModuleBuilder();
+  builder.addImportedMemory("", "my_memory");
+  return new Int8Array(builder.toBuffer());
+})();
+
 let moduleBinaryImporting2Memories = (() => {
   var builder = new WasmModuleBuilder();
   builder.addImportedMemory("", "memory1");
   builder.addImportedMemory("", "memory2");
   return new Int8Array(builder.toBuffer());
 })();
 
 let moduleBinaryWithMemSectionAndMemImport = (() => {
   var builder = new WasmModuleBuilder();
   builder.addMemory(1, 1, false);
@@ skipping 195 matching lines @@
 assertEq(typeof instanceDesc.value, "function");
 assertEq(instanceDesc.writable, true);
 assertEq(instanceDesc.enumerable, false);
 assertEq(instanceDesc.configurable, true);
 
 // 'WebAssembly.Instance' constructor function
 let Instance = WebAssembly.Instance;
 assertEq(Instance, instanceDesc.value);
 assertEq(Instance.length, 1);
 assertEq(Instance.name, "Instance");
+
 assertErrorMessage(() => Instance(), TypeError, /constructor without new is forbidden/);
 assertErrorMessage(() => new Instance(1), TypeError, "first argument must be a WebAssembly.Module");
 assertErrorMessage(() => new Instance({}), TypeError, "first argument must be a WebAssembly.Module");
 assertErrorMessage(() => new Instance(emptyModule, null), TypeError, "second argument must be an object");
+assertErrorMessage(() => new Instance(importingModule, null), TypeError, "");
+assertErrorMessage(() => new Instance(importingModule, undefined), TypeError, "");
+assertErrorMessage(() => new Instance(importingModule, {"":{g:()=>{}}}), LinkError, "");
+assertErrorMessage(() => new Instance(importingModule, {t:{f:()=>{}}}), LinkError, "");
+
 assertEq(new Instance(emptyModule) instanceof Instance, true);
 assertEq(new Instance(emptyModule, {}) instanceof Instance, true);
 
 // 'WebAssembly.Instance.prototype' data property
 let instanceProtoDesc = Object.getOwnPropertyDescriptor(Instance, 'prototype');
 assertEq(typeof instanceProtoDesc.value, "object");
 assertEq(instanceProtoDesc.writable, false);
 assertEq(instanceProtoDesc.enumerable, false);
 assertEq(instanceProtoDesc.configurable, false);
 
@@ skipping 280 matching lines @@
 //TODO assertCompileError([new ArrayBuffer()], CompileError, /failed to match magic number/);
 function assertCompileSuccess(bytes) {
     var module = null;
     compile(bytes).then(m => module = m);
     drainJobQueue();
     assertEq(module instanceof Module, true);
 }
 assertCompileSuccess(emptyModuleBinary);
 assertCompileSuccess(emptyModuleBinary.buffer);
 
-if (false) {  // TODO: implement WebAssembly.instantiate
-  // 'WebAssembly.instantiate' data property
-  let instantiateDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'instantiate');
-  assertEq(typeof instantiateDesc.value, "function");
-  assertEq(instantiateDesc.writable, true);
-  assertEq(instantiateDesc.enumerable, false);
-  assertEq(instantiateDesc.configurable, true);
+// 'WebAssembly.instantiate' data property
+let instantiateDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'instantiate');
+assertEq(typeof instantiateDesc.value, "function");
+assertEq(instantiateDesc.writable, true);
+assertEq(instantiateDesc.enumerable, false);
+assertEq(instantiateDesc.configurable, true);
 
-  // 'WebAssembly.instantiate' function
-  let instantiate = WebAssembly.instantiate;
-  assertEq(instantiate, instantiateDesc.value);
-  assertEq(instantiate.length, 2);
-  assertEq(instantiate.name, "instantiate");
-  function assertInstantiateError(args, err, msg) {
-    var error = null;
-    try {
-      instantiate(...args).catch(e => error = e);
-    } catch(e) {
-      error = e;
-    }
-    drainJobQueue();
-    assertEq(error instanceof err, true);
-    assertEq(Boolean(error.stack.match("jsapi.js")), true);
-    assertEq(Boolean(error.message.match(msg)), true);
+// 'WebAssembly.instantiate' function
+let instantiate = WebAssembly.instantiate;
+assertEq(instantiate, instantiateDesc.value);
+assertEq(instantiate.length, 1);
+assertEq(instantiate.name, "instantiate");
+function assertInstantiateError(args, err, msg) {
+  var error = null;
+  try {
+    instantiate(...args).catch(e => error = e);
+  } catch(e) {
+    error = e;
   }
-  assertInstantiateError([], TypeError, /requires more than 0 arguments/);
-  assertInstantiateError([undefined], TypeError, /first argument must be a WebAssembly.Module, ArrayBuffer or typed array object/);
-  assertInstantiateError([1], TypeError, /first argument must be a WebAssembly.Module, ArrayBuffer or typed array object/);
-  assertInstantiateError([{}], TypeError, /first argument must be a WebAssembly.Module, ArrayBuffer or typed array object/);
-  assertInstantiateError([new Uint8Array()], CompileError, /failed to match magic number/);
-  assertInstantiateError([new ArrayBuffer()], 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/);
-  function assertInstantiateSuccess(module, imports) {
-    var result = null;
-    instantiate(module, imports).then(r => result = r);
-    drainJobQueue();
-    if (module instanceof Module) {
-      assertEq(result instanceof Instance, true);
-    } else {
-      assertEq(result.module instanceof Module, true);
-      assertEq(result.instance instanceof Instance, true);
-    }
-  }
-  assertInstantiateSuccess(emptyModule);
-  assertInstantiateSuccess(emptyModuleBinary);
-  assertInstantiateSuccess(emptyModuleBinary.buffer);
-  assertInstantiateSuccess(importingModule, {"":{f:()=>{}}});
-  assertInstantiateSuccess(importingModuleBinary, {"":{f:()=>{}}});
-  assertInstantiateSuccess(importingModuleBinary.buffer, {"":{f:()=>{}}});
+  drainJobQueue();
+  assertEq(error instanceof err, true);
+  assertEq(Boolean(error.stack.match("js-api.js")), true);
+  //TOassertEq(Boolean(error.message.match(msg)), true);
 }
+var scratch_memory = new WebAssembly.Memory(new ArrayBuffer(10));
+assertInstantiateError([], TypeError, /requires more than 0 arguments/);
+assertInstantiateError([undefined], TypeError, /first argument must be a BufferSource/);
+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) {
+  var result = null;
+  instantiate(module_bytes, imports).then(r => result = r).catch(e => print(e));
+  drainJobQueue();
+  assertEq(result instanceof Instance, true);

[Derek Schuff, 2017/01/20 01:46:19]

Drive-by review! This is a change in behavior from the previous overload of
WebAssembly.instantiate where the first argument is the bytes instead of a
WebAssembly.Module. As tested in line 605 from before this change, it's supposed
to return an object that has an instance property, not the instance itself (c.f.
https://github.com/WebAssembly/design/blob/master/JS.md#webassemblyinstantiate).

+}
+assertInstantiateSuccess(emptyModuleBinary);
+assertInstantiateSuccess(emptyModuleBinary.buffer);
+assertInstantiateSuccess(importingModuleBinary, {"":{f:()=>{}}});
+assertInstantiateSuccess(importingModuleBinary.buffer, {"":{f:()=>{}}});
+assertInstantiateSuccess(memoryImportingModuleBinary, {"": {"my_memory": scratch_memory}});