Revert "Dartium w/ JsInterop enabled"

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 476 matching lines @@
         self._interface)
 
     code.Emit('$(ANNOTATIONS)typedef void $NAME($PARAMS);\n',
               ANNOTATIONS=annotations,
               NAME=typedef_name,
               PARAMS=info.ParametersAsDeclaration(self._DartType))
     self._backend.GenerateCallback(info)
 
   def GenerateInterface(self):
     interface_name = self._interface_type_info.interface_name()
-
     implementation_name = self._interface_type_info.implementation_name()
     self._library_emitter.AddTypeEntry(self._library_name,
                                        self._interface.id, implementation_name)
 
     factory_provider = None
     if interface_name in interface_factories:
       factory_provider = interface_factories[interface_name]
     factory_constructor_name = None
 
     constructors = []
@@ skipping 45 matching lines @@
     secure_base_name = self._backend.SecureBaseName(interface_name)
     if secure_base_name:
       implements.append(secure_base_name)
 
     implements_str = ''
     if implements:
       implements_str = ' implements ' + ', '.join(set(implements))
 
     mixins = self._backend.Mixins()
 
+    # TODO(terry): Do we need a more generic solution other than handling NamedNodeMap
+    #              we can't call super on a mixin interface - yet.
+    if self._options.templates._conditions['DARTIUM'] and self._options.dart_js_interop and self._interface.id == 'NamedNodeMap':
+      mixins = None
     mixins_str = ''
     if mixins:
       mixins_str = ' with ' + ', '.join(mixins)
       if not base_class:
         base_class = 'Interceptor'
-      elif (base_class == 'NativeFieldWrapperClass2' and
-            self._options.dart_js_interop and
-            not(isinstance(self._backend, Dart2JSBackend))):
-        base_class = 'JsoNativeFieldWrapper'
 
     annotations = self._metadata.GetFormattedMetadata(
         self._library_name, self._interface, None, '')
 
     class_modifiers = ''
     if (self._renamer.ShouldSuppressInterface(self._interface) or
       IsPureInterface(self._interface.id)):
       # XMLHttpRequestProgressEvent can't be abstract we need to instantiate
       # for JsInterop.
       if (not(isinstance(self._backend, Dart2JSBackend)) and
         self._interface.id == 'XMLHttpRequestProgressEvent'):
         # Only suppress abstract for XMLHttpRequestProgressEvent 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 when wrap_jso is called for a JS object.
-        if (self._renamer.ShouldSuppressInterface(self._interface) and
-            not(isinstance(self._backend, Dart2JSBackend)) and
-            self._options.dart_js_interop):
-          class_modifiers = ''
-        else:
-          class_modifiers = 'abstract '
+        class_modifiers = 'abstract '
 
     native_spec = ''
     if not IsPureInterface(self._interface.id):
       native_spec = self._backend.NativeSpec()
 
     class_name = self._interface_type_info.implementation_name()
 
     js_interop_equivalence_op = \
-      '  bool operator ==(other) => unwrap_jso(other) == unwrap_jso(this) || identical(this, other);\n' \
-      + '  int get hashCode => unwrap_jso(this).hashCode;\n'
+      '  bool operator ==(other) => unwrap_jso(other) == unwrap_jso(this) || identical(this, other);\n'
     # ClientRect overrides the equivalence operator.
     if interface_name == 'ClientRect' or interface_name == 'DomRectReadOnly':
         js_interop_equivalence_op = ''
 
     js_interop_wrapper = '''
 
   static {0} internalCreate{0}() {{
     return new {0}._internalWrap();
   }}
 
   factory {0}._internalWrap() {{
-    return new {0}.internal_();
+    return new {0}._internal();
   }}
 
-  {0}.internal_() : super.internal_();
+  {0}._internal() : super._internal();
 
 '''.format(class_name)
-    if base_class == 'NativeFieldWrapperClass2' or base_class == 'JsoNativeFieldWrapper':
+    """
+    TODO(terry): Don't use Dart expando really don't need.
+      final Object expandoJsObject = new Object();
+      final Expando<JsObject> dartium_expando = new Expando<JsObject>("Expando_jsObject");
+    """
+    if base_class == 'NativeFieldWrapperClass2':
         js_interop_wrapper = '''
   static {0} internalCreate{0}() {{
     return new {0}._internalWrap();
   }}
 
-  js.JsObject blink_jsObject;
+  JsObject blink_jsObject = null;
 
   factory {0}._internalWrap() {{
-    return new {0}.internal_();
+    return new {0}._internal();
   }}
 
-  {0}.internal_() {{ }}
+  {0}._internal() {{ }}
 
 {1}'''.format(class_name, js_interop_equivalence_op)
-        # Change to use the synthesized class so we can construct with a mixin
-        # classes prefixed with name of NativeFieldWrapperClass2 don't have a
-        # default constructor so classes with mixins can't be new'd.
-        if (self._options.templates._conditions['DARTIUM'] and
-            self._options.dart_js_interop and
-            (self._interface.id == 'NamedNodeMap' or
-             self._interface.id == 'CSSStyleDeclaration')):
-            base_class = 'JsoNativeFieldWrapper'
 
     implementation_members_emitter = implementation_emitter.Emit(
         self._backend.ImplementationTemplate(),
         LIBRARYNAME='dart.dom.%s' % self._library_name,
         ANNOTATIONS=annotations,
         CLASS_MODIFIERS=class_modifiers,
-        CLASSNAME=class_name,
+        CLASSNAME=self._interface_type_info.implementation_name(),
         EXTENDS=' extends %s' % base_class if base_class else '',
         IMPLEMENTS=implements_str,
         MIXINS=mixins_str,
         DOMNAME=self._interface.doc_js_name,
         NATIVESPEC=native_spec)
     stream_getter_signatures_emitter = None
     element_stream_getters_emitter = None
     if type(implementation_members_emitter) == tuple:
         # We add event stream getters for both Element and ElementList, so in
         # impl_Element.darttemplate, we have two additional "holes" for emitters
@@ skipping 16 matching lines @@
         constructors, factory_provider, factory_constructor_name)
 
     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(class_name)):
+        self._options.dart_js_interop):
       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 286 matching lines @@
         TYPE=return_type,
         NATIVE_TYPE=native_type)
 
   def _AddRenamingSetter(self, attr, html_name):
 
     conversion = self._InputConversion(attr.type.id, attr.id)
     if conversion:
       return self._AddConvertingSetter(attr, html_name, conversion)
     self._members_emitter.Emit(
         # TODO(sra): Use metadata to provide native name.
-        '\n  set $HTML_NAME($TYPE value) {'
+        '\n  void set $HTML_NAME($TYPE value) {'
         '\n    JS("void", "#.$NAME = #", this, value);'
         '\n  }'
         '\n',
         HTML_NAME=html_name,
         NAME=attr.id,
         TYPE=self._NarrowInputType(attr.type.id))
 
   def _AddConvertingGetter(self, attr, html_name, conversion):
     self._members_emitter.Emit(
         '\n  $(METADATA)$RETURN_TYPE get $HTML_NAME => '
         '$CONVERT(this._get_$(HTML_NAME));'
         "\n  @JSName('$NAME')"
         '\n  $(JS_METADATA)final $NATIVE_TYPE _get_$HTML_NAME;'
         '\n',
         METADATA=self._metadata.GetFormattedMetadata(
             self._library_name, self._interface, html_name, '  '),
         JS_METADATA=self._Metadata(attr.type.id, html_name, conversion.input_type),
         CONVERT=conversion.function_name,
         HTML_NAME=html_name,
         NAME=attr.id,
         RETURN_TYPE=conversion.output_type,
         NATIVE_TYPE=conversion.input_type)
 
   def _AddConvertingSetter(self, attr, html_name, conversion):
     self._members_emitter.Emit(
         # TODO(sra): Use metadata to provide native name.
-        '\n  set $HTML_NAME($INPUT_TYPE value) {'
+        '\n  void set $HTML_NAME($INPUT_TYPE value) {'
         '\n    this._set_$HTML_NAME = $CONVERT(value);'
         '\n  }'
-        '\n  set _set_$HTML_NAME(/*$NATIVE_TYPE*/ value) {'
+        '\n  void set _set_$HTML_NAME(/*$NATIVE_TYPE*/ value) {'
         '\n    JS("void", "#.$NAME = #", this, value);'
         '\n  }'
         '\n',
         CONVERT=conversion.function_name,
         HTML_NAME=html_name,
         NAME=attr.id,
         INPUT_TYPE=conversion.input_type,
         NATIVE_TYPE=conversion.output_type)
 
   def AmendIndexer(self, element_type):
@@ skipping 28 matching lines @@
         '\n'
         '  $RENAME$METADATA$MODIFIERS$TYPE $NAME($PARAMS) native;\n',
         RENAME=self._RenamingAnnotation(info.declared_name, html_name),
         METADATA=self._Metadata(info.type_name, info.declared_name,
             self.SecureOutputType(info.type_name)),
         MODIFIERS='static ' if info.IsStatic() else '',
         TYPE=self.SecureOutputType(info.type_name, False, True),
         NAME=html_name,
         PARAMS=info.ParametersAsDeclaration(self._NarrowInputType))
 
+  def _ConvertArgumentTypes(
+          self, stmts_emitter, arguments, argument_count, info):
+    temp_version = [0]
+    converted_arguments = []  
+    target_parameters = []
+    for position, arg in enumerate(arguments[:argument_count]):
+      conversion = self._InputConversion(arg.type.id, info.declared_name)
+      param_name = 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(
+            '$(INDENT)$TYPE $NAME = $CONVERT($ARG);\n',
+            TYPE=TypeOrVar(temp_type),
+            NAME=temp_name,
+            CONVERT=conversion.function_name,
+            ARG=info.param_infos[position].name)
+        converted_arguments.append(temp_name)
+        param_type = temp_type
+        verified_type = temp_type  # verified by assignment in checked mode.
+      else:
+        converted_arguments.append(info.param_infos[position].name)
+        param_type = self._NarrowInputType(arg.type.id)
+        # Verified by argument checking on entry to the dispatcher.
+
+        verified_type = self._InputType(
+            info.param_infos[position].type_id, info)
+        # The native method does not need an argument type if we know the type.
+        # But we do need the native methods to have correct function types, so
+        # be conservative.
+        if param_type == verified_type:
+          if param_type in ['String', 'num', 'int', 'double', 'bool', 'Object']:
+            param_type = 'dynamic'
+
+      target_parameters.append(
+          '%s%s' % (TypeOrNothing(param_type), param_name))
+
+    return target_parameters, converted_arguments
+
+  def _InputType(self, type_name, info):
+    conversion = self._InputConversion(type_name, info.declared_name)
+    if conversion:
+      return conversion.input_type
+    else:
+      return self._NarrowInputType(type_name) if type_name else 'dynamic'
+
   def _AddOperationWithConversions(self, info, html_name):
     # Assert all operations have same return type.
     assert len(set([op.type.id for op in info.operations])) == 1
     output_conversion = self._OutputConversion(info.type_name,
                                                info.declared_name)
     if output_conversion:
       return_type = output_conversion.output_type
       native_return_type = output_conversion.input_type
     else:
       return_type = self._NarrowInputType(info.type_name)
@@ skipping 220 matching lines @@
         map_emitter.Emit(
           "  '$IDL_NAME': () => $DART_NAME,\n",
           IDL_NAME=idl_name,
           DART_NAME=dart_name)
 
     # Emit the $!TYPE_FUNCTION_MAP
     if function_emitter:
       items = self._typeMap.items()
       items.sort()
       for (idl_name, dart_name) in items:
-        if not IsPureInterface(dart_name):
-          # Handle classes that are concrete (abstract can't be instantiated).
-          function_emitter.Emit(
-            "  '$IDL_NAME': () => $DART_NAME.internalCreate$DART_NAME,\n",
-            IDL_NAME=idl_name,
-            DART_NAME=dart_name)
+        function_emitter.Emit(
+          "  '$IDL_NAME': () => $DART_NAME.internalCreate$DART_NAME,\n",
+          IDL_NAME=idl_name,
+          DART_NAME=dart_name)
       if self._dart_path.endswith('html_dartium.dart'):
         function_emitter.Emit("  'polymer-element': () => HtmlElement.internalCreateHtmlElement,\n")
 
 
 # ------------------------------------------------------------------------------
 
 class DartLibraries():
   def __init__(self, libraries, template_loader, library_type, output_dir, dart_js_interop):
     self._libraries = {}
     for library_name in libraries:
       self._libraries[library_name] = DartLibrary(
           library_name, template_loader, library_type, output_dir, dart_js_interop)
 
   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)