Get rid of System classes for backend generators.

lib/html/scripts/systemdart2js.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 systems to generate
 dart2js binding from the IDL database."""
 
 import os
 from generator import *
 from systembase import *
 
 # Members (getters, setters, and methods) to suppress.  These are
 # either removed or custom implemented.
 _dom_dart2js_omitted_members = set([
     # Replace with custom.
     'DOMWindow.get:top',
     'HTMLIFrameElement.get:contentWindow',
 
     # Remove.
     'DOMWindow.get:frameElement',
     'HTMLIFrameElement.get:contentDocument',
 ])
 
 class Dart2JSSystem(System):

[Anton Muhin, 2012/09/26 14:20:36]

does anybody use it now?

[podivilov, 2012/09/26 15:02:04]

The whole file is a dead code.  I think we should merge
Dart2JSInterfaceGenerator into HtmlDartInterfaceGenerator and remove the file
(in a separate cl).

 
   def __init__(self, options):
     super(Dart2JSSystem, self).__init__(options)
     self._impl_file_paths = []
 
   def ProcessInterface(self, interface):
     """."""
     if IsPureInterface(interface.id):
       return
     template_file = 'impl_%s.darttemplate' % interface.id
@@ skipping 18 matching lines @@
     """Returns the file emitter of the Dart2JS implementation file."""
     path = os.path.join(self._output_dir, 'src', 'dart2js', '%s.dart' % name)
     self._impl_file_paths.append(path)
     return self._emitters.FileEmitter(path)
 
 # ------------------------------------------------------------------------------
 
 class Dart2JSInterfaceGenerator(BaseGenerator):
   """Generates a Dart2JS class for a DOM IDL interface."""
 
-  def __init__(self, system, interface, template, dart_code):
+  def __init__(self, options, interface, template, dart_code):
     """Generates Dart code for the given interface.
 
     Args:
 
       interface: an IDLInterface instance. It is assumed that all types have
           been converted to Dart types (e.g. int, String), unless they are in
           the same package as the interface.
       template: A string template.
       dart_code: an Emitter for the file containing the Dart implementation
           class.
     """
-    super(Dart2JSInterfaceGenerator, self).__init__(system._database, interface)
-    self._system = system
+    super(Dart2JSInterfaceGenerator, self).__init__(
+        options.database, options.type_registry, interface)
+    self._template_loader = options.templates
     self._interface = interface
     self._template = template
     self._dart_code = dart_code
     self._current_secondary_parent = None
 
-
   def StartInterface(self):
     interface = self._interface
     interface_name = interface.id
     self._class_name = self._ImplClassName(interface_name)
 
     base = None
     if interface.parents:
       supertype = interface.parents[0].type.id
       if IsDartCollectionType(supertype):
         # List methods are injected in AddIndexer.
@@ skipping 37 matching lines @@
 
   def FinishInterface(self):
     """."""
     pass
 
   def _ImplClassName(self, type_name):
     return '_' + type_name + 'Js'
 
   def _EmitFactoryProvider(self, interface_name, constructor_info):
     template_file = 'factoryprovider_%s.darttemplate' % interface_name
-    template = self._system._templates.TryLoad(template_file)
+    template = self._template_loader.TryLoad(template_file)
     if not template:
-      template = self._system._templates.Load('factoryprovider.darttemplate')
+      template = self._template_loader.Load('factoryprovider.darttemplate')
 
     factory_provider = '_' + interface_name + 'FactoryProvider'
     emitter = self._system._ImplFileEmitter(factory_provider)
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
         CONSTRUCTOR=interface_name,
         PARAMETERS=constructor_info.ParametersImplementationDeclaration(self._DartType),
         NAMEDCONSTRUCTOR=constructor_info.name or interface_name,
         ARGUMENTS=constructor_info.ParametersAsArgumentList())
 
   def _ShouldNarrowToImplementationType(self, type_name):
     # TODO(sra): Move into the 'system' and cache the result.
     do_not_narrow = ['DOMStringList', 'DOMStringMap', 'EventListener',
                      'IDBAny', 'IDBKey', 'MediaQueryListListener']
     if type_name in do_not_narrow:
       return False
-    if self._system._database.HasInterface(type_name):
-      interface = self._system._database.GetInterface(type_name)
+    if self._database.HasInterface(type_name):
+      interface = self._database.GetInterface(type_name)
       # Callbacks are typedef functions so don't have a class.
       return 'Callback' not in interface.ext_attrs
     return False
 
   def _NarrowToImplementationType(self, type_name):
     if self._ShouldNarrowToImplementationType(type_name):
       return self._ImplClassName(self._DartType(type_name))
     return self._DartType(type_name)
 
   def _NarrowInputType(self, type_name):
@@ skipping 99 matching lines @@
   def _FindShadowedAttribute(self, attr, merged_interfaces={}):
     """Returns (attribute, superinterface) or (None, None)."""
     def FindInParent(interface):
       """Returns matching attribute in parent, or None."""
       if interface.parents:
         parent = interface.parents[0]
         if IsDartCollectionType(parent.type.id):
           return (None, None)
         if IsPureInterface(parent.type.id):
           return (None, None)
-        if self._system._database.HasInterface(parent.type.id):
+        if self._database.HasInterface(parent.type.id):
           interfaces_to_search_in = []
           if parent.type.id in merged_interfaces:
             # IDL parent was merged into another interface, which became a
             # parent interface in Dart.
             interfaces_to_search_in.append(parent.type.id)
             parent_interface_name = merged_interfaces[parent.type.id]
           else:
             parent_interface_name = parent.type.id
 
           for interface_name in merged_interfaces:
             if merged_interfaces[interface_name] == parent_interface_name:
               # IDL parent has another interface that was merged into it.
               interfaces_to_search_in.append(interface_name)
 
           interfaces_to_search_in.append(parent_interface_name)
           for interface_name in interfaces_to_search_in:
-            interface = self._system._database.GetInterface(interface_name)
+            interface = self._database.GetInterface(interface_name)
             attr2 = FindMatchingAttribute(interface, attr)
             if attr2:
               return (attr2, parent_interface_name)
 
           return FindInParent(
-              self._system._database.GetInterface(parent_interface_name))
+              self._database.GetInterface(parent_interface_name))
       return (None, None)
 
     return FindInParent(self._interface) if attr else (None, None)
 
 
   def AddSecondaryAttribute(self, interface, attribute):
     self.SecondaryContext(interface)
     self.AddAttribute(attribute)
 
   def AddSecondaryOperation(self, interface, info):
@@ skipping 38 matching lines @@
       self._members_emitter.Emit(
           '\n'
           '  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>.
     template_file = 'immutable_list_mixin.darttemplate'
-    template = self._system._templates.Load(template_file)
+    template = self._template_loader.Load(template_file)
     self._members_emitter.Emit(template, E=self._DartType(element_type))
 
   def AddOperation(self, info):
     """
     Arguments:
       info: An OperationInfo object.
     """
     # TODO(vsm): Handle overloads.
     params = info.ParametersImplementationDeclaration(
         lambda type_name: self._NarrowInputType(type_name))
 
     native_string = ''
     if info.declared_name != info.name:
       native_string = " '%s'" % info.declared_name
 
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($PARAMS) native$NATIVESTRING;\n',
         TYPE=self._NarrowOutputType(info.type_name),
         NAME=info.name,
         PARAMS=params,
         NATIVESTRING=native_string)