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 @@
     # is useful not only for browser compat, but to allow code that links
     # against dart:dom_deprecated to load in a worker isolate.
     return '*' + javascript_binding_name
 
 
 def MatchSourceFilter(thing):
   return 'WebKit' in thing.annotations or 'Dart' in thing.annotations
 
 
 def DartType(idl_type_name):
-  return TypeRegistry().TypeInfo(idl_type_name).dart_type()
+  if idl_type_name in _idl_type_registry:
+    return _idl_type_registry[idl_type_name].get('dart_type', idl_type_name)
+  return idl_type_name
 
 
 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 15 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):
     """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, 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 387 matching lines @@
 _svg_supplemental_includes = [
     '"SVGAnimatedPropertyTearOff.h"',
     '"SVGAnimatedListPropertyTearOff.h"',
     '"SVGStaticListPropertyTearOff.h"',
     '"SVGAnimatedListPropertyTearOff.h"',
     '"SVGTransformListPropertyTearOff.h"',
     '"SVGPathSegListPropertyTearOff.h"',
 ]
 
 class TypeRegistry(object):
-  def __init__(self):
+  def __init__(self, interface_renames):
+    self._interface_renames = interface_renames
     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()
+    return self._interface_renames.get(dart_type, dart_type)
+
+  def InterfaceName(self, type_name):
+    return self._interface_renames.get(type_name, type_name)
+
   def _TypeInfo(self, type_name):
     match = re.match(r'(?:sequence<(\w+)>|(\w+)\[\])$', type_name)
     if match:
       if type_name == 'DOMString[]':
         return DOMStringArrayTypeInfo(self.TypeInfo('DOMString'))
       return SequenceIDLTypeInfo(type_name, self.TypeInfo(match.group(1) or match.group(2)))
     if not type_name in _idl_type_registry:
       return InterfaceIDLTypeInfo(type_name, {})
     type_data = _idl_type_registry.get(type_name)
     class_name = '%sIDLTypeInfo' % type_data['type']
     return globals()[class_name](type_name, type_data)