Unify formatting of parameters in interfaces and implementing classes.

lib/html/scripts/systemhtml.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 the system to generate
 Dart:html APIs from the IDL database."""
 
 import emitter
 import os
@@ skipping 167 matching lines @@
         '\n'
         '  static $RETURN_TYPE $CONSTRUCTOR($PARAMS) {\n'
         '    $CLASS _e = _document.$dom_createElement("$TAG");\n'
         '$!INITS'
         '    return _e;\n'
         '  }\n',
         RETURN_TYPE=rename_type(constructor_info.type_name),
         CONSTRUCTOR=constructor_info.ConstructorFactoryName(rename_type),
         CLASS=class_name,
         TAG=info.tag,
-        PARAMS=constructor_info.ParametersInterfaceDeclaration(rename_type))
+        PARAMS=constructor_info.ParametersDeclaration(rename_type))
     for param in constructor_info.param_infos:
       inits.Emit('    if ($E != null) _e.$E = $E;\n', E=param.name)
 
 # ------------------------------------------------------------------------------
 
 class HtmlDartInterfaceGenerator(object):
   """Generates dart interface and implementation for the DOM IDL interface."""
 
   def __init__(self, options, library_emitter, event_generator, interface,
                backend):
@@ skipping 17 matching lines @@
   def GenerateCallback(self):
     """Generates a typedef for the callback interface."""
     handlers = [operation for operation in self._interface.operations
                 if operation.id == 'handleEvent']
     info = AnalyzeOperation(self._interface, handlers)
     code = self._library_emitter.FileEmitter(self._interface.id)
     code.Emit(self._template_loader.Load('callback.darttemplate'))
     code.Emit('typedef $TYPE $NAME($PARAMS);\n',
               NAME=self._interface.id,
               TYPE=self._DartType(info.type_name),
-              PARAMS=info.ParametersImplementationDeclaration(self._DartType))
+              PARAMS=info.ParametersDeclaration(self._DartType))
     self._backend.GenerateCallback(info)
 
   def GenerateInterface(self):
     if (self._interface_type_info.has_generated_interface() and
         not self._interface_type_info.merged_into()):
       interface_emitter = self._library_emitter.FileEmitter(
           self._html_interface_name)
     else:
       interface_emitter = emitter.Emitter()
 
@@ skipping 249 matching lines @@
         # FIXME: provide a type.
         self._members_emitter.Emit('\n'
                                   '  static final $NAME = $IMPL_CLASS_NAME.$NAME;\n',
                                   IMPL_CLASS_NAME=self._backend.ImplementationClassName(),
                                   NAME=html_name)
       else:
         self._members_emitter.Emit('\n'
                                   '  $TYPE $NAME($PARAMS);\n',
                                   TYPE=SecureOutputType(self, info.type_name),
                                   NAME=html_name,
-                                  PARAMS=info.ParametersInterfaceDeclaration(self._DartType))
+                                  PARAMS=info.ParametersDeclaration(self._DartType))
     self._backend.AddOperation(info, html_name)
 
   def AddSecondaryOperation(self, interface, info):
     self._backend.SecondaryContext(interface)
     self.AddOperation(info, True)
 
   def AddConstant(self, constant):
     type = TypeOrNothing(self._DartType(constant.type.id), constant.type.id)
     self._members_emitter.Emit('\n  static const $TYPE$NAME = $VALUE;\n',
                                NAME=constant.id,
@@ skipping 137 matching lines @@
     template = self._template_loader.TryLoad(template_file)
     if not template:
       template = self._template_loader.Load('factoryprovider.darttemplate')
 
     arguments = constructor_info.ParametersAsArgumentList()
     comma = ',' if arguments else ''
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
         CONSTRUCTOR=self._html_interface_name,
-        PARAMETERS=constructor_info.ParametersImplementationDeclaration(self._DartType),
+        PARAMETERS=constructor_info.ParametersDeclaration(self._DartType),
         NAMED_CONSTRUCTOR=constructor_info.name or self._html_interface_name,
         ARGUMENTS=arguments,
         PRE_ARGUMENTS_COMMA=comma,
         ARGUMENTS_PATTERN=','.join(['#'] * len(constructor_info.param_infos)))
 
   def SecondaryContext(self, interface):
     if interface is not self._current_secondary_parent:
       self._current_secondary_parent = interface
       self._members_emitter.Emit('\n  // From $WHERE\n', WHERE=interface.id)
 
@@ skipping 182 matching lines @@
   def _AddDirectNativeOperation(self, info, html_name):
     # Do we need a native body?
     if html_name != info.declared_name:
       return_type = self._NarrowOutputType(info.type_name)
 
       operation_emitter = self._members_emitter.Emit('$!SCOPE',
           MODIFIERS='static ' if info.IsStatic() else '',
           TYPE=return_type,
           HTML_NAME=html_name,
           NAME=info.declared_name,
-          PARAMS=info.ParametersImplementationDeclaration(
+          PARAMS=info.ParametersDeclaration(
               lambda type_name: self._NarrowInputType(type_name)))
 
       operation_emitter.Emit(
           '\n'
           #'  // @native("$NAME")\n;'
           '  $MODIFIERS$TYPE $(HTML_NAME)($PARAMS) native "$NAME";\n')
     else:
       self._members_emitter.Emit(
           '\n'
           '  $MODIFIERS$TYPE $NAME($PARAMS) native;\n',
           MODIFIERS='static ' if info.IsStatic() else '',
           TYPE=self._NarrowOutputType(info.type_name),
           NAME=info.name,
-          PARAMS=info.ParametersImplementationDeclaration(
+          PARAMS=info.ParametersDeclaration(
               lambda type_name: self._NarrowInputType(type_name)))
 
   def _AddOperationWithConversions(self, info, html_name):
     # Assert all operations have same return type.
     assert len(set([op.type.id for op in info.operations])) == 1
     info = info.CopyAndWidenDefaultParameters()
     output_conversion = self._OutputConversion(info.type_name,
                                                info.declared_name)
     if output_conversion:
       return_type = output_conversion.output_type
@@ skipping 10 matching lines @@
         return self._NarrowInputType(type_name) if type_name else 'Dynamic'
 
     body = self._members_emitter.Emit(
         '\n'
         '  $MODIFIERS$TYPE $(HTML_NAME)($PARAMS) {\n'
         '$!BODY'
         '  }\n',
         MODIFIERS='static ' if info.IsStatic() else '',
         TYPE=return_type,
         HTML_NAME=html_name,
-        PARAMS=info.ParametersImplementationDeclaration(InputType))
+        PARAMS=info.ParametersDeclaration(InputType))
 
     parameter_names = [param_info.name for param_info in info.param_infos]
     parameter_types = [InputType(param_info.type_id)
                        for param_info in info.param_infos]
     operations = info.operations
 
     method_version = [0]
     temp_version = [0]
 
     def GenerateCall(operation, argument_count, checks):
@@ skipping 209 matching lines @@
 
     library_emitter = self._multiemitter.FileEmitter(library_file_path)
     library_file_dir = os.path.dirname(library_file_path)
     auxiliary_dir = os.path.relpath(auxiliary_dir, library_file_dir)
     imports_emitter = library_emitter.Emit(
         self._template, AUXILIARY_DIR=massage_path(auxiliary_dir))
     for path in sorted(self._path_to_emitter.keys()):
       relpath = os.path.relpath(path, library_file_dir)
       imports_emitter.Emit(
           "#source('$PATH');\n", PATH=massage_path(relpath))