Stop passing HtmlSystemShared around and move html renaming to IDLTypeInfo.

lib/dom/scripts/systemhtml.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 the system to generate
 Dart:html APIs from the IDL database."""
 
 import emitter
 
@@ skipping 571 matching lines @@
     inits = emitter.Emit(
         '\n'
         '  factory $CONSTRUCTOR($PARAMS) {\n'
         '    $CLASS _e = _document.$dom_createElement("$TAG");\n'
         '$!INITS'
         '    return _e;\n'
         '  }\n',
         CONSTRUCTOR=constructor_info.ConstructorFullName(),
         CLASS=class_name,
         TAG=info.tag,
-        PARAMS=constructor_info.ParametersInterfaceDeclaration())
+        PARAMS=constructor_info.ParametersInterfaceDeclaration(DartType))
     for param in constructor_info.param_infos:
       inits.Emit('    if ($E != null) _e.$E = $E;\n', E=param.name)
 
 
 # These classes require an explicit declaration for the "on" method even though
 # they don't declare any unique events, because the concrete class hierarchy
 # doesn't match the interface hierarchy.
 _html_explicit_event_classes = set(['DocumentFragment'])
 
 def _OnAttributeToEventName(on_method):
@@ skipping 12 matching lines @@
   return sorted(event_names, key=lambda name: _html_event_names[name])
 
 def DomToHtmlEvent(event_name):
   assert event_name in _html_event_names, \
          'No known html event name for event: ' + event_name
   return _html_event_names[event_name]
 
 # ------------------------------------------------------------------------------
 class HtmlSystemShared(object):
 
-  def __init__(self, database):
+  def __init__(self, context):
     self._event_classes = set()
     self._seen_event_names = {}
-    self._database = database
-    self._inheritance_closure = _ComputeInheritanceClosure(database)
-    self._html_renames = self._MakeHtmlRenames()
+    self._database = context.database
+    self._type_registry = context.type_registry
+    self._inheritance_closure = _ComputeInheritanceClosure(self._database)
 
-  def _HasAncestor(self, interface, names_to_match):
+  @staticmethod
+  def _HasAncestor(database, interface, names_to_match):
     for parent in interface.parents:
       if parent.type.id in names_to_match:
         return True
-      if not self._database.HasInterface(parent.type.id):
+      if not database.HasInterface(parent.type.id):
         continue
-      parent_interface = self._database.GetInterface(parent.type.id)
-      if self._HasAncestor(parent_interface, names_to_match):
+      parent_interface = database.GetInterface(parent.type.id)
+      if HtmlSystemShared._HasAncestor(database, parent_interface, names_to_match):
         return True
     return False
 
-  def _MakeHtmlRenames(self):
+  @staticmethod
+  def MakeHtmlRenames(database):
     html_renames = {}
 
-    for interface in self._database.GetInterfaces():
+    for interface in database.GetInterfaces():
       if (interface.id.startswith('HTML') and
-          self._HasAncestor(interface, ['Element', 'Document'])):
+          HtmlSystemShared._HasAncestor(database, interface, ['Element', 'Document'])):
         html_renames[interface.id] = interface.id[4:]
 
     for subclass in _html_strip_webkit_prefix_classes:
       html_renames['WebKit' + subclass] = subclass
 
     # TODO(jacobr): we almost want to add this commented out line back.
     #    html_renames['HTMLCollection'] = 'ElementList'
     #    html_renames['NodeList'] = 'ElementList'
     #    html_renames['HTMLOptionsCollection'] = 'ElementList'
     html_renames['DOMWindow'] = 'Window'
 
     return html_renames
 
-  def _HTMLInterfaceName(self, interface_name):
-    return self._html_renames.get(interface_name, interface_name)
-
   def _FindMatch(self, interface_name, member, member_prefix, candidates):
     for ancestor_name in self._AllAncestorInterfaces(interface_name):
-      name = self._HTMLInterfaceName(ancestor_name) + '.' + member
+      name = self._DartType(ancestor_name) + '.' + member
       if name in candidates:
         return name
-      name = (self._HTMLInterfaceName(interface_name) + '.' + member_prefix +
+      name = (self._DartType(interface_name) + '.' + member_prefix +
               member)
       if name in candidates:
         return name
     return None
 
   def _AllAncestorInterfaces(self, interface_name):
     return [interface_name] + self._inheritance_closure[interface_name]
 
   def RenameInHtmlLibrary(self, interface_name, member, member_prefix='',
                           implementation_class=False):
@@ skipping 50 matching lines @@
       for interface in interfaces_with_events:
         names.append(interface.id + 'Events')
       return names
 
   def GetParentEventsClass(self, interface):
     parent_event_classes = self.GetParentsEventsClasses(interface)
     if len(parent_event_classes) != 1:
       raise Exception('Only one parent event class allowed ' + interface.id)
     return parent_event_classes[0]
 
-  def _ImplClassName(self, type_name):
-    return '_' + type_name + 'Impl'
-
   # This returns two values: the first is whether or not an "on" property should
   # be generated for the interface, and the second is the event attributes to
   # generate if it should.
   def GetEventAttributes(self, interface):
     events =  set([attr for attr in interface.attributes
                    if attr.type.id == 'EventListener'])
 
     if events or interface.id in _html_explicit_event_classes:
       return True, events
     else:
       return False, None
 
   def IsPrivate(self, name):
     return name.startswith('_')
 
-  def DartType(self, idl_type):
-    type_info = TypeRegistry().TypeInfo(idl_type)
-    return self._HTMLInterfaceName(type_info.dart_type())
+  def _DartType(self, type_name):
+    return self._type_registry.DartType(type_name)
 
-class HtmlSystem(System):
 
-  def __init__(self, context):
-    super(HtmlSystem, self).__init__(context)
-    self._shared = HtmlSystemShared(self._database)
-
-class HtmlInterfacesSystem(HtmlSystem):
+class HtmlInterfacesSystem(System):
 
   def __init__(self, context, backend):
     super(HtmlInterfacesSystem, self).__init__(context)
     self._backend = backend
+    self._shared = HtmlSystemShared(context)
     self._dart_interface_file_paths = []
     self._elements_factory_emitter = None
 
   def ProcessInterface(self, interface):
     HtmlDartInterfaceGenerator(self, interface).Generate()
 
   def ProcessCallback(self, interface, info):
     """Generates a typedef for the callback interface."""
     interface_name = interface.id
     file_path = self._FilePathForDartInterface(interface_name)
@@ skipping 12 matching lines @@
 # ------------------------------------------------------------------------------
 
 class HtmlDartInterfaceGenerator(BaseGenerator):
   """Generates dart interface and implementation for the DOM IDL interface."""
 
   def __init__(self, system, interface):
     super(HtmlDartInterfaceGenerator, self).__init__(
         system._database, interface)
     self._system = system
     self._shared = system._shared
-    self._html_interface_name = self._shared._HTMLInterfaceName(
-        self._interface.id)
+    self._html_interface_name = system._type_registry.InterfaceName(self._interface.id)
     self._backend = system._backend.ImplementationGenerator(self._interface)
 
   def StartInterface(self):
     if not self._interface.id in _merged_html_interfaces:
       path = self._system._FilePathForDartInterface(self._html_interface_name)
       self._system._dart_interface_file_paths.append(path)
       self._interface_emitter = self._system._emitters.FileEmitter(path)
     else:
       self._interface_emitter = emitter.Emitter()
 
     template_file = 'interface_%s.darttemplate' % self._html_interface_name
     interface_template = (self._system._templates.TryLoad(template_file) or
                           self._system._templates.Load('interface.darttemplate'))
 
     typename = self._html_interface_name
 
     extends = []
     suppressed_extends = []
 
     for parent in self._interface.parents:
       # TODO(vsm): Remove source_filter.
       if MatchSourceFilter(parent):
         # Parent is a DOM type.
-        extends.append(self._shared.DartType(parent.type.id))
+        extends.append(self._DartType(parent.type.id))
       elif '<' in parent.type.id:
         # Parent is a Dart collection type.
         # TODO(vsm): Make this check more robust.
-        extends.append(self._shared.DartType(parent.type.id))
+        extends.append(self._DartType(parent.type.id))
       else:
         suppressed_extends.append('%s.%s' %
-            (self._common_prefix, self._shared.DartType(parent.type.id)))
+            (self._common_prefix, self._DartType(parent.type.id)))
 
     comment = ' extends'
     extends_str = ''
     if extends:
       extends_str += ' extends ' + ', '.join(extends)
       comment = ','
     if suppressed_extends:
       extends_str += ' /*%s %s */' % (comment, ', '.join(suppressed_extends))
 
     factory_provider = None
@@ skipping 53 matching lines @@
       self._implementation_emitter = self._system._emitters.FileEmitter(path)
     else:
       self._implementation_emitter = emitter.Emitter()
     self._backend.SetImplementationEmitter(self._implementation_emitter)
     self._implementation_members_emitter = self._backend.StartInterface()
 
     for constructor_info in constructors:
       self._members_emitter.Emit(
           '\n'
           '  $CTOR($PARAMS);\n',
-          CTOR=self._shared.DartType(constructor_info.ConstructorFullName()),
-          PARAMS=constructor_info.ParametersInterfaceDeclaration(
-                     self._shared.DartType))
+          CTOR=self._DartType(constructor_info.ConstructorFullName()),
+          PARAMS=constructor_info.ParametersInterfaceDeclaration(self._DartType))
 
     element_type = MaybeTypedArrayElementTypeInHierarchy(
         self._interface, self._system._database)
     if element_type:
       self._members_emitter.Emit(
           '\n'
           '  $CTOR(int length);\n'
           '\n'
           '  $CTOR.fromList(List<$TYPE> list);\n'
           '\n'
           '  $CTOR.fromBuffer(ArrayBuffer buffer,'
                             ' [int byteOffset, int length]);\n',
         CTOR=self._interface.id,
-        TYPE=self._shared.DartType(element_type))
+        TYPE=self._DartType(element_type))
 
     self._GenerateEvents()
 
     old_backend = self._backend
     if not self._backend.ImplementsMergedMembers():
       self._backend = HtmlGeneratorDummyBackend()
     for merged_interface in _merged_html_interfaces:
       if _merged_html_interfaces[merged_interface] == self._interface.id:
         merged_interface = self._database.GetInterface(merged_interface)
         self.AddMembers(merged_interface)
@@ skipping 21 matching lines @@
     assert(not html_setter_name or html_name == html_setter_name)
 
     if not is_secondary:
       self._members_emitter.Emit('\n  /** @domName $DOMINTERFACE.$DOMNAME */',
           DOMINTERFACE=attribute.doc_js_interface_name,
           DOMNAME=dom_name)
       modifier = 'final ' if read_only else ''
       self._members_emitter.Emit('\n  $MODIFIER$TYPE $NAME;\n',
                                  MODIFIER=modifier,
                                  NAME=html_name,
-                                 TYPE=self._shared.DartType(attribute.type.id))
+                                 TYPE=self._DartType(attribute.type.id))
     self._backend.AddAttribute(attribute, html_name, read_only)
 
   def AddSecondaryAttribute(self, interface, attribute):
     self._backend.SecondaryContext(interface)
     self.AddAttribute(attribute, True)
 
-  def AddOperation(self, info, is_secondary=False):
+  def AddOperation(self, info, skip_declaration=False):
     """
     Arguments:
       operations - contains the overloads, one or more operations with the same
         name.
     """
-    html_name = self._shared.RenameInHtmlLibrary(
-        self._interface.id, info.name)
-    if html_name and not self._shared.IsPrivate(html_name) and not is_secondary:
+    html_name = self._shared.RenameInHtmlLibrary(self._interface.id, info.name)
+    if not html_name:
+      if info.name == 'item':
+        # FIXME: item should be renamed to operator[], not removed.
+        self._backend.AddOperation(info, '_item')
+      return
+
+    if not self._shared.IsPrivate(html_name) and not skip_declaration:
       self._members_emitter.Emit('\n  /** @domName $DOMINTERFACE.$DOMNAME */',
           DOMINTERFACE=info.overloads[0].doc_js_interface_name,
           DOMNAME=info.name)
 
       self._members_emitter.Emit('\n'
                                  '  $TYPE $NAME($PARAMS);\n',
-                                 TYPE=self._shared.DartType(info.type_name),
+                                 TYPE=self._DartType(info.type_name),
                                  NAME=html_name,
-                                 PARAMS=info.ParametersInterfaceDeclaration(
-                                        self._shared.DartType))
-    self._backend.AddOperation(info)
+                                 PARAMS=info.ParametersInterfaceDeclaration(self._DartType))
+    self._backend.AddOperation(info, html_name)
 
   def AddStaticOperation(self, info):
-    self._backend.AddStaticOperation(info)
+    self.AddOperation(info, True)
 
   def AddSecondaryOperation(self, interface, info):
     self._backend.SecondaryContext(interface)
     self.AddOperation(info, True)
 
   def FinishInterface(self):
     self._backend.FinishInterface()
 
   def AddConstant(self, constant):
-    type = TypeOrNothing(DartType(constant.type.id), constant.type.id)
+    type = TypeOrNothing(self._DartType(constant.type.id), constant.type.id)
     self._members_emitter.Emit('\n  static final $TYPE$NAME = $VALUE;\n',
                                NAME=constant.id,
                                TYPE=type,
                                VALUE=constant.value)
     self._backend.AddConstant(constant)
 
   def _GenerateEvents(self):
     emit_events, event_attrs = self._shared.GetEventAttributes(self._interface)
     if not emit_events:
       return
@@ skipping 50 matching lines @@
 
     self._implementation_members_emitter.Emit(
         '\n  $TYPE get on() =>\n    new $TYPE(this);\n',
         TYPE=events_class)
 
 
 class HtmlGeneratorDummyBackend(object):
   def AddAttribute(self, attribute, html_name, read_only):
     pass
 
-  def AddOperation(self, info):
+  def AddOperation(self, info, html_name):
     pass
 
 
 # ------------------------------------------------------------------------------
 
 # TODO(jmesserly): inheritance is probably not the right way to factor this long
 # term, but it makes merging better for now.
 class HtmlFrogClassGenerator(FrogInterfaceGenerator):
   """Generates a Frog class for the dart:html library from a DOM IDL
   interface.
   """
 
   def __init__(self, system, interface):
     super(HtmlFrogClassGenerator, self).__init__(
         system, interface, None, None)
-    self._shared = self._system._shared
-    self._html_interface_name = self._shared._HTMLInterfaceName(
-        self._interface.id)
+    self._html_interface_name = system._type_registry.InterfaceName(self._interface.id)
 
   def HasImplementation(self):
     return not (IsPureInterface(self._interface.id) or
                 self._interface.id in _merged_html_interfaces)
 
   def ImplementationClassName(self):
     return self._ImplClassName(self._html_interface_name)
 
   def FilePathForDartImplementation(self):
     return os.path.join(self._system._output_dir, 'html', 'frog',
                         '%s.dart' % self._html_interface_name)
 
   def FilePathForDartFactoryProviderImplementation(self):
     return os.path.join(self._system._output_dir, 'html', 'frog',
                         '_%sFactoryProvider.dart' % self._html_interface_name)
 
   def FilePathForDartElementsFactoryProviderImplementation(self):
     return os.path.join(self._system._output_dir, 'html', 'frog',
                         '_Elements.dart')
 
   def SetImplementationEmitter(self, implementation_emitter):
     self._dart_code = implementation_emitter
 
   def ImplementsMergedMembers(self):
     return True
 
   def _ImplClassName(self, type_name):
-    return self._shared._ImplClassName(type_name)
-
-  def _NarrowToImplementationType(self, type_name):
-    if self._ShouldNarrowToImplementationType(type_name):
-      return self._ImplClassName(self._shared.DartType(type_name))
-    return self._shared.DartType(type_name)
+    return '_%sImpl' % type_name
 
   def StartInterface(self):
     interface = self._interface
     interface_name = interface.id
 
     self._class_name = self._ImplClassName(self._html_interface_name)
 
     base = None
     if interface.parents:
       supertype = interface.parents[0].type.id
       if IsDartCollectionType(supertype):
         # List methods are injected in AddIndexer.
         pass
       elif IsPureInterface(supertype):
         pass
       else:
-        base = self._ImplClassName(self._shared._HTMLInterfaceName(supertype))
+        base = self._ImplClassName(self._DartType(supertype))
 
     native_spec = MakeNativeSpec(interface.javascript_binding_name)
 
     extends = ' extends ' + base if base else ''
 
     # TODO: Include all implemented interfaces, including other Lists.
     implements = [self._html_interface_name]
     element_type = MaybeTypedArrayElementType(self._interface)
     if element_type:
-      implements.append('List<%s>' % self._shared.DartType(element_type))
+      implements.append('List<%s>' % self._DartType(element_type))
       implements.append('JavaScriptIndexingBehavior')
 
     template_file = 'impl_%s.darttemplate' % self._html_interface_name
     template = (self._system._templates.TryLoad(template_file) or
                 self._system._templates.Load('frog_impl.darttemplate'))
     self._members_emitter = self._dart_code.Emit(
         template,
         #class $CLASSNAME$EXTENDS$IMPLEMENTS$NATIVESPEC {
         #$!MEMBERS
         #}
@@ skipping 11 matching lines @@
     template_file = ('factoryprovider_%s.darttemplate' %
                      self._html_interface_name)
     template = self._system._templates.TryLoad(template_file)
     if not template:
       template = self._system._templates.Load('factoryprovider.darttemplate')
 
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
         CONSTRUCTOR=self._html_interface_name,
-        PARAMETERS=constructor_info.ParametersImplementationDeclaration(),
+        PARAMETERS=constructor_info.ParametersImplementationDeclaration(self._DartType),
         NAMED_CONSTRUCTOR=constructor_info.name or self._html_interface_name,
         ARGUMENTS=constructor_info.ParametersAsArgumentList())
 
   def AddIndexer(self, element_type):
     """Adds all the methods required to complete implementation of List."""
     # We would like to simply inherit the implementation of everything except
     # get length(), [], and maybe []=.  It is possible to extend from a base
     # array implementation class only when there is no other implementation
     # inheritance.  There might be no implementation inheritance other than
     # DOMBaseWrapper for many classes, but there might be some where the
@@ skipping 29 matching lines @@
             '  void operator[]=(int index, $TYPE value) {\n'
             '    throw new UnsupportedOperationException("Cannot assign element of immutable List.");\n'
             '  }\n',
             TYPE=self._NarrowInputType(element_type))
 
     # TODO(sra): Use separate mixins for mutable implementations of List<T>.
     # TODO(sra): Use separate mixins for typed array implementations of List<T>.
     if self._interface.id != 'NodeList':
       template_file = 'immutable_list_mixin.darttemplate'
       template = self._system._templates.Load(template_file)
-      self._members_emitter.Emit(template, E=self._shared.DartType(element_type))
+      self._members_emitter.Emit(template, E=self._DartType(element_type))
 
   def AddAttribute(self, attribute, html_name, read_only):
     if self._HasCustomImplementation(attribute.id):
       return
 
     if attribute.id != html_name:
       self._AddRenamingGetter(attribute, html_name)
       if not read_only:
         self._AddRenamingSetter(attribute, html_name)
       return
@@ skipping 52 matching lines @@
         TYPE=return_type)
 
   def _AddRenamingSetter(self, attr, html_name):
     self._members_emitter.Emit(
         '\n  void set $HTML_NAME($TYPE value)'
         ' native "this.$NAME = value;";\n',
         HTML_NAME=html_name,
         NAME=attr.id,
         TYPE=self._NarrowInputType(attr.type.id))
 
-  def AddOperation(self, info):
+  def AddOperation(self, info, html_name):
     """
     Arguments:
       info: An OperationInfo object.
     """
     if self._HasCustomImplementation(info.name):
       return
 
-    html_name = self._shared.RenameInHtmlLibrary(
-        self._interface.id, info.name, implementation_class=True)
-    if not html_name:
+    # FIXME: support static operations.
+    if info.IsStatic():
       return
 
     # Do we need a native body?
     if html_name != info.declared_name:
       return_type = self._NarrowOutputType(info.type_name)
 
       operation_emitter = self._members_emitter.Emit('$!SCOPE',
           TYPE=return_type,
           HTML_NAME=html_name,
           NAME=info.declared_name,
@@ skipping 11 matching lines @@
           NAME=info.name,
           PARAMS=info.ParametersImplementationDeclaration(
               lambda type_name: self._NarrowInputType(type_name)))
 
   def _HasCustomImplementation(self, member_name):
     member_name = '%s.%s' % (self._html_interface_name, member_name)
     return member_name in _js_custom_members
 
 # ------------------------------------------------------------------------------
 
-class HtmlFrogSystem(HtmlSystem):
+class HtmlFrogSystem(System):
 
   def __init__(self, context):
     super(HtmlFrogSystem, self).__init__(context)
 
   def ImplementationGenerator(self, interface):
     return HtmlFrogClassGenerator(self, interface)
 
   def GenerateLibraries(self, dart_files):
     self._GenerateLibFile(
         'html_frog.darttemplate',
@@ skipping 21 matching lines @@
             Collect(database.GetInterface(parent.type.id),
                     seen, collected)
 
   inheritance_closure = {}
   for interface in database.GetInterfaces():
     seen = set()
     collected = []
     Collect(interface, seen, collected)
     inheritance_closure[interface.id] = collected
   return inheritance_closure