Unwrap parameters in factory constructors.

client/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."""
 
 from systemfrog import *
 from systeminterface import *
@@ skipping 1233 matching lines @@
       template = self._system._templates.Load('factoryprovider.darttemplate')
 
     factory_provider = '_' + interface_name + 'FactoryProvider'
     emitter = self._system._ImplFileEmitter(factory_provider)
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
         CONSTRUCTOR=interface_name,
         PARAMETERS=constructor_info.ParametersImplementationDeclaration(),
         NAMED_CONSTRUCTOR=constructor_info.name or interface_name,
-        ARGUMENTS=constructor_info.ParametersAsArgumentList())
+        ARGUMENTS=self._UnwrappedParameters(constructor_info,
+                                            len(constructor_info.arg_infos)))
+
+  def _UnwrappedParameters(self, operation_info, length):
+    """Returns string for an argument list that unwraps first |length|
+    parameters."""
+    def UnwrapArgInfo(arg_info):
+      (name, type, value) = arg_info
+      # TODO(sra): Type dependent unwrapping.
+      return '_unwrap(%s)' % name
+
+    return ', '.join(map(UnwrapArgInfo, operation_info.arg_infos[:length]))
 
   def _BaseClassName(self, interface):
     if not interface.parents:
       return '_DOMTypeBase'
 
     supertype = DartType(interface.parents[0].type.id)
 
     if IsDartListType(supertype) or IsDartCollectionType(supertype):
       return 'DOMWrapperBase'
 
@@ skipping 313 matching lines @@
 
   def GenerateSingleOperation(self,  emitter, info, indent, operation):
     """Generates a call to a single operation.
 
     Arguments:
       emitter: an Emitter for the body of a block of code.
       info: the compound information about the operation and its overloads.
       indent: an indentation string for generated code.
       operation: the IDLOperation to call.
     """
-    # TODO(sra): Do we need to distinguish calling with missing optional
-    # arguments from passing 'null' which is represented as 'undefined'?
-    def UnwrapArgExpression(name, type):
-      # TODO: Type specific unwrapping.
-      return '_unwrap(%s)' % (name)
+    argument_expressions = self._UnwrappedParameters(
+        info,
+        len(operation.arguments))  # Just the parameters this far.
 
-    def ArgNameAndUnwrapper(arg_info, overload_arg):
-      (name, type, value) = arg_info
-      return (name, UnwrapArgExpression(name, type))
-
-    names_and_unwrappers = [ArgNameAndUnwrapper(info.arg_infos[i], arg)
-                            for (i, arg) in enumerate(operation.arguments)]
-    unwrap_args = [unwrap_arg for (_, unwrap_arg) in names_and_unwrappers]
-    arg_names = ['_unwrap(%s)' % name for (name, _) in names_and_unwrappers]
-
-    argument_expressions = ', '.join(arg_names)
     if info.type_name != 'void':
       # We could place the logic for handling Document directly in _wrap
       # but we chose to place it here so that bugs in the wrapper and
       # wrapperless implementations are more consistent. 
       if self._shared.MaybeReturnDocument(info.type_name): 
         emitter.Emit('$(INDENT)return _FixHtmlDocumentReference('
                      '_wrap($(THIS).$NAME($ARGS)));\n',
                      INDENT=indent,
                      THIS=self.DomObjectName(),
                      NAME=info.name,
@@ skipping 102 matching lines @@
     # dispatch has removed f(X), leaving only f(Y), but there is no guarantee
     # that Y = Z-X, so we need to check for Y.
     true_code = emitter.Emit(
         '$(INDENT)if ($COND) {\n'
         '$!TRUE'
         '$(INDENT)}\n',
         COND=test, INDENT=indent)
     self.GenerateDispatch(
         true_code, info, indent + '  ', position + 1, positive)
     return True