Rename Dartium dart:html implementation classes.

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
 import os
@@ skipping 272 matching lines @@
           constructor_info, factory_provider, factory_provider_emitter)
 
     infos = HtmlElementConstructorInfos(interface_name)
     if infos:
       template = self._template_loader.Load(
           'factoryprovider_Elements.darttemplate')
       EmitHtmlElementFactoryConstructors(
           self._library_emitter.FileEmitter('_Elements', template),
           infos,
           self._interface.id,
-          self._backend.ImplementationClassName(),
+          self._interface_type_info.implementation_name(),
           self._DartType)
 
     for info in infos:
       constructors.append(info.ConstructorInfo(self._interface.id))
       if factory_provider:
         assert factory_provider == info.factory_provider_name
       else:
         factory_provider = info.factory_provider_name
 
     # TODO(vsm): Add appropriate package / namespace syntax.
     (self._type_comment_emitter,
      self._members_emitter,
      self._top_level_emitter) = interface_emitter.Emit(
          interface_template + '$!TOP_LEVEL',
          ID=interface_name,
          EXTENDS=implements_str)
 
     self._type_comment_emitter.Emit("/// @domName $DOMNAME",
         DOMNAME=self._interface.doc_js_name)
 
     implementation_emitter = self._ImplementationEmitter()
     base_class = self._backend.BaseClassName()
     interface_type_info = self._type_registry.TypeInfo(self._interface.id)
     implemented_interfaces = [interface_type_info.interface_name()] +\
                              self._backend.AdditionalImplementedInterfaces()
     self._implementation_members_emitter = implementation_emitter.Emit(
         self._backend.ImplementationTemplate(),
-        CLASSNAME=self._backend.ImplementationClassName(),
+        CLASSNAME=self._interface_type_info.implementation_name(),
         EXTENDS=' extends %s' % base_class if base_class else '',
         IMPLEMENTS=' implements ' + ', '.join(implemented_interfaces),
         NATIVESPEC=self._backend.NativeSpec())
     self._backend.StartInterface(self._implementation_members_emitter)
 
     for constructor_info in constructors:
       constructor_info.GenerateFactoryInvocation(
           self._DartType, self._members_emitter, factory_provider)
 
     element_type = MaybeTypedArrayElementTypeInHierarchy(
@@ skipping 143 matching lines @@
         self._backend.AddOperation(info, '_item')
       return
 
     if not self._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)
 
       if info.IsStatic():
         # FIXME: provide a type.
-        self._members_emitter.Emit('\n'
-                                  '  static final $NAME = $IMPL_CLASS_NAME.$NAME;\n',
-                                  IMPL_CLASS_NAME=self._backend.ImplementationClassName(),
-                                  NAME=html_name)
+        self._members_emitter.Emit(
+            '\n'
+            '  static final $NAME = $IMPL_CLASS_NAME.$NAME;\n',
+            IMPL_CLASS_NAME=self._interface_type_info.implementation_name(),
+            NAME=html_name)
       else:
-        self._members_emitter.Emit('\n'
-                                  '  $TYPE $NAME($PARAMS);\n',
-                                  TYPE=SecureOutputType(self, info.type_name),
-                                  NAME=html_name,
-                                  PARAMS=info.ParametersInterfaceDeclaration(self._DartType))
+        self._members_emitter.Emit(
+             '\n'
+             '  $TYPE $NAME($PARAMS);\n',
+             TYPE=SecureOutputType(self, info.type_name),
+             NAME=html_name,
+             PARAMS=info.ParametersInterfaceDeclaration(self._DartType))
     self._backend.AddOperation(info, html_name)
 
   def AddSecondaryOperation(self, interface, info):
     self._backend.SecondaryContext(interface)
     self.AddOperation(info, True)
 
   def AddConstant(self, constant):
     type = TypeOrNothing(self._DartType(constant.type.id), constant.type.id)
     self._members_emitter.Emit('\n  static const $TYPE$NAME = $VALUE;\n',
                                NAME=constant.id,
                                TYPE=type,
                                VALUE=constant.value)
 
   def _ImplementationEmitter(self):
     if IsPureInterface(self._interface.id):
       return emitter.Emitter()
-
     basename = self._interface_type_info.implementation_name()
-    if self._interface_type_info.merged_into():
-      if self._backend.ImplementsMergedMembers():
-        # Merged members are implemented in target interface implementation.
-        return emitter.Emitter()
-      basename = '%s_Merged' % basename
+    if (self._interface_type_info.merged_into() and
+        self._backend.ImplementsMergedMembers()):
+      # Merged members are implemented in target interface implementation.
+      return emitter.Emitter()
     return self._library_emitter.FileEmitter(basename.lstrip('_'))
 
   def _EmitEventGetter(self, events_interface, events_class):
     self._members_emitter.Emit(
         '\n  /**'
         '\n   * @domName EventTarget.addEventListener, '
         'EventTarget.removeEventListener, EventTarget.dispatchEvent'
         '\n   */'
         '\n  $TYPE get on;\n',
         TYPE=events_interface)
@@ skipping 50 matching lines @@
   """
 
   def __init__(self, interface, options):
     self._interface = interface
     self._database = options.database
     self._template_loader = options.templates
     self._type_registry = options.type_registry
     self._interface_type_info = self._type_registry.TypeInfo(self._interface.id)
     self._current_secondary_parent = None
 
-  def ImplementationClassName(self):
-    return self._interface_type_info.implementation_name()
-
   def ImplementsMergedMembers(self):
     return True
 
   def GenerateCallback(self, info):
     pass
 
   def BaseClassName(self):
     if not self._interface.parents:
       return None
     supertype = self._interface.parents[0].type.id
     if IsDartCollectionType(supertype):
       # List methods are injected in AddIndexer.
       return None
     if IsPureInterface(supertype):
       return None
-    return self._type_registry.TypeInfo(supertype).implementation_name()
+    type_info = self._type_registry.TypeInfo(supertype)
+    if type_info.merged_into():
+      type_info = self._type_registry.TypeInfo(type_info.merged_into())
+    return type_info.implementation_name()
 
   def AdditionalImplementedInterfaces(self):
     # TODO: Include all implemented interfaces, including other Lists.
     implements = []
     element_type = MaybeTypedArrayElementType(self._interface)
     if element_type:
       implements.append('List<%s>' % self._DartType(element_type))
     if self._HasJavaScriptIndexingBehaviour():
       implements.append('JavaScriptIndexingBehavior')
     return implements
@@ skipping 500 matching lines @@
 
     library_emitter = self._multiemitter.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._path_to_emitter.keys()):
       relpath = os.path.relpath(path, library_file_dir)
       imports_emitter.Emit(
           "#source('$PATH');\n", PATH=massage_path(relpath))