Migrate to new constructor operation syntax

components/script/dom/bindings/codegen/parser/WebIDL.py

@@ -554,9 +554,6 @@ class IDLExternalInterface(IDLObjectWithIdentifier, IDLExposureMixins):
     def hasProbablyShortLivingWrapper(self):
         return False
 
-    def isNavigatorProperty(self):
-        return False
-
     def isSerializable(self):
         return False
 
@@ -611,7 +608,7 @@ class IDLPartialInterfaceOrNamespace(IDLObject):
         for attr in attrs:
             identifier = attr.identifier()
 
-            if identifier in ["Constructor", "NamedConstructor"]:
+            if identifier == "NamedConstructor":
                 self.propagatedExtendedAttrs.append(attr)
             elif identifier == "SecureContext":
                 self._haveSecureContextExtendedAttribute = True
@@ -737,7 +734,7 @@ class IDLInterfaceOrInterfaceMixinOrNamespace(IDLObjectWithScope, IDLExposureMix
         self.location = location
         # Put the new members at the beginning
         self.members = members + self.members
-    
+
     def addPartial(self, partial):
         assert self.identifier.name == partial.identifier.name
         self._partials.append(partial)
@@ -790,7 +787,7 @@ class IDLInterfaceMixin(IDLInterfaceOrInterfaceMixinOrNamespace):
 
     def __str__(self):
         return "Interface mixin '%s'" % self.identifier.name
-    
+
     def finish(self, scope):
         if self._finished:
             return
@@ -969,7 +966,11 @@ class IDLInterfaceOrNamespace(IDLInterfaceOrInterfaceMixinOrNamespace):
                               (self.identifier.name,
                                self.parent.identifier.name),
                               [self.location])
-        assert not parent or isinstance(parent, IDLInterface)
+        if parent and not isinstance(parent, IDLInterface):
+            raise WebIDLError("%s inherits from %s which is not an interface " %
+                              (self.identifier.name,
+                               self.parent.identifier.name),
+                              [self.location, parent.location])
 
         self.parent = parent
 
@@ -1076,11 +1077,34 @@ class IDLInterfaceOrNamespace(IDLInterfaceOrInterfaceMixinOrNamespace):
 
         ctor = self.ctor()
         if ctor is not None:
-            assert len(ctor._exposureGlobalNames) == 0
+            if not self.hasInterfaceObject():
+                raise WebIDLError(
+                    "Can't have both a constructor and [NoInterfaceObject]",
+                    [self.location, ctor.location])
+
+            if self.globalNames:
+                raise WebIDLError(
+                    "Can't have both a constructor and [Global]",
+                    [self.location, ctor.location])
+
+            assert(len(ctor._exposureGlobalNames) == 0 or
+                   ctor._exposureGlobalNames == self._exposureGlobalNames)
             ctor._exposureGlobalNames.update(self._exposureGlobalNames)
-            ctor.finish(scope)
+            if ctor in self.members:
+                # constructor operation.
+                self.members.remove(ctor)
+            else:
+                # extended attribute.  This can only happen with
+                # [HTMLConstructor] and this is the only way we can get into this
+                # code with len(ctor._exposureGlobalNames) !=
+                # self._exposureGlobalNames.
+                ctor.finish(scope)
 
         for ctor in self.namedConstructors:
+            if self.globalNames:
+                raise WebIDLError(
+                    "Can't have both a named constructor and [Global]",
+                    [self.location, self.namedConstructors.location])
             assert len(ctor._exposureGlobalNames) == 0
             ctor._exposureGlobalNames.update(self._exposureGlobalNames)
             ctor.finish(scope)
@@ -1462,12 +1486,11 @@ class IDLInterfaceOrNamespace(IDLInterfaceOrInterfaceMixinOrNamespace):
 
 
         # Conditional exposure makes no sense for interfaces with no
-        # interface object, unless they're navigator properties.
+        # interface object.
         # And SecureContext makes sense for interfaces with no interface object,
         # since it is also propagated to interface members.
         if (self.isExposedConditionally(exclusions=["SecureContext"]) and
-            not self.hasInterfaceObject() and
+            not self.hasInterfaceObject()):
-            not self.isNavigatorProperty()):
             raise WebIDLError("Interface with no interface object is "
                               "exposed conditionally",
                               [self.location])
@@ -1640,39 +1663,6 @@ class IDLInterfaceOrNamespace(IDLInterfaceOrInterfaceMixinOrNamespace):
             current = current.parent
         return False
 
-    def isNavigatorProperty(self):
-        naviProp = self.getExtendedAttribute("NavigatorProperty")
-        if not naviProp:
-            return False
-        assert len(naviProp) == 1
-        assert isinstance(naviProp, list)
-        assert len(naviProp[0]) != 0
-        return True
-
-    def getNavigatorProperty(self):
-        naviProp = self.getExtendedAttribute("NavigatorProperty")
-        if not naviProp:
-            return None
-        assert len(naviProp) == 1
-        assert isinstance(naviProp, list)
-        assert len(naviProp[0]) != 0
-        conditionExtendedAttributes = self._extendedAttrDict.viewkeys() & IDLInterfaceOrNamespace.conditionExtendedAttributes
-        attr = IDLAttribute(self.location,
-                            IDLUnresolvedIdentifier(BuiltinLocation("<auto-generated-identifier>"), naviProp[0]),
-                            IDLUnresolvedType(self.location, IDLUnresolvedIdentifier(self.location, self.identifier.name)),
-                            True,
-                            extendedAttrDict={ a: self._extendedAttrDict[a] for a in conditionExtendedAttributes },
-                            navigatorObjectGetter=True)
-        attr._exposureGlobalNames = self._exposureGlobalNames
-        # We're abusing Constant a little bit here, because we need Cached. The
-        # getter will create a new object every time, but we're never going to
-        # clear the cached value.
-        extendedAttrs = [ IDLExtendedAttribute(self.location, ("Throws", )),
-                          IDLExtendedAttribute(self.location, ("Cached", )),
-                          IDLExtendedAttribute(self.location, ("Constant", )) ]
-        attr.addExtendedAttributes(extendedAttrs)
-        return attr
-
     def hasChildInterfaces(self):
         return self._hasChildInterfaces
 
@@ -1731,67 +1721,39 @@ class IDLInterface(IDLInterfaceOrNamespace):
                     raise WebIDLError("[NoInterfaceObject] must take no arguments",
                                       [attr.location])
 
-                if self.ctor():
-                    raise WebIDLError("Constructor and NoInterfaceObject are incompatible",
-                                      [self.location])
-
                 self._noInterfaceObject = True
-            elif identifier == "Constructor" or identifier == "NamedConstructor" or identifier == "ChromeConstructor" or identifier == "HTMLConstructor":
+            elif identifier == "NamedConstructor" or identifier == "HTMLConstructor":
-                if identifier == "Constructor" and not self.hasInterfaceObject():
-                    raise WebIDLError(str(identifier) + " and NoInterfaceObject are incompatible",
-                                      [self.location])
-
                 if identifier == "NamedConstructor" and not attr.hasValue():
                     raise WebIDLError("NamedConstructor must either take an identifier or take a named argument list",
                                       [attr.location])
 
-                if identifier == "ChromeConstructor" and not self.hasInterfaceObject():
-                    raise WebIDLError(str(identifier) + " and NoInterfaceObject are incompatible",
-                                      [self.location])
-
                 if identifier == "HTMLConstructor":
-                    if not self.hasInterfaceObject():
-                        raise WebIDLError(str(identifier) + " and NoInterfaceObject are incompatible",
-                                          [self.location])
-
                     if not attr.noArguments():
                         raise WebIDLError(str(identifier) + " must take no arguments",
                                           [attr.location])
 
-                if self.globalNames:
-                    raise WebIDLError("[%s] must not be specified together with "
-                                      "[Global]" % identifier,
-                                      [self.location, attr.location])
-
                 args = attr.args() if attr.hasArgs() else []
 
                 retType = IDLWrapperType(self.location, self)
 
-                if identifier == "Constructor" or identifier == "ChromeConstructor" or identifier == "HTMLConstructor":
+                if identifier == "HTMLConstructor":
                     name = "constructor"
                     allowForbidden = True
                 else:
                     name = attr.value()
                     allowForbidden = False
 
-                methodIdentifier = IDLUnresolvedIdentifier(self.location, name,
+                method = IDLConstructor(
-                                                           allowForbidden=allowForbidden)
+                    attr.location, args, name,
+                    htmlConstructor=(identifier == "HTMLConstructor"))
+                method.reallyInit(self)
 
-                method = IDLMethod(self.location, methodIdentifier, retType,
+                # Are always assumed to be able to throw (since there's no way to
-                                   args, static=True,
+                # indicate otherwise).
-                                   htmlConstructor=(identifier == "HTMLConstructor"))
-                # Constructors are always NewObject and are always
-                # assumed to be able to throw (since there's no way to
-                # indicate otherwise) and never have any other
-                # extended attributes.
                 method.addExtendedAttributes(
-                    [IDLExtendedAttribute(self.location, ("NewObject",)),
+                    [IDLExtendedAttribute(self.location, ("Throws",))])
-                     IDLExtendedAttribute(self.location, ("Throws",))])
-                if identifier == "ChromeConstructor":
-                    method.addExtendedAttributes(
-                        [IDLExtendedAttribute(self.location, ("ChromeOnly",))])
 
-                if identifier == "Constructor" or identifier == "ChromeConstructor" or identifier == "HTMLConstructor":
+                if identifier == "HTMLConstructor":
                     method.resolve(self)
                 else:
                     # We need to detect conflicts for NamedConstructors across
@@ -1823,10 +1785,6 @@ class IDLInterface(IDLInterfaceOrNamespace):
                                       "an interface with inherited interfaces",
                                       [attr.location, self.location])
             elif identifier == "Global":
-                if self.ctor() or self.namedConstructors:
-                    raise WebIDLError("[Global] cannot be specified on an "
-                                      "interface with a constructor",
-                                      [attr.location, self.location]);
                 if attr.hasValue():
                     self.globalNames = [attr.value()]
                 elif attr.hasArgs():
@@ -1896,7 +1854,6 @@ class IDLInterface(IDLInterfaceOrNamespace):
             elif (identifier == "Pref" or
                   identifier == "JSImplementation" or
                   identifier == "HeaderFile" or
-                  identifier == "NavigatorProperty" or
                   identifier == "Func" or
                   identifier == "Deprecated"):
                 # Known extended attributes that take a string value
@@ -1923,6 +1880,17 @@ class IDLInterface(IDLInterfaceOrNamespace):
     def isSerializable(self):
         return self.getExtendedAttribute("Serializable")
 
+    def setNonPartial(self, location, parent, members):
+        # Before we do anything else, finish initializing any constructors that
+        # might be in "members", so we don't have partially-initialized objects
+        # hanging around.  We couldn't do it before now because we needed to have
+        # to have the IDLInterface on hand to properly set the return type.
+        for member in members:
+            if isinstance(member, IDLConstructor):
+                member.reallyInit(self)
+
+        IDLInterfaceOrNamespace.setNonPartial(self, location, parent, members)
+
 
 class IDLNamespace(IDLInterfaceOrNamespace):
     def __init__(self, location, parentScope, name, members, isKnownNonPartial):
@@ -2193,6 +2161,7 @@ class IDLType(IDLObject):
         'domstring',
         'bytestring',
         'usvstring',
+        'jsstring',
         'object',
         'date',
         'void',
@@ -2254,6 +2223,9 @@ class IDLType(IDLObject):
     def isUSVString(self):
         return False
 
+    def isJSString(self):
+        return False
+
     def isVoid(self):
         return self.name == "Void"
 
@@ -2479,6 +2451,9 @@ class IDLNullableType(IDLParametrizedType):
     def isUSVString(self):
         return self.inner.isUSVString()
 
+    def isJSString(self):
+        return self.inner.isJSString()
+
     def isFloat(self):
         return self.inner.isFloat()
 
@@ -2600,6 +2575,9 @@ class IDLSequenceType(IDLParametrizedType):
     def isUSVString(self):
         return False
 
+    def isJSString(self):
+        return False
+
     def isVoid(self):
         return False
 
@@ -2861,6 +2839,9 @@ class IDLTypedefType(IDLType):
     def isUSVString(self):
         return self.inner.isUSVString()
 
+    def isJSString(self):
+        return self.inner.isJSString()
+
     def isVoid(self):
         return self.inner.isVoid()
 
@@ -2991,6 +2972,9 @@ class IDLWrapperType(IDLType):
     def isUSVString(self):
         return False
 
+    def isJSString(self):
+        return False
+
     def isVoid(self):
         return False
 
@@ -3190,6 +3174,7 @@ class IDLBuiltinType(IDLType):
         'domstring',
         'bytestring',
         'usvstring',
+        'jsstring',
         'object',
         'date',
         'void',
@@ -3227,6 +3212,7 @@ class IDLBuiltinType(IDLType):
         Types.domstring: IDLType.Tags.domstring,
         Types.bytestring: IDLType.Tags.bytestring,
         Types.usvstring: IDLType.Tags.usvstring,
+        Types.jsstring: IDLType.Tags.jsstring,
         Types.object: IDLType.Tags.object,
         Types.date: IDLType.Tags.date,
         Types.void: IDLType.Tags.void,
@@ -3311,7 +3297,8 @@ class IDLBuiltinType(IDLType):
     def isString(self):
         return (self._typeTag == IDLBuiltinType.Types.domstring or
                 self._typeTag == IDLBuiltinType.Types.bytestring or
-                self._typeTag == IDLBuiltinType.Types.usvstring)
+                self._typeTag == IDLBuiltinType.Types.usvstring or
+                self._typeTag == IDLBuiltinType.Types.jsstring)
 
     def isByteString(self):
         return self._typeTag == IDLBuiltinType.Types.bytestring
@@ -3322,6 +3309,9 @@ class IDLBuiltinType(IDLType):
     def isUSVString(self):
         return self._typeTag == IDLBuiltinType.Types.usvstring
 
+    def isJSString(self):
+        return self._typeTag == IDLBuiltinType.Types.jsstring
+
     def isInteger(self):
         return self._typeTag <= IDLBuiltinType.Types.unsigned_long_long
 
@@ -3524,6 +3514,9 @@ BuiltinTypes = {
     IDLBuiltinType.Types.usvstring:
         IDLBuiltinType(BuiltinLocation("<builtin type>"), "USVString",
                        IDLBuiltinType.Types.usvstring),
+    IDLBuiltinType.Types.jsstring:
+        IDLBuiltinType(BuiltinLocation("<builtin type>"), "JSString",
+                       IDLBuiltinType.Types.jsstring),
     IDLBuiltinType.Types.object:
         IDLBuiltinType(BuiltinLocation("<builtin type>"), "Object",
                        IDLBuiltinType.Types.object),
@@ -3690,8 +3683,8 @@ class IDLValue(IDLObject):
             # TreatNullAsEmpty is a different type for resolution reasons,
             # however once you have a value it doesn't matter
             return self
-        elif self.type.isString() and type.isByteString():
+        elif self.type.isString() and (type.isByteString() or type.isJSString()):
-            # Allow ByteStrings to use a default value like DOMString.
+            # Allow ByteStrings and JSStrings to use a default value like DOMString.
             # No coercion is required as Codegen.py will handle the
             # extra steps. We want to make sure that our string contains
             # only valid characters, so we check that here.
@@ -4340,7 +4333,7 @@ class IDLConst(IDLInterfaceMember):
 class IDLAttribute(IDLInterfaceMember):
     def __init__(self, location, identifier, type, readonly, inherit=False,
                  static=False, stringifier=False, maplikeOrSetlike=None,
-                 extendedAttrDict=None, navigatorObjectGetter=False):
+                 extendedAttrDict=None):
         IDLInterfaceMember.__init__(self, location, identifier,
                                     IDLInterfaceMember.Tags.Attr,
                                     extendedAttrDict=extendedAttrDict)
@@ -4358,7 +4351,6 @@ class IDLAttribute(IDLInterfaceMember):
         self.maplikeOrSetlike = maplikeOrSetlike
         self.dependsOn = "Everything"
         self.affects = "Everything"
-        self.navigatorObjectGetter = navigatorObjectGetter
         self.bindingAliases = []
 
         if static and identifier.name == "prototype":
@@ -5239,7 +5231,7 @@ class IDLMethod(IDLInterfaceMember, IDLScope):
                 assert argument.type.isComplete()
 
                 if ((argument.type.isDictionary() and
-                     argument.type.inner.canBeEmpty())or
+                     argument.type.unroll().inner.canBeEmpty()) or
                     (argument.type.isUnion() and
                      argument.type.unroll().hasPossiblyEmptyDictionaryType())):
                     # Optional dictionaries and unions containing optional
@@ -5263,12 +5255,16 @@ class IDLMethod(IDLInterfaceMember, IDLScope):
                                           "must have a default value",
                                           [argument.location])
 
-                    # An argument cannot be a Nullable Dictionary
+                # An argument cannot be a nullable dictionary or a
-                    if argument.type.nullable():
+                # nullable union containing a dictionary.
-                        raise WebIDLError("An argument cannot be a nullable "
+                if (argument.type.nullable() and
-                                          "dictionary or nullable union "
+                    (argument.type.isDictionary() or
-                                          "containing a dictionary",
+                     (argument.type.isUnion() and
-                                          [argument.location])
+                      argument.type.unroll().hasDictionaryType()))):
+                    raise WebIDLError("An argument cannot be a nullable "
+                                      "dictionary or nullable union "
+                                      "containing a dictionary",
+                                      [argument.location])
 
                 # Only the last argument can be variadic
                 if variadicArgument:
@@ -5497,6 +5493,52 @@ class IDLMethod(IDLInterfaceMember, IDLScope):
         return deps
 
 
+class IDLConstructor(IDLMethod):
+    def __init__(self, location, args, name, htmlConstructor=False):
+        # We can't actually init our IDLMethod yet, because we do not know the
+        # return type yet.  Just save the info we have for now and we will init
+        # it later.
+        self._initLocation = location
+        self._initArgs = args
+        self._initName = name
+        self._htmlConstructor = htmlConstructor
+        self._inited = False
+        self._initExtendedAttrs = []
+
+    def addExtendedAttributes(self, attrs):
+        if self._inited:
+            return IDLMethod.addExtendedAttributes(self, attrs)
+        self._initExtendedAttrs.extend(attrs)
+
+    def handleExtendedAttribute(self, attr):
+        identifier = attr.identifier()
+        if (identifier == "BinaryName" or
+            identifier == "ChromeOnly" or
+            identifier == "NewObject" or
+            identifier == "SecureContext" or
+            identifier == "Throws"):
+            IDLMethod.handleExtendedAttribute(self, attr)
+        else:
+            raise WebIDLError("Unknown extended attribute %s on method" % identifier,
+                              [attr.location])
+
+    def reallyInit(self, parentInterface):
+        name = self._initName
+        location = self._initLocation
+        identifier = IDLUnresolvedIdentifier(location, name, allowForbidden=True)
+        retType = IDLWrapperType(parentInterface.location, parentInterface)
+        IDLMethod.__init__(self, location, identifier, retType, self._initArgs,
+                           static=True, htmlConstructor=self._htmlConstructor)
+        self._inited = True;
+        # Propagate through whatever extended attributes we already had
+        self.addExtendedAttributes(self._initExtendedAttrs)
+        self._initExtendedAttrs = []
+        # Constructors are always NewObject.  Whether they throw or not is
+        # indicated by [Throws] annotations in the usual way.
+        self.addExtendedAttributes(
+            [IDLExtendedAttribute(self.location, ("NewObject",))])
+
+
 class IDLImplementsStatement(IDLObject):
     def __init__(self, location, implementor, implementee):
         IDLObject.__init__(self, location)
@@ -5712,6 +5754,7 @@ class Tokenizer(object):
         "DOMString": "DOMSTRING",
         "ByteString": "BYTESTRING",
         "USVString": "USVSTRING",
+        "JSString": "JSSTRING",
         "any": "ANY",
         "boolean": "BOOLEAN",
         "byte": "BYTE",
@@ -6076,7 +6119,7 @@ class Parser(Tokenizer):
 
     def p_PartialInterfaceRest(self, p):
         """
-            PartialInterfaceRest : IDENTIFIER LBRACE InterfaceMembers RBRACE SEMICOLON
+            PartialInterfaceRest : IDENTIFIER LBRACE PartialInterfaceMembers RBRACE SEMICOLON
         """
         location = self.getLocation(p, 1)
         identifier = IDLUnresolvedIdentifier(location, p[1])
@@ -6157,12 +6200,42 @@ class Parser(Tokenizer):
 
     def p_InterfaceMember(self, p):
         """
-            InterfaceMember : Const
+            InterfaceMember : PartialInterfaceMember
-                            | AttributeOrOperationOrMaplikeOrSetlikeOrIterable
+                            | Constructor
         """
         p[0] = p[1]
 
-        
+    def p_Constructor(self, p):
+        """
+            Constructor : CONSTRUCTOR LPAREN ArgumentList RPAREN SEMICOLON
+        """
+        p[0] = IDLConstructor(self.getLocation(p, 1), p[3], "constructor")
+
+    def p_PartialInterfaceMembers(self, p):
+        """
+            PartialInterfaceMembers : ExtendedAttributeList PartialInterfaceMember PartialInterfaceMembers
+        """
+        p[0] = [p[2]]
+
+        assert not p[1] or p[2]
+        p[2].addExtendedAttributes(p[1])
+
+        p[0].extend(p[3])
+
+    def p_PartialInterfaceMembersEmpty(self, p):
+        """
+            PartialInterfaceMembers :
+        """
+        p[0] = []
+
+    def p_PartialInterfaceMember(self, p):
+        """
+            PartialInterfaceMember : Const
+                                   | AttributeOrOperationOrMaplikeOrSetlikeOrIterable
+        """
+        p[0] = p[1]
+
+
     def p_MixinMembersEmpty(self, p):
         """
             MixinMembers :
@@ -6778,7 +6851,9 @@ class Parser(Tokenizer):
         """
         t = p[2]
         assert isinstance(t, IDLType)
-        identifier = IDLUnresolvedIdentifier(self.getLocation(p, 3), p[3])
+        # Arg names can be reserved identifiers
+        identifier = IDLUnresolvedIdentifier(self.getLocation(p, 3), p[3],
+                                             allowForbidden=True)
 
         defaultValue = p[4]
 
@@ -6795,7 +6870,9 @@ class Parser(Tokenizer):
         """
         t = p[1]
         assert isinstance(t, IDLType)
-        identifier = IDLUnresolvedIdentifier(self.getLocation(p, 3), p[3])
+        # Arg names can be reserved identifiers
+        identifier = IDLUnresolvedIdentifier(self.getLocation(p, 3), p[3],
+                                             allowForbidden=True)
 
         variadic = p[2]
 
@@ -6934,6 +7011,7 @@ class Parser(Tokenizer):
                   | DOMSTRING
                   | BYTESTRING
                   | USVSTRING
+                  | JSSTRING
                   | ANY
                   | ATTRIBUTE
                   | BOOLEAN
@@ -7216,6 +7294,12 @@ class Parser(Tokenizer):
         """
         p[0] = IDLBuiltinType.Types.usvstring
 
+    def p_BuiltinStringTypeJSString(self, p):
+        """
+            BuiltinStringType : JSSTRING
+        """
+        p[0] = IDLBuiltinType.Types.jsstring
+
     def p_UnsignedIntegerTypeUnsigned(self, p):
         """
             UnsignedIntegerType : UNSIGNED IntegerType
@@ -7443,23 +7527,9 @@ class Parser(Tokenizer):
         for p in self._productions:
             if isinstance(p, IDLInterface):
                 interfaceStatements.append(p)
-                if p.identifier.name == "Navigator":
-                    navigatorInterface = p
 
         iterableIteratorIface = None
         for iface in interfaceStatements:
-            navigatorProperty = iface.getNavigatorProperty()
-            if navigatorProperty:
-                # We're generating a partial interface to add a readonly
-                # property to the Navigator interface for every interface
-                # annotated with NavigatorProperty.
-                partialInterface = IDLPartialInterfaceOrNamespace(
-                    iface.location,
-                    IDLUnresolvedIdentifier(iface.location, "Navigator"),
-                    [ navigatorProperty ],
-                    navigatorInterface)
-                self._productions.append(partialInterface)
-
             iterable = None
             # We haven't run finish() on the interface yet, so we don't know
             # whether our interface is maplike/setlike/iterable or not. This

components/script/dom/bindings/codegen/parser/tests/test_argument_keywords.py

@@ -0,0 +1,17 @@
+def WebIDLTest(parser, harness):
+    parser.parse("""
+    interface Foo {
+      void foo(object constructor);
+    };
+    """)
+
+    results = parser.finish()
+    harness.check(len(results), 1, "Should have an interface");
+    iface = results[0];
+    harness.check(len(iface.members), 1, "Should have an operation");
+    operation = iface.members[0];
+    harness.check(len(operation.signatures()), 1, "Should have one signature");
+    (retval, args) = operation.signatures()[0];
+    harness.check(len(args), 1, "Should have an argument");
+    harness.check(args[0].identifier.name, "constructor",
+                  "Should have an identifier named 'constructor'");

components/script/dom/bindings/codegen/parser/tests/test_attributes_on_types.py

@@ -205,6 +205,18 @@ def WebIDLTest(parser, harness):
 
     harness.ok(threw, "Should not allow [TreatNullAs] on long")
 
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            typedef [TreatNullAs=EmptyString] JSString Foo;
+        """)
+        parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw, "Should not allow [TreatNullAs] on JSString")
+
     parser = parser.reset()
     threw = False
     try:

components/script/dom/bindings/codegen/parser/tests/test_constructor.py

@@ -43,45 +43,55 @@ def WebIDLTest(parser, harness):
                 (QName, name, type, optional, variadic) = expectedArgs[i]
                 checkArgument(gotArgs[i], QName, name, type, optional, variadic)
 
+    def checkResults(results):
+        harness.check(len(results), 3, "Should be three productions")
+        harness.ok(isinstance(results[0], WebIDL.IDLInterface),
+                   "Should be an IDLInterface")
+        harness.ok(isinstance(results[1], WebIDL.IDLInterface),
+                   "Should be an IDLInterface")
+        harness.ok(isinstance(results[2], WebIDL.IDLInterface),
+                   "Should be an IDLInterface")
+
+        checkMethod(results[0].ctor(), "::TestConstructorNoArgs::constructor",
+                    "constructor", [("TestConstructorNoArgs (Wrapper)", [])])
+        harness.check(len(results[0].members), 0,
+                      "TestConstructorNoArgs should not have members")
+        checkMethod(results[1].ctor(), "::TestConstructorWithArgs::constructor",
+                    "constructor",
+                    [("TestConstructorWithArgs (Wrapper)",
+                      [("::TestConstructorWithArgs::constructor::name", "name", "String", False, False)])])
+        harness.check(len(results[1].members), 0,
+                      "TestConstructorWithArgs should not have members")
+        checkMethod(results[2].ctor(), "::TestConstructorOverloads::constructor",
+                    "constructor",
+                    [("TestConstructorOverloads (Wrapper)",
+                      [("::TestConstructorOverloads::constructor::foo", "foo", "Object", False, False)]),
+                     ("TestConstructorOverloads (Wrapper)",
+                      [("::TestConstructorOverloads::constructor::bar", "bar", "Boolean", False, False)])])
+        harness.check(len(results[2].members), 0,
+                      "TestConstructorOverloads should not have members")
+
     parser.parse("""
-        [Constructor]
         interface TestConstructorNoArgs {
+          constructor();
         };
 
-        [Constructor(DOMString name)]
         interface TestConstructorWithArgs {
+          constructor(DOMString name);
         };
 
-        [Constructor(object foo), Constructor(boolean bar)]
         interface TestConstructorOverloads {
+          constructor(object foo);
+          constructor(boolean bar);
         };
     """)
     results = parser.finish()
-    harness.check(len(results), 3, "Should be three productions")
+    checkResults(results)
-    harness.ok(isinstance(results[0], WebIDL.IDLInterface),
-               "Should be an IDLInterface")
-    harness.ok(isinstance(results[1], WebIDL.IDLInterface),
-               "Should be an IDLInterface")
-    harness.ok(isinstance(results[2], WebIDL.IDLInterface),
-               "Should be an IDLInterface")
-
-    checkMethod(results[0].ctor(), "::TestConstructorNoArgs::constructor",
-                "constructor", [("TestConstructorNoArgs (Wrapper)", [])])
-    checkMethod(results[1].ctor(), "::TestConstructorWithArgs::constructor",
-                "constructor",
-                [("TestConstructorWithArgs (Wrapper)",
-                 [("::TestConstructorWithArgs::constructor::name", "name", "String", False, False)])])
-    checkMethod(results[2].ctor(), "::TestConstructorOverloads::constructor",
-                "constructor",
-                [("TestConstructorOverloads (Wrapper)",
-                 [("::TestConstructorOverloads::constructor::foo", "foo", "Object", False, False)]),
-                 ("TestConstructorOverloads (Wrapper)",
-                 [("::TestConstructorOverloads::constructor::bar", "bar", "Boolean", False, False)])])
 
     parser = parser.reset()
     parser.parse("""
-        [ChromeConstructor()]
+        interface TestChromeOnlyConstructor {
-        interface TestChromeConstructor {
+          [ChromeOnly] constructor();
         };
     """)
     results = parser.finish()
@@ -89,8 +99,8 @@ def WebIDLTest(parser, harness):
     harness.ok(isinstance(results[0], WebIDL.IDLInterface),
                "Should be an IDLInterface")
 
-    checkMethod(results[0].ctor(), "::TestChromeConstructor::constructor",
+    checkMethod(results[0].ctor(), "::TestChromeOnlyConstructor::constructor",
-                "constructor", [("TestChromeConstructor (Wrapper)", [])],
+                "constructor", [("TestChromeOnlyConstructor (Wrapper)", [])],
                 chromeOnly=True)
 
     parser = parser.reset()
@@ -112,16 +122,16 @@ def WebIDLTest(parser, harness):
     threw = False
     try:
         parser.parse("""
-        [Constructor(),
+        interface TestChromeOnlyConstructor {
-         ChromeConstructor(DOMString a)]
+          constructor()
-        interface TestChromeConstructor {
+          [ChromeOnly] constructor(DOMString a);
         };
         """)
         results = parser.finish()
     except:
         threw = True
 
-    harness.ok(threw, "Can't have both a Constructor and a ChromeConstructor")
+    harness.ok(threw, "Can't have both a constructor and a ChromeOnly constructor")
 
     # Test HTMLConstructor with argument
     parser = parser.reset()
@@ -153,120 +163,197 @@ def WebIDLTest(parser, harness):
 
     harness.ok(threw, "HTMLConstructor can't be used on a callback interface")
 
-    # Test HTMLConstructor and Constructor
+    # Test HTMLConstructor and constructor operation
     parser = parser.reset()
     threw = False
     try:
         parser.parse("""
-            [Constructor,
+            [HTMLConstructor]
-             HTMLConstructor]
             interface TestHTMLConstructorAndConstructor {
+              constructor();
             };
         """)
         results = parser.finish()
     except:
         threw = True
 
-    harness.ok(threw, "Can't have both a Constructor and a HTMLConstructor")
+    harness.ok(threw, "Can't have both a constructor and a HTMLConstructor")
 
     parser = parser.reset()
     threw = False
     try:
         parser.parse("""
-            [HTMLConstructor,
+            [HTMLConstructor]
-             Constructor]
             interface TestHTMLConstructorAndConstructor {
+              [Throws]
+              constructor();
             };
         """)
         results = parser.finish()
     except:
         threw = True
 
-    harness.ok(threw, "Can't have both a HTMLConstructor and a Constructor")
+    harness.ok(threw,
+               "Can't have both a throwing constructor and a HTMLConstructor")
 
     parser = parser.reset()
     threw = False
     try:
         parser.parse("""
-            [HTMLConstructor,
+            [HTMLConstructor]
-             Constructor(DOMString a)]
             interface TestHTMLConstructorAndConstructor {
+              constructor(DOMString a);
             };
         """)
+        results = parser.finish()
     except:
         threw = True
 
-    harness.ok(threw, "Can't have both a HTMLConstructor and a Constructor")
+    harness.ok(threw,
+               "Can't have both a HTMLConstructor and a constructor operation")
 
     parser = parser.reset()
     threw = False
     try:
         parser.parse("""
-            [Constructor(DOMString a),
+            [HTMLConstructor]
-             HTMLConstructor]
             interface TestHTMLConstructorAndConstructor {
-            };
+              [Throws]
-        """)
+              constructor(DOMString a);
-    except:
-        threw = True
-
-    harness.ok(threw, "Can't have both a HTMLConstructor and a Constructor")
-
-    # Test HTMLConstructor and ChromeConstructor
-    parser = parser.reset()
-    threw = False
-    try:
-        parser.parse("""
-            [ChromeConstructor,
-             HTMLConstructor]
-            interface TestHTMLConstructorAndChromeConstructor {
             };
         """)
         results = parser.finish()
     except:
         threw = True
 
-    harness.ok(threw, "Can't have both a HTMLConstructor and a ChromeConstructor")
+    harness.ok(threw,
+               "Can't have both a HTMLConstructor and a throwing constructor "
+               "operation")
 
+    # Test HTMLConstructor and [ChromeOnly] constructor operation
     parser = parser.reset()
     threw = False
     try:
         parser.parse("""
-            [HTMLConstructor,
+            [HTMLConstructor]
-             ChromeConstructor]
+            interface TestHTMLConstructorAndConstructor {
-            interface TestHTMLConstructorAndChromeConstructor {
+              [ChromeOnly]
+              constructor();
             };
         """)
         results = parser.finish()
     except:
         threw = True
 
-    harness.ok(threw, "Can't have both a HTMLConstructor and a ChromeConstructor")
+    harness.ok(threw,
+               "Can't have both a ChromeOnly constructor and a HTMLConstructor")
 
     parser = parser.reset()
     threw = False
     try:
         parser.parse("""
-            [ChromeConstructor(DOMString a),
+            [HTMLConstructor]
-             HTMLConstructor]
+            interface TestHTMLConstructorAndConstructor {
-            interface TestHTMLConstructorAndChromeConstructor {
+              [Throws, ChromeOnly]
+              constructor();
             };
         """)
         results = parser.finish()
     except:
         threw = True
 
+    harness.ok(threw,
+               "Can't have both a throwing chromeonly constructor and a "
+               "HTMLConstructor")
+
     parser = parser.reset()
     threw = False
     try:
         parser.parse("""
-            [HTMLConstructor,
+            [HTMLConstructor]
-             ChromeConstructor(DOMString a)]
+            interface TestHTMLConstructorAndConstructor {
-            interface TestHTMLConstructorAndChromeConstructor {
+              [ChromeOnly]
+              constructor(DOMString a);
             };
         """)
         results = parser.finish()
     except:
         threw = True
 
-    harness.ok(threw, "Can't have both a HTMLConstructor and a ChromeConstructor")
+    harness.ok(threw,
+               "Can't have both a HTMLConstructor and a chromeonly constructor "
+               "operation")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            [HTMLConstructor]
+            interface TestHTMLConstructorAndConstructor {
+              [Throws, ChromeOnly]
+              constructor(DOMString a);
+            };
+        """)
+        results = parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw,
+               "Can't have both a HTMLConstructor and a throwing chromeonly "
+               "constructor operation")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            [NoInterfaceObject]
+            interface InterfaceWithoutInterfaceObject {
+              constructor();
+            };
+        """)
+        results = parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw,
+               "Can't have a constructor operation on a [NoInterfaceObject] "
+               "interface")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            interface InterfaceWithPartial {
+            };
+
+            partial interface InterfaceWithPartial {
+              constructor();
+            };
+        """)
+        results = parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw,
+               "Can't have a constructor operation on a partial interface")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            interface InterfaceWithMixin {
+            };
+
+            interface mixin Mixin {
+              constructor();
+            };
+
+            InterfaceWithMixin includes Mixin
+        """)
+        results = parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw,
+               "Can't have a constructor operation on a mixin")
+

components/script/dom/bindings/codegen/parser/tests/test_constructor_global.py

@@ -2,23 +2,9 @@ def WebIDLTest(parser, harness):
     threw = False
     try:
         parser.parse("""
-            [Constructor, Global]
+            [Global]
-            interface TestConstructorGlobal {
-            };
-        """)
-
-        results = parser.finish()
-    except:
-        threw = True
-
-    harness.ok(threw, "Should have thrown.")
-
-    parser = parser.reset()
-    threw = False
-    try:
-        parser.parse("""
-            [Global, Constructor]
             interface TestConstructorGlobal {
+              constructor();
             };
         """)
 

components/script/dom/bindings/codegen/parser/tests/test_constructor_no_interface_object.py

@@ -2,23 +2,9 @@ def WebIDLTest(parser, harness):
     threw = False
     try:
         parser.parse("""
-            [Constructor, NoInterfaceObject]
+            [NoInterfaceObject]
-            interface TestConstructorNoInterfaceObject {
-            };
-        """)
-
-        results = parser.finish()
-    except:
-        threw = True
-
-    harness.ok(threw, "Should have thrown.")
-
-    parser = parser.reset()
-    threw = False
-    try:
-        parser.parse("""
-            [NoInterfaceObject, Constructor]
             interface TestConstructorNoInterfaceObject {
+              constructor();
             };
         """)
 

components/script/dom/bindings/codegen/parser/tests/test_dictionary.py

@@ -320,14 +320,36 @@ def WebIDLTest(parser, harness):
             dictionary A {
             };
             interface X {
-              void doFoo(optional A? arg1);
+              void doFoo(optional A? arg1 = {});
             };
         """)
         results = parser.finish()
-    except:
+    except Exception as x:
-        threw = True
+        threw = x
 
-    harness.ok(threw, "Dictionary arg must not be nullable")
+    harness.ok(threw, "Optional dictionary arg must not be nullable")
+    harness.ok("nullable" in str(threw),
+               "Must have the expected exception for optional nullable dictionary arg")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            dictionary A {
+              required long x;
+            };
+            interface X {
+              void doFoo(A? arg1);
+            };
+        """)
+        results = parser.finish()
+    except Exception as x:
+        threw = x
+
+    harness.ok(threw, "Required dictionary arg must not be nullable")
+    harness.ok("nullable" in str(threw),
+               "Must have the expected exception for required nullable "
+               "dictionary arg")
 
     parser = parser.reset()
     threw = False
@@ -336,14 +358,54 @@ def WebIDLTest(parser, harness):
             dictionary A {
             };
             interface X {
-              void doFoo(optional (A or long)? arg1);
+              void doFoo(optional (A or long)? arg1 = {});
+            };
+        """)
+        results = parser.finish()
+    except Exception as x:
+        threw = x
+
+    harness.ok(threw, "Dictionary arg must not be in an optional nullable union")
+    harness.ok("nullable" in str(threw),
+               "Must have the expected exception for optional nullable union "
+               "arg containing dictionary")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            dictionary A {
+              required long x;
+            };
+            interface X {
+              void doFoo((A or long)? arg1);
+            };
+        """)
+        results = parser.finish()
+    except Exception as x:
+        threw = x
+
+    harness.ok(threw, "Dictionary arg must not be in a required nullable union")
+    harness.ok("nullable" in str(threw),
+               "Must have the expected exception for required nullable union "
+               "arg containing dictionary")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            dictionary A {
+            };
+            interface X {
+              void doFoo(sequence<A?> arg1);
             };
         """)
         results = parser.finish()
     except:
         threw = True
 
-    harness.ok(threw, "Dictionary arg must not be in a nullable union")
+    harness.ok(not threw,
+               "Nullable union should be allowed in a sequence argument")
 
     parser = parser.reset()
     threw = False

components/script/dom/bindings/codegen/parser/tests/test_distinguishability.py

@@ -166,7 +166,7 @@ def WebIDLTest(parser, harness):
                  "record<ByteString, long>",
                  "Date", "Date?", "any",
                  "Promise<any>", "Promise<any>?",
-                 "USVString", "ArrayBuffer", "ArrayBufferView", "SharedArrayBuffer",
+                 "USVString", "JSString", "ArrayBuffer", "ArrayBufferView", "SharedArrayBuffer",
                  "Uint8Array", "Uint16Array",
                  "(long or Callback)", "(long or Dict)",
     ]
@@ -183,7 +183,7 @@ def WebIDLTest(parser, harness):
     primitives = numerics + booleans
     nonNumerics = allBut(argTypes, numerics + unions)
     nonBooleans = allBut(argTypes, booleans)
-    strings = [ "DOMString", "ByteString", "Enum", "Enum2", "USVString" ]
+    strings = [ "DOMString", "ByteString", "Enum", "Enum2", "USVString", "JSString" ]
     nonStrings = allBut(argTypes, strings)
     nonObjects = primitives + strings
     objects = allBut(argTypes, nonObjects )
@@ -202,7 +202,7 @@ def WebIDLTest(parser, harness):
     notRelatedInterfaces = (nonObjects + ["UnrelatedInterface"] +
                             otherObjects + dates + sequences + bufferSourceTypes + sharedBufferSourceTypes)
     records = [ "record<DOMString, object>", "record<USVString, Dict>",
-                "record<ByteString, long>" ]
+                "record<ByteString, long>" ] # JSString not supported in records
 
     # Build a representation of the distinguishability table as a dict
     # of dicts, holding True values where needed, holes elsewhere.
@@ -222,6 +222,7 @@ def WebIDLTest(parser, harness):
     setDistinguishable("DOMString", nonStrings)
     setDistinguishable("ByteString", nonStrings)
     setDistinguishable("USVString", nonStrings)
+    setDistinguishable("JSString", nonStrings)
     setDistinguishable("Enum", nonStrings)
     setDistinguishable("Enum2", nonStrings)
     setDistinguishable("Interface", notRelatedInterfaces)
@@ -244,6 +245,7 @@ def WebIDLTest(parser, harness):
                        allBut(argTypes, sequences + ["object"]))
     setDistinguishable("record<DOMString, object>", nonUserObjects)
     setDistinguishable("record<USVString, Dict>", nonUserObjects)
+    # JSString not supported in records
     setDistinguishable("record<ByteString, long>", nonUserObjects)
     setDistinguishable("Date", allBut(argTypes, dates + ["object"]))
     setDistinguishable("Date?", allBut(argTypes, dates + nullables + ["object"]))

components/script/dom/bindings/codegen/parser/tests/test_interface.py

@@ -189,12 +189,12 @@ def WebIDLTest(parser, harness):
 
     parser = parser.reset()
     parser.parse("""
-        [Constructor(long arg)]
         interface A {
+            constructor();
+            constructor(long arg);
             readonly attribute boolean x;
             void foo();
         };
-        [Constructor]
         partial interface A {
             readonly attribute boolean y;
             void foo(long arg);
@@ -219,13 +219,13 @@ def WebIDLTest(parser, harness):
 
     parser = parser.reset()
     parser.parse("""
-        [Constructor]
         partial interface A {
             readonly attribute boolean y;
             void foo(long arg);
         };
-        [Constructor(long arg)]
         interface A {
+            constructor();
+            constructor(long arg);
             readonly attribute boolean x;
             void foo();
         };

components/script/dom/bindings/codegen/parser/tests/test_interface_maplikesetlikeiterable.py

@@ -264,18 +264,18 @@ def WebIDLTest(parser, harness):
 
     shouldPass("JS Implemented maplike interface",
                """
-               [JSImplementation="@mozilla.org/dom/test-interface-js-maplike;1",
+               [JSImplementation="@mozilla.org/dom/test-interface-js-maplike;1"]
-               Constructor()]
                interface Foo1 {
+               constructor();
                setlike<long>;
                };
                """, setRWChromeMembers)
 
     shouldPass("JS Implemented maplike interface",
                """
-               [JSImplementation="@mozilla.org/dom/test-interface-js-maplike;1",
+               [JSImplementation="@mozilla.org/dom/test-interface-js-maplike;1"]
-               Constructor()]
                interface Foo1 {
+               constructor();
                maplike<long, long>;
                };
                """, mapRWChromeMembers)
@@ -655,9 +655,9 @@ def WebIDLTest(parser, harness):
 
     shouldPass("JS Implemented read-only interface with readonly allowable overrides",
                """
-               [JSImplementation="@mozilla.org/dom/test-interface-js-maplike;1",
+               [JSImplementation="@mozilla.org/dom/test-interface-js-maplike;1"]
-               Constructor()]
                interface Foo1 {
+               constructor();
                readonly setlike<long>;
                readonly attribute boolean clear;
                };
@@ -665,9 +665,9 @@ def WebIDLTest(parser, harness):
 
     shouldFail("JS Implemented read-write interface with non-readwrite allowable overrides",
                """
-               [JSImplementation="@mozilla.org/dom/test-interface-js-maplike;1",
+               [JSImplementation="@mozilla.org/dom/test-interface-js-maplike;1"]
-               Constructor()]
                interface Foo1 {
+               constructor();
                setlike<long>;
                readonly attribute boolean clear;
                };

components/script/dom/bindings/codegen/parser/update.sh

@@ -1,11 +1,11 @@
-wget https://hg.mozilla.org/mozilla-central/raw-file/tip/dom/bindings/parser/WebIDL.py -O WebIDL.py
+wget https://hg.mozilla.org/mozilla-central/raw-file/e447e3d69684cf04a95a35b9708174a6538eb042/dom/bindings/parser/WebIDL.py -O WebIDL.py
 patch < abstract.patch
 patch < debug.patch
 patch < callback-location.patch
 patch < union-typedef.patch
 patch < inline.patch
 
-wget https://hg.mozilla.org/mozilla-central/archive/tip.tar.gz/dom/bindings/parser/tests/ -O tests.tar.gz
+wget https://hg.mozilla.org/mozilla-central/archive/e447e3d69684cf04a95a35b9708174a6538eb042.tar.gz/dom/bindings/parser/tests/ -O tests.tar.gz
 rm -r tests
 mkdir tests
 tar xvpf tests.tar.gz  -C tests --strip-components=5

components/script/dom/webidls/AnalyserNode.webidl

@@ -13,9 +13,9 @@ dictionary AnalyserOptions : AudioNodeOptions {
   double smoothingTimeConstant = 0.8;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor (BaseAudioContext context, optional AnalyserOptions options = {})]
 interface AnalyserNode : AudioNode {
+  [Throws] constructor(BaseAudioContext context, optional AnalyserOptions options = {});
   void getFloatFrequencyData (Float32Array array);
   void getByteFrequencyData (Uint8Array array);
   void getFloatTimeDomainData (Float32Array array);

components/script/dom/webidls/AudioBuffer.webidl

@@ -12,9 +12,9 @@ dictionary AudioBufferOptions {
   required float sampleRate;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor (AudioBufferOptions options)]
 interface AudioBuffer {
+  [Throws] constructor(AudioBufferOptions options);
   readonly attribute float sampleRate;
   readonly attribute unsigned long length;
   readonly attribute double duration;

components/script/dom/webidls/AudioBufferSourceNode.webidl

@@ -15,9 +15,9 @@ dictionary AudioBufferSourceOptions {
   float playbackRate = 1;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor (BaseAudioContext context, optional AudioBufferSourceOptions options = {})]
 interface AudioBufferSourceNode : AudioScheduledSourceNode {
+  [Throws] constructor(BaseAudioContext context, optional AudioBufferSourceOptions options = {});
   [Throws] attribute AudioBuffer? buffer;
   readonly attribute AudioParam playbackRate;
   readonly attribute AudioParam detune;

components/script/dom/webidls/AudioContext.webidl

@@ -22,9 +22,9 @@ dictionary AudioTimestamp {
   DOMHighResTimeStamp performanceTime;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor(optional AudioContextOptions contextOptions = {})]
 interface AudioContext : BaseAudioContext {
+  [Throws] constructor(optional AudioContextOptions contextOptions = {});
   readonly attribute double baseLatency;
   readonly attribute double outputLatency;
 

components/script/dom/webidls/BiquadFilterNode.webidl

@@ -25,9 +25,9 @@ dictionary BiquadFilterOptions : AudioNodeOptions {
   float gain = 0;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor (BaseAudioContext context, optional BiquadFilterOptions options = {})]
 interface BiquadFilterNode : AudioNode {
+  [Throws] constructor(BaseAudioContext context, optional BiquadFilterOptions options = {});
   attribute BiquadFilterType type;
   readonly attribute AudioParam frequency;
   readonly attribute AudioParam detune;

components/script/dom/webidls/Blob.webidl

@@ -4,10 +4,10 @@
 
 // https://w3c.github.io/FileAPI/#blob
 
-[Constructor(optional sequence<BlobPart> blobParts,
+[Exposed=(Window,Worker)]
-  optional BlobPropertyBag options = {}),
- Exposed=(Window,Worker)]
 interface Blob {
+  [Throws] constructor(optional sequence<BlobPart> blobParts,
+    optional BlobPropertyBag options = {});
 
   readonly attribute unsigned long long size;
   readonly attribute DOMString type;

components/script/dom/webidls/BluetoothAdvertisingEvent.webidl

@@ -10,8 +10,9 @@
 interface BluetoothServiceDataMap {
   readonly maplike<UUID, DataView>;
 };*/
-[Pref="dom.bluetooth.enabled", Constructor(DOMString type, BluetoothAdvertisingEventInit init)]
+[Pref="dom.bluetooth.enabled"]
 interface BluetoothAdvertisingEvent : Event {
+  [Throws] constructor(DOMString type, BluetoothAdvertisingEventInit init);
   [SameObject]
   readonly attribute BluetoothDevice device;
   // readonly attribute FrozenArray<UUID> uuids;

components/script/dom/webidls/ChannelMergerNode.webidl

@@ -10,7 +10,7 @@ dictionary ChannelMergerOptions : AudioNodeOptions {
   unsigned long numberOfInputs = 6;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor (BaseAudioContext context, optional ChannelMergerOptions options = {})]
 interface ChannelMergerNode : AudioNode {
+  [Throws] constructor(BaseAudioContext context, optional ChannelMergerOptions options = {});
 };

components/script/dom/webidls/ChannelSplitterNode.webidl

@@ -10,7 +10,7 @@ dictionary ChannelSplitterOptions : AudioNodeOptions {
   unsigned long numberOfOutputs = 6;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor (BaseAudioContext context, optional ChannelSplitterOptions options = {})]
 interface ChannelSplitterNode : AudioNode {
+  [Throws] constructor(BaseAudioContext context, optional ChannelSplitterOptions options = {});
 };

components/script/dom/webidls/CloseEvent.webidl

@@ -3,8 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 //https://html.spec.whatwg.org/multipage/#the-closeevent-interfaces
-[Constructor(DOMString type, optional CloseEventInit eventInitDict = {}), Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface CloseEvent : Event {
+  [Throws] constructor(DOMString type, optional CloseEventInit eventInitDict = {});
   readonly attribute boolean wasClean;
   readonly attribute unsigned short code;
   readonly attribute DOMString reason;

components/script/dom/webidls/Comment.webidl

@@ -9,6 +9,6 @@
  * liability, trademark and document use rules apply.
  */
 
-[Constructor(optional DOMString data = "")]
 interface Comment : CharacterData {
+  [Throws] constructor(optional DOMString data = "");
 };

components/script/dom/webidls/CompositionEvent.webidl

@@ -8,8 +8,9 @@
  */
 
 // https://w3c.github.io/uievents/#idl-compositionevent
-[Pref="dom.compositionevent.enabled", Constructor(DOMString type, optional CompositionEventInit eventInitDict = {})]
+[Pref="dom.compositionevent.enabled"]
 interface CompositionEvent : UIEvent {
+  [Throws] constructor(DOMString type, optional CompositionEventInit eventInitDict = {});
   readonly attribute DOMString data;
 };
 

components/script/dom/webidls/ConstantSourceNode.webidl

@@ -10,8 +10,8 @@ dictionary ConstantSourceOptions: AudioNodeOptions {
   float offset = 1;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor (BaseAudioContext context, optional ConstantSourceOptions options = {})]
 interface ConstantSourceNode : AudioScheduledSourceNode {
+  [Throws] constructor(BaseAudioContext context, optional ConstantSourceOptions options = {});
   readonly attribute AudioParam offset;
 };

components/script/dom/webidls/CustomEvent.webidl

@@ -13,9 +13,9 @@
  * http://www.openwebfoundation.org/legal/the-owf-1-0-agreements/owfa-1-0.
  */
 
-[Constructor(DOMString type, optional CustomEventInit eventInitDict = {}),
+[Exposed=(Window,Worker)]
- Exposed=(Window,Worker)]
 interface CustomEvent : Event {
+  [Throws] constructor(DOMString type, optional CustomEventInit eventInitDict = {});
   readonly attribute any detail;
 
   void initCustomEvent(DOMString type, boolean bubbles, boolean cancelable, any detail);

components/script/dom/webidls/DOMException.webidl

@@ -9,10 +9,10 @@
 
 [
   ExceptionClass,
-  Exposed=(Window,Worker,Worklet,DissimilarOriginWindow),
+  Exposed=(Window,Worker,Worklet,DissimilarOriginWindow)
-  Constructor(optional DOMString message="", optional DOMString name="Error")
 ]
 interface DOMException {
+  [Throws] constructor(optional DOMString message="", optional DOMString name="Error");
   const unsigned short INDEX_SIZE_ERR = 1;
   const unsigned short DOMSTRING_SIZE_ERR = 2; // historical
   const unsigned short HIERARCHY_REQUEST_ERR = 3;

components/script/dom/webidls/DOMMatrix.webidl

@@ -10,9 +10,9 @@
  * related or neighboring rights to this work.
  */
 
-[Constructor(optional (DOMString or sequence<unrestricted double>) init),
+[Exposed=(Window,Worker)]
- Exposed=(Window,Worker)]
 interface DOMMatrix : DOMMatrixReadOnly {
+    [Throws] constructor(optional (DOMString or sequence<unrestricted double>) init);
 
     [NewObject, Throws] static DOMMatrix fromMatrix(optional DOMMatrixInit other = {});
     [NewObject, Throws] static DOMMatrix fromFloat32Array(Float32Array array32);

components/script/dom/webidls/DOMMatrixReadOnly.webidl

@@ -10,9 +10,9 @@
  * related or neighboring rights to this work.
  */
 
-[Constructor(optional (DOMString or sequence<unrestricted double>) init),
+[Exposed=(Window,Worker)]
- Exposed=(Window,Worker)]
 interface DOMMatrixReadOnly {
+    [Throws] constructor(optional (DOMString or sequence<unrestricted double>) init);
 
     [NewObject, Throws] static DOMMatrixReadOnly fromMatrix(optional DOMMatrixInit other = {});
     [NewObject, Throws] static DOMMatrixReadOnly fromFloat32Array(Float32Array array32);

components/script/dom/webidls/DOMParser.webidl

@@ -14,8 +14,8 @@ enum SupportedType {
   "image/svg+xml"*/
 };
 
-[Constructor]
 interface DOMParser {
+  [Throws] constructor();
   [Throws]
   Document parseFromString(DOMString str, SupportedType type);
 };

components/script/dom/webidls/DOMPoint.webidl

@@ -10,10 +10,10 @@
  */
 
 // http://dev.w3.org/fxtf/geometry/Overview.html#dompoint
-[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+[Exposed=(Window,Worker)]
-             optional unrestricted double z = 0, optional unrestricted double w = 1),
- Exposed=(Window,Worker)]
 interface DOMPoint : DOMPointReadOnly {
+    [Throws] constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+                optional unrestricted double z = 0, optional unrestricted double w = 1);
     [NewObject] static DOMPoint fromPoint(optional DOMPointInit other = {});
 
     inherit attribute unrestricted double x;

components/script/dom/webidls/DOMPointReadOnly.webidl

@@ -10,10 +10,10 @@
  */
 
 // http://dev.w3.org/fxtf/geometry/Overview.html#dompointreadonly
-[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+[Exposed=(Window,Worker)]
-             optional unrestricted double z = 0, optional unrestricted double w = 1),
- Exposed=(Window,Worker)]
 interface DOMPointReadOnly {
+    [Throws] constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+                optional unrestricted double z = 0, optional unrestricted double w = 1);
     [NewObject] static DOMPointReadOnly fromPoint(optional DOMPointInit other = {});
 
     readonly attribute unrestricted double x;

components/script/dom/webidls/DOMQuad.webidl

@@ -10,10 +10,10 @@
  * related or neighboring rights to this work.
  */
 
-[Constructor(optional DOMPointInit p1 = {}, optional DOMPointInit p2 = {},
+[Exposed=(Window,Worker)]
-             optional DOMPointInit p3 = {}, optional DOMPointInit p4 = {}),
- Exposed=(Window,Worker)]
 interface DOMQuad {
+    [Throws] constructor(optional DOMPointInit p1 = {}, optional DOMPointInit p2 = {},
+                optional DOMPointInit p3 = {}, optional DOMPointInit p4 = {});
     [NewObject] static DOMQuad fromRect(optional DOMRectInit other = {});
     [NewObject] static DOMQuad fromQuad(optional DOMQuadInit other = {});
 

components/script/dom/webidls/DOMRect.webidl

@@ -2,11 +2,11 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+[Exposed=(Window,Worker)]
-             optional unrestricted double width = 0, optional unrestricted double height = 0),
- Exposed=(Window,Worker)]
 // https://drafts.fxtf.org/geometry/#domrect
 interface DOMRect : DOMRectReadOnly {
+    [Throws] constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+                optional unrestricted double width = 0, optional unrestricted double height = 0);
     inherit attribute unrestricted double x;
     inherit attribute unrestricted double y;
     inherit attribute unrestricted double width;

components/script/dom/webidls/DOMRectReadOnly.webidl

@@ -2,11 +2,11 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
-[Constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+[Exposed=(Window,Worker)]
-             optional unrestricted double width = 0, optional unrestricted double height = 0),
- Exposed=(Window,Worker)]
 // https://drafts.fxtf.org/geometry/#domrect
 interface DOMRectReadOnly {
+  [Throws] constructor(optional unrestricted double x = 0, optional unrestricted double y = 0,
+              optional unrestricted double width = 0, optional unrestricted double height = 0);
   // [NewObject] static DOMRectReadOnly fromRect(optional DOMRectInit other);
 
   readonly attribute unrestricted double x;

components/script/dom/webidls/Document.webidl

@@ -8,8 +8,8 @@
  */
 
 // https://dom.spec.whatwg.org/#interface-document
-[Constructor]
 interface Document : Node {
+  [Throws] constructor();
   [SameObject]
   readonly attribute DOMImplementation implementation;
   [Constant]

components/script/dom/webidls/DocumentFragment.webidl

@@ -3,8 +3,8 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://dom.spec.whatwg.org/#interface-documentfragment
-[Constructor]
 interface DocumentFragment : Node {
+  [Throws] constructor();
 };
 
 DocumentFragment includes NonElementParentNode;

components/script/dom/webidls/ErrorEvent.webidl

@@ -4,8 +4,9 @@
 
 // https://html.spec.whatwg.org/multipage/#the-errorevent-interface
 
-[Constructor(DOMString type, optional ErrorEventInit eventInitDict = {}), Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface ErrorEvent : Event {
+  [Throws] constructor(DOMString type, optional ErrorEventInit eventInitDict = {});
   readonly attribute DOMString message;
   readonly attribute DOMString filename;
   readonly attribute unsigned long lineno;

components/script/dom/webidls/Event.webidl

@@ -6,8 +6,9 @@
  * https://dom.spec.whatwg.org/#event
  */
 
-[Constructor(DOMString type, optional EventInit eventInitDict = {}), Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface Event {
+  [Throws] constructor(DOMString type, optional EventInit eventInitDict = {});
   [Pure]
   readonly attribute DOMString type;
   readonly attribute EventTarget? target;

components/script/dom/webidls/EventSource.webidl

@@ -6,9 +6,9 @@
  * https://html.spec.whatwg.org/multipage/#eventsource
  */
 
-[Constructor(DOMString url, optional EventSourceInit eventSourceInitDict = {}),
+[Exposed=(Window,Worker)]
- Exposed=(Window,Worker)]
 interface EventSource : EventTarget {
+  [Throws] constructor(DOMString url, optional EventSourceInit eventSourceInitDict = {});
   readonly attribute DOMString url;
   readonly attribute boolean withCredentials;
 

components/script/dom/webidls/EventTarget.webidl

@@ -5,8 +5,9 @@
  * https://dom.spec.whatwg.org/#interface-eventtarget
  */
 
-[Constructor, Exposed=(Window,Worker,Worklet,DissimilarOriginWindow)]
+[Exposed=(Window,Worker,Worklet,DissimilarOriginWindow)]
 interface EventTarget {
+  [Throws] constructor();
   void addEventListener(
     DOMString type,
     EventListener? callback,

components/script/dom/webidls/ExtendableEvent.webidl

@@ -4,11 +4,11 @@
 
 // https://w3c.github.io/ServiceWorker/#extendable-event
 
-[Constructor(DOMString type,
+[Exposed=ServiceWorker,
- optional ExtendableEventInit eventInitDict = {}),
- Exposed=ServiceWorker,
  Pref="dom.serviceworker.enabled"]
 interface ExtendableEvent : Event {
+  [Throws] constructor(DOMString type,
+ optional ExtendableEventInit eventInitDict = {});
   [Throws] void waitUntil(/*Promise<*/any/*>*/ f);
 };
 

components/script/dom/webidls/ExtendableMessageEvent.webidl

@@ -4,10 +4,10 @@
 
 // https://w3c.github.io/ServiceWorker/#extendablemessage-event-section
 
-[Constructor(DOMString type, optional ExtendableMessageEventInit eventInitDict = {}),
+[Exposed=ServiceWorker,
- Exposed=ServiceWorker,
  Pref="dom.serviceworker.enabled"]
 interface ExtendableMessageEvent : ExtendableEvent {
+  [Throws] constructor(DOMString type, optional ExtendableMessageEventInit eventInitDict = {});
   readonly attribute any data;
   readonly attribute DOMString origin;
   readonly attribute DOMString lastEventId;

components/script/dom/webidls/File.webidl

@@ -4,11 +4,11 @@
 
 // https://w3c.github.io/FileAPI/#file
 
-[Constructor(sequence<BlobPart> fileBits,
+[Exposed=(Window,Worker)]
-            DOMString fileName,
-            optional FilePropertyBag options = {}),
- Exposed=(Window,Worker)]
 interface File : Blob {
+  [Throws] constructor(sequence<BlobPart> fileBits,
+              DOMString fileName,
+              optional FilePropertyBag options = {});
   readonly attribute DOMString name;
   readonly attribute long long lastModified;
 };

components/script/dom/webidls/FileReader.webidl

@@ -5,8 +5,9 @@
  // http://dev.w3.org/2006/webapi/FileAPI/#APIASynch
 
 typedef (DOMString or object) FileReaderResult;
-[Constructor, Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface FileReader: EventTarget {
+  [Throws] constructor();
 
   // async read methods
   [Throws]

components/script/dom/webidls/FileReaderSync.webidl

@@ -4,8 +4,9 @@
 
 // https://w3c.github.io/FileAPI/#FileReaderSync
 
-[Constructor, Exposed=Worker]
+[Exposed=Worker]
 interface FileReaderSync {
+  [Throws] constructor();
   // Synchronously return strings
 
   [Throws]

components/script/dom/webidls/FocusEvent.webidl

@@ -3,9 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://w3c.github.io/uievents/#interface-FocusEvent
-[Constructor(DOMString typeArg, optional FocusEventInit focusEventInitDict = {}),
+[Exposed=Window]
- Exposed=Window]
 interface FocusEvent : UIEvent {
+  [Throws] constructor(DOMString typeArg, optional FocusEventInit focusEventInitDict = {});
   readonly attribute EventTarget?   relatedTarget;
 };
 

components/script/dom/webidls/FormData.webidl

@@ -8,9 +8,9 @@
 
 typedef (File or USVString) FormDataEntryValue;
 
-[Constructor(optional HTMLFormElement form),
+[Exposed=(Window,Worker)]
- Exposed=(Window,Worker)]
 interface FormData {
+  [Throws] constructor(optional HTMLFormElement form);
   void append(USVString name, USVString value);
   void append(USVString name, Blob value, optional USVString filename);
   void delete(USVString name);

components/script/dom/webidls/FormDataEvent.webidl

@@ -3,9 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://html.spec.whatwg.org/multipage/#the-formdataevent-interface
-[Exposed=Window,
+[Exposed=Window]
- Constructor(DOMString type, optional FormDataEventInit eventInitDict = {})]
 interface FormDataEvent : Event {
+  [Throws] constructor(DOMString type, optional FormDataEventInit eventInitDict = {});
   readonly attribute FormData formData;
 };
 

components/script/dom/webidls/GainNode.webidl

@@ -10,8 +10,8 @@ dictionary GainOptions : AudioNodeOptions {
   float gain = 1.0;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor (BaseAudioContext context, optional GainOptions options = {})]
  interface GainNode : AudioNode {
+   [Throws] constructor(BaseAudioContext context, optional GainOptions options = {});
    readonly attribute AudioParam gain;
  };

components/script/dom/webidls/GamepadEvent.webidl

@@ -3,8 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://w3c.github.io/gamepad/#gamepadevent-interface
-[Pref="dom.gamepad.enabled", Constructor(DOMString type, GamepadEventInit eventInitDict)]
+[Pref="dom.gamepad.enabled"]
 interface GamepadEvent : Event {
+  [Throws] constructor(DOMString type, GamepadEventInit eventInitDict);
   readonly attribute Gamepad gamepad;
 };
 

components/script/dom/webidls/HashChangeEvent.webidl

@@ -3,9 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://html.spec.whatwg.org/multipage/#hashchangeevent
-[Constructor(DOMString type, optional HashChangeEventInit eventInitDict = {}),
+[Exposed=Window]
- Exposed=Window]
 interface HashChangeEvent : Event {
+  [Throws] constructor(DOMString type, optional HashChangeEventInit eventInitDict = {});
   readonly attribute USVString oldURL;
   readonly attribute USVString newURL;
 };

components/script/dom/webidls/Headers.webidl

@@ -6,9 +6,9 @@
 
 typedef (Headers or sequence<sequence<ByteString>> or record<DOMString, ByteString>) HeadersInit;
 
-[Constructor(optional HeadersInit init),
+[Exposed=(Window,Worker)]
- Exposed=(Window,Worker)]
 interface Headers {
+  [Throws] constructor(optional HeadersInit init);
   [Throws]
   void append(ByteString name, ByteString value);
   [Throws]

components/script/dom/webidls/ImageData.webidl

@@ -9,10 +9,10 @@
  * You are granted a license to use, reproduce and create derivative works of this document.
  */
 
-[Constructor(unsigned long sw, unsigned long sh),
+[Exposed=(Window,Worker)]
- Constructor(/* Uint8ClampedArray */ object data, unsigned long sw, optional unsigned long sh),
- Exposed=(Window,Worker)]
 interface ImageData {
+  [Throws] constructor(unsigned long sw, unsigned long sh);
+  [Throws] constructor(/* Uint8ClampedArray */ object data, unsigned long sw, optional unsigned long sh);
   //[Constant]
   readonly attribute unsigned long width;
   //[Constant]

components/script/dom/webidls/InputEvent.webidl

@@ -8,8 +8,8 @@
  */
 
 // https://w3c.github.io/uievents/#idl-inputevent
-[Constructor(DOMString type, optional InputEventInit eventInitDict = {})]
 interface InputEvent : UIEvent {
+  [Throws] constructor(DOMString type, optional InputEventInit eventInitDict = {});
   readonly attribute DOMString? data;
   readonly attribute boolean isComposing;
 };

components/script/dom/webidls/KeyboardEvent.webidl

@@ -7,8 +7,8 @@
  *
  */
 
-[Constructor(DOMString typeArg, optional KeyboardEventInit keyboardEventInitDict = {})]
 interface KeyboardEvent : UIEvent {
+    [Throws] constructor(DOMString typeArg, optional KeyboardEventInit keyboardEventInitDict = {});
     // KeyLocationCode
     const unsigned long DOM_KEY_LOCATION_STANDARD = 0x00;
     const unsigned long DOM_KEY_LOCATION_LEFT = 0x01;

components/script/dom/webidls/MediaQueryListEvent.webidl

@@ -3,8 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://drafts.csswg.org/cssom-view/#dom-mediaquerylistevent-mediaquerylistevent
-[Constructor(DOMString type, optional MediaQueryListEventInit eventInitDict = {}), Exposed=(Window)]
+[Exposed=(Window)]
 interface MediaQueryListEvent : Event {
+  [Throws] constructor(DOMString type, optional MediaQueryListEventInit eventInitDict = {});
   readonly attribute DOMString media;
   readonly attribute boolean matches;
 };

components/script/dom/webidls/MediaStream.webidl

@@ -5,11 +5,11 @@
 // https://w3c.github.io/mediacapture-main/#dom-mediastream
 
 [Exposed=Window,
- Constructor,
+ Pref="dom.webrtc.enabled"]
- Constructor(MediaStream stream),
- Constructor(sequence<MediaStreamTrack> tracks),
-Pref="dom.webrtc.enabled"]
 interface MediaStream : EventTarget {
+    [Throws] constructor();
+    [Throws] constructor(MediaStream stream);
+    [Throws] constructor(sequence<MediaStreamTrack> tracks);
     // readonly        attribute DOMString id;
     sequence<MediaStreamTrack> getAudioTracks();
     sequence<MediaStreamTrack> getVideoTracks();

components/script/dom/webidls/MessageEvent.webidl

@@ -3,8 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://html.spec.whatwg.org/multipage/#messageevent
-[Constructor(DOMString type, optional MessageEventInit eventInitDict = {}), Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface MessageEvent : Event {
+  [Throws] constructor(DOMString type, optional MessageEventInit eventInitDict = {});
   readonly attribute any data;
   readonly attribute DOMString origin;
   readonly attribute DOMString lastEventId;

components/script/dom/webidls/MouseEvent.webidl

@@ -3,9 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://w3c.github.io/uievents/#interface-mouseevent
-[Constructor(DOMString typeArg, optional MouseEventInit mouseEventInitDict = {}),
+[Exposed=Window]
- Exposed=Window]
 interface MouseEvent : UIEvent {
+    [Throws] constructor(DOMString typeArg, optional MouseEventInit mouseEventInitDict = {});
     readonly    attribute long           screenX;
     readonly    attribute long           screenY;
     readonly    attribute long           clientX;

components/script/dom/webidls/MutationObserver.webidl

@@ -7,8 +7,9 @@
  */
 
 // https://dom.spec.whatwg.org/#mutationobserver
-[Pref="dom.mutation_observer.enabled", Constructor(MutationCallback callback)]
+[Pref="dom.mutation_observer.enabled"]
 interface MutationObserver {
+    [Throws] constructor(MutationCallback callback);
     [Throws]
     void observe(Node target, optional MutationObserverInit options = {});
     void disconnect();

components/script/dom/webidls/OfflineAudioCompletionEvent.webidl

@@ -10,8 +10,8 @@ dictionary OfflineAudioCompletionEventInit : EventInit {
   required AudioBuffer renderedBuffer;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor(DOMString type, OfflineAudioCompletionEventInit eventInitDict)]
 interface OfflineAudioCompletionEvent : Event {
+  [Throws] constructor(DOMString type, OfflineAudioCompletionEventInit eventInitDict);
   readonly attribute AudioBuffer renderedBuffer;
 };

components/script/dom/webidls/OfflineAudioContext.webidl

@@ -12,10 +12,10 @@ dictionary OfflineAudioContextOptions {
   required float sampleRate;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor (OfflineAudioContextOptions contextOptions),
- Constructor (unsigned long numberOfChannels, unsigned long length, float sampleRate)]
 interface OfflineAudioContext : BaseAudioContext {
+  [Throws] constructor(OfflineAudioContextOptions contextOptions);
+  [Throws] constructor(unsigned long numberOfChannels, unsigned long length, float sampleRate);
   readonly attribute unsigned long length;
   attribute EventHandler oncomplete;
 

components/script/dom/webidls/OffscreenCanvas.webidl

@@ -13,9 +13,9 @@ dictionary ImageEncodeOptions {
 
 //enum OffscreenRenderingContextId { "2d", "webgl", "webgl2" };
 
-[Constructor([EnforceRange] unsigned long long width, [EnforceRange] unsigned long long height),
+[Exposed=(Window,Worker)/*, Transferable*/, Pref="dom.offscreen_canvas.enabled"]
-Exposed=(Window,Worker)/*, Transferable*/, Pref="dom.offscreen_canvas.enabled"]
 interface OffscreenCanvas : EventTarget {
+  [Throws] constructor([EnforceRange] unsigned long long width, [EnforceRange] unsigned long long height);
   attribute /*[EnforceRange]*/ unsigned long long width;
   attribute /*[EnforceRange]*/ unsigned long long height;
 

components/script/dom/webidls/OscillatorNode.webidl

@@ -21,9 +21,9 @@ dictionary OscillatorOptions : AudioNodeOptions {
   // PeriodicWave periodicWave;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor (BaseAudioContext context, optional OscillatorOptions options = {})]
 interface OscillatorNode : AudioScheduledSourceNode {
+  [Throws] constructor(BaseAudioContext context, optional OscillatorOptions options = {});
   [SetterThrows]
   attribute OscillatorType type;
 

components/script/dom/webidls/PageTransitionEvent.webidl

@@ -3,9 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://html.spec.whatwg.org/multipage/#the-pagetransitionevent-interface
-[Constructor(DOMString type, optional PageTransitionEventInit eventInitDict = {}),
+[Exposed=Window]
- Exposed=Window]
 interface PageTransitionEvent : Event {
+  [Throws] constructor(DOMString type, optional PageTransitionEventInit eventInitDict = {});
   readonly attribute boolean persisted;
 };
 

components/script/dom/webidls/PannerNode.webidl

@@ -34,9 +34,9 @@ enum PanningModelType {
     "HRTF"
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor (BaseAudioContext context, optional PannerOptions options = {})]
 interface PannerNode : AudioNode {
+  [Throws] constructor(BaseAudioContext context, optional PannerOptions options = {});
   attribute PanningModelType panningModel;
   readonly attribute AudioParam positionX;
   readonly attribute AudioParam positionY;

components/script/dom/webidls/PerformanceObserver.webidl

@@ -13,9 +13,9 @@ dictionary PerformanceObserverInit {
 
 callback PerformanceObserverCallback = void (PerformanceObserverEntryList entries, PerformanceObserver observer);
 
-[Constructor(PerformanceObserverCallback callback),
+[Exposed=(Window,Worker)]
- Exposed=(Window,Worker)]
 interface PerformanceObserver {
+  [Throws] constructor(PerformanceObserverCallback callback);
   [Throws]
   void observe(PerformanceObserverInit options);
   void disconnect();

components/script/dom/webidls/PopStateEvent.webidl

@@ -3,9 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://html.spec.whatwg.org/multipage/#the-popstateevent-interface
-[Constructor(DOMString type, optional PopStateEventInit eventInitDict = {}),
+[Exposed=Window]
- Exposed=Window]
 interface PopStateEvent : Event {
+  [Throws] constructor(DOMString type, optional PopStateEventInit eventInitDict = {});
   readonly attribute any state;
 };
 

components/script/dom/webidls/ProgressEvent.webidl

@@ -12,9 +12,9 @@
  * http://www.openwebfoundation.org/legal/the-owf-1-0-agreements/owfa-1-0.
  */
 
-[Constructor(DOMString type, optional ProgressEventInit eventInitDict = {}),
+[Exposed=(Window,Worker)]
- Exposed=(Window,Worker)]
 interface ProgressEvent : Event {
+  [Throws] constructor(DOMString type, optional ProgressEventInit eventInitDict = {});
   readonly attribute boolean lengthComputable;
   readonly attribute unsigned long long loaded;
   readonly attribute unsigned long long total;

components/script/dom/webidls/PromiseRejectionEvent.webidl

@@ -4,8 +4,9 @@
 
 // https://html.spec.whatwg.org/multipage/#the-promiserejectionevent-interface
 
-[Constructor(DOMString type, optional PromiseRejectionEventInit eventInitDict = {}), Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface PromiseRejectionEvent : Event {
+  [Throws] constructor(DOMString type, optional PromiseRejectionEventInit eventInitDict = {});
   readonly attribute Promise<any> promise;
   readonly attribute any reason;
 };

components/script/dom/webidls/RTCIceCandidate.webidl

@@ -5,9 +5,9 @@
 // https://w3c.github.io/webrtc-pc/#rtcicecandidate-interface
 
 
-[Constructor(optional RTCIceCandidateInit candidateInitDict = {}),
+[Exposed=Window, Pref="dom.webrtc.enabled"]
- Exposed=Window, Pref="dom.webrtc.enabled"]
 interface RTCIceCandidate {
+    [Throws] constructor(optional RTCIceCandidateInit candidateInitDict = {});
     readonly attribute DOMString               candidate;
     readonly attribute DOMString?              sdpMid;
     readonly attribute unsigned short?         sdpMLineIndex;

components/script/dom/webidls/RTCPeerConnection.webidl

@@ -4,9 +4,9 @@
 
 // https://w3c.github.io/webrtc-pc/#interface-definition
 
-[Constructor(optional RTCConfiguration configuration = {}),
+[Exposed=Window, Pref="dom.webrtc.enabled"]
- Exposed=Window, Pref="dom.webrtc.enabled"]
 interface RTCPeerConnection : EventTarget {
+    [Throws] constructor(optional RTCConfiguration configuration = {});
     Promise<RTCSessionDescriptionInit> createOffer(optional RTCOfferOptions options = {});
     Promise<RTCSessionDescriptionInit> createAnswer(optional RTCAnswerOptions options = {});
     Promise<void>                      setLocalDescription(RTCSessionDescriptionInit description);

components/script/dom/webidls/RTCPeerConnectionIceEvent.webidl

@@ -4,9 +4,9 @@
 
 // https://w3c.github.io/webrtc-pc/#rtcpeerconnectioniceevent
 
-[Constructor(DOMString type, optional RTCPeerConnectionIceEventInit eventInitDict = {}),
+[Exposed=Window, Pref="dom.webrtc.enabled"]
- Exposed=Window, Pref="dom.webrtc.enabled"]
 interface RTCPeerConnectionIceEvent : Event {
+    [Throws] constructor(DOMString type, optional RTCPeerConnectionIceEventInit eventInitDict = {});
     readonly attribute RTCIceCandidate? candidate;
     readonly attribute DOMString?       url;
 };

components/script/dom/webidls/RTCSessionDescription.webidl

@@ -4,9 +4,9 @@
 
 // https://w3c.github.io/webrtc-pc/#rtcsessiondescription-class
 
-[Constructor(RTCSessionDescriptionInit descriptionInitDict),
+[Exposed=Window, Pref="dom.webrtc.enabled"]
- Exposed=Window, Pref="dom.webrtc.enabled"]
 interface RTCSessionDescription {
+    [Throws] constructor(RTCSessionDescriptionInit descriptionInitDict);
     readonly attribute RTCSdpType type;
     readonly attribute DOMString  sdp;
     [Default] object toJSON();

components/script/dom/webidls/RTCTrackEvent.webidl

@@ -4,9 +4,9 @@
 
 // https://w3c.github.io/webrtc-pc/#dom-rtctrackevent
 
-[Constructor(DOMString type, RTCTrackEventInit eventInitDict),
+[Exposed=Window, Pref="dom.webrtc.enabled"]
- Exposed=Window, Pref="dom.webrtc.enabled"]
 interface RTCTrackEvent : Event {
+    [Throws] constructor(DOMString type, RTCTrackEventInit eventInitDict);
     // readonly attribute RTCRtpReceiver           receiver;
     readonly attribute MediaStreamTrack         track;
     // [SameObject]

components/script/dom/webidls/Range.webidl

@@ -8,8 +8,8 @@
  * http://dvcs.w3.org/hg/csswg/raw-file/tip/cssom-view/Overview.html#extensions-to-the-range-interface
  */
 
-[Constructor]
 interface Range {
+  [Throws] constructor();
   [Pure]
   readonly attribute Node startContainer;
   [Pure]

components/script/dom/webidls/Request.webidl

@@ -6,10 +6,9 @@
 
 typedef (Request or USVString) RequestInfo;
 
-[Constructor(RequestInfo input, optional RequestInit init = {}),
+[Exposed=(Window,Worker)]
- Exposed=(Window,Worker)]
-
 interface Request {
+  [Throws] constructor(RequestInfo input, optional RequestInit init = {});
   readonly attribute ByteString method;
   readonly attribute USVString url;
   [SameObject] readonly attribute Headers headers;

components/script/dom/webidls/Response.webidl

@@ -4,9 +4,9 @@
 
 // https://fetch.spec.whatwg.org/#response-class
 
- [Constructor(optional BodyInit? body = null, optional ResponseInit init = {}),
+ [Exposed=(Window,Worker)]
-  Exposed=(Window,Worker)]
 interface Response {
+  [Throws] constructor(optional BodyInit? body = null, optional ResponseInit init = {});
   [NewObject] static Response error();
   [NewObject, Throws] static Response redirect(USVString url, optional unsigned short status = 302);
 

components/script/dom/webidls/StereoPannerNode.webidl

@@ -10,8 +10,8 @@ dictionary StereoPannerOptions: AudioNodeOptions {
   float pan = 0;
 };
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor (BaseAudioContext context, optional StereoPannerOptions options = {})]
 interface StereoPannerNode : AudioScheduledSourceNode {
+  [Throws] constructor(BaseAudioContext context, optional StereoPannerOptions options = {});
   readonly attribute AudioParam pan;
 };

components/script/dom/webidls/StorageEvent.webidl

@@ -9,8 +9,9 @@
  * Event sent to a window when a storage area changes.
  */
 
-[Constructor(DOMString type, optional StorageEventInit eventInitDict = {}), Exposed=Window]
+[Exposed=Window]
 interface StorageEvent : Event {
+  [Throws] constructor(DOMString type, optional StorageEventInit eventInitDict = {});
   readonly attribute DOMString? key;
   readonly attribute DOMString? oldValue;
   readonly attribute DOMString? newValue;

components/script/dom/webidls/TestBinding.webidl

@@ -86,13 +86,13 @@ dictionary TestDictionaryDefaults {
   object? nullableObjectValue = null;
 };
 
-[Constructor,
+[Pref="dom.testbinding.enabled",
- Constructor(sequence<unrestricted double> numberSequence),
- Constructor(unrestricted double num),
- Pref="dom.testbinding.enabled",
  Exposed=(Window,Worker)
 ]
 interface TestBinding {
+           [Throws] constructor();
+           [Throws] constructor(sequence<unrestricted double> numberSequence);
+           [Throws] constructor(unrestricted double num);
            attribute boolean booleanAttribute;
            attribute byte byteAttribute;
            attribute octet octetAttribute;

components/script/dom/webidls/TestBindingIterable.webidl

@@ -5,8 +5,9 @@
 // This interface is entirely internal to Servo, and should not be accessible to
 // web pages.
 
-[Pref="dom.testbinding.enabled", Exposed=(Window,Worker), Constructor]
+[Pref="dom.testbinding.enabled", Exposed=(Window,Worker)]
 interface TestBindingIterable {
+  [Throws] constructor();
   void add(DOMString arg);
   readonly attribute unsigned long length;
   getter DOMString getItem(unsigned long index);

components/script/dom/webidls/TestBindingPairIterable.webidl

@@ -5,8 +5,9 @@
 // This interface is entirely internal to Servo, and should not be accessible to
 // web pages.
 
-[Pref="dom.testbinding.enabled", Exposed=(Window,Worker), Constructor]
+[Pref="dom.testbinding.enabled", Exposed=(Window,Worker)]
 interface TestBindingPairIterable {
+  [Throws] constructor();
   void add(DOMString key, unsigned long value);
   iterable<DOMString, unsigned long>;
 };

components/script/dom/webidls/TestWorklet.webidl

@@ -5,8 +5,9 @@
 // This interface is entirely internal to Servo, and should not be accessible to
 // web pages.
 
-[Pref="dom.worklet.testing.enabled", Exposed=(Window), Constructor]
+[Pref="dom.worklet.testing.enabled", Exposed=(Window)]
 interface TestWorklet {
+   [Throws] constructor();
    [NewObject] Promise<void> addModule(USVString moduleURL, optional WorkletOptions options = {});
    DOMString? lookup(DOMString key);
 };

components/script/dom/webidls/Text.webidl

@@ -10,8 +10,8 @@
  */
 
 // https://dom.spec.whatwg.org/#text
-[Constructor(optional DOMString data = "")]
 interface Text : CharacterData {
+  [Throws] constructor(optional DOMString data = "");
   [NewObject, Throws]
   Text splitText(unsigned long offset);
   [Pure]

components/script/dom/webidls/TextDecoder.webidl

@@ -12,8 +12,9 @@ dictionary TextDecodeOptions {
   boolean stream = false;
 };
 
-[Constructor(optional DOMString label = "utf-8", optional TextDecoderOptions options = {}), Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface TextDecoder {
+  [Throws] constructor(optional DOMString label = "utf-8", optional TextDecoderOptions options = {});
   readonly attribute DOMString encoding;
   readonly attribute boolean fatal;
   readonly attribute boolean ignoreBOM;

components/script/dom/webidls/TextEncoder.webidl

@@ -3,8 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 /* https://encoding.spec.whatwg.org/#interface-textencoder */
-[Constructor, Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface TextEncoder {
+   [Throws] constructor();
    readonly attribute DOMString encoding;
    [NewObject]
    Uint8Array encode(optional USVString input = "");

components/script/dom/webidls/TrackEvent.webidl

@@ -4,9 +4,9 @@
 
 // https://html.spec.whatwg.org/multipage/#the-trackevent-interface
 
-[Exposed=Window,
+[Exposed=Window]
- Constructor(DOMString type, optional TrackEventInit eventInitDict = {})]
 interface TrackEvent : Event {
+  [Throws] constructor(DOMString type, optional TrackEventInit eventInitDict = {});
   readonly attribute (VideoTrack or AudioTrack or TextTrack)? track;
 };
 

components/script/dom/webidls/TransitionEvent.webidl

@@ -6,9 +6,9 @@
  * https://dom.spec.whatwg.org/#event
  */
 
-[Constructor(DOMString type, optional TransitionEventInit transitionEventInitDict = {}),
+[Exposed=Window]
- Exposed=Window]
 interface TransitionEvent : Event {
+  [Throws] constructor(DOMString type, optional TransitionEventInit transitionEventInitDict = {});
   readonly attribute DOMString          propertyName;
   readonly attribute float              elapsedTime;
   readonly attribute DOMString          pseudoElement;

components/script/dom/webidls/UIEvent.webidl

@@ -3,8 +3,8 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://w3c.github.io/uievents/#interface-uievent
-[Constructor(DOMString type, optional UIEventInit eventInitDict = {})]
 interface UIEvent : Event {
+  [Throws] constructor(DOMString type, optional UIEventInit eventInitDict = {});
   //  readonly    attribute WindowProxy? view;
   readonly attribute Window? view;
     readonly    attribute long         detail;

components/script/dom/webidls/URL.webidl

@@ -3,8 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://url.spec.whatwg.org/#url
-[Constructor(USVString url, optional USVString base), Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface URL {
+  [Throws] constructor(USVString url, optional USVString base);
   [SetterThrows]
   /*stringifier*/ attribute USVString href;
   readonly attribute USVString origin;

components/script/dom/webidls/URLSearchParams.webidl

@@ -6,10 +6,10 @@
  * https://url.spec.whatwg.org/#interface-urlsearchparams
  */
 
-[Constructor(
+[Exposed=(Window,Worker)]
-  optional (sequence<sequence<USVString>> or record<USVString, USVString> or USVString) init/* = ""*/
-), Exposed=(Window,Worker)]
 interface URLSearchParams {
+  [Throws] constructor(
+  optional (sequence<sequence<USVString>> or record<USVString, USVString> or USVString) init);
   void append(USVString name, USVString value);
   void delete(USVString name);
   USVString? get(USVString name);

components/script/dom/webidls/VRDisplayEvent.webidl

@@ -11,8 +11,9 @@ enum VRDisplayEventReason {
   "requested"
 };
 
-[Pref="dom.webvr.enabled", Constructor(DOMString type, VRDisplayEventInit eventInitDict)]
+[Pref="dom.webvr.enabled"]
 interface VRDisplayEvent : Event {
+  [Throws] constructor(DOMString type, VRDisplayEventInit eventInitDict);
   readonly attribute VRDisplay display;
   readonly attribute VRDisplayEventReason? reason;
 };

components/script/dom/webidls/VRFrameData.webidl

@@ -4,8 +4,9 @@
 
 // https://w3c.github.io/webvr/#interface-vrframedata
 
-[Pref="dom.webvr.enabled", Constructor]
+[Pref="dom.webvr.enabled"]
 interface VRFrameData {
+  [Throws] constructor();
   readonly attribute DOMHighResTimeStamp timestamp;
   readonly attribute Float32Array leftProjectionMatrix;
   readonly attribute Float32Array leftViewMatrix;

components/script/dom/webidls/WebGLContextEvent.webidl

@@ -3,9 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15
-[Constructor(DOMString type, optional WebGLContextEventInit eventInit = {}),
+[Exposed=Window]
- Exposed=Window]
 interface WebGLContextEvent : Event {
+    [Throws] constructor(DOMString type, optional WebGLContextEventInit eventInit = {});
     readonly attribute DOMString statusMessage;
 };
 

components/script/dom/webidls/WebSocket.webidl

@@ -6,8 +6,9 @@
 
 enum BinaryType { "blob", "arraybuffer" };
 
-[Constructor(DOMString url, optional (DOMString or sequence<DOMString>) protocols), Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface WebSocket : EventTarget {
+    [Throws] constructor(DOMString url, optional (DOMString or sequence<DOMString>) protocols);
     readonly attribute DOMString url;
     //ready state
     const unsigned short CONNECTING = 0;

components/script/dom/webidls/WheelEvent.webidl

@@ -3,9 +3,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
 // https://w3c.github.io/uievents/#interface-wheelevent
-[Constructor(DOMString typeArg, optional WheelEventInit wheelEventInitDict = {}),
+[Exposed=Window]
- Exposed=Window]
 interface WheelEvent : MouseEvent {
+    [Throws] constructor(DOMString typeArg, optional WheelEventInit wheelEventInitDict = {});
     const unsigned long DOM_DELTA_PIXEL = 0x00;
     const unsigned long DOM_DELTA_LINE = 0x01;
     const unsigned long DOM_DELTA_PAGE = 0x02;

components/script/dom/webidls/Worker.webidl

@@ -9,8 +9,9 @@ interface mixin AbstractWorker {
 };
 
 // https://html.spec.whatwg.org/multipage/#worker
-[Constructor(USVString scriptURL, optional WorkerOptions options = {}), Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface Worker : EventTarget {
+  [Throws] constructor(USVString scriptURL, optional WorkerOptions options = {});
   void terminate();
 
   [Throws] void postMessage(any message/*, sequence<object> transfer*/);

components/script/dom/webidls/XMLHttpRequest.webidl

@@ -24,8 +24,9 @@ enum XMLHttpRequestResponseType {
   "text"
 };
 
-[Constructor, Exposed=(Window,Worker)]
+[Exposed=(Window,Worker)]
 interface XMLHttpRequest : XMLHttpRequestEventTarget {
+  [Throws] constructor();
   // event handler
   attribute EventHandler onreadystatechange;
 

components/script/dom/webidls/XMLSerializer.webidl

@@ -6,8 +6,8 @@
  * https://w3c.github.io/DOM-Parsing/#the-domparser-interface
  */
 
-[Constructor]
 interface XMLSerializer {
+  [Throws] constructor();
   [Throws]
   DOMString serializeToString(Node root);
 };