Stop passing HtmlSystemShared around and move html renaming to IDLTypeInfo.

lib/dom/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 150 matching lines @@
     return '*' + javascript_binding_name
 
 
 def MatchSourceFilter(thing):
   return 'WebKit' in thing.annotations or 'Dart' in thing.annotations
 
 
 def DartType(idl_type_name):
   return GetIDLTypeInfo(idl_type_name).dart_type()
 
+def DartInterfaceName(interface):
+  return IDLTypeInfo.interface_renames.get(interface.id, interface.id)
 
 class ParamInfo(object):
   """Holder for various information about a parameter of a Dart operation.
 
   Attributes:
     name: Name of parameter.
     type_id: Original type id.  None for merged types.
     dart_type: DartType of parameter.
     is_optional: Parameter optionality.
   """
@@ skipping 14 matching lines @@
   # Given a list of overloaded arguments, choose a suitable name.
   def OverloadedName(args):
     return '_OR_'.join(sorted(set(arg.id for arg in args)))
 
   # Given a list of overloaded arguments, choose a suitable type.
   def OverloadedType(args):
     type_ids = sorted(set(arg.type.id for arg in args))
     dart_types = sorted(set(DartType(arg.type.id) for arg in args))
     if len(dart_types) == 1:
       if len(type_ids) == 1:
-        return (type_ids[0], dart_types[0])
+        return (type_ids[0], type_ids[0])
       else:
-        return (None, dart_types[0])
+        return (None, type_ids[0])
     else:
       return (None, TypeName(type_ids, interface))
 
   def IsOptional(argument):
     if not argument:
       return True
     if 'Callback' in argument.ext_attrs:
       # Callbacks with 'Optional=XXX' are treated as optional arguments.
       return 'Optional' in argument.ext_attrs
     if constructor:
@@ skipping 33 matching lines @@
   args = map(lambda *args: _DartArg(args, interface),
              *(op.arguments for op in split_operations))
 
   info = OperationInfo()
   info.operations = operations
   info.overloads = split_operations
   info.declared_name = operations[0].id
   info.name = operations[0].ext_attrs.get('DartName', info.declared_name)
   info.constructor_name = None
   info.js_name = info.declared_name
-  info.type_name = DartType(operations[0].type.id)   # TODO: widen.
+  info.type_name = operations[0].type.id   # TODO: widen.
   info.param_infos = args
   return info
 
 
 def AnalyzeConstructor(interface):
   """Returns an OperationInfo object for the constructor.
 
   Returns None if the interface has no Constructor.
   """
   def GetArgs(func_value):
@@ skipping 101 matching lines @@
 
   Attributes:
     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=lambda x: x):
+  def ParametersInterfaceDeclaration(self, rename_type=DartType):
     """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 ParametersImplementationDeclaration(
-      self, rename_type=None, default_value='null'):
+      self, rename_type=DartType, default_value='null'):
     """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.
     """
-    if rename_type:
-      def renamer(param_info):
-        return TypeOrNothing(rename_type(param_info.dart_type))
-      return self._FormatParams(self.param_infos, default_value, renamer)
-    else:
-      def type_fn(param_info):
-        if param_info.dart_type == 'Dynamic':
-          if param_info.type_id:
-            # It is more informative to use a comment IDL type.
-            return '/*%s*/' % param_info.type_id
-          else:
-            return 'var'
-        else:
-          return param_info.dart_type
-      return self._FormatParams(
-          self.param_infos, default_value,
-          lambda param: TypeOrNothing(param.dart_type, param.type_id))
+    return self._FormatParams(
+        self.param_infos, default_value,
+        lambda param: TypeOrNothing(rename_type(param.dart_type)))
 
   def ParametersAsArgumentList(self):
     """Returns a string of the parameter names suitable for passing the
     parameters as arguments.
     """
     return ', '.join(map(lambda param_info: param_info.name, self.param_infos))
 
   def _FormatParams(self, params, default_value, type_fn):
     def FormatParam(param):
       """Returns a parameter declaration fragment for an ParamInfo."""
@@ skipping 73 matching lines @@
     self._dart_type = dart_type
     self._native_type = native_type
     self._custom_to_native = custom_to_native
     self._custom_to_dart = custom_to_dart
     self._conversion_includes = conversion_includes + [idl_type]
 
   def idl_type(self):
     return self._idl_type
 
   def dart_type(self):
-    return self._dart_type or self._idl_type
+    dart_type = self._dart_type or self._idl_type
+    return self.interface_renames.get(dart_type, dart_type)
 
   def native_type(self):
     return self._native_type or self._idl_type
 
   def emit_to_native(self, emitter, idl_node, name, handle, interface_name):
     if 'Callback' in idl_node.ext_attrs:
       if set(['Optional', 'Callback']).issubset(idl_node.ext_attrs.keys()):
         flag = 'DartUtilities::ConvertNullToDefaultValue'
       else:
         flag = 'DartUtilities::ConvertNone'
@@ skipping 71 matching lines @@
 
   def to_native_includes(self):
     return ['"Dart%s.h"' % self.idl_type()]
 
   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._custom_to_dart
 
+  interface_renames = {}
+
 
 class SequenceIDLTypeInfo(IDLTypeInfo):
   def __init__(self, idl_type, item_info):
     super(SequenceIDLTypeInfo, self).__init__(idl_type)
     self._item_info = item_info
 
   def dart_type(self):
     return 'List<%s>' % self._item_info.dart_type()
 
   def to_dart_conversion(self, value, interface_name=None, attributes=None):
@@ skipping 215 matching lines @@
 
   match = re.match(r'sequence<(\w+)>$', idl_type_name)
   if match:
     return SequenceIDLTypeInfo(idl_type_name, GetIDLTypeInfo(match.group(1)))
 
   match = re.match(r'(\w+)\[\]$', idl_type_name)
   if match:
     return SequenceIDLTypeInfo(idl_type_name, GetIDLTypeInfo(match.group(1)))
 
   return IDLTypeInfo(idl_type_name)