Refactor idl to dart renaming logic for interfaces.

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 65 matching lines @@
     info.name = interface_name
     info.constructor_name = self.name
     info.js_name = None
     info.type_name = interface_name
     info.param_infos = map(lambda tXn: ParamInfo(tXn[1], None, tXn[0], 'null'),
                            self.opt_params)
     return info
 
 _html_element_constructors = {
   'AnchorElement' :
-    ElementConstructorInfo(tag='a', opt_params=[('String', 'href')]),
+    ElementConstructorInfo(tag='a', opt_params=[('DOMString', 'href')]),
   'AreaElement': 'area',
   'ButtonElement': 'button',
   'BRElement': 'br',
   'BaseElement': 'base',
   'BodyElement': 'body',
   'ButtonElement': 'button',
   'CanvasElement':
     ElementConstructorInfo(tag='canvas',
                            opt_params=[('int', 'width'), ('int', 'height')]),
   'ContentElement': 'content',
   'DataListElement': 'datalist',
   'DListElement': 'dl',
   'DetailsElement': 'details',
   'DivElement': 'div',
   'EmbedElement': 'embed',
   'FieldSetElement': 'fieldset',
   'FormElement': 'form',
   'HRElement': 'hr',
   'HeadElement': 'head',
   'HeadingElement': [ElementConstructorInfo('h1'),
                      ElementConstructorInfo('h2'),
                      ElementConstructorInfo('h3'),
                      ElementConstructorInfo('h4'),
                      ElementConstructorInfo('h5'),
                      ElementConstructorInfo('h6')],
   'HtmlElement': 'html',
   'IFrameElement': 'iframe',
   'ImageElement':
     ElementConstructorInfo(tag='img',
-                           opt_params=[('String', 'src'),
+                           opt_params=[('DOMString', 'src'),
                                        ('int', 'width'), ('int', 'height')]),
   'InputElement':
-    ElementConstructorInfo(tag='input', opt_params=[('String', 'type')]),
+    ElementConstructorInfo(tag='input', opt_params=[('DOMString', 'type')]),
   'KeygenElement': 'keygen',
   'LIElement': 'li',
   'LabelElement': 'label',
   'LegendElement': 'legend',
   'LinkElement': 'link',
   'MapElement': 'map',
   'MenuElement': 'menu',
   'MeterElement': 'meter',
   'OListElement': 'ol',
   'ObjectElement': 'object',
@@ skipping 28 matching lines @@
   if typename not in _html_element_constructors:
     return []
   infos = _html_element_constructors[typename]
   if isinstance(infos, str):
     infos = ElementConstructorInfo(tag=infos)
   if not isinstance(infos, list):
     infos = [infos]
   return infos
 
 def EmitHtmlElementFactoryConstructors(emitter, infos, typename, class_name,
-                                       dart_type):
+                                       rename_type):
   for info in infos:
     constructor_info = info.ConstructorInfo(typename)
 
     inits = emitter.Emit(
         '\n'
         '  static $RETURN_TYPE $CONSTRUCTOR($PARAMS) {\n'
         '    $CLASS _e = _document.$dom_createElement("$TAG");\n'
         '$!INITS'
         '    return _e;\n'
         '  }\n',
-        RETURN_TYPE=constructor_info.type_name,
-        CONSTRUCTOR=constructor_info.ConstructorFactoryName(dart_type),
+        RETURN_TYPE=rename_type(constructor_info.type_name),
+        CONSTRUCTOR=constructor_info.ConstructorFactoryName(rename_type),
         CLASS=class_name,
         TAG=info.tag,
-        PARAMS=constructor_info.ParametersInterfaceDeclaration(dart_type))
+        PARAMS=constructor_info.ParametersInterfaceDeclaration(rename_type))
     for param in constructor_info.param_infos:
       inits.Emit('    if ($E != null) _e.$E = $E;\n', E=param.name)
 
 # ------------------------------------------------------------------------------
 
 class HtmlDartInterfaceGenerator(object):
   """Generates dart interface and implementation for the DOM IDL interface."""
 
   def __init__(self, options, library_emitter, event_generator, interface,
                backend):
@@ skipping 80 matching lines @@
       self._backend.EmitFactoryProvider(
           constructor_info, factory_provider, factory_provider_emitter)
 
     infos = HtmlElementConstructorInfos(typename)
     if infos:
       template = self._template_loader.Load(
           'factoryprovider_Elements.darttemplate')
       EmitHtmlElementFactoryConstructors(
           self._library_emitter.FileEmitter('_Elements', template),
           infos,
-          self._html_interface_name,
+          self._interface.id,
           self._backend.ImplementationClassName(),
           self._DartType)
 
     for info in infos:
-      constructors.append(info.ConstructorInfo(typename))
+      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',
@@ skipping 592 matching lines @@
       checks = filter(lambda e: e != 'true', checks)
       if checks:
         (stmts_emitter, call_emitter) = body.Emit(
             '    if ($CHECKS) {\n$!STMTS$!CALL    }\n',
             INDENT='      ',
             CHECKS=' &&\n        '.join(checks))
       else:
         (stmts_emitter, call_emitter) = body.Emit('$!A$!B', INDENT='    ');
 
       method_version[0] += 1
-      target = '_%s_%d' % (html_name, method_version[0])
+      target = '_%s_%d' % (html_name, method_version[0]);
       arguments = []
       target_parameters = []
       for position, arg in enumerate(operation.arguments[:argument_count]):
         conversion = self._InputConversion(arg.type.id, operation.id)
         param_name = operation.arguments[position].id
         if conversion:
           temp_version[0] += 1
           temp_name = '%s_%s' % (param_name, temp_version[0])
           temp_type = conversion.output_type
           stmts_emitter.Emit(
@@ skipping 121 matching lines @@
                      'NodeList']
     if type_name in do_not_narrow:
       return False
     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 type_name == 'Dynamic':
+      return type_name
     if self._ShouldNarrowToImplementationType(type_name):
       return self._ImplClassName(self._DartType(type_name))
     return self._DartType(type_name)
 
   def _NarrowInputType(self, type_name):
     return self._NarrowToImplementationType(type_name)
 
   def _NarrowOutputType(self, type_name):
     return self._NarrowToImplementationType(type_name)
 
@@ skipping 63 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))