Strip unused functionality from dart:html and fix strong mode errors. Switch from blacklisting pure…

tools/dom/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 logging
@@ skipping 536 matching lines @@
       if factory_provider and factory_provider != info.factory_provider_name:
         _logger.warn('Conflicting factory provider names: %s != %s' %
           (factory_provider, info.factory_provider_name))
       factory_provider = info.factory_provider_name
 
     implementation_emitter = self._ImplementationEmitter()
 
     base_type_info = None
     if self._interface.parents:
       supertype = self._interface.parents[0].type.id
-      if not IsDartCollectionType(supertype) and not IsPureInterface(supertype):
+      if not IsDartCollectionType(supertype) and not IsPureInterface(supertype, self._database):
         base_type_info = self._type_registry.TypeInfo(supertype)
 
     if base_type_info:
       base_class = base_type_info.implementation_name()
     else:
       base_class = self._backend.RootClassName()
 
     implements = self._backend.AdditionalImplementedInterfaces()
     for parent in self._interface.parents:
       parent_type_info = self._type_registry.TypeInfo(parent.type.id)
@@ skipping 19 matching lines @@
       elif (base_class == 'NativeFieldWrapperClass2' and
             self._options.dart_js_interop and
             not(isinstance(self._backend, Dart2JSBackend))):
         base_class = 'DartHtmlDomObject'
 
     annotations = self._metadata.GetFormattedMetadata(
         self._library_name, self._interface, None, '')
 
     class_modifiers = ''
     if (self._renamer.ShouldSuppressInterface(self._interface) or
-      IsPureInterface(self._interface.id)):
+      IsPureInterface(self._interface.id, self._database)):
       # XMLHttpRequestProgressEvent can't be abstract we need to instantiate
       # for JsInterop.
       if (not(isinstance(self._backend, Dart2JSBackend)) and
         (self._interface.id == 'XMLHttpRequestProgressEvent' or
          self._interface.id == 'DOMStringMap')):
         # Suppress abstract for XMLHttpRequestProgressEvent and DOMStringMap
         # for Dartium.  Need to be able to instantiate the class; can't be abstract.
         class_modifiers = ''
       else:
         # For Dartium w/ JsInterop these suppressed interfaces are needed to
         # instanciate the internal classes.
         if (self._renamer.ShouldSuppressInterface(self._interface) and
             not(isinstance(self._backend, Dart2JSBackend)) and
             self._options.dart_js_interop):
           class_modifiers = ''
         else:
           class_modifiers = 'abstract '
 
     native_spec = ''
-    if not IsPureInterface(self._interface.id):
+    if not IsPureInterface(self._interface.id, self._database):
       native_spec = self._backend.NativeSpec()
 
     class_name = self._interface_type_info.implementation_name()
 
     js_interop_wrapper = '''
 
   @Deprecated("Internal Use Only")
   external static Type get instanceRuntimeType;
 
   @Deprecated("Internal Use Only")
@@ skipping 54 matching lines @@
 
     isElement = False
     for parent in self._database.Hierarchy(self._interface):
       if parent.id == 'Element':
         isElement = True
 
     # Write out the JsInterop code.
     if (implementation_members_emitter and
         self._options.templates._conditions['DARTIUM'] and
         self._options.dart_js_interop and
-        not IsPureInterface(self._interface.id)):
+        not IsPureInterface(self._interface.id, self._database)):
       implementation_members_emitter.Emit(js_interop_wrapper)
 
     if isElement and self._interface.id != 'Element':
       implementation_members_emitter.Emit(
           '  /**\n'
           '   * Constructor instantiated by the DOM when a custom element has been created.\n'
           '   *\n'
           '   * This can only be called by subclasses from their created constructor.\n'
           '   */\n'
           '  $CLASSNAME.created() : super.created();\n',
@@ skipping 50 matching lines @@
 
   def ImplementsMergedMembers(self):
     return True
 
   def GenerateCallback(self, info):
     pass
 
   def AdditionalImplementedInterfaces(self):
     implements = super(Dart2JSBackend, self).AdditionalImplementedInterfaces()
     if self._interface_type_info.list_item_type() and self.HasIndexedGetter():
-      implements.append('JavaScriptIndexingBehavior')
+      item_type = self._type_registry.TypeInfo(
+          self._interface_type_info.list_item_type()).dart_type()
+      implements.append('JavaScriptIndexingBehavior<%s>' % item_type)
     return implements
 
   def NativeSpec(self):
     native_spec = MakeNativeSpec(self._interface.javascript_binding_name)
     return '@Native("%s")\n' % native_spec
 
   def ImplementationTemplate(self):
     template_file = ('impl_%s.darttemplate' %
                      self._interface.doc_js_name)
     return (self._template_loader.TryLoad(template_file) or
@@ skipping 117 matching lines @@
           '    throw new UnsupportedError("Cannot assign element of immutable List.");\n'
           '  }\n',
           TYPE=self._NarrowInputType(element_type))
 
     self.EmitListMixin(self._DartType(element_type))
 
   def EmitAttribute(self, attribute, html_name, read_only):
     if self._HasCustomImplementation(attribute.id):
       return
 
-    if IsPureInterface(self._interface.id):
+    if IsPureInterface(self._interface.id, self._database):
       self._AddInterfaceAttribute(attribute, html_name, read_only)
       return
 
     # If the attribute is shadowing, we can't generate a shadowing
     # field (Issue 1633).
     # TODO(sra): _FindShadowedAttribute does not take into account the html
     #  renaming.  we should be looking for another attribute that has the same
     #  html_name.  Two attributes with the same IDL name might not match if one
     #  is renamed.
     (super_attribute, super_attribute_interface) = self._FindShadowedAttribute(
@@ skipping 149 matching lines @@
     return True
 
   def EmitOperation(self, info, html_name, dart_js_interop=False):
     """
     Arguments:
       info: An OperationInfo object.
     """
     if self._HasCustomImplementation(info.name):
       return
 
-    if IsPureInterface(self._interface.id):
+    if IsPureInterface(self._interface.id, self._database):
       self._AddInterfaceOperation(info, html_name)
     elif info.callback_args:
       self._AddFutureifiedOperation(info, html_name)
     elif any(self._OperationRequiresConversions(op) for op in info.overloads):
       # Any conversions needed?
       self._AddOperationWithConversions(info, html_name)
     else:
       self._AddDirectNativeOperation(info, html_name)
 
   def _AddDirectNativeOperation(self, info, html_name):
@@ skipping 113 matching lines @@
     return ''
 
   def _Metadata(self, idl_type, idl_member_name, dart_type, indent='  '):
     anns = self._metadata.GetDart2JSMetadata(
         idl_type, self._library_name, self._interface, idl_member_name)
 
     if not self._metadata.AnyConversionAnnotations(
         idl_type, self._interface.id, idl_member_name):
       return_type = self.SecureOutputType(idl_type)
       native_type = self._NarrowToImplementationType(idl_type)
+
       if native_type != return_type:
         anns = anns + [
           "@Returns('%s')" % native_type,
           "@Creates('%s')" % native_type,
         ]
     if dart_type == 'dynamic' or dart_type == 'Object':
       def js_type_annotation(ann):
         return re.search('^@.*Returns', ann) or re.search('^@.*Creates', ann)
       if not filter(js_type_annotation, anns):
         _logger.warn('Member with wildcard native type: %s.%s' %
             (self._interface.id, idl_member_name))
 
     return self._metadata.FormatMetadata(anns, indent);
 
   def CustomJSMembers(self):
     return _js_custom_members
 
   def _FindShadowedAttribute(self, attr):
     """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):
+        if IsPureInterface(parent.type.id, self._database):
           return (None, None)
         if self._database.HasInterface(parent.type.id):
           interfaces_to_search_in = []
           parent_interface_name = parent.type.id
           interfaces_to_search_in.append(parent_interface_name)
           parent_type_info = self._type_registry.TypeInfo(parent_interface_name)
           if parent_type_info.merged_into():
             # IDL parent was merged into another interface, which became a
             # parent interface in Dart.
             parent_interface_name = parent_type_info.merged_into()
@@ skipping 100 matching lines @@
 
   def AddFile(self, basename, library_name, path):
     self._libraries[library_name].AddFile(path)
 
   def AddTypeEntry(self, library_name, idl_name, dart_name):
     self._libraries[library_name].AddTypeEntry(idl_name, dart_name)
 
   def Emit(self, emitter, auxiliary_dir):
     for lib in self._libraries.values():
       lib.Emit(emitter, auxiliary_dir)