Remove trivially redundant tests from dispatch.

lib/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
 
@@ skipping 1052 matching lines @@
 
     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'))
 
-    argument_names = [param_info.name for param_info in info.param_infos]
-    argument_types = [InputType(param_info.dart_type)
-                      for param_info in info.param_infos]
+    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):
+      checks = filter(lambda e: e != 'true', 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])
       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=argument_names[position])
+              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(argument_names[position])
+          arguments.append(parameter_names[position])
           param_type = self._NarrowInputType(DartType(arg.type.id))
           # Verified by argument checking on entry to the dispatcher.
           verified_type = InputType(info.param_infos[position].dart_type)
 
         # 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'
@@ skipping 15 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 argument_names]
+      checks = ['_default == %s' % name for name in parameter_names]
       for i in range(0, argument_count):
         argument = operation.arguments[i]
-        argument_name = argument_names[i]
+        parameter_name = parameter_names[i]
         test_type = self._DartType(argument.type.id)
         if test_type in ['Dynamic', 'Object']:
-          checks[i] = '_default != %s' % argument_name
+          checks[i] = '_default != %s' % parameter_name
+        elif test_type == parameter_types[i]:
+          checks[i] = 'true'
         else:
           checks[i] = '(%s is %s || %s == null)' % (
-              argument_name, self._DartType(argument.type.id), argument_name)
+              parameter_name, test_type, parameter_name)
+      # Only need first _default check since we don't have any other default
+      # values in the dispatch method's signature.
+      checks = checks[:argument_count + 1]
       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 "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' % argument_names[position]
+          check = '_default != %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