Cleanup list-like interfaces generation.

lib/html/scripts/systemhtml.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 shared functionality for the system to generate
 Dart:html APIs from the IDL database."""
 
 import emitter
 import os
@@ skipping 222 matching lines @@
         not self._interface_type_info.merged_into()):
       interface_emitter = self._library_emitter.FileEmitter(interface_name)
     else:
       interface_emitter = emitter.Emitter()
 
     template_file = 'interface_%s.darttemplate' % interface_name
     interface_template = (self._template_loader.TryLoad(template_file) or
                           self._template_loader.Load('interface.darttemplate'))
 
     implements = []
-    suppressed_implements = []
-
     for parent in self._interface.parents:
       parent_type_info = self._type_registry.TypeInfo(parent.type.id)
-      parent_interface_name = parent_type_info.interface_name()
-      # TODO(vsm): Remove source_filter.
-      if MatchSourceFilter(parent):
-        # Parent is a DOM type.
-        implements.append(parent_interface_name)
-      elif '<' in parent.type.id:
-        # Parent is a Dart collection type.
-        # TODO(vsm): Make this check more robust.
-        implements.append(parent_interface_name)
-      else:
-        suppressed_implements.append('%s.%s' %
-            (self._common_prefix, parent_interface_name))
+      implements.append(parent_type_info.interface_name())
+
+    if self._interface_type_info.list_item_type():
+      item_type_info = self._type_registry.TypeInfo(
+          self._interface_type_info.list_item_type())
+      implements.append('List<%s>' % item_type_info.dart_type())
 
     if interface_name in _secure_base_types:
       implements.append(_secure_base_types[interface_name])
 
     comment = ' extends'
     implements_str = ''
     if implements:
       implements_str += ' implements ' + ', '.join(implements)
       comment = ','
-    if suppressed_implements:
-      implements_str += ' /*%s %s */' % (comment,
-          ', '.join(suppressed_implements))
 
     factory_provider = None
     if interface_name in interface_factories:
       factory_provider = interface_factories[interface_name]
 
     constructors = []
     constructor_info = AnalyzeConstructor(self._interface)
     if constructor_info:
       constructors.append(constructor_info)
       factory_provider = '_' + interface_name + 'FactoryProvider'
@@ skipping 49 matching lines @@
         CLASSNAME=self._interface_type_info.implementation_name(),
         EXTENDS=' extends %s' % base_class if base_class else '',
         IMPLEMENTS=' implements ' + ', '.join(implemented_interfaces),
         NATIVESPEC=self._backend.NativeSpec())
     self._backend.StartInterface(self._implementation_members_emitter)
 
     for constructor_info in constructors:
       constructor_info.GenerateFactoryInvocation(
           self._DartType, self._members_emitter, factory_provider)
 
-    element_type = MaybeTypedArrayElementTypeInHierarchy(
-        self._interface, self._database)
+    element_type = None
+    for interface in self._database.Hierarchy(self._interface):
+      type_info = self._type_registry.TypeInfo(interface.id)
+      if type_info.is_typed_array():
+        element_type = type_info.list_item_type()
+        break
     if element_type:
       self._members_emitter.Emit(
           '\n'
           '  factory $CTOR(int length) =>\n'
           '    $FACTORY.create$(CTOR)(length);\n'
           '\n'
           '  factory $CTOR.fromList(List<$TYPE> list) =>\n'
           '    $FACTORY.create$(CTOR)_fromList(list);\n'
           '\n'
           '  factory $CTOR.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => \n'
@@ skipping 24 matching lines @@
   def AddMembers(self, interface):
     for const in sorted(interface.constants, ConstantOutputOrder):
       self.AddConstant(const)
 
     for attr in sorted(interface.attributes, ConstantOutputOrder):
       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)
+    element_type = None
+    requires_indexer = False
+    if self._interface_type_info.list_item_type():
+      self.AddIndexer(self._interface_type_info.list_item_type())
+    else:
+      for parent in self._database.Hierarchy(self._interface):
+        if parent == self._interface:
+          continue
+        parent_type_info = self._type_registry.TypeInfo(parent.id)
+        if parent_type_info.list_item_type():
+          self.AmendIndexer(parent_type_info.list_item_type())
+          break
+
     # Group overloaded operations by id
     operationsById = {}
     for operation in interface.operations:
       if operation.id not in operationsById:
         operationsById[operation.id] = []
       operationsById[operation.id].append(operation)
 
     # Generate operations
     for id in sorted(operationsById.keys()):
       operations = operationsById[id]
@@ skipping 202 matching lines @@
 
   def GenerateCallback(self, info):
     pass
 
   def RootClassName(self):
     return None
 
   def AdditionalImplementedInterfaces(self):
     # TODO: Include all implemented interfaces, including other Lists.
     implements = []
-    element_type = MaybeTypedArrayElementType(self._interface)
-    if element_type:
+    if self._interface_type_info.is_typed_array():
+      element_type = self._interface_type_info.list_item_type()
       implements.append('List<%s>' % self._DartType(element_type))
-    if self._HasJavaScriptIndexingBehaviour():
+    if self._interface_type_info.list_item_type():
       implements.append('JavaScriptIndexingBehavior')
     return implements
 
   def NativeSpec(self):
     native_spec = MakeNativeSpec(self._interface.javascript_binding_name)
     return ' native "%s"' % native_spec
 
   def ImplementationTemplate(self):
     template_file = ('impl_%s.darttemplate' %
                      self._interface_type_info.interface_name())
@@ skipping 405 matching lines @@
     return FindConversion(idl_type, 'set', self._interface.id, member)
 
   def _HasCustomImplementation(self, member_name):
     member_name = '%s.%s' % (self._interface_type_info.interface_name(),
                              member_name)
     return member_name in _js_custom_members
 
   def CustomJSMembers(self):
     return _js_custom_members
 
-  def _HasJavaScriptIndexingBehaviour(self):
-    """Returns True if the native object has an indexer and length property."""
-    (element_type, requires_indexer) = ListImplementationInfo(
-        self._interface, self._database)
-    if element_type and requires_indexer: return True
-    return False
-
   def _NarrowToImplementationType(self, type_name):
     return self._type_registry.TypeInfo(type_name).narrow_dart_type()
 
   def _NarrowInputType(self, type_name):
     return self._NarrowToImplementationType(type_name)
 
   def _NarrowOutputType(self, type_name):
     secure_name = SecureOutputType(self, type_name, True)
     return self._NarrowToImplementationType(secure_name)
 
@@ skipping 61 matching lines @@
 
     library_emitter = self._multiemitter.FileEmitter(library_file_path)
     library_file_dir = os.path.dirname(library_file_path)
     auxiliary_dir = os.path.relpath(auxiliary_dir, library_file_dir)
     imports_emitter = library_emitter.Emit(
         self._template, AUXILIARY_DIR=massage_path(auxiliary_dir))
     for path in sorted(self._path_to_emitter.keys()):
       relpath = os.path.relpath(path, library_file_dir)
       imports_emitter.Emit(
           "#source('$PATH');\n", PATH=massage_path(relpath))