Do not split attributes on getters and setters in databasebuilder.

lib/dom/scripts/databasebuilder.py

 #!/usr/bin/python
 # Copyright (c) 2011, 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.
 
 import copy
 import database
 import idlparser
 import logging
 import os
@@ skipping 85 matching lines @@
     for type_node in idl_file.all(IDLType):
       while type_node.id in type_def_map:
         type_node.id = type_def_map[type_node.id]
 
   def _strip_ext_attributes(self, idl_file):
     """Strips unuseful extended attributes."""
     for ext_attrs in idl_file.all(IDLExtAttrs):
       # TODO: Decide which attributes are uninteresting.
       pass
 
-  def _split_declarations(self, interface, optional_argument_whitelist):
-    """Splits read-write attributes and operations with optional
-    arguments into multiple declarations"""
-
-    # split attributes into setters and getters
-    new_attributes = []
-    for attribute in interface.attributes:
-      if attribute.is_fc_getter or attribute.is_fc_setter:
-        new_attributes.append(attribute)
-        continue
-      getter_attr = copy.deepcopy(attribute)
-      getter_attr.is_fc_getter = True
-      new_attributes.append(getter_attr)
-      if not attribute.is_read_only:
-        setter_attr = copy.deepcopy(attribute)
-        setter_attr.is_fc_setter = True
-        new_attributes.append(setter_attr)
-    interface.attributes = new_attributes
-
-    # Add 'Optional' attribute to whitelisted arguments.
-    for op in interface.operations:
-      for argument in op.arguments:
-        in_optional_whitelist = (interface.id, op.id, argument.id) in optional_argument_whitelist
-        if in_optional_whitelist:
-          argument.ext_attrs['Optional'] = None
-
   def _rename_types(self, idl_file, import_options):
     """Rename interface and type names with names provided in the
     options. Also clears scopes from scoped names"""
 
     def rename(name):
       name_parts = name.split('::')
       name = name_parts[-1]
       if name in import_options.type_rename_map:
         name = import_options.type_rename_map[name]
       return name
@@ skipping 55 matching lines @@
       res = ['op']
       for special in node.specials:
         res.append(special)
       if node.id is not None:
         res.append(node.id)
       for arg in node.arguments:
         res.append(self._sign(arg.type))
       res.append(self._sign(node.type))
     elif isinstance(node, IDLAttribute):
       res = []
-      if node.is_fc_getter:
-        res.append('getter')
-      elif node.is_fc_setter:
-        res.append('setter')
+      if node.is_read_only:
+        res.append('readonly')
       res.append(node.id)
       res.append(self._sign(node.type))
     elif isinstance(node, IDLConstant):
       res = []
       res.append('const')
       res.append(node.id)
       res.append(node.value)
       res.append(self._sign(node.type))
     else:
       raise TypeError("Can't sign input of type %s" % type(node))
@@ skipping 180 matching lines @@
       if source:
         parent.annotations[source] = IDLAnnotation(
             import_options.source_attributes)
       interface.parents.append(parent)
 
   def merge_imported_interfaces(self, optional_argument_whitelist):
     """Merges all imported interfaces and loads them into the DB."""
 
     # Step 1: Pre process imported interfaces
     for interface, module_name, import_options in self._imported_interfaces:
-      self._split_declarations(interface, optional_argument_whitelist)
+      # Add 'Optional' attribute to whitelisted arguments.
+      for op in interface.operations:
+        for argument in op.arguments:
+          in_optional_whitelist = (interface.id, op.id, argument.id) in optional_argument_whitelist
+          if in_optional_whitelist:
+            argument.ext_attrs['Optional'] = None
       self._annotate(interface, module_name, import_options)
 
     # Step 2: Add all new interfaces and merge overlapping ones
     for interface, module_name, import_options in self._imported_interfaces:
       if not interface.is_supplemental:
         if self._database.HasInterface(interface.id):
           old_interface = self._database.GetInterface(interface.id)
           self._merge_interfaces(old_interface, interface, import_options)
         else:
           if import_options.add_new_interfaces:
@@ skipping 137 matching lines @@
                 del annotation[name]
 
         map(normalize, interface.parents)
         map(normalize, interface.constants)
         map(normalize, interface.attributes)
         map(normalize, interface.operations)
 
   def fetch_constructor_data(self, options):
     window_interface = self._database.GetInterface('Window')
     for attr in window_interface.attributes:
-      if not attr.is_fc_getter:
-        continue
       type = attr.type.id
       if not type.endswith('Constructor'):
         continue
       type = re.sub('(Constructor)+$', '', type)
       # TODO(antonm): Ideally we'd like to have pristine copy of WebKit IDLs and fetch
       # this information directly from it.  Unfortunately right now database is massaged
       # a lot so it's difficult to maintain necessary information on DOMWindow itself.
       interface = self._database.GetInterface(options.type_rename_map.get(type, type))
       if 'V8EnabledPerContext' in attr.ext_attrs:
         interface.ext_attrs['synthesizedV8EnabledPerContext'] = \
             attr.ext_attrs['V8EnabledPerContext']
       if 'V8EnabledAtRuntime' in attr.ext_attrs:
         interface.ext_attrs['synthesizedV8EnabledAtRuntime'] = \
             attr.ext_attrs['V8EnabledAtRuntime'] or attr.id