Support type variables as expressions.

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<MixinApplicationElement>> mixinUses;
   final Map<ClassElement, Set<ClassElement>> typesImplementedBySubclasses;
   final Set<ClassElement> classesNeedingRti;
   final Map<ClassElement, Set<ClassElement>> rtiDependencies;
   final FullFunctionSet allFunctions;
 
+  // The set of classes that use one of their type variables as expressions
+  // to get the runtime type.
+  final Set<ClassElement> classesUsingTypeVariableExpression;
+
   // We keep track of subtype and subclass relationships in four
   // distinct sets to make class hierarchy analysis faster.
   final Map<ClassElement, Set<ClassElement>> subclasses =
       new Map<ClassElement, Set<ClassElement>>();
   final Map<ClassElement, Set<ClassElement>> superclasses =
       new Map<ClassElement, Set<ClassElement>>();
   final Map<ClassElement, Set<ClassElement>> subtypes =
       new Map<ClassElement, Set<ClassElement>>();
   final Map<ClassElement, Set<ClassElement>> supertypes =
       new Map<ClassElement, Set<ClassElement>>();
 
   World(Compiler compiler)
       : mixinUses = new Map<ClassElement, Set<MixinApplicationElement>>(),
         typesImplementedBySubclasses =
             new Map<ClassElement, Set<ClassElement>>(),
         classesNeedingRti = new Set<ClassElement>(),
         rtiDependencies = new Map<ClassElement, Set<ClassElement>>(),
         allFunctions = new FullFunctionSet(compiler),
+            classesUsingTypeVariableExpression = new Set<ClassElement>(),
         this.compiler = compiler;
 
   void populate() {
     void addSubtypes(ClassElement cls) {
       if (cls.resolutionState != STATE_DONE) {
         compiler.internalErrorOnElement(
             cls, 'Class "${cls.name.slowToString()}" is not resolved.');
       }
 
       for (DartType type in cls.allSupertypes) {
@@ skipping 80 matching lines @@
       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);
       }
     });
+    // Add the classes that need RTI because they use a type variable as
+    // expression.
+    classesUsingTypeVariableExpression.forEach(potentiallyAddForRti);
   }
 
   Iterable<ClassElement> commonSupertypesOf(ClassElement x, ClassElement y) {
     Set<ClassElement> xSet = supertypes[x];
     if (xSet == null) return const <ClassElement>[];
     Set<ClassElement> ySet = supertypes[y];
     if (ySet == null) return const <ClassElement>[];
     Set<ClassElement> smallSet, largeSet;
     if (xSet.length <= ySet.length) {
       smallSet = xSet;
@@ skipping 29 matching lines @@
   }
 
   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);
   }
 
+  void registerClassUsingVariableExpression(ClassElement cls) {
+    classesUsingTypeVariableExpression.add(cls);
+  }
+
   bool needsRti(ClassElement cls) {
     return classesNeedingRti.contains(cls) || compiler.enabledRuntimeType;
   }
 
   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 48 matching lines @@
     if (mask != null) {
       noSuchMethodSelector = new TypedSelector(mask, noSuchMethodSelector);
     }
     ClassElement objectClass = compiler.objectClass;
     return allFunctions
         .filter(noSuchMethodSelector)
         .map((Element member) => member.getEnclosingClass())
         .where((ClassElement holder) => !identical(holder, objectClass));
   }
 }