Map IDBAny and IDBKey to Dynamic

lib/dom/scripts/systemwrapping.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 systems to generate
 wrapping binding from the IDL database."""
 
 import os
 from generator import *
@@ skipping 373 matching lines @@
       info: the compound information about the operation and its overloads.
       indent: an indentation string for generated code.
       operation: the IDLOperation to call.
     """
     # TODO(sra): Do we need to distinguish calling with missing optional
     # arguments from passing 'null' which is represented as 'undefined'?
     def UnwrapArgExpression(name, type):
       # TODO: Type specific unwrapping.
       return '__dom_unwrap(%s)' % (name)
 
-    def ArgNameAndUnwrapper(arg_info, overload_arg):
-      (name, type, value) = arg_info
-      return (name, UnwrapArgExpression(name, type))
+    def ArgNameAndUnwrapper(param_info, overload_arg):
+      return (param_info.name,
+              UnwrapArgExpression(param_info.name, param_info.dart_type))
 
-    names_and_unwrappers = [ArgNameAndUnwrapper(info.arg_infos[i], arg)
+    names_and_unwrappers = [ArgNameAndUnwrapper(info.param_infos[i], arg)
                             for (i, arg) in enumerate(operation.arguments)]
     unwrap_args = [unwrap_arg for (_, unwrap_arg) in names_and_unwrappers]
     arg_names = [name for (name, _) in names_and_unwrappers]
 
     self._native_version += 1
     native_name = self._MethodName('_', info.name)
     if self._native_version > 1:
       native_name = '%s_%s' % (native_name, self._native_version)
 
     argument_expressions = ', '.join(['this'] + arg_names)
@@ skipping 29 matching lines @@
     always dispatches.
     """
 
     def NullCheck(name):
       return '%s === null' % name
 
     def TypeCheck(name, type):
       return '%s is %s' % (name, type)
 
     def ShouldGenerateSingleOperation():
-      if position == len(info.arg_infos):
+      if position == len(info.param_infos):
         if len(overloads) > 1:
           raise Exception('Duplicate operations ' + str(overloads))
         return True
 
       # Check if we dispatch on RequiredCppParameter arguments.  In this
       # case all trailing arguments must be RequiredCppParameter and there
       # is no need in dispatch.
       # TODO(antonm): better diagnositics.
       if position >= len(overloads[0].arguments):
         def IsRequiredCppParameter(arg):
@@ skipping 14 matching lines @@
       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
+    # Otherwise the overloads have the same type but the type is a subtype 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