Render rest of arguments optional once met first optional argument.

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 159 matching lines @@
 
   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, render dart arguments.
+def _BuildArguments(args, interface, constructor=False):
+  def IsOptional(argument):
+    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
+
   # 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], type_ids[0])
       else:
         return (None, type_ids[0])
     else:
       return (None, TypeName(type_ids, interface))
 
-  def IsOptional(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
+  result = []
 
-  filtered = filter(None, args)
-  is_optional = any(IsOptional(arg) for arg in args)
-  (type_id, dart_type) = OverloadedType(filtered)
-  name = OverloadedName(filtered)
-  return ParamInfo(name, type_id, dart_type, is_optional)
+  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, dart_type) = OverloadedType(filtered)
+    name = OverloadedName(filtered)
+    result.append(ParamInfo(name, type_id, dart_type, is_optional))
+
+  return result
 
 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 split_operations))
-
   info = OperationInfo()
   info.operations = 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 = operations[0].type.id   # TODO: widen.
-  info.param_infos = args
+  info.param_infos = _BuildArguments([op.arguments for op in split_operations], interface)
   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, 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]
+    if not func_value:
       args = []
       idl_args = []
+  elif 'NamedConstructor' in interface.ext_attrs:
+    func_value = interface.ext_attrs.get('NamedConstructor')
+    name = func_value.id
   else:
-    func_value = interface.ext_attrs.get('NamedConstructor')
-    if func_value:
-      name = func_value.id
-      args = GetArgs(func_value)
-      idl_args = func_value.arguments
-    else:
-      return None
+    return None
+
+  if func_value:
+    idl_args = func_value.arguments
+    args =_BuildArguments([idl_args], interface, True)
 
   info = OperationInfo()
   info.overloads = None
   info.idl_args = idl_args
   info.declared_name = name
   info.name = name
   info.constructor_name = None
   info.js_name = name
   info.type_name = interface.id
   info.param_infos = args
@@ skipping 584 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)