dart2js: put all type-test related properties on the prototype and not on the constructor.

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 372 matching lines @@
  * See the comment in the beginning of this file for a description of type
  * representations.
  */
 bool checkSubtypeOfRuntimeType(o, t) {
   if (isNull(o)) return isSupertypeOfNull(t);
   if (isNull(t)) 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);
-  // We can use the object as its own type representation because we install
-  // the subtype flags and the substitution on the prototype, so they are
-  // properties of the object in JS.
-  var type;
+  var type = JS('', '#.constructor', o);
   if (isNotNull(rti)) {
     // 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.
-    type = JS('JSExtendableArray', '#.slice()', rti);
-    JS('', '#.splice(0, 0, #)', type, o);
-  } else {
-    // Use the object as representation of the raw type.
+    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()}') ||

[karlklose, 2014/12/15 13:12:21]

One of them should be 'hasField(o, ...'.

[floitsch, 2014/12/15 16:04:35]

argh.
In fact o can never have a function-type-tag.
Cleaned up the code.

+             hasField(t, '${JS_FUNCTION_TYPE_TAG()}')) {
+    // Functions are treated specially. If either `o` is a function or if t is
+    // a function type, take o as the type-object. If o isn't a function the
+    // test will fail, because `o` doesn't have the necessary fields.
     type = o;
   }
   return isSubtype(type, t);
 }
 
 Object subtypeOfRuntimeTypeCast(Object object, var type) {
   if (object != null && !checkSubtypeOfRuntimeType(object, type)) {
     String actualType = Primitives.objectTypeName(object);
     throw new CastErrorImplementation(actualType, runtimeTypeToString(type));
   }
@@ skipping 14 matching lines @@
 getArguments(var type) {
   return isJsArray(type) ? JS('var', r'#.slice(1)', type) : null;
 }
 
 /**
  * Checks whether the type represented by the type representation [s] is a
  * subtype of the type represented by the type representation [t].
  *
  * See the comment in the beginning of this file for a description of type
  * representations.
+ *
+ * [t] must be a type, usually represented by the constructor of the class, or
+ * an array (for generic types).
+ *
+ * If [t] is a function type, then [s] may be any object (and the test will
+ * look for closure properties on the object). if [t] is not a function type

[karlklose, 2014/12/15 13:12:21]

'closure properties' -> 'function type tag'?

[floitsch, 2014/12/15 16:04:34]

Changed.
Not true anymore.

+ * [s] must be a type too.
  */
 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 (isNull(s) || isNull(t)) return true;
   if (hasField(t, '${JS_FUNCTION_TYPE_TAG()}')) {
     if (hasNoField(s, '${JS_FUNCTION_TYPE_TAG()}')) {
       var signatureName =
           '${JS_OPERATOR_IS_PREFIX()}_${getField(t, JS_FUNCTION_TYPE_TAG())}';
       if (hasField(s, signatureName)) return true;
       var targetSignatureFunction = getField(s, '${JS_SIGNATURE_NAME()}');
       if (isNull(targetSignatureFunction)) return false;
       s = invokeOn(targetSignatureFunction, s, null);
     }
     return isFunctionSubtype(s, t);
   }
   // Check function types against the Function class.
-  if (getConstructorName(t) == JS_FUNCTION_CLASS_NAME() &&
-      hasField(s, '${JS_FUNCTION_TYPE_TAG()}')) {
-    return true;
+  if (hasField(s, '${JS_FUNCTION_TYPE_TAG()}')) {
+    return getConstructorName(t) == JS_FUNCTION_CLASS_NAME();
   }
+
   // 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)) {
     var test = '${JS_OPERATOR_IS_PREFIX()}${name}';
-    if (hasNoField(typeOfS, test)) return false;
+    var typeOfSPrototype = JS('', '#.prototype', typeOfS);
+    if (hasNoField(typeOfSPrototype, test)) return false;
     var field = '${JS_OPERATOR_AS_PREFIX()}${runtimeTypeToString(typeOfT)}';
-    substitution = getField(typeOfS, field);
+    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].
   if ((!isJsArray(s) && isNull(substitution)) || !isJsArray(t)) {
     return true;
   }
   // Recursively check the type arguments.
   return checkArguments(substitution, getArguments(s), getArguments(t));
@@ skipping 210 matching lines @@
  * and [t] are Dart values.
  */
 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 to avoid generating code under the invalid assumption that
  * [s] and [t] are Dart values.
  */
 bool isNotIdentical(var s, var t) => JS('bool', '# !== #', s, t);