Get rid of Dynamic.

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 871 matching lines @@
       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'
+        return self._NarrowInputType(type_name) if type_name else 'dynamic'
 
     body = self._members_emitter.Emit(
         '\n'
         '  $MODIFIERS$TYPE $(HTML_NAME)($PARAMS) {\n'
         '$!BODY'
         '  }\n',
         MODIFIERS='static ' if info.IsStatic() else '',
         TYPE=return_type,
         HTML_NAME=html_name,
         PARAMS=info.ParametersDeclaration(InputType))
@@ skipping 40 matching lines @@
           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'
+            param_type = 'dynamic'
         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 10 matching lines @@
           TARGET=target,
           PARAMS=', '.join(target_parameters),
           NATIVE=info.declared_name)
 
     def GenerateChecksAndCall(operation, argument_count):
       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']:
+        if test_type in ['dynamic', 'Object']:
           checks[i] = '?%s' % parameter_name
         elif test_type == parameter_types[i]:
           checks[i] = 'true'
         else:
           checks[i] = '(%s is %s || %s == null)' % (
               parameter_name, test_type, parameter_name)
       # 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)
 
@@ skipping 121 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(
           "#source('$PATH');\n", PATH=massage_path(relpath))