dart2js: add compiler builtins to the core-runtime.

sdk/lib/_internal/compiler/js_lib/js_rti.dart

 // Copyright (c) 2013, 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 part contains helpers for supporting runtime type information.
  *
  * The helper use a mixture of Dart and JavaScript objects. To indicate which is
  * used where we adopt the scheme of using explicit type annotation for Dart
  * objects and 'var' or omitted return type for JavaScript objects.
@@ skipping 116 matching lines @@
 
 void copyTypeArguments(Object source, Object target) {
   JS('var', r'#.$builtinTypeInfo = #.$builtinTypeInfo', target, source);
 }
 
 /**
  * Retrieves the class name from type information stored on the constructor
  * of [object].
  */
 String getClassName(var object) {
-  return JS('String', r'#.constructor.builtin$cls', getInterceptor(object));
+  return getDartTypeName(getRawRuntimeType(object));
 }
 
 /**
  * Creates the string representation for the type representation [runtimeType]
  * of type 4, the JavaScript array, where the first element represents the class
  * and the remaining elements represent the type arguments.
  */
 String getRuntimeTypeAsString(var runtimeType, {String onTypeVariable(int i)}) {
   assert(isJsArray(runtimeType));
-  String className = getConstructorName(getIndex(runtimeType, 0));
+  String className = getDartTypeName(getIndex(runtimeType, 0));
   return '$className'
          '${joinArguments(runtimeType, 1, onTypeVariable: onTypeVariable)}';
 }
 
 /**
- * Retrieves the class name from type information stored on the constructor
- * [type].
- */
-String getConstructorName(var type) => JS('String', r'#.builtin$cls', type);
-
-/**
  * Returns a human-readable representation of the type representation [type].
  */
 String runtimeTypeToString(var type, {String onTypeVariable(int i)}) {
   if (type == null) {
     return 'dynamic';
   } else if (isJsArray(type)) {
     // A list representing a type with arguments.
     return getRuntimeTypeAsString(type, onTypeVariable: onTypeVariable);
   } else if (isJsFunction(type)) {
     // A reference to the constructor.
-    return getConstructorName(type);
+    return getDartTypeName(type);
   } else if (type is int) {
     if (onTypeVariable == null) {
       return type.toString();
     } else {
       return onTypeVariable(type);
     }
   } else {
     // TODO(ahe): Handle function types, and be sure to always return a string.
     return null;
   }
@@ skipping 92 matching lines @@
   var substitution = getField(interceptor, asField);
   return checkArguments(substitution, arguments, checks);
 }
 
 /// Returns the field's type name.
 ///
 /// In minified mode, uses the unminified names if available.
 String computeTypeName(String isField, List arguments) {
   // Shorten the field name to the class name and append the textual
   // representation of the type arguments.
+  // TODO(floitsch): change this to:
+  // String className = JS_BUILTIN('depends:none;effects:none;returns:String',
+  //                               JsBuiltin.classNameFroIsCheckProperty,
+  //                               isField);
   int prefixLength = JS_OPERATOR_IS_PREFIX().length;
   return Primitives.formatType(isField.substring(prefixLength, isField.length),
                                arguments);
 }
 
 Object subtypeCast(Object object, String isField, List checks, String asField) {
   if (object != null && !checkSubtype(object, isField, checks, asField)) {
     String actualType = Primitives.objectTypeName(object);
     String typeName = computeTypeName(isField, checks);
     // TODO(johnniwinther): Move type lookup to [CastErrorImplementation] to
@@ skipping 72 matching lines @@
   var typeArguments = getRuntimeTypeArguments(context, contextName);
   return invokeOn(signature, context, typeArguments);
 }
 
 /**
  * Returns `true` if the runtime type representation [type] is a supertype of
  * [Null].
  */
 bool isSupertypeOfNull(var type) {
   // `null` means `dynamic`.
-  return type == null || getConstructorName(type) == JS_OBJECT_CLASS_NAME()
-                      || getConstructorName(type) == JS_NULL_CLASS_NAME();
+  return type == null || getDartTypeName(type) == JS_OBJECT_CLASS_NAME()
+                      || getDartTypeName(type) == JS_NULL_CLASS_NAME();
 }
 
 /**
  * Tests whether the Dart object [o] is a subtype of the runtime type
  * representation [t].
  *
  * See the comment in the beginning of this file for a description of type
  * representations.
  */
 bool checkSubtypeOfRuntimeType(o, t) {
   if (o == null) return isSupertypeOfNull(t);
   if (t == null) return true;
   // Get the runtime type information from the object here, because we may
   // overwrite o with the interceptor below.
   var rti = getRuntimeTypeInfo(o);
   o = getInterceptor(o);
-  var type = JS('', '#.constructor', o);
+  var type = getRawRuntimeType(o);
   if (rti != null) {
     // If the type has type variables (that is, `rti != null`), make a copy of
     // the type arguments and insert [o] in the first position to create a
     // compound type representation.
     rti = JS('JSExtendableArray', '#.slice()', rti);  // Make a copy.
     JS('', '#.splice(0, 0, #)', rti, type);  // Insert type at position 0.
     type = rti;
-  } else if (hasField(t, '${JS_FUNCTION_TYPE_TAG()}')) {
+  } else if (isDartFunctionType(t)) {
     // Functions are treated specially and have their type information stored
     // directly in the instance.
-    var signatureName =
-        '${JS_OPERATOR_IS_PREFIX()}_${getField(t, JS_FUNCTION_TYPE_TAG())}';
-    if (hasField(o, signatureName)) return true;
     var targetSignatureFunction = getField(o, '${JS_SIGNATURE_NAME()}');
     if (targetSignatureFunction == null) return false;
     type = invokeOn(targetSignatureFunction, o, null);
     return isFunctionSubtype(type, t);
   }
   return isSubtype(type, t);
 }
 
 Object subtypeOfRuntimeTypeCast(Object object, var type) {
   if (object != null && !checkSubtypeOfRuntimeType(object, type)) {
@@ skipping 26 matching lines @@
  * representations.
  *
  * The arguments [s] and [t] must be types, usually represented by the
  * constructor of the class, or an array (for generic types).
  */
 bool isSubtype(var s, var t) {
   // Subtyping is reflexive.
   if (isIdentical(s, t)) return true;
   // If either type is dynamic, [s] is a subtype of [t].
   if (s == null || t == null) return true;
-  if (hasField(t, '${JS_FUNCTION_TYPE_TAG()}')) {
+  if (isDartFunctionType(t)) {
     return isFunctionSubtype(s, t);
   }
   // Check function types against the Function class.
-  if (hasField(s, '${JS_FUNCTION_TYPE_TAG()}')) {
-    return getConstructorName(t) == JS_FUNCTION_CLASS_NAME();
+  if (isDartFunctionType(s)) {
+    return isDartFunctionTypeLiteral(t);
   }
 
   // Get the object describing the class and check for the subtyping flag
   // constructed from the type of [t].
   var typeOfS = isJsArray(s) ? getIndex(s, 0) : s;
   var typeOfT = isJsArray(t) ? getIndex(t, 0) : t;
   // Check for a subtyping flag.
   var name = runtimeTypeToString(typeOfT);
   // Get the necessary substitution of the type arguments, if there is one.
   var substitution;
   if (isNotIdentical(typeOfT, typeOfS)) {
+    // TODO(floitsch): change this to:
+    // if (!JS_BUILTIN('depends:none;effects:none;returns:bool',
+    //                JsBuiltin.implementsType,
+    //                typeOfSPrototype, name)) {
+    //  return false;
+    // }
     var test = '${JS_OPERATOR_IS_PREFIX()}${name}';
     var typeOfSPrototype = JS('', '#.prototype', typeOfS);
     if (hasNoField(typeOfSPrototype, test)) return false;
     var field = '${JS_OPERATOR_AS_PREFIX()}${runtimeTypeToString(typeOfT)}';
     substitution = getField(typeOfSPrototype, field);
   }
   // The class of [s] is a subclass of the class of [t].  If [s] has no type
   // arguments and no substitution, it is used as raw type.  If [t] has no
   // type arguments, it used as a raw type.  In both cases, [s] is a subtype
   // of [t].
@@ skipping 53 matching lines @@
       return false;
     }
     var tType = JS('', '#[#]', t, name);
     var sType = JS('', '#[#]', s, name);
     if (!isAssignable(tType, sType)) return false;
   }
   return true;
 }
 
 bool isFunctionSubtype(var s, var t) {
-  assert(hasField(t, '${JS_FUNCTION_TYPE_TAG()}'));
-  if (hasNoField(s, '${JS_FUNCTION_TYPE_TAG()}')) return false;
+  assert(isDartFunctionType(t));
+  if (!isDartFunctionType(s)) return false;
   if (hasField(s, '${JS_FUNCTION_TYPE_VOID_RETURN_TAG()}')) {
     if (hasNoField(t, '${JS_FUNCTION_TYPE_VOID_RETURN_TAG()}') &&
         hasField(t, '${JS_FUNCTION_TYPE_RETURN_TYPE_TAG()}')) {
       return false;
     }
   } else if (hasNoField(t, '${JS_FUNCTION_TYPE_VOID_RETURN_TAG()}')) {
     var sReturnType = getField(s, '${JS_FUNCTION_TYPE_RETURN_TYPE_TAG()}');
     var tReturnType = getField(t, '${JS_FUNCTION_TYPE_RETURN_TYPE_TAG()}');
     if (!isAssignable(sReturnType, tReturnType)) return false;
   }
@@ skipping 124 matching lines @@
  * `null` and `undefined` (which we can avoid).
  */
 bool isIdentical(var s, var t) => JS('bool', '# === #', s, t);
 
 /**
  * Returns `true` if the JavaScript values [s] and [t] are not identical. We use
  * this helper instead of [identical] because `identical` needs to merge
  * `null` and `undefined` (which we can avoid).
  */
 bool isNotIdentical(var s, var t) => JS('bool', '# !== #', s, t);