Make .prototype properties of Wasm constructors read-only

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() };
 }
 
 load("test/mjsunit/wasm/wasm-constants.js");
 load("test/mjsunit/wasm/wasm-module-builder.js");
 
 function assertEq(val, expected) {
   assertEquals(expected, val);
 }
 function wasmIsSupported() {
   return (typeof WebAssembly.Module) == "function";
 }
 function assertErrorMessage(func, type, msg) {
 //TODO   assertThrows(func, type, msg);
   assertThrows(func, type);
 }
 
-let PROP_FLAGS = false;  // property flags are implemented correctly
-
 let emptyModuleBinary = (() => {
   var builder = new WasmModuleBuilder();
   return new Int8Array(builder.toBuffer());
 })();
 
 let exportingModuleBinary = (() => {
   var builder = new WasmModuleBuilder();
   builder.addFunction("f", kSig_i_v)
     .addBody([kExprI32Const, 42])
     .exportAs("f");
@@ skipping 86 matching lines @@
 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);
 
 // 'WebAssembly.Module.prototype' data property
 let moduleProtoDesc = Object.getOwnPropertyDescriptor(Module, 'prototype');
 assertEq(typeof moduleProtoDesc.value, "object");
-if (PROP_FLAGS) assertEq(moduleProtoDesc.writable, false);
-if (PROP_FLAGS) assertEq(moduleProtoDesc.enumerable, false);
-if (PROP_FLAGS) assertEq(moduleProtoDesc.configurable, false);
+assertEq(moduleProtoDesc.writable, false);
+assertEq(moduleProtoDesc.enumerable, false);
+assertEq(moduleProtoDesc.configurable, false);
 
 // 'WebAssembly.Module.prototype' object
 let moduleProto = Module.prototype;
 assertEq(moduleProto, moduleProtoDesc.value);
 assertEq(String(moduleProto), "[object Object]");
 assertEq(Object.getPrototypeOf(moduleProto), Object.prototype);
 
 // 'WebAssembly.Module' instance objects
 let emptyModule = new Module(emptyModuleBinary);
 let importingModule = new Module(importingModuleBinary);
@@ skipping 81 matching lines @@
 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");
-if (PROP_FLAGS) assertEq(instanceProtoDesc.writable, false);
-if (PROP_FLAGS) assertEq(instanceProtoDesc.enumerable, false);
-if (PROP_FLAGS) assertEq(instanceProtoDesc.configurable, false);
+assertEq(instanceProtoDesc.writable, false);
+assertEq(instanceProtoDesc.enumerable, false);
+assertEq(instanceProtoDesc.configurable, false);
 
 // 'WebAssembly.Instance.prototype' object
 let instanceProto = Instance.prototype;
 assertEq(instanceProto, instanceProtoDesc.value);
 assertEq(String(instanceProto), "[object Object]");
 assertEq(Object.getPrototypeOf(instanceProto), Object.prototype);
 
 // 'WebAssembly.Instance' instance objects
 let exportingInstance = new Instance(exportingModule);
 assertEq(typeof exportingInstance, "object");
@@ skipping 34 matching lines @@
 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);
 
 // 'WebAssembly.Memory.prototype' data property
 let memoryProtoDesc = Object.getOwnPropertyDescriptor(Memory, 'prototype');
 assertEq(typeof memoryProtoDesc.value, "object");
-if (PROP_FLAGS) assertEq(memoryProtoDesc.writable, false);
-if (PROP_FLAGS) assertEq(memoryProtoDesc.enumerable, false);
-if (PROP_FLAGS) assertEq(memoryProtoDesc.configurable, false);
+assertEq(memoryProtoDesc.writable, false);
+assertEq(memoryProtoDesc.enumerable, false);
+assertEq(memoryProtoDesc.configurable, false);
 
 // 'WebAssembly.Memory.prototype' object
 let memoryProto = Memory.prototype;
 assertEq(memoryProto, memoryProtoDesc.value);
 assertEq(String(memoryProto), "[object Object]");
 assertEq(Object.getPrototypeOf(memoryProto), Object.prototype);
 
 // 'WebAssembly.Memory' instance objects
 let mem1 = new Memory({initial:1});
 assertEq(typeof mem1, "object");
@@ skipping 69 matching lines @@
 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/);
 assertEq(new Table({initial:1, element:"anyfunc"}) instanceof Table, true);
 assertEq(new Table({initial:1.5, element:"anyfunc"}) instanceof Table, true);
 assertEq(new Table({initial:1, maximum:1.5, element:"anyfunc"}) instanceof Table, true);
 //TODO:maximum assertEq(new Table({initial:1, maximum:Math.pow(2,32)-1, element:"anyfunc"}) instanceof Table, true);
 
 // 'WebAssembly.Table.prototype' data property
 let tableProtoDesc = Object.getOwnPropertyDescriptor(Table, 'prototype');
 assertEq(typeof tableProtoDesc.value, "object");
-if (PROP_FLAGS) assertEq(tableProtoDesc.writable, false);
-if (PROP_FLAGS) assertEq(tableProtoDesc.enumerable, false);
-if (PROP_FLAGS) assertEq(tableProtoDesc.configurable, false);
+assertEq(tableProtoDesc.writable, false);
+assertEq(tableProtoDesc.enumerable, false);
+assertEq(tableProtoDesc.configurable, false);
 
 // 'WebAssembly.Table.prototype' object
 let tableProto = Table.prototype;
 assertEq(tableProto, tableProtoDesc.value);
 assertEq(String(tableProto), "[object Object]");
 assertEq(Object.getPrototypeOf(tableProto), Object.prototype);
 
 // 'WebAssembly.Table' instance objects
 let tbl1 = new Table({initial:2, element:"anyfunc"});
 assertEq(typeof tbl1, "object");
@@ skipping 166 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:()=>{}}});
 }