Refactor idl to dart renaming logic for interfaces.

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 327 matching lines @@
     overloads: A list of IDL operation overloads with the same name.
     name: A string, the simple name of the operation.
     constructor_name: A string, the name of the constructor iff the constructor
        is named, e.g. 'fromList' in  Int8Array.fromList(list).
     type_name: A string, the name of the return type of the operation.
     param_infos: A list of ParamInfo.
   """
 
   def ParametersInterfaceDeclaration(self, rename_type):
     """Returns a formatted string declaring the parameters for the interface."""
-    return self._FormatParams(
-        self.param_infos, None,
-        lambda param: TypeOrNothing(rename_type(param.dart_type), param.type_id))
+    def type_function(param):
+      # TODO(podivilov): replace param.dart_type field with param.is_optional
+      dart_type = param.dart_type
+      if dart_type != 'Dynamic':
+        dart_type = rename_type(dart_type)
+      return TypeOrNothing(dart_type, param.type_id)
+    return self._FormatParams(self.param_infos, None, type_function)
 
   def ParametersImplementationDeclaration(self, rename_type):
     """Returns a formatted string declaring the parameters for the
     implementation.
 
     Args:
       rename_type: A function that allows the types to be renamed.
         The function is applied to the parameter's dart_type.
     """
-    return self._FormatParams(
-        self.param_infos, 'null',
-        lambda param: TypeOrNothing(rename_type(param.dart_type)))
+    def type_function(param):
+      # TODO(podivilov): replace param.dart_type field with param.is_optional
+      dart_type = param.dart_type
+      if dart_type != 'Dynamic':
+        dart_type = rename_type(dart_type)
+      return TypeOrNothing(dart_type)
+    return self._FormatParams(self.param_infos, 'null', type_function)
 
   def ParametersAsArgumentList(self, parameter_count = None):
     """Returns a string of the parameter names suitable for passing the
     parameters as arguments.
     """
     if parameter_count is None:
       parameter_count = len(self.param_infos)
     return ', '.join(map(
         lambda param_info: param_info.name,
         self.param_infos[:parameter_count]))
@@ skipping 19 matching lines @@
     argtexts = map(FormatParam, required)
     if optional:
       argtexts.append('[' + ', '.join(map(FormatParam, optional)) + ']')
     return ', '.join(argtexts)
 
   def IsStatic(self):
     is_static = self.overloads[0].is_static
     assert any([is_static == o.is_static for o in self.overloads])
     return is_static
 
-  def _ConstructorFullName(self):
+  def _ConstructorFullName(self, rename_type):
     if self.constructor_name:
-      return self.type_name + '.' + self.constructor_name
+      return rename_type(self.type_name) + '.' + self.constructor_name
     else:
-      return self.type_name
+      return rename_type(self.type_name)
 
   def ConstructorFactoryName(self, rename_type):
-    return 'create' + rename_type(self._ConstructorFullName()).replace('.', '_')
+    return 'create' + self._ConstructorFullName(rename_type).replace('.', '_')
 
   def GenerateFactoryInvocation(self, rename_type, emitter, factory_provider):
     has_optional = any(param_info.is_optional
         for param_info in self.param_infos)
 
     factory_name = self.ConstructorFactoryName(rename_type)
     if not has_optional:
       emitter.Emit(
           '\n'
           '  factory $CTOR($PARAMS) => '
           '$FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n',
-          CTOR=rename_type(self._ConstructorFullName()),
+          CTOR=self._ConstructorFullName(rename_type),
           PARAMS=self.ParametersInterfaceDeclaration(rename_type),
           FACTORY=factory_provider,
           CTOR_FACTORY_NAME=factory_name,
           FACTORY_PARAMS=self.ParametersAsArgumentList())
       return
 
     dispatcher_emitter = emitter.Emit(
         '\n'
         '  factory $CTOR($PARAMS) {\n'
         '$!DISPATCHER'
         '    return $FACTORY.$CTOR_FACTORY_NAME($FACTORY_PARAMS);\n'
         '  }\n',
-        CTOR=rename_type(self._ConstructorFullName()),
+        CTOR=self._ConstructorFullName(rename_type),
         PARAMS=self.ParametersInterfaceDeclaration(rename_type),
         FACTORY=factory_provider,
         CTOR_FACTORY_NAME=factory_name,
         FACTORY_PARAMS=self.ParametersAsArgumentList())
 
     # If we have optional parameters, check to see if they are set
     # and call the appropriate factory method.
     def EmitOptionalParameterInvocation(index):
       dispatcher_emitter.Emit(
         '    if (!?$OPT_PARAM_NAME) {\n'
@@ skipping 229 matching lines @@
     return ['"Dart%s.h"' % include for include in includes]
 
   def to_dart_conversion(self, value, interface_name=None, attributes=None):
     return 'Dart%s::toDart(%s)' % (self._idl_type, value)
 
   def custom_to_dart(self):
     return self._data.custom_to_dart
 
 
 class InterfaceIDLTypeInfo(IDLTypeInfo):
-  def __init__(self, idl_type, data):
+  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
 
 
 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()
 
@@ skipping 265 matching lines @@
     self._database = database
     self._renamer = renamer
     self._cache = {}
 
   def TypeInfo(self, type_name):
     if not type_name in self._cache:
       self._cache[type_name] = self._TypeInfo(type_name)
     return self._cache[type_name]
 
   def DartType(self, type_name):
-    dart_type = self.TypeInfo(type_name).dart_type()
-    if self._database.HasInterface(dart_type):
-      interface = self._database.GetInterface(dart_type)
-      if self._renamer:
-        return self._renamer.RenameInterface(interface)
-      else:
-        return interface.ext_attrs.get('InterfaceName', interface.id)
-    return dart_type
+    return self.TypeInfo(type_name).dart_type()
 
   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:
-      return InterfaceIDLTypeInfo(type_name, TypeData('Interface'))
+      interface = self._database.GetInterface(type_name)
+      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)