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 597 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 78 matching lines @@
   def narrow_dart_type(self):
     # TODO(podivilov): introduce ListLikeIDLTypeInfo and remove this hack.
     if self._data.suppress_public_interface:
       return ImplementationClassName(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)

[Anton Muhin, 2012/10/05 15:15:31]

why not implementation_name here?

And overall, it's somewhat confusing to have both ImplementationClassName and
implementation_name

[podivilov, 2012/10/05 16:02:51]

Done.
ImplementationClassName is a static function that renders _FooImpl name. 

implementation_name is a virtual function that returns different stuff depending
on idl type.

[Anton Muhin, 2012/10/05 16:04:16]

I do understand that, but presence of both is really confusing

[podivilov1, 2012/10/05 17:31:43]

Renamed

 
+  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 ImplementationClassName(self.idl_type())
+    return ImplementationClassName(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)