[wasm] Set JS API names and function lengths appropriately.

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 36 matching lines @@
 let wasmDesc = Object.getOwnPropertyDescriptor(this, 'WebAssembly');
 assertEq(typeof wasmDesc.value, "object");
 assertEq(wasmDesc.writable, true);
 assertEq(wasmDesc.enumerable, false);
 assertEq(wasmDesc.configurable, true);
 
 // 'WebAssembly' object
 assertEq(WebAssembly, wasmDesc.value);
 //TODO assertEq(String(WebAssembly), "[object WebAssembly]");
 
-// 'WebAssembly.(Compile|Runtime)Error' data property
+// 'WebAssembly.CompileError'
 let compileErrorDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'CompileError');
+assertEq(typeof compileErrorDesc.value, "function");
+assertEq(compileErrorDesc.writable, true);
+assertEq(compileErrorDesc.enumerable, false);
+assertEq(compileErrorDesc.configurable, true);
+let CompileError = WebAssembly.CompileError;
+assertEq(CompileError, compileErrorDesc.value);
+assertEq(CompileError.length, 1);
+assertEq(CompileError.name, "CompileError");
+let compileError = new CompileError;
+assertEq(compileError instanceof CompileError, true);
+assertEq(compileError instanceof Error, true);
+assertEq(compileError instanceof TypeError, false);
+assertEq(compileError.message, "");
+assertEq(new CompileError("hi").message, "hi");
+
+// 'WebAssembly.RuntimeError'
 let runtimeErrorDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'RuntimeError');
-assertEq(typeof compileErrorDesc.value, "function");
 assertEq(typeof runtimeErrorDesc.value, "function");
-if (PROP_FLAGS) assertEq(compileErrorDesc.writable, true);
-if (PROP_FLAGS) assertEq(runtimeErrorDesc.writable, true);
-if (PROP_FLAGS) assertEq(compileErrorDesc.enumerable, false);
-if (PROP_FLAGS) assertEq(runtimeErrorDesc.enumerable, false);
-if (PROP_FLAGS) assertEq(compileErrorDesc.configurable, true);
-if (PROP_FLAGS) assertEq(runtimeErrorDesc.configurable, true);
+assertEq(runtimeErrorDesc.writable, true);
+assertEq(runtimeErrorDesc.enumerable, false);
+assertEq(runtimeErrorDesc.configurable, true);
+let RuntimeError = WebAssembly.RuntimeError;
+assertEq(RuntimeError, runtimeErrorDesc.value);
+assertEq(RuntimeError.length, 1);
+assertEq(RuntimeError.name, "RuntimeError");
+let runtimeError = new RuntimeError;
+assertEq(runtimeError instanceof RuntimeError, true);
+assertEq(runtimeError instanceof Error, true);
+assertEq(runtimeError instanceof TypeError, false);
+assertEq(runtimeError.message, "");
+assertEq(new RuntimeError("hi").message, "hi");
 
-// 'WebAssembly.(Compile|Runtime)Error' constructor function
-let CompileError = WebAssembly.CompileError;
-let RuntimeError = WebAssembly.RuntimeError;
-assertEq(CompileError, compileErrorDesc.value);
-assertEq(RuntimeError, runtimeErrorDesc.value);
-assertEq(CompileError.length, 1);
-assertEq(RuntimeError.length, 1);
-assertEq(CompileError.name, "CompileError");
-assertEq(RuntimeError.name, "RuntimeError");
-
-// 'WebAssembly.(Compile|Runtime)Error' instance objects
-let compileError = new CompileError;
-let runtimeError = new RuntimeError;
-assertEq(compileError instanceof CompileError, true);
-assertEq(runtimeError instanceof RuntimeError, true);
-assertEq(compileError instanceof Error, true);
-assertEq(runtimeError instanceof Error, true);
-assertEq(compileError instanceof TypeError, false);
-assertEq(runtimeError instanceof TypeError, false);
-assertEq(compileError.message, "");
-assertEq(runtimeError.message, "");
-assertEq(new CompileError("hi").message, "hi");
-assertEq(new RuntimeError("hi").message, "hi");
+// 'WebAssembly.LinkError'
+let linkErrorDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'LinkError');
+assertEq(typeof linkErrorDesc.value, "function");
+assertEq(linkErrorDesc.writable, true);
+assertEq(linkErrorDesc.enumerable, false);
+assertEq(linkErrorDesc.configurable, true);
+let LinkError = WebAssembly.LinkError;
+assertEq(LinkError, linkErrorDesc.value);
+assertEq(LinkError.length, 1);
+assertEq(LinkError.name, "LinkError");
+let linkError = new LinkError;
+assertEq(linkError instanceof LinkError, true);
+assertEq(linkError instanceof Error, true);
+assertEq(linkError instanceof TypeError, false);
+assertEq(linkError.message, "");
+assertEq(new LinkError("hi").message, "hi");
 
 // 'WebAssembly.Module' data property
 let moduleDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Module');
 assertEq(typeof moduleDesc.value, "function");
 assertEq(moduleDesc.writable, true);
 assertEq(moduleDesc.enumerable, false);
 assertEq(moduleDesc.configurable, true);
 
 // 'WebAssembly.Module' constructor function
 let Module = WebAssembly.Module;
 assertEq(Module, moduleDesc.value);
-//TODO assertEq(Module.length, 1);
-//TODO assertEq(Module.name, "Module");
+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");
 //TODO assertErrorMessage(() => new Module(new Uint8Array()), CompileError, /failed to match magic number/);
 //TODO assertErrorMessage(() => new Module(new ArrayBuffer()), CompileError, /failed to match magic number/);
 assertEq(new Module(emptyModuleBinary) instanceof Module, true);
 assertEq(new Module(emptyModuleBinary.buffer) instanceof Module, true);
 
@@ skipping 85 matching lines @@
 // 'WebAssembly.Instance' data property
 let instanceDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Instance');
 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);
-//TODO assertEq(Instance.length, 1);
-//TODO assertEq(Instance.name, "Instance");
+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");
 //TODO assertErrorMessage(() => new Instance(emptyModule, null), TypeError, "second argument must be an object");
 //TODO assertEq(new Instance(emptyModule) instanceof Instance, true);
 //TODO assertEq(new Instance(emptyModule, {}) instanceof Instance, true);
 
 // 'WebAssembly.Instance.prototype' data property
 let instanceProtoDesc = Object.getOwnPropertyDescriptor(Instance, 'prototype');
 assertEq(typeof instanceProtoDesc.value, "object");
@@ skipping 31 matching lines @@
 // 'WebAssembly.Memory' data property
 let memoryDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Memory');
 assertEq(typeof memoryDesc.value, "function");
 assertEq(memoryDesc.writable, true);
 assertEq(memoryDesc.enumerable, false);
 assertEq(memoryDesc.configurable, true);
 
 // 'WebAssembly.Memory' constructor function
 let Memory = WebAssembly.Memory;
 assertEq(Memory, memoryDesc.value);
-//TODO assertEq(Memory.length, 1);
-//TODO assertEq(Memory.name, "Memory");
+assertEq(Memory.length, 1);
+assertEq(Memory.name, "Memory");
 assertErrorMessage(() => Memory(), TypeError, /constructor without new is forbidden/);
 assertErrorMessage(() => new Memory(1), TypeError, "first argument must be a memory descriptor");
 assertErrorMessage(() => new Memory({initial:{valueOf() { throw new Error("here")}}}), Error, "here");
 assertErrorMessage(() => new Memory({initial:-1}), RangeError, /bad Memory initial size/);
 assertErrorMessage(() => new Memory({initial:Math.pow(2,32)}), RangeError, /bad Memory initial size/);
 assertErrorMessage(() => new Memory({initial:1, maximum: Math.pow(2,32)/Math.pow(2,14) }), RangeError, /bad Memory maximum size/);
 assertErrorMessage(() => new Memory({initial:2, maximum:1 }), RangeError, /bad Memory maximum size/);
 assertErrorMessage(() => new Memory({maximum: -1 }), RangeError, /bad Memory maximum size/);
 assertEq(new Memory({initial:1}) instanceof Memory, true);
 assertEq(new Memory({initial:1.5}).buffer.byteLength, kPageSize);
@@ skipping 66 matching lines @@
 // 'WebAssembly.Table' data property
 let tableDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Table');
 assertEq(typeof tableDesc.value, "function");
 assertEq(tableDesc.writable, true);
 assertEq(tableDesc.enumerable, false);
 assertEq(tableDesc.configurable, true);
 
 // 'WebAssembly.Table' constructor function
 let Table = WebAssembly.Table;
 assertEq(Table, tableDesc.value);
-//TODO assertEq(Table.length, 1);
-//TODO assertEq(Table.name, "Table");
+assertEq(Table.length, 1);
+assertEq(Table.name, "Table");
 assertErrorMessage(() => Table(), TypeError, /constructor without new is forbidden/);
 assertErrorMessage(() => new Table(1), TypeError, "first argument must be a table descriptor");
 assertErrorMessage(() => new Table({initial:1, element:1}), TypeError, /must be "anyfunc"/);
 assertErrorMessage(() => new Table({initial:1, element:"any"}), TypeError, /must be "anyfunc"/);
 assertErrorMessage(() => new Table({initial:1, element:{valueOf() { return "anyfunc" }}}), TypeError, /must be "anyfunc"/);
 assertErrorMessage(() => new Table({initial:{valueOf() { throw new Error("here")}}, element:"anyfunc"}), Error, "here");
 assertErrorMessage(() => new Table({initial:-1, element:"anyfunc"}), RangeError, /bad Table initial size/);
 assertErrorMessage(() => new Table({initial:Math.pow(2,32), element:"anyfunc"}), RangeError, /bad Table initial size/);
 assertErrorMessage(() => new Table({initial:2, maximum:1, element:"anyfunc"}), RangeError, /bad Table maximum size/);
 assertErrorMessage(() => new Table({initial:2, maximum:Math.pow(2,32), element:"anyfunc"}), RangeError, /bad Table maximum size/);
@@ skipping 37 matching lines @@
 assertEq(lengthGetter.call(tbl1), 2);
 
 // 'WebAssembly.Table.prototype.get' data property
 let getDesc = Object.getOwnPropertyDescriptor(tableProto, 'get');
 assertEq(typeof getDesc.value, "function");
 assertEq(getDesc.enumerable, false);
 assertEq(getDesc.configurable, true);
 
 // 'WebAssembly.Table.prototype.get' method
 let get = getDesc.value;
-//TODO:length assertEq(get.length, 1);
+assertEq(get.length, 1);
 assertErrorMessage(() => get.call(), TypeError, /called on incompatible undefined/);
 assertErrorMessage(() => get.call({}), TypeError, /called on incompatible Object/);
 assertEq(get.call(tbl1, 0), null);
 assertEq(get.call(tbl1, 1), null);
 assertEq(get.call(tbl1, 1.5), null);
 assertErrorMessage(() => get.call(tbl1, 2), RangeError, /bad Table get index/);
 assertErrorMessage(() => get.call(tbl1, 2.5), RangeError, /bad Table get index/);
 assertErrorMessage(() => get.call(tbl1, -1), RangeError, /bad Table get index/);
 //TODO assertErrorMessage(() => get.call(tbl1, Math.pow(2,33)), RangeError, /bad Table get index/);
 assertErrorMessage(() => get.call(tbl1, {valueOf() { throw new Error("hi") }}), Error, "hi");
 
 // 'WebAssembly.Table.prototype.set' data property
 let setDesc = Object.getOwnPropertyDescriptor(tableProto, 'set');
 assertEq(typeof setDesc.value, "function");
 assertEq(setDesc.enumerable, false);
 assertEq(setDesc.configurable, true);
 
 // 'WebAssembly.Table.prototype.set' method
 let set = setDesc.value;
-//TODO assertEq(set.length, 2);
+assertEq(set.length, 2);
 assertErrorMessage(() => set.call(), TypeError, /called on incompatible undefined/);
 assertErrorMessage(() => set.call({}), TypeError, /called on incompatible Object/);
 assertErrorMessage(() => set.call(tbl1, 0), TypeError, /requires more than 1 argument/);
 assertErrorMessage(() => set.call(tbl1, 2, null), RangeError, /bad Table set index/);
 assertErrorMessage(() => set.call(tbl1, -1, null), RangeError, /bad Table set index/);
 //TODO assertErrorMessage(() => set.call(tbl1, Math.pow(2,33), null), RangeError, /bad Table set index/);
 assertErrorMessage(() => set.call(tbl1, 0, undefined), TypeError, /can only assign WebAssembly exported functions to Table/);
 assertErrorMessage(() => set.call(tbl1, 0, {}), TypeError, /can only assign WebAssembly exported functions to Table/);
 assertErrorMessage(() => set.call(tbl1, 0, function() {}), TypeError, /can only assign WebAssembly exported functions to Table/);
 assertErrorMessage(() => set.call(tbl1, 0, Math.sin), TypeError, /can only assign WebAssembly exported functions to Table/);
 assertErrorMessage(() => set.call(tbl1, {valueOf() { throw Error("hai") }}, null), Error, "hai");
 assertEq(set.call(tbl1, 0, null), undefined);
 assertEq(set.call(tbl1, 1, null), undefined);
 
 // 'WebAssembly.Table.prototype.grow' data property
 let tblGrowDesc = Object.getOwnPropertyDescriptor(tableProto, 'grow');
 assertEq(typeof tblGrowDesc.value, "function");
 assertEq(tblGrowDesc.enumerable, false);
 assertEq(tblGrowDesc.configurable, true);
 
 // 'WebAssembly.Table.prototype.grow' method
 if (false) { // TODO: Table.grow
 let tblGrow = tblGrowDesc.value;
-//TODO assertEq(tblGrow.length, 1);
+assertEq(tblGrow.length, 1);
 assertErrorMessage(() => tblGrow.call(), TypeError, /called on incompatible undefined/);
 assertErrorMessage(() => tblGrow.call({}), TypeError, /called on incompatible Object/);
 assertErrorMessage(() => tblGrow.call(tbl1, -1), RangeError, /bad Table grow delta/);
 assertErrorMessage(() => tblGrow.call(tbl1, Math.pow(2,32)), RangeError, /bad Table grow delta/);
 var tbl = new Table({element:"anyfunc", initial:1, maximum:2});
 assertEq(tbl.length, 1);
 assertEq(tbl.grow(0), 1);
 assertEq(tbl.length, 1);
 assertEq(tbl.grow(1), 1);
 assertEq(tbl.length, 2);
 assertErrorMessage(() => tbl.grow(1), Error, /failed to grow table/);
 }
 
 // 'WebAssembly.compile' data property
 let compileDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'compile');
 assertEq(typeof compileDesc.value, "function");
 assertEq(compileDesc.writable, true);
 assertEq(compileDesc.enumerable, false);
 assertEq(compileDesc.configurable, true);
 
 // 'WebAssembly.compile' function
 let compile = WebAssembly.compile;
 assertEq(compile, compileDesc.value);
-//TODO assertEq(compile.length, 1);
-//TODO assertEq(compile.name, "compile");
+assertEq(compile.length, 1);
+assertEq(compile.name, "compile");
 function assertCompileError(args, err, msg) {
   var error = null;
   try {
     compile(...args).catch(e => error = e);
   } catch (e) {
     // TODO: error shouldn't be thrown, but should be globbed onto the promise.
     error = e;
   }
   drainJobQueue();
   assertEq(error instanceof err, true);
@@ skipping 60 matching lines @@
       assertEq(result.instance instanceof Instance, true);
     }
   }
   assertInstantiateSuccess(emptyModule);
   assertInstantiateSuccess(emptyModuleBinary);
   assertInstantiateSuccess(emptyModuleBinary.buffer);
   assertInstantiateSuccess(importingModule, {"":{f:()=>{}}});
   assertInstantiateSuccess(importingModuleBinary, {"":{f:()=>{}}});
   assertInstantiateSuccess(importingModuleBinary.buffer, {"":{f:()=>{}}});
 }