Remove dart:dom scripts.

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
 
-from systemdart2js import *
+from systembase import *
 from systeminterface import *
 
 _js_custom_members = set([
     'CSSStyleDeclaration.setProperty',
     'Element.insertAdjacentElement',
     'Element.insertAdjacentHTML',
     'Element.insertAdjacentText',
     'Element.remove',
     'ElementEvents.mouseWheel',
     'IDBDatabase.transaction',
@@ skipping 743 matching lines @@
 class HtmlGeneratorDummyBackend(object):
   def AddAttribute(self, attribute, html_name, read_only):
     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 Dart2JSBackend(Dart2JSInterfaceGenerator):
+class Dart2JSBackend(BaseGenerator):
   """Generates a dart2js class for the dart:html library from a DOM IDL
   interface.
   """
 
   def __init__(self, interface, options):
-    super(Dart2JSBackend, self).__init__(options, interface, None, None)
+    super(Dart2JSBackend, self).__init__(None, None, interface)
+    self._database = options.database
+    self._template_loader = options.templates
+    self._type_registry = options.type_registry
     self._html_interface_name = options.renamer.RenameInterface(self._interface)
+    self._current_secondary_parent = None
 
   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 48 matching lines @@
         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 FinishInterface(self):

[podivilov1, 2012/10/01 10:37:34]

All green lines below are moved from systemdart2js without modifications.

+    pass
+
+  def AddConstant(self, constant):
+    # Since we are currently generating native classes without interfaces,
+    # generate the constants as part of the class.  This will need to go away
+    # if we revert back to generating interfaces.
+    self._members_emitter.Emit('\n  static const $TYPE $NAME = $VALUE;\n',
+                               NAME=constant.id,
+                               TYPE=self._DartType(constant.type.id),
+                               VALUE=constant.value)
+
   def EmitFactoryProvider(self, constructor_info, factory_provider, emitter):
     template_file = ('factoryprovider_%s.darttemplate' %
                      self._html_interface_name)
     template = self._template_loader.TryLoad(template_file)
     if not template:
       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 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
     # length, [], and maybe []=.  It is possible to extend from a base
     # array implementation class only when there is no other implementation
     # inheritance.  There might be no implementation inheritance other than
     # DOMBaseWrapper for many classes, but there might be some where the
     # array-ness is introduced by a non-root interface:
     #
     #   interface Y extends X, List<T> ...
@@ skipping 352 matching lines @@
     member_name = '%sEvents.%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
 
+  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._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):
+    return self._NarrowToImplementationType(type_name)
+
+  def _NarrowOutputType(self, type_name):
+    return self._NarrowToImplementationType(type_name)
+
+  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._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._database.GetInterface(interface_name)
+            attr2 = FindMatchingAttribute(interface, attr)
+            if attr2:
+              return (attr2, parent_interface_name)
+
+          return FindInParent(
+              self._database.GetInterface(parent_interface_name))
+      return (None, None)
+
+    return FindInParent(self._interface) if attr else (None, None)
 
 # ------------------------------------------------------------------------------
 
 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))