Implement List<T> operations on dom types via manual mixins.

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 707 matching lines @@
         if optional:
           raise Exception('Optional arguments cannot precede required ones: '
                           + str(args))
         required.append((name, type, None))
     argtexts = map(FormatArg, required)
     if optional:
       argtexts.append('[' + ', '.join(map(FormatArg, optional)) + ']')
     return ', '.join(argtexts)
 
 
+def MaybeListElementTypeName(type_name):
+  """Returns the List element type T from string of form "List<T>", or None."""
+  match = re.match(r'List<(\w*)>$', type_name)
+  if match:
+    return match.group(1)
+  return None
+
 def MaybeListElementType(interface):
   """Returns the List element type T, or None in interface does not implement
   List<T>.
   """
   for parent in interface.parents:
-    match = re.match(r'List<(\w*)>$', parent.type.id)
-    if match:
-      return match.group(1)
+    element_type = MaybeListElementTypeName(parent.type.id)
+    if element_type:
+      return element_type
   return None
 
 def MaybeTypedArrayElementType(interface):
   """Returns the typed array element type, or None in interface is not a
   TypedArray.
   """
   # Typed arrays implement ArrayBufferView and List<T>.
   for parent in interface.parents:
     if  parent.type.id == 'ArrayBufferView':
       return MaybeListElementType(interface)
@@ skipping 1104 matching lines @@
       native_spec = _frog_dom_custom_native_specs[interface_name]
     else:
       # Make the class 'hidden' so it is dynamically patched at runtime.  This
       # is useful not only for browser compat, but to allow code that links
       # against dart:dom to load in a worker isolate.
       native_spec = '*' + interface_name
 
     if base:
       extends = ' extends ' + base
     elif native_spec[0] == '=':
+      # The implementation is a singleton with no prototype.
       extends = ''
     else:
       extends = ' extends DOMTypeJs'
 
     # TODO: Include all implemented interfaces, including other Lists.
     implements = [interface_name]
     element_type = MaybeTypedArrayElementType(self._interface)
     if element_type:
       implements.append('List<' + element_type + '>')
 
@@ skipping 99 matching lines @@
     # In the non-root case we have to choose between:
     #
     #   class YImpl extends XImpl { add List<T> methods; }
     #
     # and
     #
     #   class YImpl extends ListBase<T> { copies of transitive XImpl methods; }
     #
     self._members_emitter.Emit(
         '\n'
-        '  $TYPE operator[](int index) native;\n',
+        '  $TYPE operator[](int index) native "return this[index];";\n',
         TYPE=self._NarrowOutputType(element_type))
 
     if 'HasCustomIndexSetter' in self._interface.ext_attrs:
       self._members_emitter.Emit(
           '\n'
-          '  void operator[]=(int index, $TYPE value) native;\n',
+          '  void operator[]=(int index, $TYPE value) native "this[index] = value";\n',
           TYPE=self._NarrowInputType(element_type))
     else:
       self._members_emitter.Emit(
           '\n'
           '  void operator[]=(int index, $TYPE value) {\n'
           '    throw new UnsupportedOperationException("Cannot assign element of immutable List.");\n'
           '  }\n',
           TYPE=self._NarrowInputType(element_type))
 
+    # TODO(sra): Use separate mixins for mutable implementations of List<T>.
+    # TODO(sra): Use separate mixins for typed array implementations of List<T>.
+    template_file = 'immutable_list_mixin.darttemplate'
+    template = self._system._templates.Load(template_file)
+    self._members_emitter.Emit(template, E=element_type)
+
 
   def AddTypedArrayConstructors(self, element_type):
     self._members_emitter.Emit(
         '\n'
         '  factory $CTOR(int length) =>  _construct(length);\n'
         '\n'
         '  factory $CTOR.fromList(List<$TYPE> list) => _construct(list);\n'
         '\n'
         '  factory $CTOR.fromBuffer(ArrayBuffer buffer) => _construct(buffer);\n'
         '\n'
         '  static _construct(arg) native \'return new $CTOR(arg);\';\n',
         CTOR=self._interface.id,
         TYPE=element_type)
 
 
   def AddOperation(self, info):
     """
     Arguments:
       info: An OperationInfo object.
     """
     # TODO(vsm): Handle overloads.
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($PARAMS) native;\n',
         TYPE=self._NarrowOutputType(info.type_name),
         NAME=info.name,
         PARAMS=info.ParametersImplementationDeclaration(
             lambda type_name: self._NarrowInputType(type_name)))