Switch to using IDLTypeInfo.interface_name().

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 187 matching lines @@
                backend):
     self._renamer = options.renamer
     self._database = options.database
     self._template_loader = options.templates
     self._type_registry = options.type_registry
     self._library_emitter = library_emitter
     self._event_generator = event_generator
     self._interface = interface
     self._backend = backend
     self._interface_type_info = self._type_registry.TypeInfo(self._interface.id)
-    self._html_interface_name = options.renamer.RenameInterface(self._interface)
 
   def Generate(self):
     if 'Callback' in self._interface.ext_attrs:
       self.GenerateCallback()
     else:
       self.GenerateInterface()
 
   def GenerateCallback(self):
     """Generates a typedef for the callback interface."""
     handlers = [operation for operation in self._interface.operations
                 if operation.id == 'handleEvent']
     info = AnalyzeOperation(self._interface, handlers)
     code = self._library_emitter.FileEmitter(self._interface.id)
     code.Emit(self._template_loader.Load('callback.darttemplate'))
     code.Emit('typedef $TYPE $NAME($PARAMS);\n',
               NAME=self._interface.id,
               TYPE=self._DartType(info.type_name),
               PARAMS=info.ParametersImplementationDeclaration(self._DartType))
     self._backend.GenerateCallback(info)
 
   def GenerateInterface(self):
+    interface_name = self._interface_type_info.interface_name()
+
     if (self._interface_type_info.has_generated_interface() and
         not self._interface_type_info.merged_into()):
-      interface_emitter = self._library_emitter.FileEmitter(
-          self._html_interface_name)
+      interface_emitter = self._library_emitter.FileEmitter(interface_name)
     else:
       interface_emitter = emitter.Emitter()
 
-    template_file = 'interface_%s.darttemplate' % self._html_interface_name
+    template_file = 'interface_%s.darttemplate' % interface_name
     interface_template = (self._template_loader.TryLoad(template_file) or
                           self._template_loader.Load('interface.darttemplate'))
 
-    typename = self._html_interface_name
-
     implements = []
     suppressed_implements = []
 
     for parent in self._interface.parents:
       parent_type_info = self._type_registry.TypeInfo(parent.type.id)
       parent_interface_name = parent_type_info.interface_name()
       # TODO(vsm): Remove source_filter.
       if MatchSourceFilter(parent):
         # Parent is a DOM type.
         implements.append(parent_interface_name)
       elif '<' in parent.type.id:
         # Parent is a Dart collection type.
         # TODO(vsm): Make this check more robust.
         implements.append(parent_interface_name)
       else:
         suppressed_implements.append('%s.%s' %
             (self._common_prefix, parent_interface_name))
 
-    if typename in _secure_base_types:
-      implements.append(_secure_base_types[typename])
+    if interface_name in _secure_base_types:
+      implements.append(_secure_base_types[interface_name])
 
     comment = ' extends'
     implements_str = ''
     if implements:
       implements_str += ' implements ' + ', '.join(implements)
       comment = ','
     if suppressed_implements:
       implements_str += ' /*%s %s */' % (comment,
           ', '.join(suppressed_implements))
 
     factory_provider = None
-    if typename in interface_factories:
-      factory_provider = interface_factories[typename]
+    if interface_name in interface_factories:
+      factory_provider = interface_factories[interface_name]
 
     constructors = []
     constructor_info = AnalyzeConstructor(self._interface)
     if constructor_info:
       constructors.append(constructor_info)
-      factory_provider = '_' + typename + 'FactoryProvider'
+      factory_provider = '_' + interface_name + 'FactoryProvider'
       factory_provider_emitter = self._library_emitter.FileEmitter(
-          '_%sFactoryProvider' % self._html_interface_name)
+          '_%sFactoryProvider' % interface_name)
       self._backend.EmitFactoryProvider(
           constructor_info, factory_provider, factory_provider_emitter)
 
-    infos = HtmlElementConstructorInfos(typename)
+    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._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=typename,
+         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()
@@ skipping 20 matching lines @@
           '  factory $CTOR.fromList(List<$TYPE> list) =>\n'
           '    $FACTORY.create$(CTOR)_fromList(list);\n'
           '\n'
           '  factory $CTOR.fromBuffer(ArrayBuffer buffer, [int byteOffset, int length]) => \n'
           '    $FACTORY.create$(CTOR)_fromBuffer(buffer, byteOffset, length);\n',
         CTOR=self._interface.id,
         TYPE=self._DartType(element_type),
         FACTORY=factory_provider)
 
     events_interface = self._event_generator.ProcessInterface(
-        self._interface, self._html_interface_name,
+        self._interface, interface_name,
         self._backend.CustomJSMembers(),
         interface_emitter, implementation_emitter)
     if events_interface:
       self._EmitEventGetter(events_interface, '_%sImpl' % events_interface)
 
     old_backend = self._backend
     if not self._backend.ImplementsMergedMembers():
       self._backend = HtmlGeneratorDummyBackend()
     merged_interface = self._interface_type_info.merged_interface()
     if merged_interface:
@@ skipping 142 matching lines @@
     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()
 
-    if not self._interface_type_info.merged_into():
-      name = self._html_interface_name
-      basename = '%sImpl' % name
-    else:
+    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 = '%sImpl_Merged' % self._html_interface_name
-    return self._library_emitter.FileEmitter(basename)
+      basename = '%s_Merged' % basename
+    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 47 matching lines @@
   """Generates a dart2js class for the dart:html library from a DOM IDL
   interface.
   """
 
   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._html_interface_name = options.renamer.RenameInterface(self._interface)
     self._current_secondary_parent = None
 
   def ImplementationClassName(self):
-    return self._ImplClassName(self._html_interface_name)
+    return self._interface_type_info.implementation_name()
 
   def ImplementsMergedMembers(self):
     return True
 
-  def _ImplClassName(self, type_name):
-    return '_%sImpl' % type_name
-
   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()
 
   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
 
   def NativeSpec(self):
     native_spec = MakeNativeSpec(self._interface.javascript_binding_name)
     return ' native "%s"' % native_spec
 
   def ImplementationTemplate(self):
-    template_file = 'impl_%s.darttemplate' % self._html_interface_name
+    template_file = ('impl_%s.darttemplate' %
+                     self._interface_type_info.interface_name())
     return (self._template_loader.TryLoad(template_file) or
             self._template_loader.Load('dart2js_impl.darttemplate'))
 
   def StartInterface(self, emitter):
     self._members_emitter = emitter
 
   def FinishInterface(self):
     pass
 
   def EmitFactoryProvider(self, constructor_info, factory_provider, emitter):
     template_file = ('factoryprovider_%s.darttemplate' %
-                     self._html_interface_name)
+                     self._interface_type_info.interface_name())
     template = self._template_loader.TryLoad(template_file)
     if not template:
       template = self._template_loader.Load('factoryprovider.darttemplate')
 
+    interface_name = self._interface_type_info.interface_name()
     emitter.Emit(
         template,
         FACTORYPROVIDER=factory_provider,
-        CONSTRUCTOR=self._html_interface_name,
+        CONSTRUCTOR=interface_name,
         PARAMETERS=constructor_info.ParametersImplementationDeclaration(self._DartType),
-        NAMED_CONSTRUCTOR=constructor_info.name or self._html_interface_name,
+        NAMED_CONSTRUCTOR=constructor_info.name or interface_name,
         ARGUMENTS=constructor_info.ParametersAsArgumentList())
 
   def SecondaryContext(self, interface):
     if interface is not self._current_secondary_parent:
       self._current_secondary_parent = interface
       self._members_emitter.Emit('\n  // From $WHERE\n', WHERE=interface.id)
 
   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
@@ skipping 347 matching lines @@
     return any(self._InputConversion(arg.type.id, operation.id)
                for arg in operation.arguments)
 
   def _OutputConversion(self, idl_type, member):
     return FindConversion(idl_type, 'get', self._interface.id, member)
 
   def _InputConversion(self, idl_type, member):
     return FindConversion(idl_type, 'set', self._interface.id, member)
 
   def _HasCustomImplementation(self, member_name):
-    member_name = '%s.%s' % (self._html_interface_name, member_name)
+    member_name = '%s.%s' % (self._interface_type_info.interface_name(),
+                             member_name)
     return member_name in _js_custom_members
 
   def CustomJSMembers(self):
     return _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
@@ skipping 75 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))