Move systems creation to dartdomgenerator.py.

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."""
 
 from systemfrog import *
 from systeminterface import *
@@ skipping 446 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, generator):
+  def __init__(self, database):
     self._event_classes = set()
     self._seen_event_names = {}
     self._database = database
-    self._generator = generator
+    self._inheritance_closure = _ComputeInheritanceClosure(database)
 
   def _AllowInHtmlLibrary(self, interface, member, member_prefix):
     return not self._Matches(interface, member, member_prefix,
         _html_library_remove)
 
   def _Matches(self, interface, member, member_prefix, candidates):
     for interface_name in self._AllAncestorInterfaces(interface):
       if (DartType(interface_name) + '.' + member in candidates or
           DartType(interface_name) + '.' + member_prefix + member in candidates):
         return True
     return False
 
   def _AllAncestorInterfaces(self, interface):
-    interfaces = ([interface.id] +
-        self._generator._AllImplementedInterfaces(interface))
-    return interfaces
+    return [interface.id] + self._inheritance_closure[interface.id]
 
   def RenameInHtmlLibrary(self, interface, member, member_prefix='',
                           implementation_class=False):
     """
     Returns the name of the member in the HTML library or None if the member is
     suppressed in the HTML library
     """
     if not self._AllowInHtmlLibrary(interface, member, member_prefix):
       return None
 
@@ skipping 74 matching lines @@
     if events or interface.id in _html_explicit_event_classes:
       return True, events
     else:
       return False, None
 
   def IsPrivate(self, name):
     return name.startswith('_')
 
 class HtmlSystem(System):
 
-  def __init__(self, templates, database, emitters, output_dir, generator):
+  def __init__(self, templates, database, emitters, output_dir):
     super(HtmlSystem, self).__init__(
         templates, database, emitters, output_dir)
-    self._shared = HtmlSystemShared(database, generator)
+    self._shared = HtmlSystemShared(database)
 
 class HtmlInterfacesSystem(HtmlSystem):
 
-  def __init__(self, templates, database, emitters, output_dir, generator):
+  def __init__(self, templates, database, emitters, output_dir):
     super(HtmlInterfacesSystem, self).__init__(
-        templates, database, emitters, output_dir, generator)
+        templates, database, emitters, output_dir)
     self._dart_interface_file_paths = []
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
     interface_name = interface.id
     dart_interface_file_path = self._FilePathForDartInterface(interface_name)
@@ skipping 12 matching lines @@
         template,
         common_prefix, super_interface_name,
         source_filter, self._shared)
 
   def ProcessCallback(self, interface, info):
     """Generates a typedef for the callback interface."""
     interface_name = interface.id
     file_path = self._FilePathForDartInterface(interface_name)
     self._ProcessCallback(interface, info, file_path)
 
-  def GenerateLibraries(self, lib_dir):
+  def GenerateLibraries(self):
     pass
 
 
   def _FilePathForDartInterface(self, interface_name):
     """Returns the file path of the Dart interface definition."""
     # TODO(jmesserly): is this the right path
     return os.path.join(self._output_dir, 'html', 'interface',
                         '%s.dart' % interface_name)
 
 # ------------------------------------------------------------------------------
@@ skipping 466 matching lines @@
 
   def _EmitEventGetter(self, events_class):
     self._members_emitter.Emit(
         '\n  $TYPE get on() =>\n    new $TYPE(this);\n',
         TYPE=events_class)
 
 # ------------------------------------------------------------------------------
 
 class HtmlFrogSystem(HtmlSystem):
 
-  def __init__(self, templates, database, emitters, output_dir, generator):
+  def __init__(self, templates, database, emitters, output_dir):
     super(HtmlFrogSystem, self).__init__(
-        templates, database, emitters, output_dir, generator)
+        templates, database, emitters, output_dir)
     self._dart_frog_file_paths = []
 
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
     template_file = 'impl_%s.darttemplate' % interface.id
     template = self._templates.TryLoad(template_file)
     if not template:
       template = self._templates.Load('frog_impl.darttemplate')
 
     dart_code = self._ImplFileEmitter(interface.id)
     return HtmlFrogClassGenerator(self, interface, template,
                                   super_interface_name, dart_code, self._shared)
 
-  def GenerateLibraries(self, lib_dir):
+  def GenerateLibraries(self):
     self._GenerateLibFile(
         'html_frog.darttemplate',
-        os.path.join(lib_dir, 'html_frog.dart'),
+        os.path.join(self._output_dir, 'html_frog.dart'),
         (self._interface_system._dart_interface_file_paths +
          self._interface_system._dart_callback_file_paths +
          self._dart_frog_file_paths))
 
   def Finish(self):
     pass
 
   def _ImplFileEmitter(self, name):
     """Returns the file emitter of the Frog implementation file."""
     # TODO(jmesserly): is this the right path
     path = os.path.join(self._output_dir, 'html', 'frog', '%s.dart' % name)
     self._dart_frog_file_paths.append(path)
     return self._emitters.FileEmitter(path)
 
 # -----------------------------------------------------------------------------
 
 class HtmlDartiumSystem(HtmlSystem):
 
-  def __init__(self, templates, database, emitters, auxiliary_dir, output_dir,
-               generator):
+  def __init__(self, templates, database, emitters, auxiliary_dir, output_dir):
     """Prepared for generating wrapping implementation.
 
     - Creates emitter for Dart code.
     """
     super(HtmlDartiumSystem, self).__init__(
-        templates, database, emitters, output_dir, generator)
+        templates, database, emitters, output_dir)
     self._auxiliary_dir = auxiliary_dir
-    self._shared = HtmlSystemShared(database, generator)
+    self._shared = HtmlSystemShared(database)
     self._dart_dartium_file_paths = []
     self._wrap_cases = []
 
   def InterfaceGenerator(self,
                          interface,
                          common_prefix,
                          super_interface_name,
                          source_filter):
     """."""
     template_file = 'impl_%s.darttemplate' % interface.id
     template = self._templates.TryLoad(template_file)
     # TODO(jacobr): change this name as it is confusing.
     if not template:
       template = self._templates.Load('frog_impl.darttemplate')
 
     dart_code = self._ImplFileEmitter(interface.id)
     return HtmlDartiumInterfaceGenerator(self, interface, template,
         super_interface_name, dart_code, self._BaseDefines(interface),
         self._shared)
 
   def _ImplFileEmitter(self, name):
     """Returns the file emitter of the Dartium implementation file."""
     path = os.path.join(self._output_dir, 'html', 'dartium', '%s.dart' % name)
     self._dart_dartium_file_paths.append(path)
     return self._emitters.FileEmitter(path);
 
   def ProcessCallback(self, interface, info):
     pass
 
-  def GenerateLibraries(self, lib_dir):
+  def GenerateLibraries(self):
     # Library generated for implementation.
     auxiliary_dir = os.path.relpath(self._auxiliary_dir, self._output_dir)
 
     self._GenerateLibFile(
         'html_dartium.darttemplate',
-        os.path.join(lib_dir, 'html_dartium.dart'),
+        os.path.join(self._output_dir, 'html_dartium.dart'),
         (self._interface_system._dart_interface_file_paths +
          self._interface_system._dart_callback_file_paths +
          self._dart_dartium_file_paths
          ),
         AUXILIARY_DIR=MassagePath(auxiliary_dir),
         WRAPCASES='\n'.join(self._wrap_cases))
 
   def Finish(self):
     pass
 
@@ skipping 333 matching lines @@
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $HTML_NAME($PARAMS) => $FUNCTION_CALL;\n',
         TYPE=info.type_name,
         HTML_NAME=html_name,
         PARAMS=info.ParametersImplementationDeclaration(),
         FUNCTION_CALL=function_call)
 
   def AddStaticOperation(self, info):
     pass
+
+def _ComputeInheritanceClosure(database):
+  def Collect(interface, seen, collected):
+    name = interface.id
+    if '<' in name:
+      # TODO(sra): Handle parameterized types.
+      return
+    if not name in seen:
+      seen.add(name)
+      collected.append(name)
+      for parent in interface.parents:
+        # TODO(sra): Handle parameterized types.
+        if not '<' in parent.type.id:
+          if database.HasInterface(parent.type.id):
+            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