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;
   final Map<ClassElement, Set<ClassElement>> typesImplementedBySubclasses;
   final Set<ClassElement> classesNeedingRti;
+  final Set<ClassElement> usedFactoriesOfAbstractClasses;

[ngeoffray, 2013/02/27 12:36:28]

Store the factories instead, as implied by the name?

[karlklose, 2013/02/27 16:11:32]

Obsolete.

   final Map<ClassElement, Set<ClassElement>> rtiDependencies;
   final FullFunctionSet allFunctions;
 
   World(Compiler compiler)
       : subtypes = new Map<ClassElement, Set<ClassElement>>(),
         mixinUses = new Map<ClassElement, Set<MixinApplicationElement>>(),
         typesImplementedBySubclasses =
             new Map<ClassElement, Set<ClassElement>>(),
         classesNeedingRti = new Set<ClassElement>(),
+        usedFactoriesOfAbstractClasses = new Set<ClassElement>(),
         rtiDependencies = new Map<ClassElement, Set<ClassElement>>(),
         allFunctions = new FullFunctionSet(compiler),
         this.compiler = compiler;
 
   void populate() {
     void addSubtypes(ClassElement cls) {
       if (cls.resolutionState != STATE_DONE) {
         compiler.internalErrorOnElement(
             cls, 'Class "${cls.name.slowToString()}" is not resolved.');
       }
@@ skipping 40 matching lines @@
       }
 
       Set<ClassElement> dependencies = rtiDependencies[cls];
       if (dependencies != null) {
         dependencies.forEach((ClassElement other) {
           potentiallyAddForRti(other);
         });
       }
     }
 
+    Set<ClassElement> classesUsingTypeVariableTests = new Set<ClassElement>();
     compiler.resolverWorld.isChecks.forEach((DartType type) {
-      if (type is InterfaceType) {
+      if (type.kind == TypeKind.TYPE_VARIABLE) {
+        TypeVariableElement variable = type.element;
+        classesUsingTypeVariableTests.add(variable.enclosingElement);
+      }
+    });
+    compiler.resolverWorld.addImplicitChecks(classesUsingTypeVariableTests);
+    compiler.resolverWorld.isChecks.forEach((DartType type) {
+      if (type.kind == TypeKind.INTERFACE) {
         InterfaceType itf = type;
         if (!itf.isRaw) {
           potentiallyAddForRti(itf.element);
         }
+      } else if (type.kind == TypeKind.TYPE_VARIABLE) {
+        TypeVariableElement variable = type.element;
+        potentiallyAddForRti(variable.enclosingElement);
       }
     });
+
+    // TODO(karlklose): if we know all targets of factories for the abstract
+    // class, we should check whether one of these targets needs runtime type
+    // information before adding the class.
+    usedFactoriesOfAbstractClasses.forEach((ClassElement cls) {
+      potentiallyAddForRti(cls);
+    });
   }
 
   void registerMixinUse(MixinApplicationElement mixinApplication,
                         ClassElement mixin) {
     Set<MixinApplicationElement> users =
         mixinUses.putIfAbsent(mixin, () =>
                               new Set<MixinApplicationElement>());
     users.add(mixinApplication);
   }
 
@@ skipping 63 matching lines @@
     if (receiverType != null) {
       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));
   }
+
+  void registerUsedFactoriesOfAbstractClasses(ClassElement cls) {
+    usedFactoriesOfAbstractClasses.add(cls);
+  }
 }