Implement is-checks against type variables.

sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 2409 matching lines @@
     compiler.withCurrentElement(constructor, () {
       FunctionExpression tree = constructor.parseNode(compiler);
       compiler.resolver.resolveConstructorImplementation(constructor, tree);
     });
     // [constructor.defaultImplementation] might be the implementation element
     // and only declaration elements may be registered.
     world.registerStaticUse(constructor.defaultImplementation.declaration);
     ClassElement cls = constructor.defaultImplementation.getEnclosingClass();
     // [cls] might be the implementation element and only declaration elements
     // may be registered.
-    world.registerInstantiatedClass(cls.declaration);
+    world.registerInstantiatedType(mapping.getType(node));
     if (cls.isAbstract(compiler)) {
       compiler.backend.registerAbstractClassInstantiation();
     }
     // [cls] might be the declaration element and we want to include injected
     // members.
     cls.implementation.forEachInstanceField(
         (ClassElement enclosingClass, Element member) {
           world.addToWorkList(member);
         },
         includeBackendMembers: false,
@@ skipping 49 matching lines @@
     if (inCheckContext) {
       compiler.enqueuer.resolution.registerIsCheck(type);
     }
     if (typeRequired || inCheckContext) {
       if (type is InterfaceType) {
         InterfaceType itf = type;
         itf.typeArguments.forEach((DartType argument) {
           analyzeTypeArgument(type, argument);
         });
       }
-      // TODO(ngeoffray): Also handle cases like:
-      // 1) a is T
-      // 2) T a (in checked mode).
+      // TODO(ngeoffray): Also handle T a (in checked mode).
     }
     return type;
   }
 
   visitModifiers(Modifiers node) {
     // TODO(ngeoffray): Implement this.
     unimplemented(node, 'modifiers');
   }
 
   visitLiteralList(LiteralList node) {
@@ skipping 1205 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }