Add NativeEnqueuer to work with the Enqueuer.

sdk/lib/_internal/compiler/implementation/lib/js_helper.dart

 // 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.
 
 #library('dart:_js_helper');
 
 #import('dart:collection');
 
 #source('constant_map.dart');
 #source('native_helper.dart');
@@ skipping 284 matching lines @@
 
 index$slow(var a, var index) {
   if (a is String || isJsArray(a)) {
     if (index is !int) {
       if (index is !num) throw new ArgumentError(index);
       if (!identical(index.truncate(), index)) throw new ArgumentError(index);
     }
     if (index < 0 || index >= a.length) {
       throw new RangeError.value(index);
     }
-    return JS('Object', r'#[#]', a, index);
+    return JS('', r'#[#]', a, index);
   }
   return UNINTERCEPTED(a[index]);
 }
 
 void indexSet$slow(var a, var index, var value) {
   if (isJsArray(a)) {
     if (index is !int) {
       throw new ArgumentError(index);
     }
     if (index < 0 || index >= a.length) {
       throw new RangeError.value(index);
     }
     checkMutable(a, 'indexed set');
-    JS('Object', r'#[#] = #', a, index, value);
+    JS('void', r'#[#] = #', a, index, value);
     return;
   }
   UNINTERCEPTED(a[index] = value);
 }
 
 checkMutable(list, reason) {
   if (JS('bool', r'!!(#.immutable$list)', list)) {
     throw new UnsupportedError(reason);
   }
 }
@@ skipping 10 matching lines @@
   return res;
 }
 
 class ListIterator<T> implements Iterator<T> {
   int i;
   List<T> list;
   ListIterator(List<T> this.list) : i = 0;
   bool get hasNext => i < JS('int', r'#.length', list);
   T next() {
     if (!hasNext) throw new StateError("No more elements");
-    var value = JS('Object', r'#[#]', list, i);
+    var value = JS('', r'#[#]', list, i);
     i += 1;
     return value;
   }
 }
 
 createInvocationMirror(name, internalName, type, arguments, argumentNames) =>
     new JSInvocationMirror(name, internalName, type, arguments, argumentNames);
 
 class JSInvocationMirror implements InvocationMirror {
   static const METHOD = 0;
@@ skipping 96 matching lines @@
     }
 
     // This is somewhat nasty, but we don't want to drag in a bunch of
     // dependencies to handle a situation that cannot happen. So we
     // avoid using Dart [:throw:] and Dart [toString].
     JS('void', "throw 'Unable to print message: ' + String(#)", string);
   }
 
   static int parseInt(String string) {
     checkString(string);
-    var match = JS('List',
+    var match = JS('=List',
                    r'/^\s*[+-]?(?:0(x)[a-f0-9]+|\d+)\s*$/i.exec(#)',
                    string);
     if (match == null) {
       throw new FormatException(string);
     }
     var base = 10;
     if (match[1] != null) base = 16;
     var result = JS('num', r'parseInt(#, #)', string, base);
     if (result.isNaN) throw new FormatException(string);
     return result;
@@ skipping 37 matching lines @@
     if (identical(name.charCodeAt(0), DOLLAR_CHAR_VALUE)) name = name.substring(1);
     return name;
   }
 
   static String objectToString(Object object) {
     String name = objectTypeName(object);
     return "Instance of '$name'";
   }
 
   static List newList(length) {
-    if (length == null) return JS('Object', r'new Array()');
+    // TODO(sra): For good concrete type analysis we need the JS-type to
+    // specifically name the JavaScript Array implementation.  'List' matches
+    // all the dart:html types that implement List<T>.
+    if (length == null) return JS('=List', r'new Array()');
     if ((length is !int) || (length < 0)) {
       throw new ArgumentError(length);
     }
-    var result = JS('Object', r'new Array(#)', length);
+    var result = JS('=List', r'new Array(#)', length);
     JS('void', r'#.fixed$length = #', result, true);
     return result;
   }
 
   static num dateNow() => JS('num', r'Date.now()');
 
   static String stringFromCharCodes(charCodes) {
     for (var i in charCodes) {
       if (i is !int) throw new ArgumentError(i);
     }
@@ skipping 36 matching lines @@
     if (value.isNaN ||
         value < -MAX_MILLISECONDS_SINCE_EPOCH ||
         value > MAX_MILLISECONDS_SINCE_EPOCH) {
       throw new ArgumentError();
     }
     if (years <= 0 || years < 100) return patchUpY2K(value, years, isUtc);
     return value;
   }
 
   static patchUpY2K(value, years, isUtc) {
-    var date = JS('Object', r'new Date(#)', value);
+    var date = JS('', r'new Date(#)', value);
     if (isUtc) {
       JS('num', r'#.setUTCFullYear(#)', date, years);
     } else {
       JS('num', r'#.setFullYear(#)', date, years);
     }
     return JS('num', r'#.valueOf()', date);
   }
 
   // Lazily keep a JS Date stored in the JS object.
   static lazyAsJsDate(receiver) {
@@ skipping 291 matching lines @@
 
 /**
  * Throws the given Dart object as an exception by wrapping it in a
  * proper JavaScript error object and then throwing that. That gives
  * us a reasonable stack trace on most JavaScript implementations. The
  * code in [unwrapException] deals with getting the original Dart
  * object out of the wrapper again.
  */
 $throw(ex) {
   if (ex == null) ex = const NullPointerException();
-  var jsError = JS('Object', r'new Error()');
+  var jsError = JS('var', r'new Error()');
   JS('void', r'#.name = #', jsError, ex);
   JS('void', r'#.description = #', jsError, ex);
   JS('void', r'#.dartException = #', jsError, ex);
   JS('void', r'#.toString = #', jsError,
      DART_CLOSURE_TO_JS(toStringWrapper));
   JS('void', r'throw #', jsError);
 }
 
 /**
  * This method is installed as JavaScript toString method on exception
  * objects in [$throw]. So JavaScript 'this' binds to an instance of
  * JavaScript Error to which we have added a property 'dartException'
  * which holds a Dart object.
  */
-toStringWrapper() => JS('Object', r'this.dartException').toString();
+toStringWrapper() => JS('', r'this.dartException').toString();
 
 makeLiteralListConst(list) {
   JS('bool', r'#.immutable$list = #', list, true);
   JS('bool', r'#.fixed$length = #', list, true);
   return list;
 }
 
 throwRuntimeError(message) {
   throw new RuntimeError(message);
 }
 
 throwAbstractClassInstantiationError(className) {
   throw new AbstractClassInstantiationError(className);
 }
 
 /**
  * Called from catch blocks in generated code to extract the Dart
  * exception from the thrown value. The thrown value may have been
  * created by [$throw] or it may be a 'native' JS exception.
  *
  * Some native exceptions are mapped to new Dart instances, others are
  * returned unmodified.
  */
 unwrapException(ex) {
   // Note that we are checking if the object has the property. If it
   // has, it could be set to null if the thrown value is null.
   if (JS('bool', r'"dartException" in #', ex)) {
-    return JS('Object', r'#.dartException', ex);
+    return JS('', r'#.dartException', ex);
   }
 
   // Grab hold of the exception message. This field is available on
   // all supported browsers.
   var message = JS('var', r'#.message', ex);
 
   if (JS('bool', r'# instanceof TypeError', ex)) {
     // The type and arguments fields are Chrome specific but they
     // allow us to get very detailed information about what kind of
     // exception occurred.
@@ skipping 151 matching lines @@
  */
 getFallThroughError() => const FallThroughErrorImplementation();
 
 /**
  * Represents the type Dynamic. The compiler treats this specially.
  */
 abstract class Dynamic_ {
 }
 
 /**
+ * A metadata annotation describing the types instantiated by a native element.
+ */
+class Creates {
+  final String types;
+  const Creates(this.types);
+}
+
+/**
+ * A metadata annotation describing the types returned or yielded by a native
+ * element.
+ */
+class Returns {
+  final String types;
+  const Returns(this.types);
+}
+
+/**
  * Represents the type of Null. The compiler treats this specially.
  * TODO(lrn): Null should be defined in core. It's a class, like int.
  * It just happens to act differently in assignability tests and,
  * like int, can't be extended or implemented.
  */
 class Null {
   factory Null() {
     throw new UnsupportedError('new Null()');
   }
 }
@@ skipping 350 matching lines @@
 Type getOrCreateCachedRuntimeType(String key) {
   Type result = JS('Type', r'#[#]', runtimeTypeCache, key);
   if (result == null) {
     result = new TypeImpl(key);
     JS('var', r'#[#] = #', runtimeTypeCache, key, result);
   }
   return result;
 }
 
 String getRuntimeTypeString(var object) {
-  var typeInfo = JS('Object', r'#.builtin$typeInfo', object);
+  var typeInfo = JS('var', r'#.builtin$typeInfo', object);
   return JS('String', r'#.runtimeType', typeInfo);
 }