Rework overloads/optionals dispatch to use new ?a syntax.

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
 
@@ skipping 1058 matching lines @@
       else:
         return self._NarrowInputType(type_name)
 
     body = self._members_emitter.Emit(
         '\n'
         '  $TYPE $(HTML_NAME)($PARAMS) {\n'
         '$!BODY'
         '  }\n',
         TYPE=return_type,
         HTML_NAME=html_name,
-        PARAMS=info.ParametersImplementationDeclaration(InputType, '_default'))
+        PARAMS=info.ParametersImplementationDeclaration(InputType))
 
     parameter_names = [param_info.name for param_info in info.param_infos]
     parameter_types = [InputType(param_info.dart_type)
                        for param_info in info.param_infos]
     operations = info.operations
 
     method_version = [0]
     temp_version = [0]
 
     def GenerateCall(operation, argument_count, checks):
@@ skipping 56 matching lines @@
         call_emitter.Emit('$(INDENT)return $CALL;\n', CALL=call)
 
       self._members_emitter.Emit(
           '  $TYPE$TARGET($PARAMS) native "$NATIVE";\n',
           TYPE=TypeOrNothing(native_return_type),
           TARGET=target,
           PARAMS=', '.join(target_parameters),
           NATIVE=info.declared_name)
 
     def GenerateChecksAndCall(operation, argument_count):
-      checks = ['_default == %s' % name for name in parameter_names]
+      checks = ['!?%s' % name for name in parameter_names]
       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[i] = '_default != %s' % parameter_name
+          checks[i] = '?%s' % parameter_name
         elif test_type == parameter_types[i]:
           checks[i] = 'true'
         else:
-          checks[i] = '(%s is %s || %s == null)' % (
+          checks[i] = '(%s is %s || %s === null)' % (
               parameter_name, test_type, parameter_name)
-      # There can be multiple _default checks.  We need them all since a later
+      # 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):
             GenerateChecksAndCall(operation, position)
         GenerateChecksAndCall(operation, len(operation.arguments))
       body.Emit(
           '    throw const Exception("Incorrect number or type of arguments");'
           '\n');
     else:
       operation = operations[0]
       argument_count = len(operation.arguments)
       for position, argument in list(enumerate(operation.arguments))[::-1]:
         if self._IsOptional(operation, argument):
-          check = '_default != %s' % parameter_names[position]
+          check = '?%s' % parameter_names[position]
           GenerateCall(operation, position + 1, [check])
           argument_count = position
       GenerateCall(operation, argument_count, [])
 
 
   def _IsOptional(self, operation, argument):
     return IsOptional(argument)
 
 
   def _OperationRequiresConversions(self, operation):
@@ skipping 35 matching lines @@
     return HtmlDart2JSClassGenerator(self, interface)
 
   def GenerateLibraries(self, dart_files):
     self._GenerateLibFile(
         'html_dart2js.darttemplate',
         os.path.join(self._output_dir, 'html_dart2js.dart'),
         dart_files)
 
   def Finish(self):
     pass