Move Dart type narrowing to TypeRegistry.

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
 from htmlrenamer import html_interface_renames
 
 _pure_interfaces = set([
     # TODO(sra): DOMStringMap should be a class implementing Map<String,String>.
     'DOMStringMap',
     'ElementTimeControl',
     'ElementTraversal',
+    'EventListener',
     'MediaQueryListListener',
     'NodeSelector',
     'SVGExternalResourcesRequired',
     'SVGFilterPrimitiveStandardAttributes',
     'SVGFitToViewBox',
     'SVGLangSpace',
     'SVGLocatable',
     'SVGStylable',
     'SVGTests',
     'SVGTransformable',
@@ skipping 466 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):
+  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
     # conversion function)
     self.function_name = name
@@ skipping 83 matching lines @@
   def __init__(self, idl_type, data):
     self._idl_type = idl_type
     self._data = data
 
   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 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 68 matching lines @@
 
 
 class InterfaceIDLTypeInfo(IDLTypeInfo):
   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())
+    # 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)
+
+
+class CallbackIDLTypeInfo(IDLTypeInfo):
+  def __init__(self, idl_type, data):
+    super(CallbackIDLTypeInfo, self).__init__(idl_type, data)
+
+  def narrow_dart_type(self):

[Anton Muhin, 2012/10/04 17:30:07]

why this override?

[podivilov1, 2012/10/04 17:46:54]

Done.

+    return self.dart_type()
+
 
 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 vector_to_dart_template_parameter(self):
@@ skipping 59 matching lines @@
   def webcore_getter_name(self):
     return self._data.webcore_getter_name
 
   def webcore_setter_name(self):
     return self._data.webcore_setter_name
 
   def _capitalized_native_type(self):
     return re.sub(r'(^| )([a-z])', lambda x: x.group(2).upper(), self.native_type())
 
 
-class SVGTearOffIDLTypeInfo(IDLTypeInfo):
+class SVGTearOffIDLTypeInfo(InterfaceIDLTypeInfo):
   def __init__(self, idl_type, data):
-    super(SVGTearOffIDLTypeInfo, self).__init__(idl_type, data)
+    super(SVGTearOffIDLTypeInfo, self).__init__(idl_type, data, idl_type)
 
   def native_type(self):
     if self._data.native_type:
       return self._data.native_type
     tear_off_type = 'SVGPropertyTearOff'
     if self._idl_type.endswith('List'):
       tear_off_type = 'SVGListPropertyTearOff'
     return '%s<%s>' % (tear_off_type, self._idl_type)
 
   def receiver(self):
@@ skipping 194 matching lines @@
   def _TypeInfo(self, type_name):
     match = re.match(r'(?:sequence<(\w+)>|(\w+)\[\])$', type_name)
     if match:
       if type_name == 'DOMString[]':
         return DOMStringArrayTypeInfo(TypeData('Sequence'), self.TypeInfo('DOMString'))
       item_info = self.TypeInfo(match.group(1) or match.group(2))
       return SequenceIDLTypeInfo(type_name, TypeData('Sequence'), item_info)
 
     if not type_name in _idl_type_registry:
       interface = self._database.GetInterface(type_name)
+      if 'Callback' in interface.ext_attrs:
+        return CallbackIDLTypeInfo(type_name, TypeData('Callback'))
       return InterfaceIDLTypeInfo(
           type_name,
           TypeData('Interface'),
           self._renamer.RenameInterface(interface))
 
     type_data = _idl_type_registry.get(type_name)
     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)