Bug 1297480 - Add BindingAlias= for WebIDL attrbutes, use it to slim CSS2Properties down. r=bz

As opposed to Alias attribute, which reuses the JS function object for the property, BindingAlias will only reuse the generated attribute binding implementation, without changing observable behavior. It can be used to reduce amount of generated code, if the attributes are known to behave exactly the same.

This cuts the size of generated CSS2PropertiesBinding.cpp by half, and removes ~100kB of dupicated code from libxul.

MozReview-Commit-ID: G0q8TbaqFdp

--HG--
extra : rebase_source : 87a2a501cc8adb379df1f4563d3696a339abd0fc

Author: adrian17

dom/bindings/Codegen.py

@@ -2706,8 +2706,15 @@ def __init__(self, descriptor, name, static, unforgeable=False):
                           not isNonExposedNavigatorObjectGetter(m, descriptor)]
         else:
             attributes = []
-        self.chrome = [m for m in attributes if isChromeOnly(m)]
-        self.regular = [m for m in attributes if not isChromeOnly(m)]
+
+        attributes = [
+            {"name": name, "attr": attr}
+            for attr in attributes
+            for name in [attr.identifier.name] + attr.bindingAliases
+        ]
+
+        self.chrome = [m for m in attributes if isChromeOnly(m["attr"])]
+        self.regular = [m for m in attributes if not isChromeOnly(m["attr"])]
         self.static = static
         self.unforgeable = unforgeable
 
@@ -2724,6 +2731,9 @@ def generateArray(self, array, name):
         if len(array) == 0:
             return ""
 
+        def condition(m, d):
+            return PropertyDefiner.getControllingCondition(m["attr"], d)
+
         def flags(attr):
             unforgeable = " | JSPROP_PERMANENT" if self.unforgeable else ""
             return EnumerabilityFlags(attr) + unforgeable
@@ -2791,16 +2801,16 @@ def setter(attr):
             return "%s, %s" % \
                    (accessor, jitinfo)
 
-        def specData(attr):
-            return (attr.identifier.name, flags(attr), getter(attr),
-                    setter(attr))
+        def specData(entry):
+            name, attr = entry["name"], entry["attr"]
+            return (name, flags(attr), getter(attr), setter(attr))
 
         return self.generatePrefableArray(
             array, name,
             lambda fields: '  { "%s", %s, %s, %s }' % fields,
             '  { nullptr, 0, nullptr, nullptr, nullptr, nullptr }',
             'JSPropertySpec',
-            PropertyDefiner.getControllingCondition, specData)
+            condition, specData)
 
 
 class ConstDefiner(PropertyDefiner):

dom/bindings/GenerateCSS2PropertiesWebIDL.py

@@ -33,16 +33,15 @@ def generate(output, idlFilename, preprocessorHeader):
         if pref is not "":
             extendedAttrs.append('Pref="%s"' % pref)
 
-        # webkit properties get a capitalized "WebkitFoo" accessor (added here)
-        # as well as a camelcase "webkitFoo" accessor (added next).
+        # webkit properties get a camelcase "webkitFoo" accessor
+        # as well as a capitalized "WebkitFoo" alias (added here).
         if (prop.startswith("Webkit")):
-            props += generateLine(prop, extendedAttrs)
+            extendedAttrs.append('BindingAlias="%s"' % prop)
 
-        # Generate a line with camelCase spelling of property-name (or capitalized,
+        # Generate a name with camelCase spelling of property-name (or capitalized,
         # for Moz-prefixed properties):
         if not prop.startswith("Moz"):
             prop = prop[0].lower() + prop[1:]
-        props += generateLine(prop, extendedAttrs)
 
         # Per spec, what's actually supposed to happen here is that we're supposed
         # to have properties for:
@@ -56,15 +55,14 @@ def generate(output, idlFilename, preprocessorHeader):
         # in that list.
         #
         # In practice, cssFloat is the only case in which "name" doesn't contain
-        # "-" but also doesn't match "prop".  So the above generatePropLine() call
-        # covered (3) and all of (1) except "float".  If we now output attributes
+        # "-" but also doesn't match "prop".  So the generateLine() call will
+        # cover (3) and all of (1) except "float".  If we now add an alias
         # for all the cases where "name" doesn't match "prop", that will cover
         # "float" and (2).
         if prop != name:
-            extendedAttrs.append('BinaryName="%s"' % prop)
-            # Throw in a '_' before the attribute name, because some of these
-            # property names collide with IDL reserved words.
-            props += generateLine("_" + name, extendedAttrs)
+            extendedAttrs.append('BindingAlias="%s"' % name)
+
+        props += generateLine(prop, extendedAttrs)
 
 
     idlFile = open(idlFilename, "r")

dom/bindings/parser/WebIDL.py

@@ -1181,6 +1181,22 @@ def finish(self, scope):
                 parent = parent.parent
 
     def validate(self):
+
+        def checkDuplicateNames(member, name, attributeName):
+            for m in self.members:
+                if m.identifier.name == name:
+                    raise WebIDLError("[%s=%s] has same name as interface member" %
+                                      (attributeName, name),
+                                      [member.location, m.location])
+                if m.isMethod() and m != member and name in m.aliases:
+                    raise WebIDLError("conflicting [%s=%s] definitions" %
+                                      (attributeName, name),
+                                      [member.location, m.location])
+                if m.isAttr() and m != member and name in m.bindingAliases:
+                    raise WebIDLError("conflicting [%s=%s] definitions" %
+                                      (attributeName, name),
+                                      [member.location, m.location])
+
         # We don't support consequential unforgeable interfaces.  Need to check
         # this here, because in finish() an interface might not know yet that
         # it's consequential.
@@ -1293,15 +1309,15 @@ def validate(self):
                         raise WebIDLError("[Alias] must not be used on an "
                                           "[Unforgeable] operation",
                                           [member.location])
-                    for m in self.members:
-                        if m.identifier.name == alias:
-                            raise WebIDLError("[Alias=%s] has same name as "
-                                              "interface member" % alias,
-                                              [member.location, m.location])
-                        if m.isMethod() and m != member and alias in m.aliases:
-                            raise WebIDLError("duplicate [Alias=%s] definitions" %
-                                              alias,
-                                              [member.location, m.location])
+
+                    checkDuplicateNames(member, alias, "Alias")
+
+            # Check that the name of a [BindingAlias] doesn't conflict with an
+            # interface member.
+            if member.isAttr():
+                for bindingAlias in member.bindingAliases:
+                    checkDuplicateNames(member, bindingAlias, "BindingAlias")
+
 
         if (self.getExtendedAttribute("Pref") and
             self._exposureGlobalNames != set([self.parentScope.primaryGlobalName])):
@@ -3581,6 +3597,11 @@ def _addAlias(self, alias):
                               [self.location])
         self.aliases.append(alias)
 
+    def _addBindingAlias(self, bindingAlias):
+        if bindingAlias in self.bindingAliases:
+            raise WebIDLError("Duplicate [BindingAlias=%s] on attribute" % bindingAlias,
+                              [self.location])
+        self.bindingAliases.append(bindingAlias)
 
 class IDLMaplikeOrSetlikeOrIterableBase(IDLInterfaceMember):
 
@@ -4011,6 +4032,7 @@ def __init__(self, location, identifier, type, readonly, inherit=False,
         self.dependsOn = "Everything"
         self.affects = "Everything"
         self.navigatorObjectGetter = navigatorObjectGetter
+        self.bindingAliases = []
 
         if static and identifier.name == "prototype":
             raise WebIDLError("The identifier of a static attribute must not be 'prototype'",
@@ -4155,6 +4177,11 @@ def handleExtendedAttribute(self, attr):
             raise WebIDLError("Readonly attributes must not be flagged as "
                               "[%s]" % identifier,
                               [self.location])
+        elif identifier == "BindingAlias":
+            if not attr.hasValue():
+                raise WebIDLError("[BindingAlias] takes an identifier or string",
+                                  [attr.location])
+            self._addBindingAlias(attr.value())
         elif (((identifier == "Throws" or identifier == "GetterThrows" or
                 identifier == "CanOOM" or identifier == "GetterCanOOM") and
                self.getExtendedAttribute("StoreInSlot")) or