Make dartj2s do type conversions on constructor arguments

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 logging
@@ skipping 979 matching lines @@
         '\n'
         '  $RENAME$METADATA$MODIFIERS$TYPE $NAME($PARAMS) native;\n',
         RENAME=self._RenamingAnnotation(info.declared_name, html_name),
         METADATA=self._Metadata(info.type_name, info.declared_name,
             self.SecureOutputType(info.type_name)),
         MODIFIERS='static ' if info.IsStatic() else '',
         TYPE=self.SecureOutputType(info.type_name, False, True),
         NAME=html_name,
         PARAMS=info.ParametersAsDeclaration(self._NarrowInputType))
 
+  def _ConvertArgumentTypes(
+          self, stmts_emitter, arguments, argument_count, info):
+    temp_version = [0]
+    converted_arguments = []  
+    target_parameters = []
+    for position, arg in enumerate(arguments[:argument_count]):
+      conversion = self._InputConversion(arg.type.id, info.declared_name)
+      param_name = 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(
+            '$(INDENT)$TYPE $NAME = $CONVERT($ARG);\n',
+            TYPE=TypeOrVar(temp_type),
+            NAME=temp_name,
+            CONVERT=conversion.function_name,
+            ARG=info.param_infos[position].name)
+        converted_arguments.append(temp_name)
+        param_type = temp_type
+        verified_type = temp_type  # verified by assignment in checked mode.
+      else:
+        converted_arguments.append(info.param_infos[position].name)
+        param_type = self._NarrowInputType(arg.type.id)
+        # Verified by argument checking on entry to the dispatcher.
+
+        verified_type = self._InputType(
+            info.param_infos[position].type_id, info)
+        # The native method does not need an argument type if we know the type.
+        # But we do need the native methods to have correct function types, so
+        # be conservative.
+        if param_type == verified_type:
+          if param_type in ['String', 'num', 'int', 'double', 'bool', 'Object']:
+            param_type = 'dynamic'
+
+      target_parameters.append(
+          '%s%s' % (TypeOrNothing(param_type), param_name))
+
+    return target_parameters, converted_arguments
+
+  def _InputType(self, type_name, info):
+    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'
+
   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
     output_conversion = self._OutputConversion(info.type_name,
                                                info.declared_name)
     if output_conversion:
       return_type = output_conversion.output_type
       native_return_type = output_conversion.input_type
     else:
       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'
-
     parameter_names = [param_info.name for param_info in info.param_infos]
-    parameter_types = [InputType(param_info.type_id)
+    parameter_types = [self._InputType(param_info.type_id, info)
                        for param_info in info.param_infos]
     operations = info.operations
 
-    temp_version = [0]
+    def InputType(type_name):
+        return self._InputType(type_name, info)

[terry, 2015/03/23 14:45:59]

Why does InputType exist can't you just all use _InputType?

[Alan Knight, 2015/03/23 18:00:12]

I have to pass it as a closure, so I needed something that was already bound to
self. Maybe there's a cleverer way to do that in Python?

 
     def GenerateCall(
         stmts_emitter, call_emitter, version, operation, argument_count):
       target = '_%s_%d' % (
           html_name[1:] if html_name.startswith('_') else 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(
-              '$(INDENT)$TYPE $NAME = $CONVERT($ARG);\n',
-              TYPE=TypeOrVar(temp_type),
-              NAME=temp_name,
-              CONVERT=conversion.function_name,
-              ARG=parameter_names[position])
-          arguments.append(temp_name)
-          param_type = temp_type
-          verified_type = temp_type  # verified by assignment in checked mode.
-        else:
-          arguments.append(parameter_names[position])
-          param_type = self._NarrowInputType(arg.type.id)
-          # Verified by argument checking on entry to the dispatcher.
 
-          verified_type = InputType(info.param_infos[position].type_id)
-          # The native method does not need an argument type if we know the type.
-          # But we do need the native methods to have correct function types, so
-          # be conservative.
-          if param_type == verified_type:
-            if param_type in ['String', 'num', 'int', 'double', 'bool', 'Object']:
-              param_type = 'dynamic'
-
-        target_parameters.append(
-            '%s%s' % (TypeOrNothing(param_type), param_name))
+      (target_parameters, arguments) = self._ConvertArgumentTypes(
+          stmts_emitter, operation.arguments, argument_count, info)
 
       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)
 
       call_emitter.Emit(call)
@@ skipping 202 matching lines @@
 
   def AddFile(self, basename, library_name, path):
     self._libraries[library_name].AddFile(path)
 
   def AddTypeEntry(self, library_name, idl_name, dart_name):
     self._libraries[library_name].AddTypeEntry(idl_name, dart_name)
 
   def Emit(self, emitter, auxiliary_dir):
     for lib in self._libraries.values():
       lib.Emit(emitter, auxiliary_dir)