Fixing an issue where optional parameters were having their types dropped.

sdk/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 291 matching lines @@
 
     events_class_name = self._event_generator.ProcessInterface(
         self._interface, interface_name,
         self._backend.CustomJSMembers(),
         implementation_emitter)
     if events_class_name:
       self._backend.EmitEventGetter(events_class_name)
 
     merged_interface = self._interface_type_info.merged_interface()
     if merged_interface:
-      self._backend.AddMembers(self._database.GetInterface(merged_interface), 
+      self._backend.AddMembers(self._database.GetInterface(merged_interface),
         not self._backend.ImplementsMergedMembers())
 
     self._backend.AddMembers(self._interface)
     self._backend.AddSecondaryMembers(self._interface)
     self._backend.FinishInterface()
 
   def _ImplementationEmitter(self):
     basename = self._interface_type_info.implementation_name()
     if (self._interface_type_info.merged_into() and
         self._backend.ImplementsMergedMembers()):
@@ skipping 307 matching lines @@
           '\n'
           '  $MODIFIERS$TYPE $NAME($PARAMS) native;\n',
           MODIFIERS='static ' if info.IsStatic() else '',
           TYPE=self.SecureOutputType(info.type_name),
           NAME=info.name,
           PARAMS=info.ParametersDeclaration(self._NarrowInputType))
 
   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
       native_return_type = output_conversion.input_type
     else:
       return_type = self._NarrowInputType(info.type_name)
       native_return_type = return_type
 
     def InputType(type_name):
@@ skipping 19 matching lines @@
     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))
+            CHECKS=' && '.join(checks))

[sra1, 2012/11/09 21:34:41]

Can you put this back?

[blois, 2012/11/09 23:20:41]

Done :)

       else:
         (stmts_emitter, call_emitter) = body.Emit('$!A$!B', INDENT='    ');
 
       method_version[0] += 1
       target = '_%s_%d' % (html_name, method_version[0]);
       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'

[sra1, 2012/11/09 21:34:41]

What is the effect of removing this on code size in checked mode?  I believe
that the compiler is still dumb enough that it will be a size and perf hit.

[blois, 2012/11/09 23:20:41]

Done.

         target_parameters.append(
             '%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)
@@ skipping 13 matching lines @@
 
     def GenerateChecksAndCall(operation, argument_count):
       checks = []
       for i in range(0, argument_count):
         argument = operation.arguments[i]
         parameter_name = parameter_names[i]
         test_type = self._DartType(argument.type.id)
         if test_type in ['dynamic', 'Object']:
           checks.append('?%s' % parameter_name)
         elif test_type != parameter_types[i]:
-          checks.append('(%s is %s || %s == null)' % (
-              parameter_name, test_type, parameter_name))
+          checks.append('(?%s && %s is %s)' % (parameter_name, parameter_name, test_type))

[sra1, 2012/11/09 21:34:41]

This was not a null-means-missing check.
If you explicitly pass null, that null matches any type.

Given
foo(Widget w, int x);
foo(String s, String y);

foo(null, 4) must match the first overload.

openCursor(null, 'prevunique') was historically sensitive to this.

+
       checks.extend(['!?%s' % name for name in parameter_names[argument_count:]])
       # There can be multiple presence checks.  We need them all since a later
       # optional argument could have been passed by name, leaving 'holes'.
       GenerateCall(operation, argument_count, checks)
 
     # TODO: Optimize the dispatch to avoid repeated checks.
     if len(operations) > 1:
       for operation in operations:
         for position, argument in enumerate(operation.arguments):
           if self._IsOptional(operation, argument):
@@ skipping 126 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(
           "part '$PATH';\n", PATH=massage_path(relpath))