Auto merge of #22958 - Manishearth:attrs-on-types, r=nox

Add support for attributes on types in WebIDL

WebIDL moved `[Clamp]`, `[RangeEnforced]`, and `[TreatNullAs]` to applying directly to types in https://github.com/heycam/webidl/pull/286.

I implemented parser support for this upstream in [bug 1359269](https://bugzilla.mozilla.org/show_bug.cgi?id=1359269). This pull request downstreams those changes and updates codegen as well as any webidls to conform.

Needed to land #22874

r? @nox

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/22958)
<!-- Reviewable:end -->

components/script/dom/bindings/codegen/CodegenRust.py

@@ -573,9 +573,6 @@ def getJSToNativeConversionInfo(type, descriptorProvider, failureCode=None,
                                 isAutoRooted=False,
                                 invalidEnumValueFatal=True,
                                 defaultValue=None,
-                                treatNullAs="Default",
-                                isEnforceRange=False,
-                                isClamp=False,
                                 exceptionCode=None,
                                 allowTreatNonObjectAsNull=False,
                                 isCallbackReturnValue=False,
@@ -603,12 +600,6 @@ def getJSToNativeConversionInfo(type, descriptorProvider, failureCode=None,
 
     If defaultValue is not None, it's the IDL default value for this conversion
 
-    If isEnforceRange is true, we're converting an integer and throwing if the
-    value is out of range.
-
-    If isClamp is true, we're converting an integer and clamping if the
-    value is out of range.
-
     If allowTreatNonObjectAsNull is true, then [TreatNonObjectAsNull]
     extended attributes on nullable callback functions will be honored.
 
@@ -631,6 +622,13 @@ def getJSToNativeConversionInfo(type, descriptorProvider, failureCode=None,
     # We should not have a defaultValue if we know we're an object
     assert not isDefinitelyObject or defaultValue is None
 
+    isEnforceRange = type.enforceRange
+    isClamp = type.clamp
+    if type.treatNullAsEmpty:
+        treatNullAs = "EmptyString"
+    else:
+        treatNullAs = "Default"
+
     # If exceptionCode is not set, we'll just rethrow the exception we got.
     # Note that we can't just set failureCode to exceptionCode, because setting
     # failureCode will prevent pending exceptions from being set in cases when
@@ -1301,9 +1299,6 @@ class CGArgumentConverter(CGThing):
             descriptorProvider,
             invalidEnumValueFatal=invalidEnumValueFatal,
             defaultValue=argument.defaultValue,
-            treatNullAs=argument.treatNullAs,
-            isEnforceRange=argument.enforceRange,
-            isClamp=argument.clamp,
             isMember="Variadic" if argument.variadic else False,
             isAutoRooted=type_needs_auto_root(argument.type),
             allowTreatNonObjectAsNull=argument.allowTreatNonCallableAsNull())
@@ -3508,9 +3503,6 @@ class FakeArgument():
         self.variadic = False
         self.defaultValue = None
         self._allowTreatNonObjectAsNull = allowTreatNonObjectAsNull
-        self.treatNullAs = interfaceMember.treatNullAs
-        self.enforceRange = False
-        self.clamp = False
 
     def allowTreatNonCallableAsNull(self):
         return self._allowTreatNonObjectAsNull
@@ -4874,7 +4866,7 @@ class CGProxySpecialOperation(CGPerSignatureCall):
             # arguments[0] is the index or name of the item that we're setting.
             argument = arguments[1]
             info = getJSToNativeConversionInfo(
-                argument.type, descriptor, treatNullAs=argument.treatNullAs,
+                argument.type, descriptor,
                 exceptionCode="return false;")
             template = info.template
             declType = info.declType
@@ -6886,7 +6878,7 @@ class CGCallbackInterface(CGCallback):
 
 class FakeMember():
     def __init__(self):
-        self.treatNullAs = "Default"
+        pass
 
     def isStatic(self):
         return False

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

@@ -420,48 +420,11 @@ class IDLObjectWithIdentifier(IDLObject):
         if parentScope:
             self.resolve(parentScope)
 
-        self.treatNullAs = "Default"
-
     def resolve(self, parentScope):
         assert isinstance(parentScope, IDLScope)
         assert isinstance(self.identifier, IDLUnresolvedIdentifier)
         self.identifier.resolve(parentScope, self)
 
-    def checkForStringHandlingExtendedAttributes(self, attrs,
-                                                 isDictionaryMember=False,
-                                                 isOptional=False):
-        """
-        A helper function to deal with TreatNullAs.  Returns the list
-        of attrs it didn't handle itself.
-        """
-        assert isinstance(self, IDLArgument) or isinstance(self, IDLAttribute)
-        unhandledAttrs = list()
-        for attr in attrs:
-            if not attr.hasValue():
-                unhandledAttrs.append(attr)
-                continue
-
-            identifier = attr.identifier()
-            value = attr.value()
-            if identifier == "TreatNullAs":
-                if not self.type.isDOMString() or self.type.nullable():
-                    raise WebIDLError("[TreatNullAs] is only allowed on "
-                                      "arguments or attributes whose type is "
-                                      "DOMString",
-                                      [self.location])
-                if isDictionaryMember:
-                    raise WebIDLError("[TreatNullAs] is not allowed for "
-                                      "dictionary members", [self.location])
-                if value != 'EmptyString':
-                    raise WebIDLError("[TreatNullAs] must take the identifier "
-                                      "'EmptyString', not '%s'" % value,
-                                      [self.location])
-                self.treatNullAs = value
-            else:
-                unhandledAttrs.append(attr)
-
-        return unhandledAttrs
-
 
 class IDLObjectWithScope(IDLObjectWithIdentifier, IDLScope):
     def __init__(self, location, parentScope, identifier):
@@ -2090,9 +2053,15 @@ class IDLType(IDLObject):
         IDLObject.__init__(self, location)
         self.name = name
         self.builtin = False
+        self.clamp = False
+        self.treatNullAsEmpty = False
+        self.enforceRange = False
+        self._extendedAttrDict = {}
 
     def __eq__(self, other):
-        return other and self.builtin == other.builtin and self.name == other.name
+        return (other and self.builtin == other.builtin and self.name == other.name and
+                          self.clamp == other.clamp and self.enforceRange == other.enforceRange and
+                          self.treatNullAsEmpty == other.treatNullAsEmpty)
 
     def __ne__(self, other):
         return not self == other
@@ -2218,12 +2187,14 @@ class IDLType(IDLObject):
         assert self.tag() == IDLType.Tags.callback
         return self.nullable() and self.inner.callback._treatNonObjectAsNull
 
-    def addExtendedAttributes(self, attrs):
-        if len(attrs) != 0:
-            raise WebIDLError("There are no extended attributes that are "
-                              "allowed on types, for now (but this is "
-                              "changing; see bug 1359269)",
+    def withExtendedAttributes(self, attrs):
+        if len(attrs) > 0:
+            raise WebIDLError("Extended attributes on types only supported for builtins",
                               [attrs[0].location, self.location])
+        return self
+
+    def getExtendedAttribute(self, name):
+        return self._extendedAttrDict.get(name, None)
 
     def resolveType(self, parentScope):
         pass
@@ -2244,8 +2215,9 @@ class IDLUnresolvedType(IDLType):
         Unresolved types are interface types
     """
 
-    def __init__(self, location, name):
+    def __init__(self, location, name, attrs=[]):
         IDLType.__init__(self, location, name)
+        self.extraTypeAttributes = attrs
 
     def isComplete(self):
         return False
@@ -2267,7 +2239,7 @@ class IDLUnresolvedType(IDLType):
             typedefType = IDLTypedefType(self.location, obj.innerType,
                                          obj.identifier)
             assert not typedefType.isComplete()
-            return typedefType.complete(scope)
+            return typedefType.complete(scope).withExtendedAttributes(self.extraTypeAttributes)
         elif obj.isCallback() and not obj.isInterface():
             assert self.name.name == obj.identifier.name
             return IDLCallbackType(obj.location, obj)
@@ -2275,6 +2247,9 @@ class IDLUnresolvedType(IDLType):
         name = self.name.resolve(scope, None)
         return IDLWrapperType(self.location, obj)
 
+    def withExtendedAttributes(self, attrs):
+        return IDLUnresolvedType(self.location, self.name, attrs)
+
     def isDistinguishableFrom(self, other):
         raise TypeError("Can't tell whether an unresolved type is or is not "
                         "distinguishable from other things")
@@ -2790,12 +2765,17 @@ class IDLTypedefType(IDLType):
     def _getDependentObjects(self):
         return self.inner._getDependentObjects()
 
+    def withExtendedAttributes(self, attrs):
+        return IDLTypedefType(self.location, self.inner.withExtendedAttributes(attrs), self.name)
+
 
 class IDLTypedef(IDLObjectWithIdentifier):
     def __init__(self, location, parentScope, innerType, name):
+        # Set self.innerType first, because IDLObjectWithIdentifier.__init__
+        # will call our __str__, which wants to use it.
+        self.innerType = innerType
         identifier = IDLUnresolvedIdentifier(location, name)
         IDLObjectWithIdentifier.__init__(self, location, parentScope, identifier)
-        self.innerType = innerType
 
     def __str__(self):
         return "Typedef %s %s" % (self.identifier.name, self.innerType)
@@ -3107,10 +3087,59 @@ class IDLBuiltinType(IDLType):
         Types.ReadableStream: IDLType.Tags.interface,
     }
 
-    def __init__(self, location, name, type):
+    def __init__(self, location, name, type, clamp=False, enforceRange=False, treatNullAsEmpty=False,
+                 attrLocation=[]):
+        """
+        The mutually exclusive clamp/enforceRange/treatNullAsEmpty arguments are used to create instances
+        of this type with the appropriate attributes attached. Use .clamped(), .rangeEnforced(), and .treatNullAs().
+
+        attrLocation is an array of source locations of these attributes for error reporting.
+        """
         IDLType.__init__(self, location, name)
         self.builtin = True
         self._typeTag = type
+        self._clamped = None
+        self._rangeEnforced = None
+        self._withTreatNullAs = None
+        if self.isNumeric():
+            if clamp:
+                self.clamp = True
+                self.name = "Clamped" + self.name
+                self._extendedAttrDict["Clamp"] = True
+            elif enforceRange:
+                self.enforceRange = True
+                self.name = "RangeEnforced" + self.name
+                self._extendedAttrDict["EnforceRange"] = True
+        elif clamp or enforceRange:
+            raise WebIDLError("Non-numeric types cannot be [Clamp] or [EnforceRange]", attrLocation)
+        if self.isDOMString():
+            if treatNullAsEmpty:
+                self.treatNullAsEmpty = True
+                self.name = "NullIsEmpty" + self.name
+                self._extendedAttrDict["TreatNullAs"] = ["EmptyString"]
+        elif treatNullAsEmpty:
+            raise WebIDLError("Non-string types cannot be [TreatNullAs]", attrLocation)
+
+    def clamped(self, attrLocation):
+        if not self._clamped:
+            self._clamped = IDLBuiltinType(self.location, self.name,
+                                           self._typeTag, clamp=True,
+                                           attrLocation=attrLocation)
+        return self._clamped
+
+    def rangeEnforced(self, attrLocation):
+        if not self._rangeEnforced:
+            self._rangeEnforced = IDLBuiltinType(self.location, self.name,
+                                           self._typeTag, enforceRange=True,
+                                           attrLocation=attrLocation)
+        return self._rangeEnforced
+
+    def withTreatNullAs(self, attrLocation):
+        if not self._withTreatNullAs:
+            self._withTreatNullAs = IDLBuiltinType(self.location, self.name,
+                                           self._typeTag, treatNullAsEmpty=True,
+                                           attrLocation=attrLocation)
+        return self._withTreatNullAs
 
     def isPrimitive(self):
         return self._typeTag <= IDLBuiltinType.Types.double
@@ -3246,6 +3275,45 @@ class IDLBuiltinType(IDLType):
     def _getDependentObjects(self):
         return set()
 
+    def withExtendedAttributes(self, attrs):
+        ret = self
+        for attribute in attrs:
+            identifier = attribute.identifier()
+            if identifier == "Clamp":
+                if not attribute.noArguments():
+                    raise WebIDLError("[Clamp] must take no arguments",
+                                      [attribute.location])
+                if ret.enforceRange or self.enforceRange:
+                    raise WebIDLError("[EnforceRange] and [Clamp] are mutually exclusive",
+                                      [self.location, attribute.location])
+                ret = self.clamped([self.location, attribute.location])
+            elif identifier == "EnforceRange":
+                if not attribute.noArguments():
+                    raise WebIDLError("[EnforceRange] must take no arguments",
+                                      [attribute.location])
+                if ret.clamp or self.clamp:
+                    raise WebIDLError("[EnforceRange] and [Clamp] are mutually exclusive",
+                                      [self.location, attribute.location])
+                ret = self.rangeEnforced([self.location, attribute.location])
+            elif identifier == "TreatNullAs":
+                if not self.isDOMString():
+                    raise WebIDLError("[TreatNullAs] only allowed on DOMStrings",
+                                      [self.location, attribute.location])
+                assert not self.nullable()
+                if not attribute.hasValue():
+                    raise WebIDLError("[TreatNullAs] must take an identifier argument"
+                                      [attribute.location])
+                value = attribute.value()
+                if value != 'EmptyString':
+                    raise WebIDLError("[TreatNullAs] must take the identifier "
+                                      "'EmptyString', not '%s'" % value,
+                                      [attribute.location])
+                ret = self.withTreatNullAs([self.location, attribute.location])
+            else:
+                raise WebIDLError("Unhandled extended attribute on type",
+                                  [self.location, attribute.location])
+        return ret
+
 BuiltinTypes = {
     IDLBuiltinType.Types.byte:
         IDLBuiltinType(BuiltinLocation("<builtin type>"), "Byte",
@@ -3460,6 +3528,10 @@ class IDLValue(IDLObject):
             # extra normalization step.
             assert self.type.isDOMString()
             return self
+        elif self.type.isDOMString() and type.treatNullAsEmpty:
+            # 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():
             # Allow ByteStrings to use a default value like DOMString.
             # No coercion is required as Codegen.py will handle the
@@ -4096,8 +4168,6 @@ class IDLAttribute(IDLInterfaceMember):
         self.lenientThis = False
         self._unforgeable = False
         self.stringifier = stringifier
-        self.enforceRange = False
-        self.clamp = False
         self.slotIndices = None
         assert maplikeOrSetlike is None or isinstance(maplikeOrSetlike, IDLMaplikeOrSetlike)
         self.maplikeOrSetlike = maplikeOrSetlike
@@ -4134,6 +4204,9 @@ class IDLAttribute(IDLInterfaceMember):
             assert not isinstance(t.name, IDLUnresolvedIdentifier)
             self.type = t
 
+        if self.readonly and (self.type.clamp or self.type.enforceRange or self.type.treatNullAsEmpty):
+            raise WebIDLError("A readonly attribute cannot be [Clamp] or [EnforceRange]",
+                              [self.location])
         if self.type.isDictionary() and not self.getExtendedAttribute("Cached"):
             raise WebIDLError("An attribute cannot be of a dictionary type",
                               [self.location])
@@ -4357,16 +4430,6 @@ class IDLAttribute(IDLInterfaceMember):
                 raise WebIDLError("[LenientFloat] used on an attribute with a "
                                   "non-restricted-float type",
                                   [attr.location, self.location])
-        elif identifier == "EnforceRange":
-            if self.readonly:
-                raise WebIDLError("[EnforceRange] used on a readonly attribute",
-                                  [attr.location, self.location])
-            self.enforceRange = True
-        elif identifier == "Clamp":
-            if self.readonly:
-                raise WebIDLError("[Clamp] used on a readonly attribute",
-                                  [attr.location, self.location])
-            self.clamp = True
         elif identifier == "StoreInSlot":
             if self.getExtendedAttribute("Cached"):
                 raise WebIDLError("[StoreInSlot] and [Cached] must not be "
@@ -4468,10 +4531,6 @@ class IDLAttribute(IDLInterfaceMember):
         self.type.resolveType(parentScope)
         IDLObjectWithIdentifier.resolve(self, parentScope)
 
-    def addExtendedAttributes(self, attrs):
-        attrs = self.checkForStringHandlingExtendedAttributes(attrs)
-        IDLInterfaceMember.addExtendedAttributes(self, attrs)
-
     def hasLenientThis(self):
         return self.lenientThis
 
@@ -4491,7 +4550,7 @@ class IDLAttribute(IDLInterfaceMember):
 
 
 class IDLArgument(IDLObjectWithIdentifier):
-    def __init__(self, location, identifier, type, optional=False, defaultValue=None, variadic=False, dictionaryMember=False):
+    def __init__(self, location, identifier, type, optional=False, defaultValue=None, variadic=False, dictionaryMember=False, allowTypeAttributes=False):
         IDLObjectWithIdentifier.__init__(self, location, None, identifier)
 
         assert isinstance(type, IDLType)
@@ -4502,37 +4561,19 @@ class IDLArgument(IDLObjectWithIdentifier):
         self.variadic = variadic
         self.dictionaryMember = dictionaryMember
         self._isComplete = False
-        self.enforceRange = False
-        self.clamp = False
         self._allowTreatNonCallableAsNull = False
         self._extendedAttrDict = {}
+        self.allowTypeAttributes = allowTypeAttributes
 
         assert not variadic or optional
         assert not variadic or not defaultValue
 
     def addExtendedAttributes(self, attrs):
-        attrs = self.checkForStringHandlingExtendedAttributes(
-            attrs,
-            isDictionaryMember=self.dictionaryMember,
-            isOptional=self.optional)
         for attribute in attrs:
             identifier = attribute.identifier()
-            if identifier == "Clamp":
-                if not attribute.noArguments():
-                    raise WebIDLError("[Clamp] must take no arguments",
-                                      [attribute.location])
-                if self.enforceRange:
-                    raise WebIDLError("[EnforceRange] and [Clamp] are mutually exclusive",
-                                      [self.location])
-                self.clamp = True
-            elif identifier == "EnforceRange":
-                if not attribute.noArguments():
-                    raise WebIDLError("[EnforceRange] must take no arguments",
-                                      [attribute.location])
-                if self.clamp:
-                    raise WebIDLError("[EnforceRange] and [Clamp] are mutually exclusive",
-                                      [self.location])
-                self.enforceRange = True
+            if self.allowTypeAttributes and (identifier == "EnforceRange" or identifier == "Clamp" or
+                                             identifier == "TreatNullAs"):
+                self.type = self.type.withExtendedAttributes([attribute])
             elif identifier == "TreatNonCallableAsNull":
                 self._allowTreatNonCallableAsNull = True
             elif (self.dictionaryMember and
@@ -4583,6 +4624,8 @@ class IDLArgument(IDLObjectWithIdentifier):
                 # codegen doesn't have to special-case this.
                 self.defaultValue = IDLUndefinedValue(self.location)
 
+        if self.dictionaryMember and self.type.treatNullAsEmpty:
+            raise WebIDLError("Dictionary members cannot be [TreatNullAs]", [self.location])
         # Now do the coercing thing; this needs to happen after the
         # above creation of a default value.
         if self.defaultValue:
@@ -5811,31 +5854,42 @@ class Parser(Tokenizer):
             # We're at the end of the list
             p[0] = []
             return
-        # Add our extended attributes
         p[2].addExtendedAttributes(p[1])
         p[0] = [p[2]]
         p[0].extend(p[3])
 
-    def p_DictionaryMember(self, p):
+    def p_DictionaryMemberRequired(self, p):
         """
-            DictionaryMember : Required Type IDENTIFIER Default SEMICOLON
+            DictionaryMember : REQUIRED TypeWithExtendedAttributes IDENTIFIER SEMICOLON
         """
-        # These quack a lot like optional arguments, so just treat them that way.
+        # These quack a lot like required arguments, so just treat them that way.
         t = p[2]
         assert isinstance(t, IDLType)
         identifier = IDLUnresolvedIdentifier(self.getLocation(p, 3), p[3])
-        defaultValue = p[4]
-        optional = not p[1]
-
-        if not optional and defaultValue:
-            raise WebIDLError("Required dictionary members can't have a default value.",
-                              [self.getLocation(p, 4)])
 
         p[0] = IDLArgument(self.getLocation(p, 3), identifier, t,
-                           optional=optional,
-                           defaultValue=defaultValue, variadic=False,
+                           optional=False,
+                           defaultValue=None, variadic=False,
                            dictionaryMember=True)
 
+    def p_DictionaryMember(self, p):
+        """
+            DictionaryMember : Type IDENTIFIER Default SEMICOLON
+        """
+        # These quack a lot like optional arguments, so just treat them that way.
+        t = p[1]
+        assert isinstance(t, IDLType)
+        identifier = IDLUnresolvedIdentifier(self.getLocation(p, 2), p[2])
+        defaultValue = p[3]
+
+        # Any attributes that precede this may apply to the type, so
+        # we configure the argument to forward type attributes down instead of producing
+        # a parse error
+        p[0] = IDLArgument(self.getLocation(p, 2), identifier, t,
+                           optional=True,
+                           defaultValue=defaultValue, variadic=False,
+                           dictionaryMember=True, allowTypeAttributes=True)
+
     def p_Default(self, p):
         """
             Default : EQUALS DefaultValue
@@ -5923,7 +5977,7 @@ class Parser(Tokenizer):
 
     def p_Typedef(self, p):
         """
-            Typedef : TYPEDEF Type IDENTIFIER SEMICOLON
+            Typedef : TYPEDEF TypeWithExtendedAttributes IDENTIFIER SEMICOLON
         """
         typedef = IDLTypedef(self.getLocation(p, 1), self.globalScope(),
                              p[2], p[3])
@@ -6016,8 +6070,8 @@ class Parser(Tokenizer):
 
     def p_Iterable(self, p):
         """
-            Iterable : ITERABLE LT Type GT SEMICOLON
-                     | ITERABLE LT Type COMMA Type GT SEMICOLON
+            Iterable : ITERABLE LT TypeWithExtendedAttributes GT SEMICOLON
+                     | ITERABLE LT TypeWithExtendedAttributes COMMA TypeWithExtendedAttributes GT SEMICOLON
         """
         location = self.getLocation(p, 2)
         identifier = IDLUnresolvedIdentifier(location, "__iterable",
@@ -6033,7 +6087,7 @@ class Parser(Tokenizer):
 
     def p_Setlike(self, p):
         """
-            Setlike : ReadOnly SETLIKE LT Type GT SEMICOLON
+            Setlike : ReadOnly SETLIKE LT TypeWithExtendedAttributes GT SEMICOLON
         """
         readonly = p[1]
         maplikeOrSetlikeType = p[2]
@@ -6047,7 +6101,7 @@ class Parser(Tokenizer):
 
     def p_Maplike(self, p):
         """
-            Maplike : ReadOnly MAPLIKE LT Type COMMA Type GT SEMICOLON
+            Maplike : ReadOnly MAPLIKE LT TypeWithExtendedAttributes COMMA TypeWithExtendedAttributes GT SEMICOLON
         """
         readonly = p[1]
         maplikeOrSetlikeType = p[2]
@@ -6085,7 +6139,7 @@ class Parser(Tokenizer):
 
     def p_AttributeRest(self, p):
         """
-            AttributeRest : ReadOnly ATTRIBUTE Type AttributeName SEMICOLON
+            AttributeRest : ReadOnly ATTRIBUTE TypeWithExtendedAttributes AttributeName SEMICOLON
         """
         location = self.getLocation(p, 2)
         readonly = p[1]
@@ -6339,32 +6393,47 @@ class Parser(Tokenizer):
 
     def p_Argument(self, p):
         """
-            Argument : ExtendedAttributeList Optional Type Ellipsis ArgumentName Default
+            Argument : ExtendedAttributeList ArgumentRest
         """
-        t = p[3]
+        p[0] = p[2]
+        p[0].addExtendedAttributes(p[1])
+
+    def p_ArgumentRestOptional(self, p):
+        """
+            ArgumentRest : OPTIONAL TypeWithExtendedAttributes ArgumentName Default
+        """
+        t = p[2]
         assert isinstance(t, IDLType)
-        identifier = IDLUnresolvedIdentifier(self.getLocation(p, 5), p[5])
+        identifier = IDLUnresolvedIdentifier(self.getLocation(p, 3), p[3])
 
-        optional = p[2]
-        variadic = p[4]
-        defaultValue = p[6]
+        defaultValue = p[4]
 
-        if not optional and defaultValue:
-            raise WebIDLError("Mandatory arguments can't have a default value.",
-                              [self.getLocation(p, 6)])
 
         # We can't test t.isAny() here and give it a default value as needed,
         # since at this point t is not a fully resolved type yet (e.g. it might
         # be a typedef).  We'll handle the 'any' case in IDLArgument.complete.
 
-        if variadic:
-            if optional:
-                raise WebIDLError("Variadic arguments should not be marked optional.",
-                                  [self.getLocation(p, 2)])
-            optional = variadic
+        p[0] = IDLArgument(self.getLocation(p, 3), identifier, t, True, defaultValue, False)
 
-        p[0] = IDLArgument(self.getLocation(p, 5), identifier, t, optional, defaultValue, variadic)
-        p[0].addExtendedAttributes(p[1])
+    def p_ArgumentRest(self, p):
+        """
+            ArgumentRest : Type Ellipsis ArgumentName
+        """
+        t = p[1]
+        assert isinstance(t, IDLType)
+        identifier = IDLUnresolvedIdentifier(self.getLocation(p, 3), p[3])
+
+        variadic = p[2]
+
+        # We can't test t.isAny() here and give it a default value as needed,
+        # since at this point t is not a fully resolved type yet (e.g. it might
+        # be a typedef).  We'll handle the 'any' case in IDLArgument.complete.
+
+        # variadic implies optional
+        # Any attributes that precede this may apply to the type, so
+        # we configure the argument to forward type attributes down instead of producing
+        # a parse error
+        p[0] = IDLArgument(self.getLocation(p, 3), identifier, t, variadic, None, variadic, allowTypeAttributes=True)
 
     def p_ArgumentName(self, p):
         """
@@ -6403,30 +6472,6 @@ class Parser(Tokenizer):
         """
         p[0] = p[1]
 
-    def p_Optional(self, p):
-        """
-            Optional : OPTIONAL
-        """
-        p[0] = True
-
-    def p_OptionalEmpty(self, p):
-        """
-            Optional :
-        """
-        p[0] = False
-
-    def p_Required(self, p):
-        """
-            Required : REQUIRED
-        """
-        p[0] = True
-
-    def p_RequiredEmpty(self, p):
-        """
-            Required :
-        """
-        p[0] = False
-
     def p_Ellipsis(self, p):
         """
             Ellipsis : ELLIPSIS
@@ -6567,6 +6612,12 @@ class Parser(Tokenizer):
         """
         p[0] = self.handleNullable(p[1], p[2])
 
+    def p_TypeWithExtendedAttributes(self, p):
+        """
+            TypeWithExtendedAttributes : ExtendedAttributeList Type
+        """
+        p[0] = p[2].withExtendedAttributes(p[1])
+
     def p_SingleTypeNonAnyType(self, p):
         """
             SingleType : NonAnyType
@@ -6589,9 +6640,9 @@ class Parser(Tokenizer):
 
     def p_UnionMemberTypeNonAnyType(self, p):
         """
-            UnionMemberType : NonAnyType
+            UnionMemberType : ExtendedAttributeList NonAnyType
         """
-        p[0] = p[1]
+        p[0] = p[2].withExtendedAttributes(p[1])
 
     def p_UnionMemberType(self, p):
         """
@@ -6641,7 +6692,7 @@ class Parser(Tokenizer):
 
     def p_NonAnyTypeSequenceType(self, p):
         """
-            NonAnyType : SEQUENCE LT Type GT Null
+            NonAnyType : SEQUENCE LT TypeWithExtendedAttributes GT Null
         """
         innerType = p[3]
         type = IDLSequenceType(self.getLocation(p, 1), innerType)
@@ -6657,7 +6708,7 @@ class Parser(Tokenizer):
 
     def p_NonAnyTypeRecordType(self, p):
         """
-            NonAnyType : RECORD LT StringType COMMA Type GT Null
+            NonAnyType : RECORD LT StringType COMMA TypeWithExtendedAttributes GT Null
         """
         keyType = p[3]
         valueType = p[5]

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

@@ -0,0 +1,238 @@
+# Import the WebIDL module, so we can do isinstance checks and whatnot
+import WebIDL
+
+def WebIDLTest(parser, harness):
+    # Basic functionality
+    threw = False
+    try:
+        parser.parse("""
+            typedef [EnforceRange] long Foo;
+            typedef [Clamp] long Bar;
+            typedef [TreatNullAs=EmptyString] DOMString Baz;
+            dictionary A {
+                required [EnforceRange] long a;
+                required [Clamp] long b;
+                [ChromeOnly, EnforceRange] long c;
+                Foo d;
+            };
+            interface B {
+                attribute Foo typedefFoo;
+                attribute [EnforceRange] long foo;
+                attribute [Clamp] long bar;
+                attribute [TreatNullAs=EmptyString] DOMString baz;
+                void method([EnforceRange] long foo, [Clamp] long bar,
+                            [TreatNullAs=EmptyString] DOMString baz);
+                void method2(optional [EnforceRange] long foo, optional [Clamp] long bar,
+                             optional [TreatNullAs=EmptyString] DOMString baz);
+            };
+            interface Setlike {
+                setlike<[Clamp] long>;
+            };
+            interface Maplike {
+                maplike<[Clamp] long, [EnforceRange] long>;
+            };
+            interface Iterable {
+                iterable<[Clamp] long, [EnforceRange] long>;
+            };
+        """)
+        results = parser.finish()
+    except:
+        threw = True
+
+    harness.ok(not threw, "Should not have thrown on parsing normal")
+    if not threw:
+        harness.check(results[0].innerType.enforceRange, True, "Foo is [EnforceRange]")
+        harness.check(results[1].innerType.clamp, True, "Bar is [Clamp]")
+        harness.check(results[2].innerType.treatNullAsEmpty, True, "Baz is [TreatNullAs=EmptyString]")
+        A = results[3]
+        harness.check(A.members[0].type.enforceRange, True, "A.a is [EnforceRange]")
+        harness.check(A.members[1].type.clamp, True, "A.b is [Clamp]")
+        harness.check(A.members[2].type.enforceRange, True, "A.c is [EnforceRange]")
+        harness.check(A.members[3].type.enforceRange, True, "A.d is [EnforceRange]")
+        B = results[4]
+        harness.check(B.members[0].type.enforceRange, True, "B.typedefFoo is [EnforceRange]")
+        harness.check(B.members[1].type.enforceRange, True, "B.foo is [EnforceRange]")
+        harness.check(B.members[2].type.clamp, True, "B.bar is [Clamp]")
+        harness.check(B.members[3].type.treatNullAsEmpty, True, "B.baz is [TreatNullAs=EmptyString]")
+        method = B.members[4].signatures()[0][1]
+        harness.check(method[0].type.enforceRange, True, "foo argument of method is [EnforceRange]")
+        harness.check(method[1].type.clamp, True, "bar argument of method is [Clamp]")
+        harness.check(method[2].type.treatNullAsEmpty, True, "baz argument of method is [TreatNullAs=EmptyString]")
+        method2 = B.members[5].signatures()[0][1]
+        harness.check(method[0].type.enforceRange, True, "foo argument of method2 is [EnforceRange]")
+        harness.check(method[1].type.clamp, True, "bar argument of method2 is [Clamp]")
+        harness.check(method[2].type.treatNullAsEmpty, True, "baz argument of method2 is [TreatNullAs=EmptyString]")
+
+    ATTRIBUTES = [("[Clamp]", "long"), ("[EnforceRange]", "long"), ("[TreatNullAs=EmptyString]", "DOMString")]
+    TEMPLATES = [
+        ("required dictionary members", """
+            dictionary Foo {
+                %s required %s foo;
+            };
+        """),
+        ("optional arguments", """
+            interface Foo {
+                void foo(%s optional %s foo);
+            };
+        """),
+        ("typedefs", """
+            %s typedef %s foo;
+        """),
+        ("attributes", """
+            interface Foo {
+            %s attribute %s foo;
+            };
+        """),
+        ("readonly attributes", """
+            interface Foo {
+                readonly attribute %s %s foo;
+            };
+        """),
+        ("readonly unresolved attributes", """
+            interface Foo {
+              readonly attribute Bar baz;
+            };
+            typedef %s %s Bar;
+        """)              
+    ];
+
+    for (name, template) in TEMPLATES:
+        parser = parser.reset()
+        threw = False
+        try:
+            parser.parse(template % ("", "long"))
+            parser.finish()
+        except:
+            threw = True
+        harness.ok(not threw, "Template for %s parses without attributes" % name)
+        for (attribute, type) in ATTRIBUTES:
+            parser = parser.reset()
+            threw = False
+            try:
+                parser.parse(template % (attribute, type))
+                parser.finish()
+            except:
+                threw = True
+            harness.ok(threw,
+                       "Should not allow %s on %s" % (attribute, name))
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            typedef [Clamp, EnforceRange] long Foo;
+        """)
+        parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw, "Should not allow mixing [Clamp] and [EnforceRange]")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            typedef [EnforceRange, Clamp] long Foo;
+        """)
+        parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw, "Should not allow mixing [Clamp] and [EnforceRange]")
+
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            typedef [Clamp] long Foo;
+            typedef [EnforceRange] Foo bar;
+        """)
+        parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw, "Should not allow mixing [Clamp] and [EnforceRange] via typedefs")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            typedef [EnforceRange] long Foo;
+            typedef [Clamp] Foo bar;
+        """)
+        parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw, "Should not allow mixing [Clamp] and [EnforceRange] via typedefs")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            typedef [Clamp] DOMString Foo;
+        """)
+        parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw, "Should not allow [Clamp] on DOMString")
+
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            typedef [EnforceRange] DOMString Foo;
+        """)
+        parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw, "Should not allow [EnforceRange] on DOMString")
+
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            typedef [TreatNullAs=EmptyString] long Foo;
+        """)
+        parser.finish()
+    except:
+        threw = True
+
+    harness.ok(threw, "Should not allow [TreatNullAs] on long")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            interface Foo {
+               void foo([Clamp] Bar arg);
+            };
+            typedef long Bar;
+        """)
+        results = parser.finish()
+    except:
+        threw = True
+    harness.ok(not threw, "Should allow type attributes on unresolved types")
+    harness.check(results[0].members[0].signatures()[0][1][0].type.clamp, True,
+                  "Unresolved types with type attributes should correctly resolve with attributes")
+
+    parser = parser.reset()
+    threw = False
+    try:
+        parser.parse("""
+            interface Foo {
+               void foo(Bar arg);
+            };
+            typedef [Clamp] long Bar;
+        """)
+        results = parser.finish()
+    except:
+        threw = True
+    harness.ok(not threw, "Should allow type attributes on typedefs")
+    harness.check(results[0].members[0].signatures()[0][1][0].type.clamp, True,
+                  "Unresolved types that resolve to typedefs with attributes should correctly resolve with attributes")

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

@@ -56,9 +56,9 @@ def WebIDLTest(parser, harness):
     results = parser.finish()
     # Pull out the first argument out of the arglist of the first (and
     # only) signature.
-    harness.ok(results[0].members[0].signatures()[0][1][0].clamp,
+    harness.ok(results[0].members[0].signatures()[0][1][0].type.clamp,
                "Should be clamped")
-    harness.ok(not results[0].members[1].signatures()[0][1][0].clamp,
+    harness.ok(not results[0].members[1].signatures()[0][1][0].type.clamp,
                "Should not be clamped")
 
     parser = parser.reset()
@@ -86,9 +86,9 @@ def WebIDLTest(parser, harness):
     results = parser.finish()
     # Pull out the first argument out of the arglist of the first (and
     # only) signature.
-    harness.ok(results[0].members[0].signatures()[0][1][0].enforceRange,
+    harness.ok(results[0].members[0].signatures()[0][1][0].type.enforceRange,
                "Should be enforceRange")
-    harness.ok(not results[0].members[1].signatures()[0][1][0].enforceRange,
+    harness.ok(not results[0].members[1].signatures()[0][1][0].type.enforceRange,
                "Should not be enforceRange")
 
     parser = parser.reset()

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

@@ -0,0 +1,16 @@
+def WebIDLTest(parser, harness):
+    exception = None
+    try:
+        parser.parse(
+            """
+            typedef long foo;
+            typedef long foo;
+            """)
+
+        results = parser.finish()
+    except Exception as e:
+        exception = e
+
+    harness.ok(exception, "Should have thrown.")
+    harness.ok("Multiple unresolvable definitions of identifier 'foo'" in str(exception),
+               "Should have a sane exception message")

components/script/dom/webidls/Blob.webidl

@@ -13,8 +13,8 @@ interface Blob {
   readonly attribute DOMString type;
 
   // slice Blob into byte-ranged chunks
-  Blob slice([Clamp] optional long long start,
-             [Clamp] optional long long end,
+  Blob slice(optional [Clamp] long long start,
+             optional [Clamp] long long end,
              optional DOMString contentType);
 };
 

components/script/dom/webidls/CSSStyleDeclaration.webidl

@@ -18,7 +18,7 @@ interface CSSStyleDeclaration {
   DOMString getPropertyPriority(DOMString property);
   [CEReactions, Throws]
   void setProperty(DOMString property, [TreatNullAs=EmptyString] DOMString value,
-                                       [TreatNullAs=EmptyString] optional DOMString priority = "");
+                                       optional [TreatNullAs=EmptyString] DOMString priority = "");
   [CEReactions, Throws]
   DOMString removeProperty(DOMString property);
   // readonly attribute CSSRule? parentRule;
@@ -27,471 +27,471 @@ interface CSSStyleDeclaration {
 };
 
 partial interface CSSStyleDeclaration {
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString all;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString all;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString background;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString backgroundColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString background-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString backgroundPosition;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString background-position;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString backgroundPositionX;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString background-position-x;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString backgroundPositionY;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString background-position-y;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString backgroundRepeat;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString background-repeat;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString backgroundImage;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString background-image;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString backgroundAttachment;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString background-attachment;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString backgroundSize;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString background-size;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString backgroundOrigin;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString background-origin;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString backgroundClip;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString background-clip;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString background;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString backgroundColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString background-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString backgroundPosition;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString background-position;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString backgroundPositionX;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString background-position-x;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString backgroundPositionY;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString background-position-y;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString backgroundRepeat;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString background-repeat;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString backgroundImage;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString background-image;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString backgroundAttachment;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString background-attachment;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString backgroundSize;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString background-size;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString backgroundOrigin;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString background-origin;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString backgroundClip;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString background-clip;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderRadius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-radius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderSpacing;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-spacing;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBottom;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-bottom;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBottomColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-bottom-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBottomLeftRadius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-bottom-left-radius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBottomRightRadius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-bottom-right-radius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBottomStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-bottom-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBottomWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-bottom-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderLeft;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-left;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderLeftColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-left-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderLeftStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-left-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderLeftWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-left-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderRight;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-right;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderRightColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-right-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderRightStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-right-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderRightWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-right-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderTop;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-top;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderTopColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-top-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderTopLeftRadius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-top-left-radius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderTopRightRadius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-top-right-radius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderTopStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-top-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderTopWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-top-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-image-source;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderImageSource;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-image-slice;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderImageSlice;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-image-repeat;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderImageRepeat;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-image-outset;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderImageOutset;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-image-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderImageWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-image;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderImage;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderRadius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-radius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderSpacing;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-spacing;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBottom;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-bottom;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBottomColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-bottom-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBottomLeftRadius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-bottom-left-radius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBottomRightRadius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-bottom-right-radius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBottomStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-bottom-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBottomWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-bottom-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderLeft;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-left;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderLeftColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-left-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderLeftStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-left-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderLeftWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-left-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderRight;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-right;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderRightColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-right-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderRightStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-right-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderRightWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-right-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderTop;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-top;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderTopColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-top-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderTopLeftRadius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-top-left-radius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderTopRightRadius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-top-right-radius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderTopStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-top-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderTopWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-top-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-image-source;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderImageSource;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-image-slice;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderImageSlice;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-image-repeat;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderImageRepeat;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-image-outset;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderImageOutset;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-image-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderImageWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-image;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderImage;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-block-start-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBlockStartColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-block-start-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBlockStartWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-block-start-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBlockStartStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-block-end-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBlockEndColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-block-end-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBlockEndWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-block-end-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBlockEndStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-block-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBlockColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-block-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBlockStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-block-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBlockWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-block-end;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBlockEnd;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-block-start;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBlockStart;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-block;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderBlock;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-inline-start-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderInlineStartColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-inline-start-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderInlineStartWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-inline-start-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderInlineStartStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-inline-end-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderInlineEndColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-inline-end-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderInlineEndWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-inline-end-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderInlineEndStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-inline-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderInlineColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-inline-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderInlineStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-inline-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderInlineWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-inline-start;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderInlineStart;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-inline-end;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderInlineEnd;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-inline;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderInline;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-block-start-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBlockStartColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-block-start-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBlockStartWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-block-start-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBlockStartStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-block-end-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBlockEndColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-block-end-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBlockEndWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-block-end-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBlockEndStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-block-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBlockColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-block-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBlockStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-block-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBlockWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-block-end;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBlockEnd;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-block-start;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBlockStart;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-block;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderBlock;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-inline-start-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderInlineStartColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-inline-start-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderInlineStartWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-inline-start-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderInlineStartStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-inline-end-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderInlineEndColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-inline-end-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderInlineEndWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-inline-end-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderInlineEndStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-inline-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderInlineColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-inline-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderInlineStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-inline-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderInlineWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-inline-start;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderInlineStart;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-inline-end;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderInlineEnd;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-inline;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderInline;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString content;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString content;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString color;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString display;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString display;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString opacity;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString opacity;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString visibility;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString visibility;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString cursor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString cursor;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString boxSizing;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString box-sizing;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString boxShadow;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString box-shadow;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString textShadow;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString text-shadow;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString boxSizing;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString box-sizing;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString boxShadow;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString box-shadow;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString textShadow;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString text-shadow;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString _float;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString _float;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString clear;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString clear;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString clip;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString clip;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transform;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transformOrigin;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transform-origin;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString perspective;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString perspectiveOrigin;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString perspective-origin;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transformStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transform-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString backfaceVisibility;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString backface-visibility;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString rotate;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString scale;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString translate;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transform;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transformOrigin;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transform-origin;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString perspective;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString perspectiveOrigin;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString perspective-origin;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transformStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transform-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString backfaceVisibility;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString backface-visibility;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString rotate;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString scale;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString translate;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString direction;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString unicodeBidi;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString unicode-bidi;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString direction;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString unicodeBidi;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString unicode-bidi;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString filter;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString filter;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString inset;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString inset;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString lineHeight;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString line-height;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString lineHeight;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString line-height;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString mixBlendMode;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString mix-blend-mode;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString mixBlendMode;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString mix-blend-mode;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString verticalAlign;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString vertical-align;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString verticalAlign;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString vertical-align;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString listStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString list-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString listStylePosition;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString list-style-position;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString listStyleType;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString list-style-type;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString listStyleImage;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString list-style-image;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString listStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString list-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString listStylePosition;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString list-style-position;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString listStyleType;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString list-style-type;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString listStyleImage;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString list-style-image;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString quotes;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString quotes;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString counterIncrement;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString counter-increment;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString counterReset;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString counter-reset;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString counterIncrement;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString counter-increment;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString counterReset;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString counter-reset;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString overflow;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString overflowX;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString overflow-x;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString overflowY;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString overflow-y;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString overflowWrap;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString overflow-wrap;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString overflow;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString overflowX;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString overflow-x;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString overflowY;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString overflow-y;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString overflowWrap;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString overflow-wrap;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString tableLayout;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString table-layout;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderCollapse;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-collapse;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString emptyCells;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString empty-cells;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString captionSide;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString caption-side;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString tableLayout;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString table-layout;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderCollapse;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-collapse;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString emptyCells;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString empty-cells;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString captionSide;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString caption-side;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString whiteSpace;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString white-space;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString whiteSpace;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString white-space;
 
-  [Pref="layout.writing-mode.enabled", CEReactions, SetterThrows, TreatNullAs=EmptyString]
-  attribute DOMString writingMode;
-  [Pref="layout.writing-mode.enabled", CEReactions, SetterThrows, TreatNullAs=EmptyString]
-  attribute DOMString writing-mode;
+  [Pref="layout.writing-mode.enabled", CEReactions, SetterThrows]
+  attribute [TreatNullAs=EmptyString] DOMString writingMode;
+  [Pref="layout.writing-mode.enabled", CEReactions, SetterThrows]
+  attribute [TreatNullAs=EmptyString] DOMString writing-mode;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString letterSpacing;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString letter-spacing;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString wordBreak;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString word-break;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString wordSpacing;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString word-spacing;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString wordWrap;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString word-wrap;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString textOverflow;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString text-overflow;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString letterSpacing;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString letter-spacing;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString wordBreak;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString word-break;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString wordSpacing;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString word-spacing;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString wordWrap;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString word-wrap;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString textOverflow;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString text-overflow;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString textAlign;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString text-align;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString textDecoration;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString text-decoration;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString textDecorationLine;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString text-decoration-line;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString textIndent;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString text-indent;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString textJustify;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString text-justify;
-  // [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString textOrientation;
-  // [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString text-orientation;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString textRendering;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString text-rendering;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString textTransform;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString text-transform;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString textAlign;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString text-align;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString textDecoration;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString text-decoration;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString textDecorationLine;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString text-decoration-line;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString textIndent;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString text-indent;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString textJustify;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString text-justify;
+  // [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString textOrientation;
+  // [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString text-orientation;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString textRendering;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString text-rendering;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString textTransform;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString text-transform;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString font;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString fontFamily;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString font-family;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString fontSize;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString font-size;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString fontStretch;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString font-stretch;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString fontStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString font-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString fontVariant;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString font-variant;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString fontVariantCaps;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString font-variant-caps;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString fontWeight;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString font-weight;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString font;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString fontFamily;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString font-family;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString fontSize;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString font-size;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString fontStretch;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString font-stretch;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString fontStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString font-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString fontVariant;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString font-variant;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString fontVariantCaps;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString font-variant-caps;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString fontWeight;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString font-weight;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString margin;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString marginBottom;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString margin-bottom;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString marginLeft;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString margin-left;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString marginRight;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString margin-right;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString marginTop;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString margin-top;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString margin-block-start;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString marginBlockStart;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString margin-block-end;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString marginBlockEnd;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString margin-block;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString marginBlock;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString margin-inline-start;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString marginInlineStart;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString margin-inline-end;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString marginInlineEnd;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString margin-inline;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString marginInline;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString margin;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString marginBottom;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString margin-bottom;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString marginLeft;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString margin-left;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString marginRight;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString margin-right;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString marginTop;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString margin-top;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString margin-block-start;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString marginBlockStart;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString margin-block-end;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString marginBlockEnd;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString margin-block;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString marginBlock;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString margin-inline-start;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString marginInlineStart;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString margin-inline-end;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString marginInlineEnd;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString margin-inline;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString marginInline;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString padding;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString paddingBottom;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString padding-bottom;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString paddingLeft;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString padding-left;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString paddingRight;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString padding-right;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString paddingTop;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString padding-top;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString padding-block-start;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString paddingBlockStart;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString padding-block-end;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString paddingBlockEnd;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString padding-block;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString paddingBlock;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString padding-inline-start;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString paddingInlineStart;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString padding-inline-end;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString paddingInlineEnd;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString padding-inline;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString paddingInline;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString padding;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString paddingBottom;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString padding-bottom;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString paddingLeft;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString padding-left;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString paddingRight;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString padding-right;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString paddingTop;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString padding-top;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString padding-block-start;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString paddingBlockStart;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString padding-block-end;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString paddingBlockEnd;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString padding-block;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString paddingBlock;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString padding-inline-start;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString paddingInlineStart;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString padding-inline-end;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString paddingInlineEnd;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString padding-inline;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString paddingInline;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString outline;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString outlineColor;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString outline-color;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString outlineStyle;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString outline-style;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString outlineWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString outline-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString outlineOffset;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString outline-offset;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString outline;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString outlineColor;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString outline-color;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString outlineStyle;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString outline-style;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString outlineWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString outline-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString outlineOffset;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString outline-offset;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString position;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString position;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString pointerEvents;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString pointer-events;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString pointerEvents;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString pointer-events;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString top;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString right;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString left;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString bottom;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString offset-block-start;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString offsetBlockStart;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString offset-block-end;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString offsetBlockEnd;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString offset-inline-start;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString offsetInlineStart;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString offset-inline-end;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString offsetInlineEnd;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString inset-block-start;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString insetBlockStart;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString inset-block-end;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString insetBlockEnd;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString inset-block;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString insetBlock;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString inset-inline-start;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString insetInlineStart;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString inset-inline-end;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString insetInlineEnd;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString inset-inline;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString insetInline;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString top;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString right;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString left;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString bottom;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString offset-block-start;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString offsetBlockStart;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString offset-block-end;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString offsetBlockEnd;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString offset-inline-start;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString offsetInlineStart;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString offset-inline-end;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString offsetInlineEnd;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString inset-block-start;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString insetBlockStart;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString inset-block-end;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString insetBlockEnd;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString inset-block;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString insetBlock;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString inset-inline-start;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString insetInlineStart;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString inset-inline-end;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString insetInlineEnd;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString inset-inline;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString insetInline;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString height;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString minHeight;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString min-height;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString maxHeight;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString max-height;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString height;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString minHeight;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString min-height;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString maxHeight;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString max-height;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString minWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString min-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString maxWidth;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString max-width;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString block-size;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString blockSize;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString inline-size;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString inlineSize;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString max-block-size;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString maxBlockSize;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString max-inline-size;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString maxInlineSize;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString min-block-size;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString minBlockSize;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString min-inline-size;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString minInlineSize;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString minWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString min-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString maxWidth;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString max-width;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString block-size;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString blockSize;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString inline-size;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString inlineSize;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString max-block-size;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString maxBlockSize;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString max-inline-size;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString maxInlineSize;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString min-block-size;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString minBlockSize;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString min-inline-size;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString minInlineSize;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString zIndex;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString z-index;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString zIndex;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString z-index;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString imageRendering;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString image-rendering;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString imageRendering;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString image-rendering;
 
-  [Pref="layout.columns.enabled", CEReactions, SetterThrows, TreatNullAs=EmptyString]
-  attribute DOMString columnCount;
-  [Pref="layout.columns.enabled", CEReactions, SetterThrows, TreatNullAs=EmptyString]
-  attribute DOMString column-count;
-  [Pref="layout.columns.enabled", CEReactions, SetterThrows, TreatNullAs=EmptyString]
-  attribute DOMString columnWidth;
-  [Pref="layout.columns.enabled", CEReactions, SetterThrows, TreatNullAs=EmptyString]
-  attribute DOMString column-width;
-  [Pref="layout.columns.enabled", CEReactions, SetterThrows, TreatNullAs=EmptyString]
-  attribute DOMString columns;
-  [Pref="layout.columns.enabled", CEReactions, SetterThrows, TreatNullAs=EmptyString]
-  attribute DOMString columnGap;
-  [Pref="layout.columns.enabled", CEReactions, SetterThrows, TreatNullAs=EmptyString]
-  attribute DOMString column-gap;
+  [Pref="layout.columns.enabled", CEReactions, SetterThrows]
+  attribute [TreatNullAs=EmptyString] DOMString columnCount;
+  [Pref="layout.columns.enabled", CEReactions, SetterThrows]
+  attribute [TreatNullAs=EmptyString] DOMString column-count;
+  [Pref="layout.columns.enabled", CEReactions, SetterThrows]
+  attribute [TreatNullAs=EmptyString] DOMString columnWidth;
+  [Pref="layout.columns.enabled", CEReactions, SetterThrows]
+  attribute [TreatNullAs=EmptyString] DOMString column-width;
+  [Pref="layout.columns.enabled", CEReactions, SetterThrows]
+  attribute [TreatNullAs=EmptyString] DOMString columns;
+  [Pref="layout.columns.enabled", CEReactions, SetterThrows]
+  attribute [TreatNullAs=EmptyString] DOMString columnGap;
+  [Pref="layout.columns.enabled", CEReactions, SetterThrows]
+  attribute [TreatNullAs=EmptyString] DOMString column-gap;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transition;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transitionDuration;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transition-duration;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transitionTimingFunction;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transition-timing-function;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transitionProperty;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transition-property;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transitionDelay;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString transition-delay;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transition;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transitionDuration;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transition-duration;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transitionTimingFunction;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transition-timing-function;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transitionProperty;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transition-property;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transitionDelay;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString transition-delay;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flex;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flexFlow;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flex-flow;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flexDirection;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flex-direction;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flexWrap;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flex-wrap;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString justifyContent;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString justify-content;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString alignItems;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString align-items;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString alignContent;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString align-content;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString order;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flexBasis;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flex-basis;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flexGrow;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flex-grow;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flexShrink;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString flex-shrink;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString alignSelf;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString align-self;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flex;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flexFlow;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flex-flow;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flexDirection;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flex-direction;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flexWrap;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flex-wrap;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString justifyContent;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString justify-content;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString alignItems;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString align-items;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString alignContent;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString align-content;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString order;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flexBasis;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flex-basis;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flexGrow;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flex-grow;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flexShrink;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString flex-shrink;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString alignSelf;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString align-self;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animation;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animation-name;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animationName;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animation-duration;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animationDuration;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animation-timing-function;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animationTimingFunction;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animation-iteration-count;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animationIterationCount;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animation-direction;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animationDirection;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animation-play-state;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animationPlayState;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animation-fill-mode;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animationFillMode;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animation-delay;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString animationDelay;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animation;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animation-name;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animationName;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animation-duration;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animationDuration;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animation-timing-function;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animationTimingFunction;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animation-iteration-count;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animationIterationCount;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animation-direction;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animationDirection;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animation-play-state;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animationPlayState;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animation-fill-mode;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animationFillMode;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animation-delay;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString animationDelay;
 
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-end-end-radius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderEndEndRadius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-start-end-radius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderStartEndRadius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-start-start-radius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderStartStartRadius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString border-end-start-radius;
-  [CEReactions, SetterThrows, TreatNullAs=EmptyString] attribute DOMString borderEndStartRadius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-end-end-radius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderEndEndRadius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-start-end-radius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderStartEndRadius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-start-start-radius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderStartStartRadius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString border-end-start-radius;
+  [CEReactions, SetterThrows] attribute [TreatNullAs=EmptyString] DOMString borderEndStartRadius;
 
 };

components/script/dom/webidls/CharacterData.webidl

@@ -11,7 +11,7 @@
 
 [Abstract]
 interface CharacterData : Node {
-  [Pure, TreatNullAs=EmptyString] attribute DOMString data;
+  [Pure] attribute [TreatNullAs=EmptyString] DOMString data;
   [Pure] readonly attribute unsigned long length;
   [Pure, Throws]
   DOMString substringData(unsigned long offset, unsigned long count);

components/script/dom/webidls/Document.webidl

@@ -152,8 +152,8 @@ Document implements DocumentAndElementEventHandlers;
 
 // https://html.spec.whatwg.org/multipage/#Document-partial
 partial interface Document {
-  [CEReactions, TreatNullAs=EmptyString]
-  attribute DOMString fgColor;
+  [CEReactions]
+  attribute [TreatNullAs=EmptyString] DOMString fgColor;
 
   // https://github.com/servo/servo/issues/8715
   // [CEReactions, TreatNullAs=EmptyString]
@@ -167,8 +167,8 @@ partial interface Document {
   // [CEReactions, TreatNullAs=EmptyString]
   // attribute DOMString alinkColor;
 
-  [CEReactions, TreatNullAs=EmptyString]
-  attribute DOMString bgColor;
+  [CEReactions]
+  attribute [TreatNullAs=EmptyString] DOMString bgColor;
 
   [SameObject]
   readonly attribute HTMLCollection anchors;

components/script/dom/webidls/Element.webidl

@@ -109,10 +109,10 @@ partial interface Element {
 
 // https://w3c.github.io/DOM-Parsing/#extensions-to-the-element-interface
 partial interface Element {
-  [CEReactions, Throws,TreatNullAs=EmptyString]
-  attribute DOMString innerHTML;
-  [CEReactions, Throws,TreatNullAs=EmptyString]
-  attribute DOMString outerHTML;
+  [CEReactions, Throws]
+  attribute [TreatNullAs=EmptyString] DOMString innerHTML;
+  [CEReactions, Throws]
+  attribute [TreatNullAs=EmptyString] DOMString outerHTML;
 };
 
 // https://fullscreen.spec.whatwg.org/#api

components/script/dom/webidls/HTMLBodyElement.webidl

@@ -11,7 +11,7 @@ HTMLBodyElement implements WindowEventHandlers;
 
 // https://html.spec.whatwg.org/multipage/#HTMLBodyElement-partial
 partial interface HTMLBodyElement {
-  [CEReactions, TreatNullAs=EmptyString] attribute DOMString text;
+  [CEReactions] attribute [TreatNullAs=EmptyString] DOMString text;
 
   // https://github.com/servo/servo/issues/8715
   //[CEReactions, TreatNullAs=EmptyString] attribute DOMString link;
@@ -22,6 +22,6 @@ partial interface HTMLBodyElement {
   // https://github.com/servo/servo/issues/8717
   //[CEReactions, TreatNullAs=EmptyString] attribute DOMString aLink;
 
-  [CEReactions, TreatNullAs=EmptyString] attribute DOMString bgColor;
+  [CEReactions] attribute [TreatNullAs=EmptyString] DOMString bgColor;
   [CEReactions] attribute DOMString background;
 };

components/script/dom/webidls/HTMLElement.webidl

@@ -46,7 +46,7 @@ interface HTMLElement : Element {
   //         attribute boolean spellcheck;
   // void forceSpellCheck();
 
-  [TreatNullAs=EmptyString] attribute DOMString innerText;
+  attribute [TreatNullAs=EmptyString] DOMString innerText;
 
   // command API
   // readonly attribute DOMString? commandType;

components/script/dom/webidls/HTMLFontElement.webidl

@@ -5,8 +5,8 @@
 // https://html.spec.whatwg.org/multipage/#htmlfontelement
 [HTMLConstructor]
 interface HTMLFontElement : HTMLElement {
-  [CEReactions, TreatNullAs=EmptyString]
-  attribute DOMString color;
+  [CEReactions]
+  attribute [TreatNullAs=EmptyString] DOMString color;
   [CEReactions]
   attribute DOMString face;
   [CEReactions]

components/script/dom/webidls/HTMLImageElement.webidl

@@ -43,8 +43,8 @@ partial interface HTMLImageElement {
   [CEReactions]
            attribute DOMString longDesc;
 
-  [CEReactions, TreatNullAs=EmptyString]
-  attribute DOMString border;
+  [CEReactions]
+  attribute [TreatNullAs=EmptyString] DOMString border;
 };
 
 // https://drafts.csswg.org/cssom-view/#extensions-to-the-htmlimageelement-interface

components/script/dom/webidls/HTMLInputElement.webidl

@@ -68,8 +68,8 @@ interface HTMLInputElement : HTMLElement {
            attribute DOMString type;
   [CEReactions]
            attribute DOMString defaultValue;
-  [CEReactions, TreatNullAs=EmptyString, SetterThrows]
-           attribute DOMString value;
+  [CEReactions, SetterThrows]
+           attribute [TreatNullAs=EmptyString] DOMString value;
   //          attribute Date? valueAsDate;
   //          attribute unrestricted double valueAsNumber;
   //          attribute double valueLow;

components/script/dom/webidls/HTMLTableCellElement.webidl

@@ -40,6 +40,6 @@ partial interface HTMLTableCellElement {
   // [CEReactions]
   //          attribute DOMString vAlign;
 
-  [CEReactions, TreatNullAs=EmptyString]
-  attribute DOMString bgColor;
+  [CEReactions]
+  attribute [TreatNullAs=EmptyString] DOMString bgColor;
 };

components/script/dom/webidls/HTMLTableElement.webidl

@@ -48,8 +48,8 @@ partial interface HTMLTableElement {
   [CEReactions]
   attribute DOMString width;
 
-  [CEReactions, TreatNullAs=EmptyString]
-           attribute DOMString bgColor;
+  [CEReactions]
+           attribute [TreatNullAs=EmptyString] DOMString bgColor;
   // [CEReactions, TreatNullAs=EmptyString]
   //          attribute DOMString cellPadding;
   // [CEReactions, TreatNullAs=EmptyString]

components/script/dom/webidls/HTMLTableRowElement.webidl

@@ -27,6 +27,6 @@ partial interface HTMLTableRowElement {
   // [CEReactions]
   //          attribute DOMString vAlign;
 
-  [CEReactions, TreatNullAs=EmptyString]
-           attribute DOMString bgColor;
+  [CEReactions]
+           attribute [TreatNullAs=EmptyString] DOMString bgColor;
 };

components/script/dom/webidls/HTMLTextAreaElement.webidl

@@ -37,8 +37,7 @@ interface HTMLTextAreaElement : HTMLElement {
   readonly attribute DOMString type;
   [CEReactions]
            attribute DOMString defaultValue;
-  [TreatNullAs=EmptyString]
-           attribute DOMString value;
+           attribute [TreatNullAs=EmptyString] DOMString value;
   readonly attribute unsigned long textLength;
 
   // readonly attribute boolean willValidate;

components/script/dom/webidls/MediaList.webidl

@@ -5,7 +5,7 @@
 // https://drafts.csswg.org/cssom/#the-medialist-interface
 // [LegacyArrayClass]
 interface MediaList {
-  [TreatNullAs=EmptyString] /* stringifier */ attribute DOMString mediaText;
+  /* stringifier */ attribute [TreatNullAs=EmptyString] DOMString mediaText;
   readonly attribute unsigned long length;
   getter DOMString? item(unsigned long index);
   void appendMedium(DOMString medium);

components/script/dom/webidls/WebSocket.webidl

@@ -23,7 +23,7 @@ interface WebSocket : EventTarget {
     attribute EventHandler onclose;
     //readonly attribute DOMString extensions;
     readonly attribute DOMString protocol;
-    [Throws] void close([Clamp] optional unsigned short code, optional USVString reason);
+    [Throws] void close(optional [Clamp] unsigned short code, optional USVString reason);
 
     //messaging
     attribute EventHandler onmessage;