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

client/dom/scripts/systemfrog.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
 frog binding from the IDL database."""
 
 import os
 from generator import *
@@ skipping 86 matching lines @@
     elif native_spec[0] == '=':
       # The implementation is a singleton with no prototype.
       extends = ''
     else:
       extends = ' extends _DOMTypeJs'
 
     # TODO: Include all implemented interfaces, including other Lists.
     implements = [interface_name]
     element_type = MaybeTypedArrayElementType(self._interface)
     if element_type:
-      implements.append('List<' + element_type + '>')
+      implements.append('List<%s>' % DartType(element_type))
 
     self._members_emitter = self._dart_code.Emit(
         self._template,
         #class $CLASSNAME$EXTENDS$IMPLEMENTS$NATIVESPEC {
         #$!MEMBERS
         #}
         CLASSNAME=self._class_name,
         EXTENDS=extends,
         IMPLEMENTS=' implements ' + ', '.join(implements),
         NATIVESPEC=' native "' + native_spec + '"')
@@ skipping 39 matching lines @@
     if self._system._database.HasInterface(type_name):
       interface = self._system._database.GetInterface(type_name)
       if RecognizeCallback(interface):
         # Callbacks are typedef functions so don't have a class.
         return type_name
       else:
         return self._ImplClassName(type_name)
     return type_name
 
   def _NarrowInputType(self, type_name):
-    return self._NarrowToImplementationType(type_name)
+    return self._NarrowToImplementationType(DartType(type_name))
 
   def _NarrowOutputType(self, type_name):
-    return self._NarrowToImplementationType(type_name)
+    return self._NarrowToImplementationType(DartType(type_name))
 
   def AddConstant(self, constant):
     # Since we are currently generating native classes without interfaces,
     # generate the constants as part of the class.  This will need to go away
     # if we revert back to generating interfaces.
     self._members_emitter.Emit('\n  static final $TYPE $NAME = $VALUE;\n',
                                NAME=constant.id,
-                               TYPE=constant.type.id,
+                               TYPE=DartType(constant.type.id),
                                VALUE=constant.value)
 
     pass
 
   def AddAttribute(self, getter, setter):
     output_type = getter and self._NarrowOutputType(getter.type.id)
     input_type = setter and self._NarrowInputType(setter.type.id)
 
     # If the (getter, setter) pair is shadowing, we can't generate a shadowing
     # field (Issue 1633).
     (super_getter, super_getter_interface) = self._FindShadowedAttribute(getter)
     (super_setter, super_setter_interface) = self._FindShadowedAttribute(setter)
     if super_getter or super_setter:
       if getter and not setter and super_getter and not super_setter:
-        if getter.type.id == super_getter.type.id:
+        if DartType(getter.type.id) == DartType(super_getter.type.id):
           # Compatible getter, use the superclass property.  This works because
           # JavaScript will do its own dynamic dispatch.
           self._members_emitter.Emit(
               '\n'
               '  // Use implementation from $SUPER.\n'
               '  // final $TYPE $NAME;\n',
               SUPER=super_getter_interface.id,
               NAME=getter.id, TYPE=output_type)
           return
 
@@ skipping 100 matching lines @@
           '\n'
           '  void operator[]=(int index, $TYPE value) {\n'
           '    throw new UnsupportedOperationException("Cannot assign element of immutable List.");\n'
           '  }\n',
           TYPE=self._NarrowInputType(element_type))
 
     # TODO(sra): Use separate mixins for mutable implementations of List<T>.
     # TODO(sra): Use separate mixins for typed array implementations of List<T>.
     template_file = 'immutable_list_mixin.darttemplate'
     template = self._system._templates.Load(template_file)
-    self._members_emitter.Emit(template, E=element_type)
+    self._members_emitter.Emit(template, E=DartType(element_type))
 
 
   def AddTypedArrayConstructors(self, element_type):
     self._members_emitter.Emit(
         '\n'
         '  factory $CTOR(int length) =>  _construct_$CTOR(length);\n'
         '\n'
         '  factory $CTOR.fromList(List<$TYPE> list) => _construct_$CTOR(list);\n'
         '\n'
         '  factory $CTOR.fromBuffer(ArrayBuffer buffer) => _construct_$CTOR(buffer);\n'
         '\n'
         '  static _construct_$CTOR(arg) native \'return new $CTOR(arg);\';\n',
         CTOR=self._interface.id,
-        TYPE=element_type)
+        TYPE=DartType(element_type))
 
 
   def AddOperation(self, info):
     """
     Arguments:
       info: An OperationInfo object.
     """
     # TODO(vsm): Handle overloads.
     params = info.ParametersImplementationDeclaration(
         lambda type_name: self._NarrowInputType(type_name))
 
     native_body = dom_frog_native_bodies.get(
         self._interface.id + '.' + info.name, '')
     if native_body:
       native_body = " '''" + native_body + "'''"
 
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($PARAMS) native$NATIVESTRING;\n',
         TYPE=self._NarrowOutputType(info.type_name),
         NAME=info.name,
         PARAMS=params,
         NATIVESTRING=native_body)