Create exceptions and promises in the correct realm

Closes #242 by superseding it.

Author: domenic

README.md

@@ -258,7 +258,7 @@ Returns a boolean indicating whether _value_ is an instance of the wrapper class
 
 This is useful in other parts of your program that are not implementation class files, but instead receive wrapper classes from client code.
 
-#### `convert(value, { context })`
+#### `convert(globalObject, value, { context })`
 
 Performs the Web IDL conversion algorithm for this interface, converting _value_ into the correct representation of the interface type suitable for consumption by implementation classes: the corresponding impl.
 
@@ -296,13 +296,13 @@ jsdom does this for `Window`, which is written in custom, non-webidl2js-generate
 
 ### For callback interfaces
 
-#### `convert(value, { context })`
+#### `convert(globalObject, value, { context })`
 
-Performs the Web IDL conversion algorithm for this callback interface, converting _value_ into a function that performs [call a user object's operation](https://heycam.github.io/webidl/#call-a-user-objects-operation) when called, with _thisArg_ being the `this` value of the converted function.
+Performs the Web IDL conversion algorithm for this callback interface, converting `value` into a function that performs [call a user object's operation](https://heycam.github.io/webidl/#call-a-user-objects-operation) when called, with _thisArg_ being the `this` value of the converted function. `globalObject` is used to ensure error cases result in `Error` or `Promise` objects from the correct realm.
 
-The resulting function has an _objectReference_ property, which is the same object as _value_ and can be used to perform identity checks, as `convert` returns a new function object every time.
+The resulting function has an `objectReference` property, which is the same object as `value` and can be used to perform identity checks, as `convert` returns a new function object every time.
 
-If any part of the conversion fails, _context_ can be used to describe the provided value in any resulting error message.
+If any part of the conversion fails, `context` can be used to describe the provided value in any resulting error message.
 
 #### `install(globalObject, globalNames)`
 
@@ -312,11 +312,11 @@ The second argument `globalNames` is the same as for [the `install()` export for
 
 ### For dictionaries
 
-#### `convert(value, { context })`
+#### `convert(globalObject, value, { context })`
 
-Performs the Web IDL conversion algorithm for this dictionary, converting _value_ into the correct representation of the dictionary type suitable for consumption by implementation classes: a `null`-[[Prototype]] object with its properties properly converted.
+Performs the Web IDL conversion algorithm for this dictionary, converting `value` into the correct representation of the dictionary type suitable for consumption by implementation classes: a `null`-[[Prototype]] object with its properties properly converted. `globalObject` is used to ensure error cases result in `Error` or `Promise` objects from the correct realm.
 
-If any part of the conversion fails, _context_ can be used to describe the provided value in any resulting error message.
+If any part of the conversion fails, `context` can be used to describe the provided value in any resulting error message.
 
 ### Other requirements
 

lib/constructs/async-iterable.js

@@ -38,7 +38,7 @@ class AsyncIterable {
 
     this.interface.addMethod(this.interface.defaultWhence, key, [], `
       if (!exports.is(this)) {
-        throw new TypeError("'${key}' called on an object that is not a valid instance of ${this.interface.name}.");
+        throw new globalObject.TypeError("'${key}' called on an object that is not a valid instance of ${this.interface.name}.");
       }
 
       ${conv.body}

lib/constructs/attribute.js

@@ -35,11 +35,11 @@ class Attribute {
 
     const async = this.idl.idlType.generic === "Promise";
     const promiseHandlingBefore = async ? `try {` : ``;
-    const promiseHandlingAfter = async ? `} catch (e) { return Promise.reject(e); }` : ``;
+    const promiseHandlingAfter = async ? `} catch (e) { return globalObject.Promise.reject(e); }` : ``;
 
     let brandCheck = `
       if (!exports.is(esValue)) {
-        throw new TypeError("'$KEYWORD$ ${this.idl.name}' called on an object that is not a valid instance of ${this.interface.name}.");
+        throw new globalObject.TypeError("'$KEYWORD$ ${this.idl.name}' called on an object that is not a valid instance of ${this.interface.name}.");
       }
     `;
     let getterBody = `return utils.tryWrapperForImpl(esValue[implSymbol]["${this.idl.name}"]);`;
@@ -150,7 +150,7 @@ class Attribute {
         setterBody = `
           const Q = esValue["${this.idl.name}"];
           if (!utils.isObject(Q)) {
-            throw new TypeError("Property '${this.idl.name}' is not an object");
+            throw new globalObject.TypeError("Property '${this.idl.name}' is not an object");
           }
         `;
 
@@ -180,7 +180,7 @@ class Attribute {
       addMethod("toString", [], `
         const esValue = this;
         if (!exports.is(esValue)) {
-          throw new TypeError("'toString' called on an object that is not a valid instance of ${this.interface.name}.");
+          throw new globalObject.TypeError("'toString' called on an object that is not a valid instance of ${this.interface.name}.");
         }
 
         ${getterBody}

lib/constructs/callback-function.js

@@ -25,7 +25,7 @@ class CallbackFunction {
       "" :
       `
         if (typeof value !== "function") {
-          throw new TypeError(context + " is not a function");
+          throw new globalObject.TypeError(context + " is not a function");
         }
       `;
 
@@ -109,7 +109,7 @@ class CallbackFunction {
     }
 
     this.str += `
-      exports.convert = (value, { context = "The provided value" } = {}) => {
+      exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
         ${assertCallable}
         function invokeTheCallbackFunction(${inputArgs}) {
           const thisArg = utils.tryWrapperForImpl(this);
@@ -144,7 +144,7 @@ class CallbackFunction {
     if (isAsync) {
       this.str += `
           } catch (err) {
-            return Promise.reject(err);
+            return globalObject.Promise.reject(err);
           }
       `;
     }

lib/constructs/callback-interface.js

@@ -94,9 +94,9 @@ class CallbackInterface {
     }
 
     this.str += `
-      exports.convert = function convert(value, { context = "The provided value" } = {}) {
+      exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
         if (!utils.isObject(value)) {
-          throw new TypeError(\`\${context} is not an object.\`);
+          throw new globalObject.TypeError(\`\${context} is not an object.\`);
         }
 
         function callTheUserObjectsOperation(${argNames.join(", ")}) {
@@ -115,7 +115,7 @@ class CallbackInterface {
             if (typeof O !== "function") {
               X = O[${utils.stringifyPropertyName(opName)}];
               if (typeof X !== "function") {
-                throw new TypeError(\`\${context} does not correctly implement ${name}.\`)
+                throw new globalObject.TypeError(\`\${context} does not correctly implement ${name}.\`)
               }
               thisArg = O;
             }
@@ -151,7 +151,7 @@ class CallbackInterface {
     if (isAsync) {
       this.str += `
           } catch (err) {
-            return Promise.reject(err);
+            return globalObject.Promise.reject(err);
           }
       `;
     }
@@ -215,8 +215,9 @@ class CallbackInterface {
           return;
         }
 
+        const ctorRegistry = utils.initCtorRegistry(globalObject);
         const ${name} = () => {
-          throw new TypeError("Illegal invocation");
+          throw new globalObject.TypeError("Illegal invocation");
         };
       `;
 

lib/constructs/dictionary.js

@@ -55,7 +55,7 @@ class Dictionary {
       if (field.required) {
         str += `
           else {
-            throw new TypeError("${field.name} is required in '${this.name}'");
+            throw new globalObject.TypeError("${field.name} is required in '${this.name}'");
           }
         `;
       } else if (field.default) {
@@ -76,26 +76,26 @@ class Dictionary {
 
   generate() {
     this.str += `
-      exports._convertInherit = (obj, ret, { context = "The provided value" } = {}) => {
+      exports._convertInherit = (globalObject, obj, ret, { context = "The provided value" } = {}) => {
     `;
 
     if (this.idl.inheritance) {
       this.str += `
-          ${this.idl.inheritance}._convertInherit(obj, ret, { context });
+          ${this.idl.inheritance}._convertInherit(globalObject, obj, ret, { context });
       `;
     }
 
     this.str += `
           ${this._generateConversions()}
         };
 
-        exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+        exports.convert = (globalObject, obj, { context = "The provided value" } = {}) => {
           if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
-            throw new TypeError(\`\${context} is not an object.\`);
+            throw new globalObject.TypeError(\`\${context} is not an object.\`);
           }
 
           const ret = Object.create(null);
-          exports._convertInherit(obj, ret, { context });
+          exports._convertInherit(globalObject, obj, ret, { context });
           return ret;
         };
     `;

lib/constructs/enumeration.js

@@ -18,10 +18,10 @@ class Enumeration {
       const enumerationValues = new Set(${JSON.stringify([...values])});
       exports.enumerationValues = enumerationValues;
 
-      exports.convert = function convert(value, { context = "The provided value" } = {}) {
+      exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
         const string = \`\${value}\`;
         if (!enumerationValues.has(string)) {
-          throw new TypeError(\`\${context} '\${string}' is not a valid enumeration value for ${this.name}\`);
+          throw new globalObject.TypeError(\`\${context} '\${string}' is not a valid enumeration value for ${this.name}\`);
         }
         return string;
       };

lib/constructs/interface.js

@@ -437,12 +437,12 @@ class Interface {
           next() {
             const internal = this && this[utils.iterInternalSymbol];
             if (!internal) {
-              return Promise.reject(new TypeError("next() called on a value that is not a ${this.name} async iterator object"));
+              return globalObject.Promise.reject(new globalObject.TypeError("next() called on a value that is not a ${this.name} async iterator object"));
             }
 
             const nextSteps = () => {
               if (internal.isFinished) {
-                return Promise.resolve(newObjectInRealm(globalObject, { value: undefined, done: true }));
+                return globalObject.Promise.resolve(newObjectInRealm(globalObject, { value: undefined, done: true }));
               }
 
               const nextPromise = internal.target[implSymbol][utils.asyncIteratorNext](this);
@@ -484,12 +484,12 @@ class Interface {
           return(value) {
             const internal = this && this[utils.iterInternalSymbol];
             if (!internal) {
-              return Promise.reject(new TypeError("return() called on a value that is not a ${this.name} async iterator object"));
+              return globalObject.Promise.reject(new globalObject.TypeError("return() called on a value that is not a ${this.name} async iterator object"));
             }
 
             const returnSteps = () => {
               if (internal.isFinished) {
-                return Promise.resolve(newObjectInRealm(globalObject, { value, done: true }));
+                return globalObject.Promise.resolve(newObjectInRealm(globalObject, { value, done: true }));
               }
               internal.isFinished = true;
 
@@ -522,7 +522,7 @@ class Interface {
             next() {
               const internal = this && this[utils.iterInternalSymbol];
               if (!internal) {
-                throw new TypeError("next() called on a value that is not a ${this.name} iterator object");
+                throw new globalObject.TypeError("next() called on a value that is not a ${this.name} iterator object");
               }
 
               const { target, kind, index } = internal;
@@ -606,11 +606,11 @@ class Interface {
       exports.isImpl = value => {
         return utils.isObject(value) && value instanceof Impl.implementation;
       };
-      exports.convert = (value, { context = "The provided value" } = {}) => {
+      exports.convert = (globalObject, value, { context = "The provided value" } = {}) => {
         if (exports.is(value)) {
           return utils.implForWrapper(value);
         }
-        throw new TypeError(\`\${context} is not of type '${this.name}'.\`);
+        throw new globalObject.TypeError(\`\${context} is not of type '${this.name}'.\`);
       };
     `;
 
@@ -1364,7 +1364,7 @@ class Interface {
       `;
     } else {
       body = `
-        throw new TypeError("Illegal constructor");
+        throw new globalObject.TypeError("Illegal constructor");
       `;
     }
 
@@ -1386,7 +1386,7 @@ class Interface {
     // Don't bother checking "length" attribute as interfaces that support indexed properties must implement one.
     // "Has value iterator" implies "supports indexed properties".
     if (this.supportsIndexedProperties) {
-      this.addProperty(this.defaultWhence, Symbol.iterator, 'ctorRegistry["%Array%"].prototype[Symbol.iterator]');
+      this.addProperty(this.defaultWhence, Symbol.iterator, "globalObject.Array.prototype[Symbol.iterator]");
     }
   }
 

lib/constructs/iterable.js

@@ -25,7 +25,7 @@ class Iterable {
   generateFunction(key, kind) {
     this.interface.addMethod(this.interface.defaultWhence, key, [], `
       if (!exports.is(this)) {
-        throw new TypeError("'${key}' called on an object that is not a valid instance of ${this.interface.name}.");
+        throw new globalObject.TypeError("'${key}' called on an object that is not a valid instance of ${this.interface.name}.");
       }
       return exports.createDefaultIterator(globalObject, this, "${kind}");
     `);
@@ -42,13 +42,12 @@ class Iterable {
       this.interface.addProperty(whence, Symbol.iterator, `${this.interface.name}.prototype.entries`);
       this.interface.addMethod(whence, "forEach", ["callback"], `
         if (!exports.is(this)) {
-          throw new TypeError("'forEach' called on an object that is not a valid instance of ${this.interface.name}.");
+          throw new globalObject.TypeError("'forEach' called on an object that is not a valid instance of ${this.interface.name}.");
         }
         if (arguments.length < 1) {
-          throw new TypeError("Failed to execute 'forEach' on '${this.name}': 1 argument required, " +
-                              "but only 0 present.");
+          throw new globalObject.TypeError("Failed to execute 'forEach' on '${this.name}': 1 argument required, but only 0 present.");
         }
-        callback = ${requires.addRelative("Function")}.convert(callback, {
+        callback = ${requires.addRelative("Function")}.convert(globalObject, callback, {
           context: "Failed to execute 'forEach' on '${this.name}': The callback provided as parameter 1"
         });
         const thisArg = arguments[1];
@@ -62,10 +61,10 @@ class Iterable {
         }
       `);
     } else {
-      this.interface.addProperty(whence, "keys", 'ctorRegistry["%Array%"].prototype.keys');
-      this.interface.addProperty(whence, "values", 'ctorRegistry["%Array%"].prototype.values');
-      this.interface.addProperty(whence, "entries", 'ctorRegistry["%Array%"].prototype.entries');
-      this.interface.addProperty(whence, "forEach", 'ctorRegistry["%Array%"].prototype.forEach');
+      this.interface.addProperty(whence, "keys", "globalObject.Array.prototype.keys");
+      this.interface.addProperty(whence, "values", "globalObject.Array.prototype.values");
+      this.interface.addProperty(whence, "entries", "globalObject.Array.prototype.entries");
+      this.interface.addProperty(whence, "forEach", "globalObject.Array.prototype.forEach");
       // @@iterator is added in Interface class.
     }
 

lib/constructs/operation.js

@@ -97,7 +97,7 @@ class Operation {
     const whence = this.getWhence();
     const async = this.isAsync();
     const promiseHandlingBefore = async ? `try {` : ``;
-    const promiseHandlingAfter = async ? `} catch (e) { return Promise.reject(e); }` : ``;
+    const promiseHandlingAfter = async ? `} catch (e) { return globalObject.Promise.reject(e); }` : ``;
     const hasCallWithGlobal = this.hasCallWithGlobal();
 
     const type = this.static ? "static operation" : "regular operation";
@@ -115,7 +115,7 @@ class Operation {
       str += `
         const esValue = this !== null && this !== undefined ? this : globalObject;
         if (!exports.is(esValue)) {
-          throw new TypeError("'${this.name}' called on an object that is not a valid instance of ${this.interface.name}.");
+          throw new globalObject.TypeError("'${this.name}' called on an object that is not a valid instance of ${this.interface.name}.");
         }
       `;
     }

lib/output/utils.js

@@ -31,9 +31,6 @@ const implSymbol = Symbol("impl");
 const sameObjectCaches = Symbol("SameObject caches");
 const ctorRegistrySymbol = Symbol.for("[webidl2js]  constructor registry");
 
-// This only contains the intrinsic names that are referenced from the `ctorRegistry`:
-const intrinsicConstructors = ["Array"];
-
 const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {}).prototype);
 
 function initCtorRegistry(globalObject) {
@@ -42,13 +39,13 @@ function initCtorRegistry(globalObject) {
   }
 
   const ctorRegistry = Object.create(null);
-  for (const intrinsic of intrinsicConstructors) {
-    ctorRegistry[`%${intrinsic}%`] = globalObject[intrinsic];
-  }
 
+  // In addition to registering all the WebIDL2JS-generated types in the constructor registry,
+  // we also register a few intrinsics that we make use of in generated code, since they are not
+  // easy to grab from the globalObject variable.
   ctorRegistry["%Object.prototype%"] = globalObject.Object.prototype;
   ctorRegistry["%IteratorPrototype%"] = Object.getPrototypeOf(
-    Object.getPrototypeOf(new ctorRegistry["%Array%"]()[Symbol.iterator]())
+    Object.getPrototypeOf(new globalObject.Array()[Symbol.iterator]())
   );
 
   try {

lib/parameters.js

@@ -113,8 +113,7 @@ module.exports.generateOverloadConversions = function (ctx, typeOfOp, name, pare
       const plural = minArgs > 1 ? "s" : "";
       str += `
         if (arguments.length < ${minArgs}) {
-          throw new TypeError("${errPrefix}${minArgs} argument${plural} required, but only " + arguments.length +
-                              " present.");
+          throw new globalObject.TypeError(\`${errPrefix}${minArgs} argument${plural} required, but only \${arguments.length} present.\`);
         }
       `;
     }
@@ -127,7 +126,7 @@ module.exports.generateOverloadConversions = function (ctx, typeOfOp, name, pare
         .filter(o => o.typeList.length === numArgs);
       if (S.length === 0) {
         switchCases.push(`
-          throw new TypeError("${errPrefix}only " + arguments.length + " arguments present.");
+          throw new globalObject.TypeError(\`${errPrefix}only \${arguments.length} arguments present.\`);
         `);
         continue;
       }
@@ -303,7 +302,7 @@ module.exports.generateOverloadConversions = function (ctx, typeOfOp, name, pare
         } else if (any.length) {
           possibilities.push(`{ ${continued(any[0], i)} }`);
         } else {
-          possibilities.push(`throw new TypeError("${errPrefix}No such overload");`);
+          possibilities.push(`throw new globalObject.TypeError("${errPrefix}No such overload");`);
         }
 
         caseSrc += possibilities.join(" else ");