Do not rename idl types to dart types at top level - this info is needed for native bindings genera…

client/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 153 matching lines @@
 
   def _AddGetter(self, attr):
     # FIXME: Instead of injecting the interface name into the method when it is
     # also implemented in the base class, suppress the method altogether if it
     # has the same signature.  I.e., let the JS do the virtual dispatch instead.
     method_name = self._MethodName('_get_', attr.id)
     self._members_emitter.Emit(
         '\n'
         '  $TYPE get $NAME() { return $METHOD(this); }\n'
         '  static $TYPE $METHOD(var _this) native;\n',
-        NAME=attr.id, TYPE=attr.type.id, METHOD=method_name)
+        NAME=attr.id, TYPE=DartType(attr.type.id), METHOD=method_name)
 
   def _AddSetter(self, attr):
     # FIXME: See comment on getter.
     method_name = self._MethodName('_set_', attr.id)
     self._members_emitter.Emit(
         '\n'
         '  void set $NAME($TYPE value) { $METHOD(this, value); }\n'
         '  static void $METHOD(var _this, $TYPE value) native;\n',
-        NAME=attr.id, TYPE=attr.type.id, METHOD=method_name)
+        NAME=attr.id, TYPE=DartType(attr.type.id), METHOD=method_name)
 
   def AddSecondaryAttribute(self, interface, getter, setter):
     self._SecondaryContext(interface)
     self.AddAttribute(getter, setter)
 
   def AddSecondaryOperation(self, interface, info):
     self._SecondaryContext(interface)
     self.AddOperation(info)
 
   def AddEventAttributes(self, event_attrs):
@@ skipping 16 matching lines @@
     #   interface Y extends X, List<T> ...
     #
     # In the non-root case we have to choose between:
     #
     #   class YImpl extends XImpl { add List<T> methods; }
     #
     # and
     #
     #   class YImpl extends ListBase<T> { copies of transitive XImpl methods; }
     #
+    dart_element_type = DartType(element_type)
     if self._HasNativeIndexGetter(self._interface):
-      self._EmitNativeIndexGetter(self._interface, element_type)
+      self._EmitNativeIndexGetter(self._interface, dart_element_type)
     else:
       self._members_emitter.Emit(
           '\n'
           '  $TYPE operator[](int index) {\n'
           '    return item(index);\n'
           '  }\n',
-          TYPE=element_type)
+          TYPE=dart_element_type)
 
     if self._HasNativeIndexSetter(self._interface):
-      self._EmitNativeIndexSetter(self._interface, element_type)
+      self._EmitNativeIndexSetter(self._interface, dart_element_type)
     else:
       self._members_emitter.Emit(
           '\n'
           '  void operator[]=(int index, $TYPE value) {\n'
           '    throw new UnsupportedOperationException("Cannot assign element of immutable List.");\n'
           '  }\n',
-          TYPE=element_type)
+          TYPE=dart_element_type)
 
     self._members_emitter.Emit(
         '\n'
         '  void add($TYPE value) {\n'
         '    throw new UnsupportedOperationException("Cannot add to immutable List.");\n'
         '  }\n'
         '\n'
         '  void addLast($TYPE value) {\n'
         '    throw new UnsupportedOperationException("Cannot add to immutable List.");\n'
         '  }\n'
@@ skipping 68 matching lines @@
         '    throw new NotImplementedException();\n'
         '  }\n'
         '\n'
         '  bool isEmpty() {\n'
         '    return length == 0;\n'
         '  }\n'
         '\n'
         '  Iterator<$TYPE> iterator() {\n'
         '    return new _FixedSizeListIterator<$TYPE>(this);\n'
         '  }\n',
-        TYPE=element_type)
+        TYPE=dart_element_type)
 
   def _HasNativeIndexGetter(self, interface):
     return ('IndexedGetter' in interface.ext_attrs or
             'NumericIndexedGetter' in interface.ext_attrs)
 
-  def _EmitNativeIndexGetter(self, interface, element_type):
+  def _EmitNativeIndexGetter(self, interface, dart_element_type):
     method_name = '_index'
     self._members_emitter.Emit(
         '\n'
         '  $TYPE operator[](int index) { return $METHOD(this, index); }\n'
         '  static $TYPE $METHOD(var _this, int index) native;\n',
-        TYPE=element_type, METHOD=method_name)
+        TYPE=dart_element_type, METHOD=method_name)
 
   def _HasNativeIndexSetter(self, interface):
     return 'CustomIndexedSetter' in interface.ext_attrs
 
-  def _EmitNativeIndexSetter(self, interface, element_type):
+  def _EmitNativeIndexSetter(self, interface, dart_element_type):
     method_name = '_set_index'
     self._members_emitter.Emit(
         '\n'
         '  void operator[]=(int index, $TYPE value) {\n'
         '    return $METHOD(this, index, value);\n'
         '  }\n'
         '  static $METHOD(_this, index, value) native;\n',
-        TYPE=element_type, METHOD=method_name)
+        TYPE=dart_element_type, METHOD=method_name)
 
   def AddOperation(self, info):
     """
     Arguments:
       info: An OperationInfo object.
     """
     body = self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($PARAMS) {\n'
         '$!BODY'
@@ skipping 94 matching lines @@
     positive = []
     negative = []
     first_overload = overloads[0]
     (param_name, param_type, param_default) = info.arg_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 = first_overload.arguments[position].type.id
+      type = DartType(first_overload.arguments[position].type.id)
       test = TypeCheck(param_name, type)
-      pred = lambda op: len(op.arguments) > position and op.arguments[position].type.id == type
+      pred = lambda op: len(op.arguments) > position and DartType(op.arguments[position].type.id) == type
     else:
       type = None
       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)
@@ skipping 31 matching lines @@
     # 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