Get rid of System classes for backend generators.

lib/html/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 420 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 HtmlInterfacesSystem(System):
-  def __init__(self, options, dart_library_generator, backend):
+  def __init__(self, options, dart_library_generator, create_generator_backend):
     super(HtmlInterfacesSystem, self).__init__(options)
     self._dart_library_generator = dart_library_generator
-    self._backend = backend
+    self._create_generator_backend = create_generator_backend
     self._shared = HtmlSystemShared(options)
-    self._dart_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."""
-    code = self._CreateEmitter('%s.dart' % interface.id)
-    code.Emit(self._templates.Load('callback.darttemplate'))
-    code.Emit('typedef $TYPE $NAME($PARAMS);\n',
-              NAME=interface.id,
-              TYPE=DartType(info.type_name),
-              PARAMS=info.ParametersImplementationDeclaration(DartType))
-    self._backend.ProcessCallback(interface, info)
+    backend = self._create_generator_backend(interface)
+    HtmlDartInterfaceGenerator(self, interface, backend).Generate()
 
   def _CreateEmitter(self, filename):
     return self._dart_library_generator.CreateFileEmitter(filename)
 
 # ------------------------------------------------------------------------------
 
 class HtmlDartInterfaceGenerator(BaseGenerator):
   """Generates dart interface and implementation for the DOM IDL interface."""
 
-  def __init__(self, system, interface):
+  def __init__(self, system, interface, backend):
     super(HtmlDartInterfaceGenerator, self).__init__(
-        system._database, interface)
+        system._database, system._type_registry, interface)
     self._system = system
+    self._backend = backend
     self._shared = system._shared
     self._html_interface_name = system._renamer.RenameInterface(self._interface)
-    self._backend = system._backend.ImplementationGenerator(self._interface)
+
+  def GenerateCallback(self, info):
+    """Generates a typedef for the callback interface."""
+    code = self._system._CreateEmitter('%s.dart' % self._interface.id)
+    code.Emit(self._system._templates.Load('callback.darttemplate'))
+    code.Emit('typedef $TYPE $NAME($PARAMS);\n',
+              NAME=self._interface.id,
+              TYPE=DartType(info.type_name),
+              PARAMS=info.ParametersImplementationDeclaration(DartType))
+    self._backend.GenerateCallback(info)
 
   def StartInterface(self):
     if not self._interface.id in _merged_html_interfaces:
       path = '%s.dart' % self._html_interface_name
       self._interface_emitter = self._system._CreateEmitter(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
@@ skipping 266 matching lines @@
     pass
 
   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 HtmlDart2JSClassGenerator(Dart2JSInterfaceGenerator):
+class Dart2JSGeneratorBackend(Dart2JSInterfaceGenerator):

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

if you want to keep both generator and backend, I think it should go in oposite
order: Dart2JSBackendGenerator, although I indeed think Dart2JSGenerator is
enough or Dart2JSImplementationGenerator to keep Interface vs. Implementation
distinction

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

Renamed to Dart2JSBackend. Interface vs. Implementation distinction is
unfortunate, because it leads to significant code duplication.

   """Generates a dart2js class for the dart:html library from a DOM IDL
   interface.
   """
 
-  def __init__(self, system, interface):
-    super(HtmlDart2JSClassGenerator, self).__init__(
-        system, interface, None, None)
-    self._html_interface_name = system._renamer.RenameInterface(self._interface)
+  def __init__(self, interface, options):
+    super(Dart2JSGeneratorBackend, self).__init__(
+        options, interface, None, None)
+    self._html_interface_name = options.renamer.RenameInterface(self._interface)
 
   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 SetImplementationEmitter(self, implementation_emitter):
     self._dart_code = implementation_emitter
@@ skipping 28 matching lines @@
     # 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._DartType(element_type))
 
     if self._HasJavaScriptIndexingBehaviour():
       implements.append('JavaScriptIndexingBehavior')
 
     template_file = 'impl_%s.darttemplate' % self._html_interface_name
-    template = (self._system._templates.TryLoad(template_file) or
-                self._system._templates.Load('dart2js_impl.darttemplate'))
+    template = (self._template_loader.TryLoad(template_file) or
+                self._template_loader.Load('dart2js_impl.darttemplate'))
     self._members_emitter = self._dart_code.Emit(
         template,
         #class $CLASSNAME$EXTENDS$IMPLEMENTS$NATIVESPEC {
         #$!MEMBERS
         #}
         CLASSNAME=self._class_name,
         EXTENDS=extends,
         IMPLEMENTS=' implements ' + ', '.join(implements),
         NATIVESPEC=' native "' + native_spec + '"')
     if self._members_emitter == None:
       raise Exception("Class %s doesn't use the $!MEMBERS variable" %
                       self._class_name)
 
     return self._members_emitter
 
   def EmitFactoryProvider(self, constructor_info, factory_provider, emitter):
     template_file = ('factoryprovider_%s.darttemplate' %
                      self._html_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')
 
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
         CONSTRUCTOR=self._html_interface_name,
         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):
@@ skipping 34 matching lines @@
             '\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>.
     if self._interface.id != 'NodeList':
       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 AddAttribute(self, attribute, html_name, read_only):
     if self._HasCustomImplementation(attribute.id):
       return
 
     if attribute.id != html_name:
       self._AddAttributeUsingProperties(attribute, html_name, read_only)
       return
 
@@ skipping 302 matching lines @@
     member_name = '%s.%s' % (self._html_interface_name, member_name)
     return member_name in _js_custom_members
 
   def _HasJavaScriptIndexingBehaviour(self):
     """Returns True if the native object has an indexer and length property."""
     (element_type, requires_indexer) = ListImplementationInfo(
         self._interface, self._database)
     if element_type and requires_indexer: return True
     return False
 
+
 # ------------------------------------------------------------------------------
 
-class HtmlDart2JSSystem(System):
-
-  def __init__(self, options):
-    super(HtmlDart2JSSystem, self).__init__(options)
-
-  def ImplementationGenerator(self, interface):
-    return HtmlDart2JSClassGenerator(self, interface)
-
-
 class DartLibraryEmitter():
   def __init__(self, emitters, template, dart_sources_dir):
     self._emitters = emitters
     self._template = template
     self._dart_sources_dir = dart_sources_dir
     self._dart_sources_list = []
 
   def CreateFileEmitter(self, filename):
     path = os.path.join(self._dart_sources_dir, filename)
     self._dart_sources_list.append(path)
     return self._emitters.FileEmitter(path)
 
   def EmitLibrary(self, library_file_path, auxiliary_dir):
     def massage_path(path):
       # The most robust way to emit path separators is to use / always.
       return path.replace('\\', '/')
 
     library_emitter = self._emitters.FileEmitter(library_file_path)
     library_file_dir = os.path.dirname(library_file_path)
     auxiliary_dir = os.path.relpath(auxiliary_dir, library_file_dir)
     imports_emitter = library_emitter.Emit(
         self._template, AUXILIARY_DIR=massage_path(auxiliary_dir))
     for path in sorted(self._dart_sources_list):
       relpath = os.path.relpath(path, library_file_dir)
       imports_emitter.Emit(
           "#source('$PATH');\n", PATH=massage_path(relpath))