Implement is-checks against type variables.

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 _js_helper;
 
 import 'dart:collection';
 import 'dart:_foreign_helper' show DART_CLOSURE_TO_JS,
                                    JS,
                                    JS_CALL_IN_ISOLATE,
@@ skipping 1523 matching lines @@
     }
   }
   return true;
 }
 
 getArguments(var type) => JS('var', r'#.slice(1)', type);
 
 getField(var object, var name) => JS('var', r'#[#]', object, name);
 
 /**
+ * Tests whether the Dart object [o] is a subtype of the runtime type
+ * representation [t], which is a type representation as described in the
+ * comment on [isSubtype].
+ */
+bool objectIsSubtype(Object o, var t) {
+  if (JS('bool', '# == null', o) || JS('bool', '# == null', t)) return true;
+  // In the case of [List], [t] will be an array with the type representation
+  // in the first entry and the type argument in the second.
+  var typeOfT = isJsArray(t) ? getField(t, 0) : t;
+  var nativeCheck = getField(typeOfT, '\$nativeCheck');
+  if (nativeCheck != null) {
+    bool isInstance = invoke(nativeCheck, [o]);
+    if (!isInstance) return false;
+    if (o is List) {
+      // If the object is a list and passed the native check, we know that [t]
+      // is an array containing the type argument as its second entry.
+      return isSubtype(getRuntimeTypeArgument(o, null, 0), getField(t, 1));
+    }
+    return true;
+  } else {
+    var type;
+    var rti = getRuntimeTypeInfo(o);
+    // 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, otherwise use [o] itself.
+    if (JS('bool', '# != null', rti)) {
+      type = JS('List', '#.slice().splice(0, 0, #)', rti, o);
+    } else {
+      // 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.
+      type = o;
+    }
+    return isSubtype(type, t);
+  }
+}
+
+
+/**
  * Check whether the type represented by [s] is a subtype of the type
  * represented by [t].
  *
  * Type representations can be:
  *  1) a JavaScript constructor for a class C: the represented type is the raw
  *     type C.
- *  2) a JavaScript object: this represents a class for which there is no
+ *  2) a Dart object.
+ *  3) a JavaScript object: this represents a class for which there is no
  *     JavaScript constructor, because it is only used in type arguments or it
  *     is native. The represented type is the raw type of this class.
- *  3) a JavaScript array: the first entry is of type 1 or 2 and identifies the
- *     class of the type and the rest of the array are the type arguments.
- *  4) [:null:]: the dynamic type.
+ *  4) a JavaScript array: the first entry is of type 1, 2 or 3 and contains the
+ *     subtyping flags and the substitution of the type and the rest of the
+ *     array are the type arguments.
+ *  5) [:null:]: the dynamic type.
  */
 bool isSubtype(var s, var t) {
   // If either type is dynamic, [s] is a subtype of [t].
   if (JS('bool', '# == null', s) || JS('bool', '# == null', t)) return true;
   // Subtyping is reflexive.
   if (JS('bool', '# === #', s, t)) return true;
   // Get the object describing the class and check for the subtyping flag
   // constructed from the type of [t].
   var typeOfS = isJsArray(s) ? s[0] : s;
   var typeOfT = isJsArray(t) ? t[0] : t;
   // Check for a subtyping flag.
   var test = '${JS_OPERATOR_IS_PREFIX()}${runtimeTypeToString(typeOfT)}';
   if (getField(typeOfS, test) == null) return false;
   // The class of [s] is a subclass of the class of [t]. If either of the types
   // is raw, [s] is a subtype of [t].
   if (!isJsArray(s) || !isJsArray(t)) return true;
   // Get the necessary substitution of the type arguments, if there is one.
   var substitution;
   if (JS('bool', '# !== #', typeOfT, typeOfS)) {
     var field = '${JS_OPERATOR_AS_PREFIX()}${runtimeTypeToString(typeOfT)}';
     substitution = getField(typeOfS, field);
   }
   // Recursively check the type arguments.
   return checkArguments(substitution, getArguments(s), getArguments(t));
 }
 
 createRuntimeType(String name) => new TypeImpl(name);