Force named arguments in constructors.

lib/html/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 219 matching lines @@
   # to a dart argument.
   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 = _BuildArguments([op.arguments for op in split_operations], interface)
+  info.requires_named_arguments = False
   return info
 
 
 def AnalyzeConstructor(interface):
   """Returns an OperationInfo object for the constructor.
 
   Returns None if the interface has no Constructor.
   """
   if 'Constructor' in interface.ext_attrs:
     name = None
@@ skipping 13 matching lines @@
 
   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
+  info.requires_named_arguments = False
   return info
 
 def IsDartListType(type):
   return type == 'List' or type.startswith('sequence<')
 
 def IsDartCollectionType(type):
   return IsDartListType(type)
 
 def FindMatchingAttribute(interface, attr1):
   matches = [attr2 for attr2 in interface.attributes
@@ skipping 49 matching lines @@
 
   Attributes:
     overloads: A list of IDL operation overloads with the same name.
     name: A string, the simple name of the operation.
     constructor_name: A string, the name of the constructor iff the constructor
        is named, e.g. 'fromList' in  Int8Array.fromList(list).
     type_name: A string, the name of the return type of the operation.
     param_infos: A list of ParamInfo.
   """
 
-  def ParametersInterfaceDeclaration(self, rename_type):
+  def ParametersInterfaceDeclaration(self, rename_type, force_optional=False):
     """Returns a formatted string declaring the parameters for the interface."""
-    return self._FormatParams(self.param_infos, rename_type, True)
+    return self._FormatParams(self.param_infos, rename_type, True,
+                              force_optional=force_optional)
 
   def ParametersImplementationDeclaration(self, rename_type):
     """Returns a formatted string declaring the parameters for the
     implementation.
 
     Args:
       rename_type: A function that allows the types to be renamed.
         The function is applied to the parameter's dart_type.
     """
     return self._FormatParams(self.param_infos, rename_type, False)
 
   def ParametersAsArgumentList(self, parameter_count = None):
     """Returns a string of the parameter names suitable for passing the
     parameters as arguments.
     """
     if parameter_count is None:
       parameter_count = len(self.param_infos)
     return ', '.join(map(
         lambda param_info: param_info.name,
         self.param_infos[:parameter_count]))
 
-  def _FormatParams(self, params, rename_type, provide_comments):
+  def _FormatParams(self, params, rename_type, provide_comments,
+                    force_optional=False):
     def FormatParam(param):
       dart_type = rename_type(param.type_id) if param.type_id else 'Dynamic'
       type = TypeOrNothing(dart_type, param.type_id if provide_comments else None)
       return '%s%s' % (type, param.name)
 
     required = []
     optional = []
     for param_info in params:
       if param_info.is_optional:
         optional.append(param_info)
       else:
         if optional:
           raise Exception('Optional parameters cannot precede required ones: '
                           + str(params))
         required.append(param_info)
     argtexts = map(FormatParam, required)
     if optional:
-      argtexts.append('[' + ', '.join(map(FormatParam, optional)) + ']')
+      needs_named = self.requires_named_arguments and not force_optional
+      left_bracket, right_bracket = '{}' if needs_named else '[]'
+      argtexts.append(
+          left_bracket +
+          ', '.join(map(FormatParam, optional)) +
+          right_bracket)
     return ', '.join(argtexts)
 
   def IsStatic(self):
     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, rename_type):
     if self.constructor_name:
       return rename_type(self.type_name) + '.' + self.constructor_name
@@ skipping 692 matching lines @@
             self._database.GetInterface(type_name))
       else:
         dart_interface_name = type_name
       return InterfaceIDLTypeInfo(type_name, type_data, dart_interface_name)
 
     if type_data.clazz == 'ListLike':
       return ListLikeIDLTypeInfo(type_name, type_data, self.TypeInfo(type_data.item_type))
 
     class_name = '%sIDLTypeInfo' % type_data.clazz
     return globals()[class_name](type_name, type_data)