Do not split attributes on getters and setters in databasebuilder.

lib/dom/scripts/systembase.py

 #!/usr/bin/python
 # Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 """This module provides base functionality for systems to generate
 Dart APIs from the IDL database."""
 
 import os
 from generator import *
@@ skipping 98 matching lines @@
   def Generate(self):
     self.StartInterface()
     self.AddMembers(self._interface)
     self.AddSecondaryMembers(self._interface)
     self.FinishInterface()
 
   def AddMembers(self, interface):
     for const in sorted(interface.constants, ConstantOutputOrder):
       self.AddConstant(const)
 
-    attributes = [attr for attr in interface.attributes
-                  if attr.type.id != 'EventListener']
-    for (getter, setter) in  _PairUpAttributes(attributes):
-      self.AddAttribute(getter, setter)
+    for attr in interface.attributes:
+      if attr.type.id != 'EventListener':
+        self.AddAttribute(attr)
 
     # The implementation should define an indexer if the interface directly
     # extends List.
     (element_type, requires_indexer) = ListImplementationInfo(
           interface, self._database)
     if element_type:
       if requires_indexer:
         self.AddIndexer(element_type)
       else:
         self.AmendIndexer(element_type)
@@ skipping 15 matching lines @@
 
   def AddSecondaryMembers(self, interface):
     # With multiple inheritance, attributes and operations of non-first
     # interfaces need to be added.  Sometimes the attribute or operation is
     # defined in the current interface as well as a parent.  In that case we
     # avoid making a duplicate definition and pray that the signatures match.
     secondary_parents = self._TransitiveSecondaryParents(interface)
     for parent_interface in secondary_parents:
       if isinstance(parent_interface, str):  # IsDartCollectionType(parent_interface)
         continue
-      attributes = [attr for attr in parent_interface.attributes
-                    if not FindMatchingAttribute(interface, attr)]
-      for (getter, setter) in _PairUpAttributes(attributes):
-        self.AddSecondaryAttribute(parent_interface, getter, setter)
+      for attr in parent_interface.attributes:
+        if not FindMatchingAttribute(interface, attr):
+          self.AddSecondaryAttribute(parent_interface, attr)
 
       # Group overloaded operations by id
       operationsById = {}
       for operation in parent_interface.operations:
         if operation.id not in operationsById:
           operationsById[operation.id] = []
         operationsById[operation.id].append(operation)
 
       # Generate operations
       for id in sorted(operationsById.keys()):
         if not any(op.id == id for op in interface.operations):
           operations = operationsById[id]
           info = AnalyzeOperation(interface, operations)
           self.AddSecondaryOperation(parent_interface, info)
 
   def AddConstant(self, constant):
     pass
 
-  def AddAttribute(self, getter, setter):
+  def AddAttribute(self, attribute):
     pass
 
   def AddIndexer(self, element_type):
     pass
 
   def AmendIndexer(self, element_type):
     pass
 
   def AddOperation(self, info):
     pass
 
   def AddStaticOperation(self, info):
     pass
 
-  def AddSecondaryAttribute(self, interface, getter, setter):
+  def AddSecondaryAttribute(self, interface, attribute):
     pass
 
-  def AddSecondaryOperation(self, interface, attr):
+  def AddSecondaryOperation(self, interface, info):
     pass
 
   def _TransitiveSecondaryParents(self, interface):
     """Returns a list of all non-primary parents.
 
     The list contains the interface objects for interfaces defined in the
     database, and the name for undefined interfaces.
     """
     def walk(parents):
       for parent in parents:
         if IsDartCollectionType(parent.type.id):
           result.append(parent.type.id)
           continue
         if self._database.HasInterface(parent.type.id):
           parent_interface = self._database.GetInterface(parent.type.id)
           result.append(parent_interface)
           walk(parent_interface.parents)
 
     result = []
     if interface.parents:
       parent = interface.parents[0]
       if IsPureInterface(parent.type.id):
         walk(interface.parents)
       else:
         walk(interface.parents[1:])
     return result
 
 
-def _PairUpAttributes(attributes):
-  """Returns a list of (getter, setter) pairs sorted by name.
-
-  One element of the pair may be None.
-  """
-  names = sorted(set(attr.id for attr in attributes))
-  getters = {}
-  setters = {}
-  for attr in attributes:
-    if attr.is_fc_getter:
-      getters[attr.id] = attr
-    elif attr.is_fc_setter and 'Replaceable' not in attr.ext_attrs:
-      setters[attr.id] = attr
-  return [(getters.get(id), setters.get(id)) for id in names]
+def IsReadOnly(attribute):
+  return attribute.is_read_only or 'Replaceable' in attribute.ext_attrs