Map IDBAny and IDBKey to Dynamic

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."""
 
 from systemfrog import *
 from systeminterface import *
@@ skipping 1304 matching lines @@
 
     factory_provider = '_' + interface_name + 'FactoryProvider'
     emitter = self._system._ImplFileEmitter(factory_provider)
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
         CONSTRUCTOR=interface_name,
         PARAMETERS=constructor_info.ParametersImplementationDeclaration(),
         NAMED_CONSTRUCTOR=constructor_info.name or interface_name,
         ARGUMENTS=self._UnwrappedParameters(constructor_info,
-                                            len(constructor_info.arg_infos)))
+                                            len(constructor_info.param_infos)))
 
   def _UnwrappedParameters(self, operation_info, length):
     """Returns string for an argument list that unwraps first |length|
     parameters."""
-    def UnwrapArgInfo(arg_info):
-      (name, type, value) = arg_info
+    def UnwrapParamInfo(param_info):
       # TODO(sra): Type dependent unwrapping.
-      return '_unwrap(%s)' % name
+      return '_unwrap(%s)' % param_info.name
 
-    return ', '.join(map(UnwrapArgInfo, operation_info.arg_infos[:length]))
+    return ', '.join(map(UnwrapParamInfo, operation_info.param_infos[:length]))
 
   def _BaseClassName(self, interface):
     if not interface.parents:
       return '_DOMTypeBase'
 
     supertype = DartType(interface.parents[0].type.id)
 
     if IsDartListType(supertype) or IsDartCollectionType(supertype):
       return 'DOMWrapperBase'
 
@@ skipping 261 matching lines @@
     Returns True if the dispatch can fall through on failure, False if the code
     always dispatches.
     """
 
     def NullCheck(name):
       return '%s === null' % name
 
     def TypeCheck(name, type):
       return '%s is %s' % (name, type)
 
-    if position == len(info.arg_infos):
+    if position == len(info.param_infos):
       if len(overloads) > 1:
         raise Exception('Duplicate operations ' + str(overloads))
       operation = overloads[0]
       self.GenerateSingleOperation(emitter, info, indent, operation)
       return False
 
     # FIXME: Consider a simpler dispatch that iterates over the
     # overloads and generates an overload specific check.  Revisit
     # when we move to named optional arguments.
 
     # Partition the overloads to divide and conquer on the dispatch.
     positive = []
     negative = []
     first_overload = overloads[0]
-    (param_name, param_type, param_default) = info.arg_infos[position]
+    param = info.param_infos[position]
 
     if position < len(first_overload.arguments):
       # FIXME: This will not work if the second overload has a more
       # precise type than the first.  E.g.,
       # void foo(Node x);
       # void foo(Element x);
       type = DartType(first_overload.arguments[position].type.id)
-      test = TypeCheck(param_name, type)
+      test = TypeCheck(param.name, type)
       pred = lambda op: (len(op.arguments) > position and
           DartType(op.arguments[position].type.id) == type)
     else:
       type = None
-      test = NullCheck(param_name)
+      test = NullCheck(param.name)
       pred = lambda op: position >= len(op.arguments)
 
     for overload in overloads:
       if pred(overload):
         positive.append(overload)
       else:
         negative.append(overload)
 
     if positive and negative:
       (true_code, false_code) = emitter.Emit(
@@ skipping 11 matching lines @@
 
     if negative:
       raise Exception('Internal error, must be all positive')
 
     # All overloads require the same test.  Do we bother?
 
     # If the test is the same as the method's formal parameter then checked mode
     # will have done the test already. (It could be null too but we ignore that
     # case since all the overload behave the same and we don't know which types
     # in the IDL are not nullable.)
-    if type == param_type:
+    if type == param.dart_type:
       return self.GenerateDispatch(
           emitter, info, indent, position + 1, positive)
 
     # Otherwise the overloads have the same type but the type is a substype of
     # the method's synthesized formal parameter. e.g we have overloads f(X) and
     # f(Y), implemented by the synthesized method f(Z) where X<Z and Y<Z. The
     # dispatch has removed f(X), leaving only f(Y), but there is no guarantee
     # that Y = Z-X, so we need to check for Y.
     true_code = emitter.Emit(
         '$(INDENT)if ($COND) {\n'
         '$!TRUE'
         '$(INDENT)}\n',
         COND=test, INDENT=indent)
     self.GenerateDispatch(
         true_code, info, indent + '  ', position + 1, positive)
     return True