Use fields in hidden native DOM classes instead of getters/setters.

client/dom/scripts/dartgenerator.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 generates Dart APIs from the IDL database."""
 
 import emitter
 import idlnode
 import logging
@@ skipping 472 matching lines @@
                                             source_filter)
                   for system in self._systems]
 
     for generator in generators:
       generator.StartInterface()
 
     for const in sorted(interface.constants, ConstantOutputOrder):
       for generator in generators:
         generator.AddConstant(const)
 
-    for attr in sorted(interface.attributes, AttributeOutputOrder):
-      if attr.type.id == 'EventListener':
-        # Remove EventListener attributes like 'onclick' when addEventListener
-        # is available.
-        if 'EventTarget' in self._AllImplementedInterfaces(interface):
-          continue
-      if attr.is_fc_getter:
-        for generator in generators:
-          generator.AddGetter(attr)
-      elif attr.is_fc_setter:
-        for generator in generators:
-          generator.AddSetter(attr)
+    attributes = [attr for attr in interface.attributes
+                  if not self._OmitAttribute(interface, attr)]
+    for (getter, setter) in  _PairUpAttributes(attributes):
+      for generator in generators:
+        generator.AddAttribute(getter, setter)
 
     # The implementation should define an indexer if the interface directly
     # extends List.
     element_type = MaybeListElementType(interface)
     if element_type:
       for generator in generators:
         generator.AddIndexer(element_type)
 
     # Group overloaded operations by id
     operationsById = {}
@@ skipping 10 matching lines @@
         generator.AddOperation(info)
 
     # 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.
 
     for parent_interface in self._TransitiveSecondaryParents(interface):
       if isinstance(parent_interface, str):  # _IsDartCollectionType(parent_interface)
         continue
-      attributes = sorted(parent_interface.attributes,
-                          AttributeOutputOrder)
-      for attr in attributes:
-        if not self._DefinesSameAttribute(interface, attr):
-          if attr.is_fc_getter:
-            for generator in generators:
-              generator.AddSecondaryGetter(parent_interface, attr)
-          elif attr.is_fc_setter:
-            for generator in generators:
-              generator.AddSecondarySetter(parent_interface, attr)
+      attributes = [attr for attr in parent_interface.attributes
+                    if not self._DefinesSameAttribute(interface, attr)]
+      for (getter, setter) in _PairUpAttributes(attributes):
+        for generator in generators:
+          generator.AddSecondaryAttribute(parent_interface, getter, setter)
 
       # 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)
           for generator in generators:
             generator.AddSecondaryOperation(parent_interface, info)
 
     for generator in generators:
       generator.FinishInterface()
     return
 
+  def _OmitAttribute(self, interface, attr):
+    # Remove EventListener attributes like 'onclick' when addEventListener
+    # is available.
+    if attr.type.id == 'EventListener':
+      if 'EventTarget' in self._AllImplementedInterfaces(interface):
+        return True
+    return False
+
   def _DefinesSameAttribute(self, interface, attr1):
     return any(attr1.id == attr2.id
                and attr1.is_fc_getter == attr2.is_fc_getter
                and attr1.is_fc_setter == attr2.is_fc_setter
                for attr2 in interface.attributes)
 
   def _TransitiveSecondaryParents(self, interface):
     """Returns a list of all non-primary parents.
 
     The list contains the interface objects for interfaces defined in the
@@ skipping 54 matching lines @@
   """Returns the info for the callback method if the interface smells like a
   callback.
   """
   if 'Callback' not in interface.ext_attrs: return None
   handlers = [op for op in interface.operations if op.id == 'handleEvent']
   if not handlers: return None
   if not (handlers == interface.operations): return None
   return _AnalyzeOperation(interface, handlers)
 
 
+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:
+      setters[attr.id] = attr
+  return [(getters.get(id), setters.get(id)) for id in names]
+
+
 def _AnalyzeOperation(interface, operations):
   """Makes operation calling convention decision for a set of overloads.
 
   Returns: An OperationInfo object.
   """
 
   # Zip together arguments from each overload by position, then convert
   # to a dart argument.
 
   # Given a list of overloaded arguments, choose a suitable name.
@@ skipping 581 matching lines @@
     if (not self._super_interface or
         self._interface.id is self._super_interface):
       self._EmitConstant(self._members_emitter, constant)
 
   def _EmitConstant(self, emitter, constant):
     emitter.Emit('\n  static final $TYPE $NAME = $VALUE;\n',
                  NAME=constant.id,
                  TYPE=constant.type.id,
                  VALUE=constant.value)
 
-  def AddGetter(self, attr):
-    self._members_emitter.Emit('\n  $TYPE get $NAME();\n',
-                               NAME=attr.id, TYPE=attr.type.id)
-
-  def AddSetter(self, attr):
-    self._members_emitter.Emit('\n  void set $NAME($TYPE value);\n',
-                               NAME=attr.id, TYPE=attr.type.id)
+  def AddAttribute(self, getter, setter):
+    if getter:
+      self._members_emitter.Emit('\n  $TYPE get $NAME();\n',
+                                 NAME=getter.id, TYPE=getter.type.id)
+    if setter:
+      self._members_emitter.Emit('\n  void set $NAME($TYPE value);\n',
+                                 NAME=setter.id, TYPE=setter.type.id)
 
   def AddIndexer(self, element_type):
     # Interface inherits all operations from List<element_type>.
     pass
 
   def AddOperation(self, info):
     """
     Arguments:
       operations - contains the overloads, one or more operations with the same
         name.
     """
     self._members_emitter.Emit('\n'
                                '  $TYPE $NAME($PARAMS);\n',
                                TYPE=info.type_name,
                                NAME=info.name,
                                PARAMS=info.ParametersInterfaceDeclaration())
 
   # Interfaces get secondary members directly via the superinterfaces.
-  def AddSecondaryGetter(self, interface, attr):
+  def AddSecondaryAttribute(self, interface, getter, setter):
     pass
-  def AddSecondarySetter(self, interface, attr):
-    pass
+
   def AddSecondaryOperation(self, interface, attr):
     pass
 
 
 # Given a sorted sequence of type identifiers, return an appropriate type
 # name
 def TypeName(typeIds, interface):
   # Dynamically type this field for now.
   return 'var'
 
@@ skipping 95 matching lines @@
   def AddConstant(self, constant):
     # Constants are already defined on the interface.
     pass
 
   def _MethodName(self, prefix, name):
     method_name = prefix + name
     if name in self._base_members:  # Avoid illegal Dart 'static override'.
       method_name = method_name + '_' + self._interface.id
     return method_name
 
-  def AddGetter(self, attr):
+  def AddAttribute(self, getter, setter):
+    if getter:
+      self._AddGetter(getter)
+    if setter:
+      self._AddSetter(setter)
+
+  def _AddGetter(self, attr):
     # FIXME: Instead of injecting the interface name into the method when it is
     # also implemented in the base class, suppress the method altogether if it
     # has the same signature.  I.e., let the JS do the virtual dispatch instead.
     method_name = self._MethodName('_get_', attr.id)
     self._members_emitter.Emit(
         '\n'
         '  $TYPE get $NAME() { return $METHOD(this); }\n'
         '  static $TYPE $METHOD(var _this) native;\n',
         NAME=attr.id, TYPE=attr.type.id, METHOD=method_name)
     if (self._interface.id, attr.id) not in _custom_getters:
       self._js_code.Emit(
           '\n'
           'function native_$(CLASS)_$(METHOD)(_this) {\n'
           '  try {\n'
           '    return __dom_wrap(_this.$dom.$NAME);\n'
           '  } catch (e) {\n'
           '    throw __dom_wrap_exception(e);\n'
           '  }\n'
           '}\n',
           CLASS=self._class_name, NAME=attr.id, METHOD=method_name)
       self._externs.add((self._interface.id, attr.id, 'attribute'))
 
-  def AddSetter(self, attr):
+  def _AddSetter(self, attr):
     # FIXME: See comment on getter.
     method_name = self._MethodName('_set_', attr.id)
     self._members_emitter.Emit(
         '\n'
         '  void set $NAME($TYPE value) { $METHOD(this, value); }\n'
         '  static void $METHOD(var _this, $TYPE value) native;\n',
         NAME=attr.id, TYPE=attr.type.id, METHOD=method_name)
     self._js_code.Emit(
         '\n'
         'function native_$(CLASS)_$(METHOD)(_this, value) {\n'
         '  try {\n'
         '    _this.$dom.$NAME = __dom_unwrap(value);\n'
         '  } catch (e) {\n'
         '    throw __dom_wrap_exception(e);\n'
         '  }\n'
         '}\n',
         CLASS=self._class_name, NAME=attr.id, METHOD=method_name)
     self._externs.add((self._interface.id, attr.id, 'attribute'))
 
-  def AddSecondaryGetter(self, interface, attr):
+  def AddSecondaryAttribute(self, interface, getter, setter):
     self._SecondaryContext(interface)
-    self.AddGetter(attr)
-
-  def AddSecondarySetter(self, interface, attr):
-    self._SecondaryContext(interface)
-    self.AddSetter(attr)
+    self.AddAttribute(getter, setter)
 
   def AddSecondaryOperation(self, interface, info):
     self._SecondaryContext(interface)
     self.AddOperation(info)
 
   def _SecondaryContext(self, interface):
     if interface is not self._current_secondary_parent:
       self._current_secondary_parent = interface
       self._members_emitter.Emit('\n  // From $WHERE\n', WHERE=interface.id)
 
@@ skipping 513 matching lines @@
     # Since we are currently generating native classes without interfaces,
     # generate the constants as part of the class.  This will need to go away
     # if we revert back to generating interfaces.
     self._members_emitter.Emit('\n  static final $TYPE $NAME = $VALUE;\n',
                                NAME=constant.id,
                                TYPE=constant.type.id,
                                VALUE=constant.value)
 
     pass
 
-  def AddGetter(self, attr):
+  def AddAttribute(self, getter, setter):
+    use_fields = True
+    output_type = getter and self._NarrowOutputType(getter.type.id)
+    input_type = setter and self._NarrowInputType(setter.type.id)
+    if use_fields and getter and setter:
+      if input_type == output_type:
+        self._members_emitter.Emit(
+            '\n  $TYPE $NAME;\n',
+            NAME=getter.id, TYPE=output_type)
+        return
+    if use_fields and getter and not setter:
+        self._members_emitter.Emit(
+            '\n  final $TYPE $NAME;\n',
+            NAME=getter.id, TYPE=output_type)
+        return
+    if getter:

[vsm, 2012/02/06 18:37:18]

Do we ever fall past this?

+      self._AddGetter(getter)
+    if setter:
+      self._AddSetter(setter)
+
+  def _AddGetter(self, attr):
     # TODO(sra): Remove native body when Issue 829 fixed.
     self._members_emitter.Emit(
         '\n  $TYPE get $NAME() native "return this.$NAME;";\n',
         NAME=attr.id, TYPE=self._NarrowOutputType(attr.type.id))
 
-  def AddSetter(self, attr):
+  def _AddSetter(self, attr):
     # TODO(sra): Remove native body when Issue 829 fixed.
     self._members_emitter.Emit(
         '\n  void set $NAME($TYPE value) native "this.$NAME = value;";\n',
         NAME=attr.id, TYPE=self._NarrowInputType(attr.type.id))
 
-  def AddSecondaryGetter(self, interface, attr):
+  def AddSecondaryAttribute(self, interface, getter, setter):
     self._SecondaryContext(interface)
-    self.AddGetter(attr)
-
-  def AddSecondarySetter(self, interface, attr):
-    self._SecondaryContext(interface)
-    self.AddSetter(attr)
+    self.AddAttribute(getter, setter)
 
   def AddSecondaryOperation(self, interface, info):
     self._SecondaryContext(interface)
     self.AddOperation(info)
 
   def _SecondaryContext(self, interface):
     if interface is not self._current_secondary_parent:
       self._current_secondary_parent = interface
       self._members_emitter.Emit('\n  // From $WHERE\n', WHERE=interface.id)
 
@@ skipping 180 matching lines @@
   def FinishInterface(self):
     interface = self._interface
     interface_name = interface.id
 
     base = self._BaseClassName(interface)
     self._dart_impl_emitter.Emit(
         self._templates.Load('dart_implementation.darttemplate'),
         CLASS=self._class_name, BASE=base, INTERFACE=interface_name,
         MEMBERS=self._members_emitter.Fragments())
 
-  def AddGetter(self, attr):
+  def AddAttribute(self, getter, setter):
+    if getter:
+      self._AddGetter(getter)
+    if setter:
+      self._AddSetter(setter)
+
+  def _AddGetter(self, attr):
     self._members_emitter.Emit(
         '\n'
         '  $TYPE get $NAME() native "$(INTERFACE)_$(NAME)_Getter";\n',
         NAME=attr.id, TYPE=attr.type.id, INTERFACE=self._interface.id)
 
-  def AddSetter(self, attr):
+  def _AddSetter(self, attr):
     self._members_emitter.Emit(
         '\n'
         '  void set $NAME($TYPE) native "$(INTERFACE)_$(NAME)_Setter";\n',
         NAME=attr.id, TYPE=attr.type.id, INTERFACE=self._interface.id)
 
   def _HasNativeIndexGetter(self, interface):
     return ('HasCustomIndexGetter' in interface.ext_attrs or
             'HasNumericIndexGetter' in interface.ext_attrs)
 
   def _EmitNativeIndexGetter(self, interface, element_type):
@@ skipping 74 matching lines @@
                    INDENT=indent,
                    NATIVENAME=native_name,
                    ARGS=argument_expressions)
 
     self._members_emitter.Emit('  $TYPE $NATIVE_NAME($PARAMS) native '
                                '"$(INTERFACE)$(NATIVE_NAME)_Callback";\n',
                                NATIVE_NAME=native_name,
                                TYPE=info.type_name,
                                PARAMS=', '.join(arg_names),
                                INTERFACE=self._interface.id)