Avoid generating an overriding field in dart:dom

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 557 matching lines @@
 
     # 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 = [attr for attr in parent_interface.attributes
-                    if not self._DefinesSameAttribute(interface, attr)]
+                    if not _FindMatchingAttribute(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)
@@ skipping 11 matching lines @@
     return
 
   def _IsEventAttribute(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
     database, and the name for undefined interfaces.
     """
     def walk(parents):
       for parent in parents:
         if _IsDartCollectionType(parent.type.id):
           result.append(parent.type.id)
@@ skipping 79 matching lines @@
   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 _FindMatchingAttribute(interface, attr1):
+  matches = [attr2 for attr2 in interface.attributes
+             if attr1.id == attr2.id
+             and attr1.is_fc_getter == attr2.is_fc_getter
+             and attr1.is_fc_setter == attr2.is_fc_setter]
+  if matches:
+    assert len(matches) == 1
+    return matches[0]
+  return None
+
+
 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 1340 matching lines @@
     self._members_emitter.Emit('\n  static final $TYPE $NAME = $VALUE;\n',
                                NAME=constant.id,
                                TYPE=constant.type.id,
                                VALUE=constant.value)
 
     pass
 
   def AddAttribute(self, getter, setter):
     output_type = getter and self._NarrowOutputType(getter.type.id)
     input_type = setter and self._NarrowInputType(setter.type.id)
+
+    # If the (getter, setter) pair is shadowing, we can't generate a shadowing
+    # field (Issue 1633).
+    (super_getter, super_getter_interface) = self._FindShadowedAttribute(getter)
+    (super_setter, super_setter_interface) = self._FindShadowedAttribute(setter)
+    if super_getter or super_setter:
+      if getter and not setter and super_getter and not super_setter:
+        if getter.type.id == super_getter.type.id:
+          # Compatible getter, use the superclass property.  This works because
+          # JavaScript will do its own dynamic dispatch.
+          self._members_emitter.Emit(
+              '\n'
+              '  // Use implementation from $SUPER.\n'
+              '  // final $TYPE $NAME;\n',
+              SUPER=super_getter_interface.id,
+              NAME=getter.id, TYPE=output_type)
+          return
+
+      self._members_emitter.Emit('\n  // Shadowing definition.')
+      self._AddAttributeUsingProperties(getter, setter)
+      return
+
     if getter and setter and input_type == output_type:
       self._members_emitter.Emit(
           '\n  $TYPE $NAME;\n',
           NAME=getter.id, TYPE=output_type)
       return
     if getter and not setter:
       self._members_emitter.Emit(
           '\n  final $TYPE $NAME;\n',
           NAME=getter.id, TYPE=output_type)
       return
+    self._AddAttributeUsingProperties(getter, setter)
+
+  def _AddAttributeUsingProperties(self, getter, setter):
     if getter:
       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):
     # TODO(sra): Remove native body when Issue 829 fixed.
     self._members_emitter.Emit(
-        '\n  void set $NAME($TYPE value) native "this.$NAME = value;";\n',
+        '  void set $NAME($TYPE value) native "this.$NAME = value;";\n',
         NAME=attr.id, TYPE=self._NarrowInputType(attr.type.id))
 
+  def _FindShadowedAttribute(self, attr):
+    """Returns (attribute, superinterface) or (None, None)."""
+    def FindInParent(interface):
+      """Returns matching attribute in parent, or None."""
+      if interface.parents:
+        parent = interface.parents[0]
+        if _IsDartCollectionType(parent.type.id):
+          return (None, None)
+        if self._system._database.HasInterface(parent.type.id):
+          parent_interface = self._system._database.GetInterface(parent.type.id)
+          attr2 = _FindMatchingAttribute(parent_interface, attr)
+          if attr2:
+            return (attr2, parent_interface)
+          return FindInParent(parent_interface)
+      return (None, None)
+
+    return FindInParent(self._interface) if attr else (None, None)
+
+
   def AddSecondaryAttribute(self, interface, getter, setter):
     self._SecondaryContext(interface)
     self.AddAttribute(getter, setter)
 
   def AddSecondaryOperation(self, interface, info):
     self._SecondaryContext(interface)
     self.AddOperation(info)
 
   def AddEventAttributes(self, event_attrs):
     pass
@@ skipping 377 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)