Move splitting operations with optional arguments to generator.

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
 
 _pure_interfaces = set([
     # TODO(sra): DOMStringMap should be a class implementing Map<String,String>.
     'DOMStringMap',
     'ElementTimeControl',
     'ElementTraversal',
     'MediaQueryListListener',
     'NodeSelector',
     'SVGExternalResourcesRequired',
@@ skipping 167 matching lines @@
     self.dart_type = dart_type
     self.default_value = default_value
 
   def __repr__(self):
     content = 'name = %s, type_id = %s, dart_type = %s, default_value = %s' % (
         self.name, self.type_id, self.dart_type, self.default_value)
     return '<ParamInfo(%s)>' % content
 
 
 # Given a list of overloaded arguments, render a dart argument.
-def _DartArg(args, interface):
+def _DartArg(args, interface, constructor=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)))
 
   # Given a list of overloaded arguments, choose a suitable type.
   def OverloadedType(args):
     type_ids = sorted(set(arg.type.id for arg in args))
     dart_types = sorted(set(DartType(arg.type.id) for arg in args))
     if len(dart_types) == 1:
       if len(type_ids) == 1:
         return (type_ids[0], dart_types[0])
       else:
         return (None, dart_types[0])
     else:
       return (None, TypeName(type_ids, interface))
 
+  def NeedsDefaultValue(argument):
+    if not argument:
+      return True
+    if 'Callback' in argument.ext_attrs:
+      # Callbacks with 'Optional=XXX' are treated as optional arguments.
+      return 'Optional' in argument.ext_attrs
+    if constructor:
+      # FIXME: Constructors with 'Optional=XXX' shouldn't be treated as
+      # optional arguments.
+      return 'Optional' in argument.ext_attrs
+    return False
+
   filtered = filter(None, args)
-  optional = any(not arg or arg.is_optional for arg in args)
+  needs_default_value = any(NeedsDefaultValue(arg) for arg in args)
   (type_id, dart_type) = OverloadedType(filtered)
   name = OverloadedName(filtered)
-  if optional:
+  if needs_default_value:
     return ParamInfo(name, type_id, dart_type, 'null')
   else:
     return ParamInfo(name, type_id, dart_type, None)
 
+def IsOptional(argument):
+  return ('Optional' in argument.ext_attrs and
+          argument.ext_attrs['Optional'] == None)
 
 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 = []
+  for operation in operations:
+    for i in range(0, len(operation.arguments)):
+      if IsOptional(operation.arguments[i]):
+        new_operation = copy.deepcopy(operation)
+        new_operation.arguments = new_operation.arguments[:i]
+        split_operations.append(new_operation)
+    split_operations.append(operation)
+
   # Zip together arguments from each overload by position, then convert
   # to a dart argument.
   args = map(lambda *args: _DartArg(args, interface),
-             *(op.arguments for op in operations))
+             *(op.arguments for op in split_operations))
 
   info = OperationInfo()
-  info.overloads = operations
+  info.overloads = split_operations
   info.declared_name = operations[0].id
   info.name = operations[0].ext_attrs.get('DartName', info.declared_name)
   info.constructor_name = None
   info.js_name = info.declared_name
   info.type_name = DartType(operations[0].type.id)   # TODO: widen.
   info.param_infos = args
   return info
 
 
 def AnalyzeConstructor(interface):
   """Returns an OperationInfo object for the constructor.
 
   Returns None if the interface has no Constructor.
   """
   def GetArgs(func_value):
-    return map(lambda arg: _DartArg([arg], interface), func_value.arguments)
+    return map(lambda arg: _DartArg([arg], interface, True),
+               func_value.arguments)
 
   if 'Constructor' in interface.ext_attrs:
     name = None
     func_value = interface.ext_attrs.get('Constructor')
     if func_value:
       # [Constructor(param,...)]
       args = GetArgs(func_value)
       idl_args = func_value.arguments
     else: # [Constructor]
       args = []
@@ skipping 506 matching lines @@
     '"SVGAnimatedListPropertyTearOff.h"',
     '"SVGTransformListPropertyTearOff.h"',
     '"SVGPathSegListPropertyTearOff.h"',
 ]
 
 def GetIDLTypeInfo(idl_type_name):
   match = re.match(r'sequence<(\w+)>$', idl_type_name)
   if match:
     return SequenceIDLTypeInfo(idl_type_name, GetIDLTypeInfo(match.group(1)))
   return _idl_type_registry.get(idl_type_name, IDLTypeInfo(idl_type_name))