Use [[Unforgeables]] object for unforgeable properties

Author: ExE-Boss

lib/constructs/attribute.js

@@ -13,16 +13,26 @@ class Attribute {
     this.static = idl.special === "static";
   }
 
+  getWhence() {
+    const { idl } = this;
+    const isOnInstance = utils.isOnInstance(idl, this.interface.idl);
+
+    if (utils.getExtAttr(idl.extAttrs, "LegacyUnforgeable")) {
+      return "unforgeables";
+    }
+
+    return isOnInstance ? "instance" : "prototype";
+  }
+
   generate() {
     const requires = new utils.RequiresMap(this.ctx);
 
-    const configurable = !utils.getExtAttr(this.idl.extAttrs, "LegacyUnforgeable");
+    const whence = this.getWhence();
+    const configurable = whence !== "unforgeables";
     const shouldReflect =
       this.idl.extAttrs.some(attr => attr.name.startsWith("Reflect")) && this.ctx.processReflect !== null;
     const sameObject = utils.getExtAttr(this.idl.extAttrs, "SameObject");
 
-    const onInstance = utils.isOnInstance(this.idl, this.interface.idl);
-
     const async = this.idl.idlType.generic === "Promise";
     const promiseHandlingBefore = async ? `try {` : ``;
     const promiseHandlingAfter = async ? `} catch (e) { return Promise.reject(e); }` : ``;
@@ -40,7 +50,7 @@ class Attribute {
 
     const addMethod = this.static ?
       this.interface.addStaticMethod.bind(this.interface) :
-      this.interface.addMethod.bind(this.interface, onInstance ? "instance" : "prototype");
+      this.interface.addMethod.bind(this.interface, whence);
 
     if (this.static) {
       brandCheck = "";

lib/constructs/interface.js

@@ -57,6 +57,7 @@ class Interface {
 
     this.iterable = null;
     this._analyzed = false;
+    this._needsUnforgeablesObject = false;
 
     this._outputMethods = new Map();
     this._outputStaticMethods = new Map();
@@ -109,14 +110,14 @@ class Interface {
     }
   }
 
-  // whence is either "instance" or "prototype"
+  // whence is either "instance", "prototype" or "unforgeables"
   // type is either "regular", "get", or "set"
   addMethod(whence, propName, args, body, type = "regular", {
     configurable = true,
     enumerable = typeof propName === "string",
     writable = type === "regular" ? true : undefined
   } = {}) {
-    if (whence !== "instance" && whence !== "prototype") {
+    if (whence !== "instance" && whence !== "prototype" && whence !== "unforgeables") {
       throw new Error(`Internal error: Invalid whence ${whence}`);
     }
     if (type !== "regular") {
@@ -139,6 +140,10 @@ class Interface {
 
     const descriptor = { configurable, enumerable, writable };
     this._outputMethods.set(propName, { whence, type, args, body, descriptor });
+
+    if (whence === "unforgeables" && !this.isGlobal) {
+      this._needsUnforgeablesObject = true;
+    }
   }
 
   // type is either "regular", "get", or "set"
@@ -1205,6 +1210,8 @@ class Interface {
   }
 
   generateIface() {
+    const { _needsUnforgeablesObject } = this;
+
     this.str += `
       function makeWrapper(globalObject, newTarget) {
         let proto;
@@ -1252,7 +1259,13 @@ class Interface {
         const wrapper = exports.create(globalObject, constructorArgs, privateData);
         return utils.implForWrapper(wrapper);
       };
+    `;
+
+    if (_needsUnforgeablesObject) {
+      this.generateUnforgeablesObject();
+    }
 
+    this.str += `
       exports._internalSetup = (wrapper, globalObject) => {
     `;
 
@@ -1262,6 +1275,16 @@ class Interface {
       `;
     }
 
+    if (_needsUnforgeablesObject) {
+      this.str += `
+        const unforgeables = getUnforgeables(globalObject);
+        for (const key of Reflect.ownKeys(unforgeables)) {
+          const descriptor = Reflect.getOwnPropertyDescriptor(unforgeables, key);
+          Object.defineProperty(wrapper, key, descriptor);
+        }
+      `;
+    }
+
     this.generateOnInstance();
 
     this.str += `
@@ -1496,6 +1519,7 @@ class Interface {
   }
 
   generateOnInstance() {
+    const { isGlobal } = this;
     const methods = [];
     const props = new Map();
 
@@ -1506,7 +1530,7 @@ class Interface {
     }
 
     for (const [name, { whence, type, args, body, descriptor }] of this._outputMethods) {
-      if (whence !== "instance") {
+      if (whence !== "instance" && (whence !== "unforgeables" || !isGlobal)) {
         continue;
       }
 
@@ -1564,9 +1588,78 @@ class Interface {
     }
   }
 
+  generateUnforgeablesObject() {
+    const methods = [];
+    const props = new Map();
+
+    function addOne(name, args, body) {
+      methods.push(`
+        ${name}(${utils.formatArgs(args)}) {${body}}
+      `);
+    }
+
+    for (const [name, { whence, type, args, body, descriptor }] of this._outputMethods) {
+      if (whence !== "unforgeables") {
+        continue;
+      }
+
+      const propName = utils.stringifyPropertyKey(name);
+      if (type === "regular") {
+        addOne(propName, args, body);
+      } else {
+        if (body[0] !== undefined) {
+          addOne(`get ${propName}`, [], body[0]);
+        }
+        if (body[1] !== undefined) {
+          addOne(`set ${propName}`, args, body[1]);
+        }
+      }
+
+      const descriptorModifier = utils.getPropertyDescriptorModifier(defaultObjectLiteralDescriptor, descriptor, type);
+      if (descriptorModifier === undefined) {
+        continue;
+      }
+      props.set(utils.stringifyPropertyKey(name), descriptorModifier);
+    }
+
+    this.str += `
+      function getUnforgeables(globalObject) {
+        let unforgeables = unforgeablesMap.get(globalObject);
+        if (unforgeables === undefined) {
+          unforgeables = Object.create(
+            null,
+    `;
+
+    if (methods.length > 0) {
+      this.str += `Object.getOwnPropertyDescriptors({ ${methods.join(", ")} }),`;
+    }
+
+    this.str += ");";
+
+    if (props.size > 0) {
+      const propStrs = [...props].map(([name, body]) => `${name}: ${body}`);
+      this.str += `
+          Object.defineProperties(unforgeables, {
+            ${propStrs.join(", ")}
+          });`;
+    }
+
+    this.str += `
+          unforgeablesMap.set(globalObject, unforgeables);
+        }
+        return unforgeables;
+      }
+    `;
+  }
+
   generateInstall() {
     const { idl, name } = this;
 
+    if (this._needsUnforgeablesObject) {
+      this.str += `
+        const unforgeablesMap = new WeakMap();`;
+    }
+
     this.str += `
       const exposed = new Set(${JSON.stringify([...this.exposed])});
 
@@ -1640,6 +1733,7 @@ class Interface {
     this.generateExport();
     this.generateIface();
     this.generateInstall();
+
     if (this.isLegacyPlatformObj) {
       this.generateLegacyProxyHandler();
     }

lib/constructs/operation.js

@@ -15,16 +15,24 @@ class Operation {
     this.static = idl.special === "static";
   }
 
-  isOnInstance() {
-    const firstOverloadOnInstance = utils.isOnInstance(this.idls[0], this.interface.idl);
-    for (const overload of this.idls.slice(1)) {
-      if (utils.isOnInstance(overload, this.interface.idl) !== firstOverloadOnInstance) {
+  getWhence() {
+    const { idls } = this;
+    const firstOverloadOnInstance = utils.isOnInstance(idls[0], this.interface.idl);
+    const hasLegacyUnforgeable = Boolean(utils.getExtAttr(idls[0].extAttrs, "LegacyUnforgeable"));
+
+    for (let i = 1; i < idls.length; i++) {
+      if (Boolean(utils.getExtAttr(idls[i].extAttrs, "LegacyUnforgeable")) !== hasLegacyUnforgeable) {
         throw new Error(
           `[LegacyUnforgeable] is not applied uniformly to operation "${this.name}" on ${this.interface.name}`
         );
       }
     }
-    return firstOverloadOnInstance;
+
+    if (hasLegacyUnforgeable) {
+      return "unforgeables";
+    }
+
+    return firstOverloadOnInstance ? "instance" : "prototype";
   }
 
   isAsync() {
@@ -86,7 +94,7 @@ class Operation {
       throw new Error(`Internal error: this operation does not have a name (in interface ${this.interface.name})`);
     }
 
-    const onInstance = this.isOnInstance();
+    const whence = this.getWhence();
     const async = this.isAsync();
     const promiseHandlingBefore = async ? `try {` : ``;
     const promiseHandlingAfter = async ? `} catch (e) { return Promise.reject(e); }` : ``;
@@ -159,9 +167,9 @@ class Operation {
     if (this.static) {
       this.interface.addStaticMethod(this.name, argNames, str);
     } else {
-      const forgeable = !utils.getExtAttr(this.idls[0].extAttrs, "LegacyUnforgeable");
+      const forgeable = whence !== "unforgeables";
       this.interface.addMethod(
-        onInstance ? "instance" : "prototype",
+        whence,
         this.name,
         argNames,
         str,

lib/utils.js

@@ -39,8 +39,7 @@ function hasCEReactions(idl) {
 }
 
 function isOnInstance(memberIDL, interfaceIDL) {
-  return memberIDL.special !== "static" && (getExtAttr(memberIDL.extAttrs, "LegacyUnforgeable") ||
-    isGlobal(interfaceIDL));
+  return memberIDL.special !== "static" && isGlobal(interfaceIDL);
 }
 
 function symbolName(symbol) {