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

client/dom/scripts/systeminterface.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 providesfunctionality for systems to generate
 Dart interfaces from the IDL database."""
 
 import os
 import systembase
@@ skipping 80 matching lines @@
       typename = self._interface.id
 
 
     extends = []
     suppressed_extends = []
 
     for parent in self._interface.parents:
       # TODO(vsm): Remove source_filter.
       if MatchSourceFilter(self._source_filter, parent):
         # Parent is a DOM type.
-        extends.append(parent.type.id)
+        extends.append(DartType(parent.type.id))
       elif '<' in parent.type.id:
         # Parent is a Dart collection type.
         # TODO(vsm): Make this check more robust.
         extends.append(parent.type.id)
       else:
         suppressed_extends.append('%s.%s' %
                                   (self._common_prefix, parent.type.id))
 
     comment = ' extends'
     extends_str = ''
@@ skipping 30 matching lines @@
 
     element_type = MaybeTypedArrayElementType(self._interface)
     if element_type:
       self._members_emitter.Emit(
           '\n'
           '  $CTOR(int length);\n'
           '\n'
           '  $CTOR.fromList(List<$TYPE> list);\n'
           '\n'
           '  $CTOR.fromBuffer(ArrayBuffer buffer);\n',
-        CTOR=self._interface.id,
-        TYPE=element_type)
+          CTOR=self._interface.id,
+          TYPE=DartType(element_type))
 
 
   def FinishInterface(self):
     # TODO(vsm): Use typedef if / when that is supported in Dart.
     # Define variant as subtype.
     if (self._super_interface and
         self._interface.id is not self._super_interface):
       consts_emitter = self._top_level_emitter.Emit(
           '\n'
           'interface $NAME extends $BASE {\n'
           '$!CONSTS'
           '}\n',
           NAME=self._interface.id,
           BASE=self._super_interface)
       for const in sorted(self._interface.constants, ConstantOutputOrder):
         self._EmitConstant(consts_emitter, const)
 
   def AddConstant(self, constant):
     if (not self._super_interface or
         self._interface.id is self._super_interface):
       self._EmitConstant(self._members_emitter, constant)
 
   def _EmitConstant(self, emitter, constant):
     emitter.Emit('\n  static final $TYPE $NAME = $VALUE;\n',
                  NAME=constant.id,
-                 TYPE=constant.type.id,
+                 TYPE=DartType(constant.type.id),
                  VALUE=constant.value)
 
   def AddAttribute(self, getter, setter):
     if getter and setter and getter.type.id == setter.type.id:
       self._members_emitter.Emit('\n  $TYPE $NAME;\n',
-                                 NAME=getter.id, TYPE=getter.type.id);
+                                 NAME=getter.id, TYPE=DartType(getter.type.id));
       return
     if getter and not setter:
       self._members_emitter.Emit('\n  final $TYPE $NAME;\n',
-                                 NAME=getter.id, TYPE=getter.type.id);
+                                 NAME=getter.id, TYPE=DartType(getter.type.id));
       return
     raise Exception('Unexpected getter/setter combination %s %s' %
                     (getter, setter))
 
   def AddIndexer(self, element_type):
     # Interface inherits all operations from List<element_type>.
     pass
 
   def AddOperation(self, info):
     """
     Arguments:
       operations - contains the overloads, one or more operations with the same
         name.
     """
     self._members_emitter.Emit('\n'
                                '  $TYPE $NAME($PARAMS);\n',
                                TYPE=info.type_name,
                                NAME=info.name,
                                PARAMS=info.ParametersInterfaceDeclaration())
 
   # Interfaces get secondary members directly via the superinterfaces.
   def AddSecondaryAttribute(self, interface, getter, setter):
     pass
 
   def AddSecondaryOperation(self, interface, attr):
     pass
 
   def AddEventAttributes(self, event_attrs):
     pass