Add interface_name and implementation_name to IDLTypeInfo class and use them instead of dart_type.

lib/html/scripts/generator.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 systems to generate
 Dart APIs from the IDL database."""
 
 import copy
 import re
@@ skipping 488 matching lines @@
     else:
       return '\n'
   return ''.join(FormatLine(line) for line in text.split('\n'))
 
 # Given a sorted sequence of type identifiers, return an appropriate type
 # name
 def TypeName(type_ids, interface):
   # Dynamically type this field for now.
   return 'Dynamic'
 
-def ImplementationClassName(interface_name):
+def ImplementationClassNameForInterfaceName(interface_name):
   return '_%sImpl' % interface_name
 
 # ------------------------------------------------------------------------------
 
 class Conversion(object):
   """Represents a way of converting between types."""
   def __init__(self, name, input_type, output_type):
     # input_type is the type of the API input (and the argument type of the
     # conversion function)
     # output_type is the type of the API output (and the result type of the
@@ skipping 88 matching lines @@
 
   def idl_type(self):
     return self._idl_type
 
   def dart_type(self):
     return self._data.dart_type or self._idl_type
 
   def narrow_dart_type(self):
     return self.dart_type()
 
+  def interface_name(self):
+    raise NotImplementedError()
+
+  def implementation_name(self):
+    raise NotImplementedError()
+
   def native_type(self):
     return self._data.native_type or self._idl_type
 
   def bindings_class(self):
     return 'Dart%s' % self.idl_type()
 
   def vector_to_dart_template_parameter(self):
     return self.bindings_class()
 
   def requires_v8_scope(self):
@@ skipping 71 matching lines @@
   def __init__(self, idl_type, data, dart_interface_name):
     super(InterfaceIDLTypeInfo, self).__init__(idl_type, data)
     self._dart_interface_name = dart_interface_name
 
   def dart_type(self):
     return self._data.dart_type or self._dart_interface_name
 
   def narrow_dart_type(self):
     # TODO(podivilov): introduce ListLikeIDLTypeInfo and remove this hack.
     if self._data.suppress_public_interface:
-      return ImplementationClassName(self.idl_type())
+      return ImplementationClassNameForInterfaceName(self.idl_type())
     # TODO(podivilov): only primitive and collection types should override
     # dart_type.
     if self._data.dart_type != None:
       return self.dart_type()
     if IsPureInterface(self.idl_type()):
       return self.idl_type()
-    return ImplementationClassName(self._dart_interface_name)
+    return self.implementation_name()
+
+  def interface_name(self):
+    return self._dart_interface_name
+
+  def implementation_name(self):
+    # TODO(podivilov): introduce ListLikeIDLTypeInfo and remove this hack.
+    if self._data.suppress_public_interface:
+      return ImplementationClassNameForInterfaceName(self.idl_type())
+    return ImplementationClassNameForInterfaceName(self._dart_interface_name)
 
 
 class CallbackIDLTypeInfo(IDLTypeInfo):
   def __init__(self, idl_type, data):
     super(CallbackIDLTypeInfo, self).__init__(idl_type, data)
 
 
 class SequenceIDLTypeInfo(IDLTypeInfo):
   def __init__(self, idl_type, data, item_info):
     super(SequenceIDLTypeInfo, self).__init__(idl_type, data)
     self._item_info = item_info
 
   def dart_type(self):
     return 'List<%s>' % self._item_info.dart_type()
 
+  def interface_name(self):
+    return self.dart_type()
+
+  def implementation_name(self):
+    return self.dart_type()
+
   def vector_to_dart_template_parameter(self):
     raise Exception('sequences of sequences are not supported yet')
 
   def to_native_info(self, idl_node, interface_name):
     item_native_type = self._item_info.vector_to_dart_template_parameter()
     return '%s', 'Vector<%s>' % item_native_type, 'DartUtilities', 'toNativeVector<%s>' % item_native_type
 
   def pass_native_by_ref(self): return True
 
   def to_dart_conversion(self, value, interface_name=None, attributes=None):
@@ skipping 287 matching lines @@
     if type_data.clazz == 'Interface':
       if self._database.HasInterface(type_name):
         dart_interface_name = self._renamer.RenameInterface(
             self._database.GetInterface(type_name))
       else:
         dart_interface_name = type_name
       return InterfaceIDLTypeInfo(type_name, type_data, dart_interface_name)
 
     class_name = '%sIDLTypeInfo' % type_data.clazz
     return globals()[class_name](type_name, type_data)