Make it possible to have depency cycles involving the generated files

This commit switches the generated files from using module.exports to using exports. This means that, as long as imports are referenced in certain careful ways, such as

const Foo = require("./generated/Foo");

// later
Foo.isImpl()

instead of

const isFooImpl = require("./generated/Foo").isImpl;

// later
isFooImpl()

that the generated files can now be used as part of dependency cycles. Although this is fragile and not a pattern that should be used often, it can be important for implementing certain parts of the web platform which involve circular dependencies at the spec level.

Author: ExE-Boss

lib/constructs/attribute.js

@@ -28,7 +28,7 @@ class Attribute {
       objName = `obj`;
     }
     let brandCheck = `
-      if (!this || !module.exports.is(this)) {
+      if (!this || !exports.is(this)) {
         throw new TypeError("Illegal invocation");
       }
     `;
@@ -111,7 +111,7 @@ class Attribute {
 
     if (!this.static && this.idl.special === "stringifier") {
       addMethod("toString", [], `
-        if (!this || !module.exports.is(this)) {
+        if (!this || !exports.is(this)) {
           throw new TypeError("Illegal invocation");
         }
         ${getterBody};

lib/constructs/dictionary.js

@@ -70,8 +70,7 @@ class Dictionary {
 
   generate() {
     this.str += `
-      module.exports = {
-        convertInherit(obj, ret, { context = "The provided value" } = {}) {
+      exports.convertInherit = function convertInherit(obj, ret, { context = "The provided value" } = {}) {
     `;
 
     if (this.idl.inheritance) {
@@ -82,18 +81,17 @@ class Dictionary {
 
     this.str += `
           ${this._generateConversions()}
-        },
+        };
 
-        convert(obj, { context = "The provided value" } = {}) {
+        exports.convert = function convert(obj, { context = "The provided value" } = {}) {
           if (obj !== undefined && typeof obj !== "object" && typeof obj !== "function") {
             throw new TypeError(\`\${context} is not an object.\`);
           }
 
           const ret = Object.create(null);
           module.exports.convertInherit(obj, ret, { context });
           return ret;
-        }
-      };
+        };
     `;
 
     if (this.idl.inheritance) {

lib/constructs/enumeration.js

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

lib/constructs/interface.js

@@ -519,63 +519,65 @@ class Interface {
   generateMixins() {
     for (const iface of this.consequentialInterfaces()) {
       this.str += `
-        ${iface}._mixedIntoPredicates.push(module.exports.is);
+        ${iface}._mixedIntoPredicates.push(exports.is);
       `;
     }
   }
 
   generateExport() {
     this.str += `
-      // When an interface-module that implements this interface as a mixin is loaded, it will append its own \`.is()\`
-      // method into this array. It allows objects that directly implements *those* interfaces to be recognized as
-      // implementing this mixin interface.
-      _mixedIntoPredicates: [],
-      is(obj) {
+      /**
+       * When an interface-module that implements this interface as a mixin is loaded, it will append its own \`.is()\`
+       * method into this array. It allows objects that directly implements *those* interfaces to be recognized as
+       * implementing this mixin interface.
+       */
+      exports._mixedIntoPredicates = [];
+      exports.is = function is(obj) {
         if (obj) {
           if (utils.hasOwn(obj, impl) && obj[impl] instanceof Impl.implementation) {
             return true;
           }
-          for (const isMixedInto of module.exports._mixedIntoPredicates) {
+          for (const isMixedInto of exports._mixedIntoPredicates) {
             if (isMixedInto(obj)) {
               return true;
             }
           }
         }
         return false;
-      },
-      isImpl(obj) {
+      };
+      exports.isImpl = function isImpl(obj) {
         if (obj) {
           if (obj instanceof Impl.implementation) {
             return true;
           }
 
           const wrapper = utils.wrapperForImpl(obj);
-          for (const isMixedInto of module.exports._mixedIntoPredicates) {
+          for (const isMixedInto of exports._mixedIntoPredicates) {
             if (isMixedInto(wrapper)) {
               return true;
             }
           }
         }
         return false;
-      },
-      convert(obj, { context = "The provided value" } = {}) {
-        if (module.exports.is(obj)) {
+      };
+      exports.convert = function convert(obj, { context = "The provided value" } = {}) {
+        if (exports.is(obj)) {
           return utils.implForWrapper(obj);
         }
         throw new TypeError(\`\${context} is not of type '${this.name}'.\`);
-      },
+      };
     `;
 
     if (this.iterable && this.iterable.isPair) {
       this.str += `
-        createDefaultIterator(target, kind) {
+        exports.createDefaultIterator = function createDefaultIterator(target, kind) {
           const iterator = Object.create(IteratorPrototype);
           Object.defineProperty(iterator, utils.iterInternalSymbol, {
             value: { target, kind, index: 0 },
             configurable: true
           });
           return iterator;
-        },
+        };
       `;
     }
   }
@@ -1098,7 +1100,7 @@ class Interface {
 
   generateIface() {
     this.str += `
-      create(globalObject, constructorArgs, privateData) {
+      exports.create = function create(globalObject, constructorArgs, privateData) {
         if (globalObject[ctorRegistry] === undefined) {
           throw new Error('Internal error: invalid global object');
         }
@@ -1109,14 +1111,14 @@ class Interface {
         }
 
         let obj = Object.create(ctor.prototype);
-        obj = iface.setup(obj, globalObject, constructorArgs, privateData);
+        obj = exports.setup(obj, globalObject, constructorArgs, privateData);
         return obj;
-      },
-      createImpl(globalObject, constructorArgs, privateData) {
-        const obj = iface.create(globalObject, constructorArgs, privateData);
+      };
+      exports.createImpl = function createImpl(globalObject, constructorArgs, privateData) {
+        const obj = exports.create(globalObject, constructorArgs, privateData);
         return utils.implForWrapper(obj);
-      },
-      _internalSetup(obj) {
+      };
+      exports._internalSetup = function _internalSetup(obj) {
     `;
 
     if (this.idl.inheritance) {
@@ -1128,11 +1130,11 @@ class Interface {
     this.generateOnInstance();
 
     this.str += `
-      },
-      setup(obj, globalObject, constructorArgs = [], privateData = {}) {
+      };
+      exports.setup = function setup(obj, globalObject, constructorArgs = [], privateData = {}) {
         privateData.wrapper = obj;
 
-        iface._internalSetup(obj);
+        exports._internalSetup(obj);
         Object.defineProperty(obj, impl, {
           value: new Impl.implementation(globalObject, constructorArgs, privateData),
           configurable: true
@@ -1149,7 +1151,7 @@ class Interface {
           Impl.init(obj[impl], privateData);
         }
         return obj;
-      },
+      };
     `;
   }
 
@@ -1180,7 +1182,7 @@ class Interface {
 
       body = `
         ${conversions.body}
-        return iface.setup(${formatArgs(setupArgs)});
+        return exports.setup(${formatArgs(setupArgs)});
       `;
     } else {
       body = `
@@ -1414,7 +1416,7 @@ class Interface {
     const { idl, name } = this;
 
     this.str += `
-      install(globalObject) {
+      exports.install = function install(globalObject) {
     `;
 
     if (idl.inheritance) {
@@ -1444,26 +1446,17 @@ class Interface {
           writable: true,
           value: ${name}
         });
-      },
+      };
     `;
   }
 
   generate() {
     this.generateIterator();
 
-    this.str += `
-      const iface = {
-    `;
-
     this.generateExport();
     this.generateIface();
     this.generateInstall();
 
-    this.str += `
-      }; // iface
-      module.exports = iface;
-    `;
-
     this.generateMixins();
     this.generateRequires();
   }

lib/constructs/iterable.js

@@ -20,10 +20,10 @@ class Iterable {
 
   generateFunction(key, kind) {
     this.interface.addMethod(this.interface.defaultWhence, key, [], `
-      if (!this || !module.exports.is(this)) {
+      if (!this || !exports.is(this)) {
         throw new TypeError("Illegal invocation");
       }
-      return module.exports.createDefaultIterator(this, "${kind}");
+      return exports.createDefaultIterator(this, "${kind}");
     `);
   }
 
@@ -35,7 +35,7 @@ class Iterable {
       this.generateFunction("entries", "key+value");
       this.interface.addProperty(whence, Symbol.iterator, `${this.interface.name}.prototype.entries`);
       this.interface.addMethod(whence, "forEach", ["callback"], `
-        if (!this || !module.exports.is(this)) {
+        if (!this || !exports.is(this)) {
           throw new TypeError("Illegal invocation");
         }
         if (arguments.length < 1) {

lib/constructs/operation.js

@@ -61,7 +61,7 @@ class Operation {
 
     if (!this.static) {
       str += `
-        if (!this || !module.exports.is(this)) {
+        if (!this || !exports.is(this)) {
           throw new TypeError("Illegal invocation");
         }
       `;