Unify formatting of parameters in interfaces and implementing classes.

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 321 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):
-    """Returns a formatted string declaring the parameters for the interface."""
-    return self._FormatParams(self.param_infos, rename_type, True)
-
-  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 ParametersDeclaration(self, rename_type):
     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)
+      return '%s%s' % (TypeOrNothing(dart_type, param.type_id), param.name)
 
     required = []
     optional = []
-    for param_info in params:
+    for param_info in self.param_infos:
       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)) + ']')
     return ', '.join(argtexts)
 
+  def ParametersAsArgumentList(self, parameter_count = None):

[podivilov, 2012/10/17 14:21:16]

Please move back to reduce the diff.

[Anton Muhin, 2012/10/17 14:26:30]

Cannot, it's a single function :)

+    """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 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
     else:
       return rename_type(self.type_name)
 
   def ConstructorFactoryName(self, rename_type):
     return 'create' + self._ConstructorFullName(rename_type).replace('.', '_')
 
   def GenerateFactoryInvocation(self, rename_type, emitter, factory_provider):
     has_optional = any(param_info.is_optional
         for param_info in self.param_infos)
 
     factory_name = self.ConstructorFactoryName(rename_type)
     if not has_optional:
       emitter.Emit(
           '\n'
           '  factory $CTOR($PARAMS) => '
           '$FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n',
           CTOR=self._ConstructorFullName(rename_type),
-          PARAMS=self.ParametersInterfaceDeclaration(rename_type),
+          PARAMS=self.ParametersDeclaration(rename_type),
           FACTORY=factory_provider,
           CTOR_FACTORY_NAME=factory_name,
           FACTORY_PARAMS=self.ParametersAsArgumentList())
       return
 
     dispatcher_emitter = emitter.Emit(
         '\n'
         '  factory $CTOR($PARAMS) {\n'
         '$!DISPATCHER'
         '    return $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
         '  }\n',
         CTOR=self._ConstructorFullName(rename_type),
-        PARAMS=self.ParametersInterfaceDeclaration(rename_type),
+        PARAMS=self.ParametersDeclaration(rename_type),
         FACTORY=factory_provider,
         CTOR_FACTORY_NAME=factory_name,
         FACTORY_PARAMS=self.ParametersAsArgumentList())
 
     # If we have optional parameters, check to see if they are set
     # and call the appropriate factory method.
     def EmitOptionalParameterInvocation(index):
       dispatcher_emitter.Emit(
         '    if (!?$OPT_PARAM_NAME) {\n'
         '      return $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
@@ skipping 651 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)