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.
-    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
+    element_type = MaybeListElementType(interface)
+    if element_type:
+      for generator in generators:
+        generator.AddIndexer(element_type)
 
     # 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(interface, str):  # _IsDartCollectionType(parent_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:
@@ 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 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 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_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 native "$NATIVE" {\n'
-        '$CONSTRUCTOR$!MEMBERS'
+        'class $CLASS$BASE$IMPLEMENTS native "$NATIVE" {\n'
+        '$!MEMBERS'
         '$!ADDITIONS'
         '}\n',
         CLASS=self._class_name, BASE=extends,
-        INTERFACE=interface_name, CONSTRUCTOR=constructor,
+        INTERFACE=interface_name,
+        IMPLEMENTS=implements,
         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)