Support runtime check of function types.

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;
@@ skipping 112 matching lines @@
     // the calls of the list constructor whenever we determine that
     // JSArray needs type arguments.
     compiler.backend.addBackendRtiDependencies(this);
     // Compute the set of all classes that need runtime type information.
     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);
+      } else {
+        TypeVariableType typeVariable = type.typeVariableOccurrence;
+        if (typeVariable != null) {
+          TypeVariableElement variable = typeVariable.element;
+          potentiallyAddForRti(variable.enclosingElement);

[ngeoffray, 2013/03/13 09:30:46]

Why wasn't the previous code for type variable good enough?

[Johnni Winther, 2013/03/22 07:30:24]

This code handles both types [:T:] and [:void f(T t):].

+        } else if (type.kind == TypeKind.FUNCTION) {
+          compiler.resolverWorld.closurizedMembers.forEach((Element member) {
+            DartType memberType = member.computeType(compiler);
+            typeVariable = memberType.typeVariableOccurrence;
+            if (typeVariable != null &&
+                compiler.types.isPotentialSubtype(memberType, type)) {
+              TypeVariableElement variable = typeVariable.element;
+              potentiallyAddForRti(variable.enclosingElement);
+            }
+          });
+          compiler.resolverWorld.callMethods.forEach((Element member) {
+            DartType memberType = member.computeType(compiler);
+            if (compiler.types.isPotentialSubtype(memberType, type)) {
+              potentiallyAddForRti(member.getEnclosingClass());
+            }
+          });
+        }
       }
     });
     // 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>[];
@@ skipping 106 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));
   }
 }