Some more refactorings of overload dispatcher generation.

tools/dom/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 771 matching lines @@
       return_type = self._NarrowInputType(info.type_name)
       native_return_type = return_type
 
     def InputType(type_name):
       conversion = self._InputConversion(type_name, info.declared_name)
       if conversion:
         return conversion.input_type
       else:
         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.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):
-      if checks:
-        (stmts_emitter, call_emitter) = body.Emit(
-            '    if ($CHECKS) {\n$!STMTS$!CALL    }\n',
-            INDENT='      ',
-            CHECKS=' &&\n        '.join(checks))
-      else:
-        (stmts_emitter, call_emitter) = body.Emit('$!A$!B', INDENT='    ');
-
-      method_version[0] += 1
-      target = '_%s_%d' % (html_name, method_version[0]);
+    def GenerateCall(stmts_emitter, call_emitter, version, operation, argument_count):
+      target = '_%s_%d' % (html_name, version);
       arguments = []
       target_parameters = []
       for position, arg in enumerate(operation.arguments[:argument_count]):
         conversion = self._InputConversion(arg.type.id, operation.id)
         param_name = operation.arguments[position].id
         if conversion:
           temp_version[0] += 1
           temp_name = '%s_%s' % (param_name, temp_version[0])
           temp_type = conversion.output_type
           stmts_emitter.Emit(
@@ skipping 22 matching lines @@
             '%s%s' % (TypeOrNothing(param_type), param_name))
 
       argument_list = ', '.join(arguments)
       # TODO(sra): If the native method has zero type checks, we can 'inline' is
       # and call it directly with a JS-expression.
       call = '%s(%s)' % (target, argument_list)
 
       if output_conversion:
         call = '%s(%s)' % (output_conversion.function_name, call)
 
-      if operation.type.id == 'void':
-        call_emitter.Emit('$(INDENT)$CALL;\n$(INDENT)return;\n',
-                          CALL=call)
-      else:
-        call_emitter.Emit('$(INDENT)return $CALL;\n', CALL=call)
+      call_emitter.Emit(call)
 
       self._members_emitter.Emit(
           '  $RENAME$ANNOTATIONS$MODIFIERS$TYPE$TARGET($PARAMS) native;\n',
           RENAME=self._RenamingAnnotation(info.declared_name, target),
           ANNOTATIONS=self._Annotations(info.type_name, info.declared_name),
           MODIFIERS='static ' if info.IsStatic() else '',
           TYPE=TypeOrNothing(native_return_type),
           TARGET=target,
           PARAMS=', '.join(target_parameters))
 
+    declaration = '%s%s %s(%s)' % (
+        'static ' if info.IsStatic() else '',
+        return_type,
+        html_name,
+        info.ParametersDeclaration(InputType))
     self._GenerateDispatcherBody(
-        body,
         operations,
         parameter_names,
+        declaration,
         GenerateCall,
         self._IsOptional,
         can_omit_type_check=lambda type, pos: type == parameter_types[pos])
 
   def _AddInterfaceOperation(self, info, html_name):
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($PARAMS);\n',
         TYPE=self.SecureOutputType(info.type_name),
         NAME=info.name,
@@ skipping 152 matching lines @@
     for library_name in libraries:
       self._libraries[library_name] = DartLibrary(
           library_name, template_loader, library_type, output_dir)
 
   def AddFile(self, basename, library_name, path):
     self._libraries[library_name].AddFile(path)
 
   def Emit(self, emitter, auxiliary_dir):
     for lib in self._libraries.values():
       lib.Emit(emitter, auxiliary_dir)