Dartium 45 roll

tools/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 json
@@ skipping 439 matching lines @@
       optional is a list of parameter declarations corresponding to the
         optional parameters
       named is a boolean which is true if the optional parameters should
         be named
       A parameter declaration is a tuple (dec, var) where var is the
         variable name, and dec is a string suitable for declaring the
         variable in a parameter list.  That is, dec + var is a valid
         parameter declaration.
     """
     def FormatParam(param):
-      dart_type = rename_type(param.type_id) if param.type_id else 'dynamic'
+      # Is the type a typedef if so it's a union so it's dynamic.
+      # TODO(terry): This may have to change for dart2js for code shaking the
+      #              return types (unions) needs to be emitted with @create
+      #              annotations and/or with JS('type1|type2',...)
+      if hasattr(rename_type, 'im_self') and rename_type.im_self._database.HasTypeDef(param.type_id):
+        dart_type = 'dynamic'
+      else:
+        dart_type = rename_type(param.type_id) if param.type_id else 'dynamic'
       return (TypeOrNothing(dart_type, param.type_id), param.name)
     required = []
     optional = []
     for param_info in self.param_infos:
       if param_info.is_optional:
         optional.append(FormatParam(param_info))
       else:
         if optional:
           raise Exception('Optional parameters cannot precede required ones: '
                           + str(param_info))
@@ skipping 889 matching lines @@
 
 class TypeRegistry(object):
   def __init__(self, database, renamer=None):
     self._database = database
     self._renamer = renamer
     self._cache = {}
 
   def HasInterface(self, type_name):
     return self._database.HasInterface(type_name)
 
+  def HasTypeDef(self, type_def_name):
+    return self._database.HasTypeDef(type_def_name)
+
   def TypeInfo(self, type_name):
     if not type_name in self._cache:
       self._cache[type_name] = self._TypeInfo(type_name)
     return self._cache[type_name]
 
   def DartType(self, type_name):
     return self.TypeInfo(type_name).dart_type()
 
   def _TypeInfo(self, type_name):
     match = re.match(r'(?:sequence<([\w ]+)>|(\w+)\[\])$', type_name)
     if match:
       type_data = TypeData('Sequence')
-      item_info = self.TypeInfo(match.group(1) or match.group(2))
+      if self.HasTypeDef(match.group(1) or match.group(2)):
+        # It's a typedef (union)
+        item_info = self.TypeInfo('any')
+      else:
+        item_info = self.TypeInfo(match.group(1) or match.group(2))
       # TODO(vsm): Generalize this code.
       if 'SourceInfo' in type_name:
         type_data.native_type = 'const Vector<RefPtr<SourceInfo> >& '
       return SequenceIDLTypeInfo(type_name, type_data, item_info)
 
     if not type_name in _idl_type_registry:
       if self._database.HasEnum(type_name):
         return PrimitiveIDLTypeInfo(
             type_name,
             TypeData(clazz='Primitive', dart_type='String', native_type='String'))
 
       if self._database.HasInterface(type_name):
         interface = self._database.GetInterface(type_name)
-      else:
+      elif self._database.HasDictionary(type_name):
         interface = self._database.GetDictionary(type_name)
+      elif type_name.startswith('sequence<('):
+        if type_name.find(' or ') != -1:
+          # Union type of sequence is an any type (no type).
+          type_data = TypeData('Sequence')
+          item_info = self.TypeInfo('any')
+          return SequenceIDLTypeInfo(type_name, type_data, item_info)
+      elif type_name.startswith('sequence<sequence<'):
+        # TODO(terry): Cleanup up list of list, etc.
+        type_data = TypeData('Sequence')
+        item_info = self.TypeInfo('any')
+        return SequenceIDLTypeInfo(type_name, type_data, item_info)
+      elif self.HasTypeDef(type_name):
+        # It's a typedef (implied union)
+        return self.TypeInfo('any')
+
       if 'Callback' in interface.ext_attrs:
         return CallbackIDLTypeInfo(type_name, TypeData('Callback',
             self._renamer.DartifyTypeName(type_name)))
       return InterfaceIDLTypeInfo(
           type_name,
           TypeData('Interface'),
           self._renamer.RenameInterface(interface),
           self)
 
     type_data = _idl_type_registry.get(type_name)
@@ skipping 54 matching lines @@
             return_type == 'Rectangle')
 
 def wrap_return_type_blink(return_type, type_name, type_registry):
     """Returns True if we should wrap the returned value. This checks
     a number of different variations, calling the more basic functions
     above."""
     return (wrap_unwrap_type_blink(return_type, type_registry) or
             wrap_unwrap_type_blink(type_name, type_registry) or
             wrap_type_blink(return_type, type_registry) or
             wrap_unwrap_list_blink(return_type, type_registry))