Implement is-checks against type variables.

sdk/lib/_internal/compiler/implementation/world.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 dart2js;
 
 class World {
   final Compiler compiler;
   final Map<ClassElement, Set<ClassElement>> subtypes;
   final Map<ClassElement, Set<MixinApplicationElement>> mixinUses;
@@ skipping 42 matching lines @@
 
     compiler.resolverWorld.instantiatedClasses.forEach(addSubtypes);
 
     // Find the classes that need runtime type information. Such
     // classes are:
     // (1) used in a is check with type variables,
     // (2) dependencies of classes in (1),
     // (3) subclasses of (2) and (3).
 
     void potentiallyAddForRti(ClassElement cls) {
-      if (cls.typeVariables.isEmpty) return;
       if (classesNeedingRti.contains(cls)) return;
       classesNeedingRti.add(cls);
 
       Set<ClassElement> classes = subtypes[cls];
       if (classes != null) {
         classes.forEach((ClassElement sub) {
           potentiallyAddForRti(sub);
         });
       }
 
       Set<ClassElement> dependencies = rtiDependencies[cls];
       if (dependencies != null) {
         dependencies.forEach((ClassElement other) {
           potentiallyAddForRti(other);
         });
       }
     }
 
     compiler.resolverWorld.isChecks.forEach((DartType type) {
       if (type is InterfaceType) {
         InterfaceType itf = type;
         if (!itf.isRaw) {
           potentiallyAddForRti(itf.element);
         }
+      } else if (type is TypeVariableType) {
+        TypeVariableElement variable = type.element;
+        ClassElement enclosing = variable.enclosingElement;

[ngeoffray, 2013/02/22 11:04:30]

Why this change?

+        potentiallyAddForRti(enclosing);
       }
     });
   }
 
   void registerMixinUse(MixinApplicationElement mixinApplication,
                         ClassElement mixin) {
     Set<MixinApplicationElement> users =
         mixinUses.putIfAbsent(mixin, () =>
                               new Set<MixinApplicationElement>());
     users.add(mixinApplication);
   }
 
   bool isUsedAsMixin(ClassElement cls) {
     Set<MixinApplicationElement> uses = mixinUses[cls];
     return uses != null && !uses.isEmpty;
   }
 
 
   void registerRtiDependency(Element element, Element dependency) {
     // We're not dealing with typedef for now.
     if (!element.isClass() || !dependency.isClass()) return;
     Set<ClassElement> classes =
         rtiDependencies.putIfAbsent(element, () => new Set<ClassElement>());
     classes.add(dependency);
   }
 
   bool needsRti(ClassElement cls) {
-    return classesNeedingRti.contains(cls) || compiler.enabledRuntimeType;
+    return classesNeedingRti.contains(cls) ||
+           compiler.enabledRuntimeType ||
+           compiler.hasVariableTypecheck;

[ngeoffray, 2013/02/22 11:04:30]

So any class needs rti when the check is on? Shouldn't we track the classes used
in a type variable, and the class that declares the type variable does a type
variable is check?

   }
 
   bool hasAnyUserDefinedGetter(Selector selector) {
     return allFunctions.filter(selector).any((each) => each.isGetter());
   }
 
   bool hasAnyUserDefinedSetter(Selector selector) {
      return allFunctions.filter(selector).any((each) => each.isSetter());
   }
 
@@ skipping 38 matching lines @@
       noSuchMethodSelector = new TypedSelector(
           receiverType, selector.typeKind, noSuchMethodSelector);
     }
     ClassElement objectClass = compiler.objectClass;
     return allFunctions
         .filter(noSuchMethodSelector)
         .map((Element member) => member.getEnclosingClass())
         .where((ClassElement holder) => !identical(holder, objectClass));
   }
 }