Revert "Implement typed array constructors."

client/dom/scripts/dartgenerator.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.
 
 """This module generates Dart APIs from the IDL database."""
 
 import emitter
 import idlnode
 import logging
@@ skipping 63 matching lines @@
     'FileReader': '',
     'XMLHttpRequest': '',
     'WebKitCSSMatrix': '[String spec]',
     'WebKitPoint': 'num x, num y',
     # dart:html types
     'CSSMatrix': '[String spec]',
     'Point': 'num x, num y',
 }
 
 #
-# Interface version of the DOM needs to delegate typed array constructors to a
-# factory provider.
-#
-_interface_factories = {
-    'Float32Array': '_TypedArrayFactoryProvider',
-    'Float64Array': '_TypedArrayFactoryProvider',
-    'Int8Array': '_TypedArrayFactoryProvider',
-    'Int16Array': '_TypedArrayFactoryProvider',
-    'Int32Array': '_TypedArrayFactoryProvider',
-    'Uint8Array': '_TypedArrayFactoryProvider',
-    'Uint16Array': '_TypedArrayFactoryProvider',
-    'Uint32Array': '_TypedArrayFactoryProvider',
-}
-
-#
 # Custom methods that must be implemented by hand.
 #
 _custom_methods = set([
     ('DOMWindow', 'setInterval'),
     ('DOMWindow', 'setTimeout'),
     ('WorkerContext', 'setInterval'),
     ('WorkerContext', 'setTimeout'),
     ('CanvasRenderingContext2D', 'setFillStyle'),
     ('CanvasRenderingContext2D', 'setStrokeStyle'),
     ('CanvasRenderingContext2D', 'setFillStyle'),
     ])
 
 #
 # Custom getters that must be implemented by hand.
 #
 _custom_getters = set([
     ('DOMWindow', 'localStorage'),
     ])
 
 #
 # Custom native specs for the Frog dom.
 #
 _frog_dom_custom_native_specs = {
     'Console': '=console',      # Decorate the singleton Console object.
     'DOMWindow': '@*DOMWindow', # DOMWindow aliased with global scope.
-
-    # Temporary hack: make these not be 'hidden'.  Will not work on IE9.
-    'Float32Array': 'Float32Array',
-    'Float64Array': 'Float64Array',
-    'Int8Array': 'Int8Array',
-    'Int16Array': 'Int16Array',
-    'Int32Array': 'Int32Array',
-    'Uint8Array': 'Uint8Array',
-    'Uint16Array': 'Uint16Array',
-    'Uint32Array': 'Uint32Array',
 }
 
 #
 # Publically visible types common across all supported browsers.
 #
 _BROWSER_SHARED_TYPES = [
         'Attr',
         'CDATASection',
         'CSSFontFaceRule',
         'CSSImportRule',
@@ skipping 584 matching lines @@
       if attr.type.id == 'EventListener': 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)
 
     # 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)
+    for parent in interface.parents:
+      match = re.match(r'List<(\w*)>$', parent.type.id)
+      if match:
+        element_type = match.group(1)
+        for generator in generators:
+          generator.AddIndexer(element_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]
       info = self._AnalyzeOperation(interface, operations)
       for generator in generators:
         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)
+      if isinstance(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:
@@ skipping 540 matching lines @@
     type_name: A string, the name of the return type of the operation.
     arg_declarations: A list of strings, Dart argument declarations for the
         member that implements the set of overloads.  Each string is of the form
         "T arg" or "T arg = null".
     arg_infos: A list of (name, type, default_value) tuples.
         default_value is None for mandatory arguments.
   """
   pass
 
 
-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)
-  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)
-  return None
-
-
 def AttributeOutputOrder(a, b):
   """Canonical output ordering for attributes."""
     # Getters before setters:
   if a.id < b.id: return -1
   if a.id > b.id: return 1
   if a.is_fc_setter < b.is_fc_setter: return -1
   if a.is_fc_setter > b.is_fc_setter: return 1
   return 0
 
 def ConstantOutputOrder(a, b):
@@ skipping 84 matching lines @@
 
     comment = ' extends'
     if extends:
       extends_emitter.Emit(' extends $SUPERS', SUPERS=', '.join(extends))
       comment = ','
     if suppressed_extends:
       extends_emitter.Emit(' /*$COMMENT $SUPERS */',
                            COMMENT=comment,
                            SUPERS=', '.join(suppressed_extends))
 
-    if typename in _interface_factories:
-      extends_emitter.Emit(' factory $F', F=_interface_factories[typename])
-
-    element_type = MaybeTypedArrayElementType(self._interface)
-    if element_type:
-      self._members_emitter.Emit(
-          '\n'
-          '  $CTOR(int length);\n'
-          '\n'
-          '  $CTOR.fromList(List<$TYPE> list);\n'
-          '\n'
-          '  $CTOR.fromBuffer(ArrayBuffer buffer);\n',
-        CTOR=self._interface.id,
-        TYPE=element_type)
-
-
   def FinishInterface(self):
     # Write snippet text that was inlined in the IDL.
     for snippet in self._interface.snippets:
       self._members_emitter.Emit('\n$LINES',
                                  LINES=IndentText(snippets.text, '  '))
 
     # TODO(vsm): Test if snippets are extra methods or extra types.
     # Since Dart doesn't permit inner types, append after the interface.
     # Consider moving these types to auxilary classes instead.
     if self._extra_snippets is not None:
@@ skipping 849 matching lines @@
         if not [op for op in interface.operations if op.id == 'addEventListener']:
           base = self._ImplClassName(supertype)
       else:
         base = self._ImplClassName(supertype)
 
     if base:
       extends = " extends " + base
     else:
       extends = ""
 
+    if interface_name in _constructable_types.keys():
+      parameters = _constructable_types[interface_name]
+      constructor = '  %s(%s) native;\n\n' % (interface_name, parameters)
+    else:
+      constructor = ''
+
     if interface_name in _frog_dom_custom_native_specs:
       native_spec = _frog_dom_custom_native_specs[interface_name]
     else:
-      # Is the type's JavaScript constructor accessible from the global scope?
-      # If so, we can directly patch the prototype.  We don't really want to do
-      # this yet because the dynamic patching mechanism is tricky and we want to
-      # test it a lot.  But patching is currently broken on FireFox for non-leaf
-      # types, so 'hide' only the leaf types.
+      # Is the type's constructor accessible from the global scope? If so, we
+      # can directly patch the prototype.  We don't really want to do this yet
+      # because the dynamic patching mechanism is tricky and we want to test it
+      # a lot.  But patching is currently broken on FireFox for non-leaf types,
+      # so 'hide' only the leaf types.
       is_hidden = interface_name not in _BROWSER_SHARED_TYPES
       if interface_name not in self._interfaces_with_subtypes:
         is_hidden = True
 
       native_spec = '*' if is_hidden else ''
       native_spec += interface_name
 
-    # TODO: Include all implemented interfaces, including other Lists.
-    implements = ''
-    element_type = MaybeTypedArrayElementType(self._interface)
-    if element_type:
-      implements = ' implements List<' + element_type + '>'
-
     (self._members_emitter, self._base_emitter) = self._dart_code.Emit(
         '\n'
-        'class $CLASS$BASE$IMPLEMENTS native "$NATIVE" {\n'
-        '$!MEMBERS'
+        'class $CLASS$BASE native "$NATIVE" {\n'
+        '$CONSTRUCTOR$!MEMBERS'
         '$!ADDITIONS'
         '}\n',
         CLASS=self._class_name, BASE=extends,
-        INTERFACE=interface_name,
-        IMPLEMENTS=implements,
+        INTERFACE=interface_name, CONSTRUCTOR=constructor,
         NATIVE=native_spec)
 
-    if interface_name in _constructable_types.keys():
-      self._members_emitter.Emit(
-          '  $NAME($PARAMS) native;\n\n',
-          NAME=interface_name,
-          PARAMS=_constructable_types[interface_name])
-
-    element_type = MaybeTypedArrayElementType(interface)
-    if element_type:
-      self.AddTypedArrayConstructors(element_type)
-
     if not base:
       # Emit shared base functionality here as we have no common base type.
       self._base_emitter.Emit(
           '\n'
           '  var dartObjectLocalStorage;\n'
           '\n'
           '  String get typeName() native;\n')
 
   def _ImplClassName(self, type_name):
     return type_name
@@ skipping 59 matching lines @@
     #
     # and
     #
     #   class YImpl extends ListBase<T> { copies of transitive XImpl methods; }
     #
     self._members_emitter.Emit(
         '\n'
         '  $TYPE operator[](int index) native;\n',
         TYPE=element_type)
 
-    if 'HasCustomIndexSetter' in self._interface.ext_attrs:
-      self._members_emitter.Emit(
-          '\n'
-          '  void operator[]=(int index, $TYPE value) native;\n',
-          TYPE=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=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($ARGS) native;\n',
         TYPE=info.type_name,
         NAME=info.name,
         ARGS=info.arg_implementation_declaration)