Revert "Revert "Conversions between Dart code and DOM code.""

lib/dom/scripts/generator.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 systems to generate
 Dart APIs from the IDL database."""
 
 import copy
 import re
@@ skipping 151 matching lines @@
     type_id: Original type id.  None for merged types.
     dart_type: DartType of parameter.
     is_optional: Parameter optionality.
   """
   def __init__(self, name, type_id, dart_type, is_optional):
     self.name = name
     self.type_id = type_id
     self.dart_type = dart_type
     self.is_optional = is_optional
 
+  def Copy(self):
+    return ParamInfo(self.name, self.type_id, self.dart_type, self.is_optional)
+
   def __repr__(self):
     content = 'name = %s, type_id = %s, dart_type = %s, is_optional = %s' % (
         self.name, self.type_id, self.dart_type, self.is_optional)
     return '<ParamInfo(%s)>' % content
 
 
 # Given a list of overloaded arguments, render a dart argument.
 def _DartArg(args, interface, constructor=False):
   # Given a list of overloaded arguments, choose a suitable name.
   def OverloadedName(args):
@@ skipping 224 matching lines @@
     is_static = self.overloads[0].is_static
     assert any([is_static == o.is_static for o in self.overloads])
     return is_static
 
   def ConstructorFullName(self):
     if self.constructor_name:
       return self.type_name + '.' + self.constructor_name
     else:
       return self.type_name
 
+  def CopyAndWidenDefaultParameters(self):
+    """Returns equivalent OperationInfo, but default parameters are Dynamic."""
+    info = copy.copy(self)
+    info.param_infos = [param.Copy() for param in self.param_infos]
+    for param in info.param_infos:
+      if param.is_optional:
+        param.dart_type = 'Dynamic'
+    return info
+
 
 def ConstantOutputOrder(a, b):
   """Canonical output ordering for constants."""
   if a.id < b.id: return -1
   if a.id > b.id: return 1
   return 0
 
 
 def _FormatNameList(names):
   """Returns JavaScript array literal expression with one name per line."""
@@ skipping 16 matching lines @@
   return ''.join(FormatLine(line) for line in text.split('\n'))
 
 # Given a sorted sequence of type identifiers, return an appropriate type
 # name
 def TypeName(type_ids, interface):
   # Dynamically type this field for now.
   return 'Dynamic'
 
 # ------------------------------------------------------------------------------
 
+class Conversion(object):
+  """Represents a way of converting between types."""
+  def __init__(self, name, input_type, output_type):
+    # input_type is the type of the API input (and the argument type of the
+    # conversion function)
+    # output_type is the type of the API output (and the result type of the
+    # conversion function)
+    self.function_name = name
+    self.input_type = input_type
+    self.output_type = output_type
+
+#  TYPE -> "DIRECTION INTERFACE.MEMBER" -> conversion
+#  TYPE -> "DIRECTION INTERFACE.*" -> conversion
+#  TYPE -> "DIRECTION" -> conversion
+#
+# where DIRECTION is 'get' for getters and operation return values, 'set' for
+# setters and operation arguments.  INTERFACE and MEMBER are the idl names.
+#
+dart2js_conversions = {
+    'IDBKey': {
+        'get':
+          Conversion('_convertNativeToDart_IDBKey', 'Dynamic', 'Dynamic'),
+        'set':
+          Conversion('_convertDartToNative_IDBKey', 'Dynamic', 'Dynamic'),
+        },
+    'ImageData': {
+        'get':
+          Conversion('_convertNativeToDart_ImageData', 'Dynamic', 'ImageData'),
+        'set':
+          Conversion('_convertDartToNative_ImageData', 'ImageData', 'Dynamic')
+        },
+    'Dictionary': {
+        'get':
+          Conversion('_convertNativeToDart_Dictionary', 'Dynamic', 'Map'),
+        'set':
+          Conversion('_convertDartToNative_Dictionary', 'Map', 'Dynamic'),
+        },
+
+    'DOMString[]': {
+        'set':
+          Conversion(
+              '_convertDartToNative_StringArray', 'List<String>', 'List'),
+        },
+}
+
+def FindConversion(idl_type, direction, interface, member):
+  table = dart2js_conversions.get(idl_type)
+  if table:
+    return (table.get('%s %s.%s' % (direction, interface, member)) or
+            table.get('%s %s.*' % (direction, interface)) or
+            table.get(direction))
+  return None
+
+# ------------------------------------------------------------------------------
+
 class IDLTypeInfo(object):
   def __init__(self, idl_type, data):
     self._idl_type = idl_type
     self._data = data
 
   def idl_type(self):
     return self._idl_type
 
   def dart_type(self):
     return self._data.dart_type or self._idl_type
@@ skipping 318 matching lines @@
     if match:
       if type_name == 'DOMString[]':
         return DOMStringArrayTypeInfo(TypeData('Sequence'), self.TypeInfo('DOMString'))
       item_info = self.TypeInfo(match.group(1) or match.group(2))
       return SequenceIDLTypeInfo(type_name, TypeData('Sequence'), item_info)
     if not type_name in _idl_type_registry:
       return InterfaceIDLTypeInfo(type_name, TypeData('Interface'))
     type_data = _idl_type_registry.get(type_name)
     class_name = '%sIDLTypeInfo' % type_data.clazz
     return globals()[class_name](type_name, type_data)