Merge 38 changes to bleeding edge

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 96 matching lines @@
     # Nodes with different tags in different browsers can be listed as multiple
     # tags here provided there is not conflict in usage (e.g. browser X has tag
     # T and no other browser has tag T).
 
     'AnalyserNode': 'AnalyserNode,RealtimeAnalyserNode',
     'AudioContext': 'AudioContext,webkitAudioContext',
 
     'ChannelMergerNode': 'ChannelMergerNode,AudioChannelMerger',
     'ChannelSplitterNode': 'ChannelSplitterNode,AudioChannelSplitter',
 
-    'ClientRect': 'ClientRect,DOMRect',
     'ClientRectList': 'ClientRectList,DOMRectList',
 
     'CSSStyleDeclaration':
         #                    IE                   Firefox
         'CSSStyleDeclaration,MSStyleCSSProperties,CSS2Properties',
 
     'Clipboard': 'Clipboard,DataTransfer',
 
     'ApplicationCache':
         'ApplicationCache,DOMApplicationCache,OfflineResourceList',
@@ skipping 104 matching lines @@
       return argument.optional
     if 'DartForceOptional' in argument.ext_attrs:
       return True
     return False
 
   # Given a list of overloaded arguments, choose a suitable name.
   def OverloadedName(args):
     return '_OR_'.join(sorted(set(arg.id for arg in args)))
 
   def DartType(idl_type_name):
-   if idl_type_name in _idl_type_registry:
-     return _idl_type_registry[idl_type_name].dart_type or idl_type_name
-   return idl_type_name
+    if idl_type_name in _idl_type_registry:
+      return _idl_type_registry[idl_type_name].dart_type or idl_type_name
+    return idl_type_name
 
   # Given a list of overloaded arguments, choose a suitable type.
   def OverloadedType(args):
     type_ids = sorted(set(arg.type.id for arg in args))
     if len(set(DartType(arg.type.id) for arg in args)) == 1:
       return type_ids[0]
     else:
       return None
 
   result = []
 
   is_optional = False
   for arg_tuple in map(lambda *x: x, *args):
     is_optional = is_optional or any(arg is None or IsOptional(arg) for arg in arg_tuple)
 
     filtered = filter(None, arg_tuple)
     type_id = OverloadedType(filtered)
     name = OverloadedName(filtered)
     result.append(ParamInfo(name, type_id, is_optional))
 
   return result
 
-# Argument default value set (literal value or null).
-def HasDefault(argument):
-  return (argument.default_value != None) or argument.default_value_is_null
+# Argument default value is one that we suppress
+# FIXME(leafp) We may wish to eliminate this special treatment of optional
+# arguments entirely, since default values are being used more pervasively
+# in the IDL now.
+def HasSuppressedOptionalDefault(argument):
+  return (argument.default_value == 'Undefined') or argument.default_value_is_null
 
 def IsOptional(argument):
-  return argument.optional and (not(HasDefault(argument))) \
+  return argument.optional and (not(HasSuppressedOptionalDefault(argument))) \
          or 'DartForceOptional' in argument.ext_attrs
 
 def AnalyzeOperation(interface, operations):
   """Makes operation calling convention decision for a set of overloads.
 
   Returns: An OperationInfo object.
   """
 
   # split operations with optional args into multiple operations
   split_operations = []
@@ skipping 160 matching lines @@
       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(params))
+                          + str(param_info))
         required.append(FormatParam(param_info))
     needs_named = optional and self.requires_named_arguments and not force_optional
     return (required, optional, needs_named)
 
   def ParametersAsDecStringList(self, rename_type, force_optional=False):
     """Returns a list of strings where each string corresponds to a parameter
     declaration.  All of the optional/named parameters if any will appear as
     a single entry at the end of the list.
     """
     (required, optional, needs_named) = \
@@ skipping 802 matching lines @@
 
   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)
+    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))
       # 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):
@@ skipping 36 matching lines @@
     if type_data.clazz == 'BasicTypedList':
       if type_name == 'ArrayBuffer':
         dart_interface_name = 'ByteBuffer'
       else:
         dart_interface_name = self._renamer.RenameInterfaceId(type_name)
       return BasicTypedListIDLTypeInfo(
           type_name, type_data, dart_interface_name, self)
 
     class_name = '%sIDLTypeInfo' % type_data.clazz
     return globals()[class_name](type_name, type_data)