Support runtime check of function types.

sdk/lib/_internal/compiler/implementation/js_backend/emitter.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 js_backend;
 
 /**
  * A function element that represents a closure call. The signature is copied
  * from the given element.
  */
@@ skipping 30 matching lines @@
   // Has the same signature as [DefineStubFunction].
   void addProperty(String name, jsAst.Expression value) {
     properties.add(new jsAst.Property(js.string(name), value));
   }
 
   jsAst.Expression toObjectInitializer() {
     return new jsAst.ObjectInitializer(properties);
   }
 }
 
+// Function signatures used in the generation of runtime type information.
+typedef void FunctionTypeSignatureEmitter(Element method,
+                                          FunctionType methodType);
+// TODO(johnniwinther): Clean up terminology for rti in the emitter.
+typedef void FunctionTypeTestEmitter(FunctionType functionType);
+typedef void SubstitutionEmitter(Element element, {bool emitNull});
+
 /**
  * Generates the code for all used classes in the program. Static fields (even
  * in classes) are ignored, since they can be treated as non-class elements.
  *
  * The code for the containing (used) methods must exist in the [:universe:].
  */
 class CodeEmitterTask extends CompilerTask {
   bool needsInheritFunction = false;
   bool needsDefineClass = false;
   bool needsMixinSupport = false;
@@ skipping 44 matching lines @@
 
   /**
    * Raw ClassElement symbols occuring in is-checks and type assertions.  If the
    * program contains parameterized checks `x is Set<int>` and
    * `x is Set<String>` then the ClassElement `Set` will occur once in
    * [checkedClasses].
    */
   Set<ClassElement> checkedClasses;
 
   /**
-   * Raw Typedef symbols occuring in is-checks and type assertions.  If the
-   * program contains `x is F<int>` and `x is F<bool>` then the TypedefElement
-   * `F` will occur once in [checkedTypedefs].
+   * The set of function types that checked, both explicity through tests of
+   * typedefs and implicitly through type annotations in checked mode.
    */
-  Set<TypedefElement> checkedTypedefs;
+  Set<FunctionType> checkedFunctionTypes;
+
+  Map<ClassElement, Set<FunctionType>> checkedGenericFunctionTypes =
+      new Map<ClassElement, Set<FunctionType>>();
+
+  Set<FunctionType> checkedNonGenericFunctionTypes =
+      new Set<FunctionType>();
+
+  void registerDynamicFunctionTypeCheck(FunctionType functionType) {
+    ClassElement classElement = Types.getClassContext(functionType);
+    if (classElement != null) {
+      checkedGenericFunctionTypes.putIfAbsent(classElement,
+          () => new Set<FunctionType>()).add(functionType);
+    } else {
+      checkedNonGenericFunctionTypes.add(functionType);
+    }
+  }
 
   final bool generateSourceMap;
 
   Iterable<ClassElement> cachedClassesUsingTypeVariableTests;
 
   Iterable<ClassElement> get classesUsingTypeVariableTests {
     if (cachedClassesUsingTypeVariableTests == null) {
       cachedClassesUsingTypeVariableTests = compiler.codegenWorld.isChecks
           .where((DartType t) => t is TypeVariableType)
           .map((TypeVariableType v) => v.element.getEnclosingClass())
@@ skipping 10 matching lines @@
         constantEmitter = new ConstantEmitter(compiler, namer),
         super(compiler) {
     nativeEmitter = new NativeEmitter(this);
   }
 
   void addComment(String comment, CodeBuffer buffer) {
     buffer.write(jsAst.prettyPrint(js.comment(comment), compiler));
   }
 
   void computeRequiredTypeChecks() {
-    assert(checkedClasses == null && checkedTypedefs == null);
+    assert(checkedClasses == null && checkedFunctionTypes == null);
 
     backend.rti.addImplicitChecks(compiler.codegenWorld,
                                   classesUsingTypeVariableTests);
 
     checkedClasses = new Set<ClassElement>();
-    checkedTypedefs = new Set<TypedefElement>();
+    checkedFunctionTypes = new Set<FunctionType>();
     compiler.codegenWorld.isChecks.forEach((DartType t) {
-      if (t is InterfaceType) {
-        checkedClasses.add(t.element);
-      } else if (t is TypedefType) {
-        checkedTypedefs.add(t.element);
+      if (!t.isMalformed) {
+        if (t is InterfaceType) {
+          checkedClasses.add(t.element);
+        } else if (t is FunctionType) {
+          checkedFunctionTypes.add(t);
+        }
       }
     });
   }
 
   ClassElement computeMixinClass(MixinApplicationElement mixinApplication) {
     ClassElement mixin = mixinApplication.mixin;
     while (mixin.isMixinApplication) {
       mixinApplication = mixin;
       mixin = mixinApplication.mixin;
     }
@@ skipping 1115 matching lines @@
 
     void generateIsTest(Element other) {
       if (other == compiler.objectClass && other != classElement) {
         // Avoid emitting [:$isObject:] on all classes but [Object].
         return;
       }
       other = backend.getImplementationClass(other);
       builder.addProperty(namer.operatorIs(other), js('true'));
     }
 
+    void generateIsFunctionTypeTest(FunctionType type) {
+      String operator = namer.operatorIsType(type);
+      builder.addProperty(operator, new jsAst.LiteralBool(true));
+    }
+
+    void generateFunctionTypeSignature(Element method, FunctionType type) {
+      assert(method.isImplementation);
+      String thisAccess = 'this';
+      Node node = method.parseNode(compiler);
+      ClosureClassMap closureData =
+          compiler.closureToClassMapper.closureMappingCache[node];
+      if (closureData != null) {
+        Element thisElement =
+            closureData.freeVariableMapping[closureData.thisElement];
+        if (thisElement != null) {
+          String thisName = backend.namer.getName(thisElement);
+          thisAccess = 'this.$thisName';
+        }
+      }
+      RuntimeTypes rti = backend.rti;
+      String encoding = rti.getSignatureEncoding(type, () => '$thisAccess');
+      String operatorSignature = namer.operatorSignature();
+      builder.addProperty(operatorSignature,
+          new jsAst.LiteralExpression(encoding));
+    }
+
     void generateSubstitution(Element other, {bool emitNull: false}) {
       RuntimeTypes rti = backend.rti;
-      // TODO(karlklose): support typedefs with variables.
       jsAst.Expression expression;
       bool needsNativeCheck = nativeEmitter.requiresNativeIsCheck(other);
       if (other.kind == ElementKind.CLASS) {
         String substitution = rti.getSupertypeSubstitution(classElement, other,
             alwaysGenerateFunction: true);
         if (substitution != null) {
           expression = new jsAst.LiteralExpression(substitution);
         } else if (emitNull || needsNativeCheck) {
           expression = new jsAst.LiteralNull();
         }
       }
       if (expression != null) {
         builder.addProperty(namer.substitutionName(other), expression);
       }
     }
 
-    generateIsTestsOn(classElement, generateIsTest, generateSubstitution);
+    generateIsTestsOn(classElement, generateIsTest,
+        generateIsFunctionTypeTest, generateFunctionTypeSignature,
+        generateSubstitution);
   }
 
   void emitRuntimeTypeSupport(CodeBuffer buffer) {
     RuntimeTypes rti = backend.rti;
     TypeChecks typeChecks = rti.requiredChecks;
 
     // Add checks to the constructors of instantiated classes.
     for (ClassElement cls in typeChecks) {
       String holder = namer.isolateAccess(backend.getImplementationClass(cls));
       for (TypeCheck check in typeChecks[cls]) {
         ClassElement cls = check.cls;
         buffer.write('$holder.${namer.operatorIs(cls)}$_=${_}true$N');
         Substitution substitution = check.substitution;
         if (substitution != null) {
           String body = substitution.getCode(rti, false);
           buffer.write('$holder.${namer.substitutionName(cls)}$_=${_}$body$N');
         }
       };
     }
+
+    void addSignature(FunctionType type) {
+      String encoding = rti.getTypeEncoding(type);
+      buffer.add('${namer.signatureName(type)}$_=${_}$encoding$N');
+    }
+
+    checkedNonGenericFunctionTypes.forEach(addSignature);
+
+    checkedGenericFunctionTypes.forEach((_, Set<FunctionType> functionTypes) {
+      functionTypes.forEach(addSignature);
+    });
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [classElement] must be a declaration element.
    */
   void visitClassFields(ClassElement classElement,
                         void addField(Element member,
                                       String name,
@@ skipping 111 matching lines @@
   }
 
   void generateCheckedSetter(Element member,
                              String fieldName,
                              String accessorName,
                              ClassBuilder builder) {
     assert(canGenerateCheckedSetter(member));
     DartType type = member.computeType(compiler);
     // TODO(ahe): Generate a dynamic type error here.
     if (type.element.isErroneous()) return;
-    FunctionElement helperElement
-        = backend.getCheckedModeHelper(type, typeCast: false);
+    type = type.unalias(compiler);
+    CheckedModeHelper helper =
+        backend.getCheckedModeHelper(type, typeCast: false);
+    FunctionElement helperElement = helper.getElement(compiler);
     String helperName = namer.isolateAccess(helperElement);
     List<jsAst.Expression> arguments = <jsAst.Expression>[js('v')];
     if (helperElement.computeSignature(compiler).parameterCount != 1) {
-      arguments.add(js.string(namer.operatorIs(type.element)));
+      arguments.add(js.string(namer.operatorIsType(type)));
     }
 
     String setterName = namer.setterNameFromAccessorName(accessorName);
     String receiver = backend.isInterceptorClass(member.getEnclosingClass())
         ? 'receiver' : 'this';
     List<String> args = backend.isInterceptedMethod(member)
         ? ['receiver', 'v']
         : ['v'];
     builder.addProperty(setterName,
         js.fun(args,
@@ skipping 220 matching lines @@
     return arity;
   }
 
   int _compareSelectorNames(Selector selector1, Selector selector2) {
     String name1 = selector1.name.toString();
     String name2 = selector2.name.toString();
     if (name1 != name2) return Comparable.compare(name1, name2);
     return _selectorRank(selector1) - _selectorRank(selector2);
   }
 
-  Iterable<Element> getTypedefChecksOn(DartType type) {
-    bool isSubtype(TypedefElement typedef) {
-      FunctionType typedefType =
-          typedef.computeType(compiler).unalias(compiler);
-      return compiler.types.isSubtype(type, typedefType);
+  /**
+   * Returns a mapping containing all checked function types for which [type]
+   * can be a subtype. A function type is mapped to [:true:] if [type] is
+   * statically known to be a subtype of it and to [:false:] if [type] might
+   * be a subtype, provided with the right type arguments.
+   */
+  // TODO(johnniwinther): Change to return a mapping from function types to
+  // a set of variable points and use this to detect statically/dynamically
+  // known subtype relations.
+  Map<FunctionType, bool> getFunctionTypeChecksOn(DartType type) {
+    Map<FunctionType, bool> functionTypeMap =
+        new LinkedHashMap<FunctionType, bool>();
+    for (FunctionType functionType in checkedFunctionTypes) {
+      if (compiler.types.isSubtype(type, functionType)) {
+        functionTypeMap[functionType] = true;
+      } else if (compiler.types.isPotentialSubtype(type, functionType)) {
+        functionTypeMap[functionType] = false;
+      }
     }
-    return checkedTypedefs.where(isSubtype).toList()
-        ..sort(Elements.compareByPosition);
+    // TODO(johnniwinther): Ensure stable ordering of the keys.
+    return functionTypeMap;
   }
 
   /**
    * Generate "is tests" for [cls]: itself, and the "is tests" for the
    * classes it implements and type argument substitution functions for these
    * tests.   We don't need to add the "is tests" of the super class because
    * they will be inherited at runtime, but we may need to generate the
    * substitutions, because they may have changed.
    */
   void generateIsTestsOn(ClassElement cls,
                          void emitIsTest(Element element),
-                         void emitSubstitution(Element element, {emitNull})) {
+                         FunctionTypeTestEmitter emitIsFunctionTypeTest,
+                         FunctionTypeSignatureEmitter emitFunctionTypeSignature,
+                         SubstitutionEmitter emitSubstitution) {
     if (checkedClasses.contains(cls)) {
       emitIsTest(cls);
       emitSubstitution(cls);
     }
 
     RuntimeTypes rti = backend.rti;
     ClassElement superclass = cls.superclass;
 
     bool haveSameTypeVariables(ClassElement a, ClassElement b) {
       if (a.isClosure()) return true;
       return a.typeVariables == b.typeVariables;
     }
 
     if (superclass != null && superclass != compiler.objectClass &&
         !haveSameTypeVariables(cls, superclass)) {
       // We cannot inherit the generated substitutions, because the type
       // variable layout for this class is different.  Instead we generate
       // substitutions for all checks and make emitSubstitution a NOP for the
       // rest of this function.
       Set<ClassElement> emitted = new Set<ClassElement>();
       // TODO(karlklose): move the computation of these checks to
       // RuntimeTypeInformation.
-      if (backend.needsRti(cls)) {
+      if (backend.classNeedsRti(cls)) {
         emitSubstitution(superclass, emitNull: true);
         emitted.add(superclass);
       }
       for (DartType supertype in cls.allSupertypes) {
         ClassElement superclass = supertype.element;
         if (classesUsingTypeVariableTests.contains(superclass)) {
           emitSubstitution(superclass, emitNull: true);
           emitted.add(superclass);
         }
         for (ClassElement check in checkedClasses) {
           if (supertype.element == check && !emitted.contains(check)) {
             // Generate substitution.  If no substitution is necessary, emit
             // [:null:] to overwrite a (possibly) existing substitution from the
             // super classes.
             emitSubstitution(check, emitNull: true);
             emitted.add(check);
           }
         }
       }
       void emitNothing(_, {emitNull}) {};
       emitSubstitution = emitNothing;
     }
 
     Set<Element> generated = new Set<Element>();
     // A class that defines a [:call:] method implicitly implements
     // [Function] and needs checks for all typedefs that are used in is-checks.
     if (checkedClasses.contains(compiler.functionClass) ||
-        !checkedTypedefs.isEmpty) {
+        !checkedFunctionTypes.isEmpty) {
       Element call = cls.lookupLocalMember(Compiler.CALL_OPERATOR_NAME);
       if (call == null) {
         // If [cls] is a closure, it has a synthetic call operator method.
         call = cls.lookupBackendMember(Compiler.CALL_OPERATOR_NAME);
       }
       if (call != null && call.isFunction()) {
         generateInterfacesIsTests(compiler.functionClass,
                                   emitIsTest,
                                   emitSubstitution,
                                   generated);
-        getTypedefChecksOn(call.computeType(compiler)).forEach(emitIsTest);
-      }
+        FunctionType callType = call.computeType(compiler);
+        Map<FunctionType, bool> functionTypeChecks =
+            getFunctionTypeChecksOn(callType);
+        generateFunctionTypeTests(call, callType, functionTypeChecks,
+            emitFunctionTypeSignature, emitIsFunctionTypeTest);
+     }
     }
 
     for (DartType interfaceType in cls.interfaces) {
       generateInterfacesIsTests(interfaceType.element, emitIsTest,
                                 emitSubstitution, generated);
     }
   }
 
   /**
    * Generate "is tests" where [cls] is being implemented.
    */
   void generateInterfacesIsTests(ClassElement cls,
                                  void emitIsTest(ClassElement element),
-                                 void emitSubstitution(ClassElement element),
+                                 SubstitutionEmitter emitSubstitution,
                                  Set<Element> alreadyGenerated) {
     void tryEmitTest(ClassElement check) {
       if (!alreadyGenerated.contains(check) && checkedClasses.contains(check)) {
         alreadyGenerated.add(check);
         emitIsTest(check);
         emitSubstitution(check);
       }
     };
 
     tryEmitTest(cls);
 
     for (DartType interfaceType in cls.interfaces) {
       Element element = interfaceType.element;
       tryEmitTest(element);
       generateInterfacesIsTests(element, emitIsTest, emitSubstitution,
                                 alreadyGenerated);
     }
 
     // We need to also emit "is checks" for the superclass and its supertypes.
     ClassElement superclass = cls.superclass;
     if (superclass != null) {
       tryEmitTest(superclass);
       generateInterfacesIsTests(superclass, emitIsTest, emitSubstitution,
                                 alreadyGenerated);
     }
   }
 
+  const int MAX_FUNCTION_TYPE_PREDICATES = 10;
+
+  /**
+   * Generates function type checks on [method] with type [methodType] against
+   * the function type checks in [functionTypeChecks].
+   */
+  void generateFunctionTypeTests(
+      Element method,
+      FunctionType methodType,
+      Map<FunctionType, bool> functionTypeChecks,
+      FunctionTypeSignatureEmitter emitFunctionTypeSignature,
+      FunctionTypeTestEmitter emitIsFunctionTypeTest) {
+    bool hasDynamicFunctionTypeCheck = false;
+    int neededPredicates = 0;
+    functionTypeChecks.forEach((FunctionType functionType, bool knownSubtype) {
+      if (!knownSubtype) {
+        registerDynamicFunctionTypeCheck(functionType);
+        hasDynamicFunctionTypeCheck = true;
+      } else {
+        neededPredicates++;
+      }
+    });
+    bool alwaysUseSignature = false;
+    if (hasDynamicFunctionTypeCheck ||
+        neededPredicates > MAX_FUNCTION_TYPE_PREDICATES) {
+      emitFunctionTypeSignature(method, methodType);
+      alwaysUseSignature = true;
+    }
+    functionTypeChecks.forEach((FunctionType functionType, bool knownSubtype) {
+      if (knownSubtype) {
+        if (alwaysUseSignature) {
+          registerDynamicFunctionTypeCheck(functionType);
+        } else {
+          emitIsFunctionTypeTest(functionType);
+        }
+      }
+    });
+  }
+
   /**
    * Return a function that returns true if its argument is a class
    * that needs to be emitted.
    */
   Function computeClassFilter() {
     Set<ClassElement> unneededClasses = new Set<ClassElement>();
     // The [Bool] class is not marked as abstract, but has a factory
     // constructor that always throws. We never need to emit it.
     unneededClasses.add(compiler.boolClass);
 
@@ skipping 142 matching lines @@
       ClassBuilder closureBuilder = new ClassBuilder();
       // If a static function is used as a closure we need to add its name
       // in case it is used in spawnFunction.
       String methodName = namer.STATIC_CLOSURE_NAME_NAME;
       emitClosureClassHeader(
           mangledName, superName, <String>[invocationName, methodName],
           closureBuilder);
 
       addParameterStubs(callElement, closureBuilder.addProperty);
 
-      DartType type = element.computeType(compiler);
-      getTypedefChecksOn(type).forEach((Element typedef) {
-        String operator = namer.operatorIs(typedef);
-        closureBuilder.addProperty(operator, js('true'));
-      });
-
       // TODO(ngeoffray): Cache common base classes for closures, bound
       // closures, and static closures that have common type checks.
       boundClosures.add(
           js('$classesCollector.$mangledName = #',
               closureBuilder.toObjectInitializer()));
 
       staticGetters[element] = closureClassElement;
+
+      void emitFunctionTypeSignature(Element method, FunctionType methodType) {
+        RuntimeTypes rti = backend.rti;
+        // [:() => null:] is dummy encoding of [this] which is never needed for
+        // the encoding of the type of the static [method].
+        String encoding = rti.getSignatureEncoding(methodType, () => 'null');
+        String operatorSignature = namer.operatorSignature();
+        // TODO(johnniwinther): Make MiniJsParser support function expressions.
+        closureBuilder.addProperty(operatorSignature,
+            new jsAst.LiteralExpression(encoding));
+      }
+
+      void emitIsFunctionTypeTest(FunctionType functionType) {
+        String operator = namer.operatorIsType(functionType);
+        closureBuilder.addProperty(operator, js('true'));
+      }
+
+      FunctionType methodType = element.computeType(compiler);
+      Map<FunctionType, bool> functionTypeChecks =
+          getFunctionTypeChecksOn(methodType);
+      generateFunctionTypeTests(element, methodType, functionTypeChecks,
+          emitFunctionTypeSignature, emitIsFunctionTypeTest);
     }
   }
 
   void emitClosureClassHeader(String mangledName,
                               String superName,
                               List<String> fieldNames,
                               ClassBuilder builder) {
     builder.addProperty('',
         js.string("$superName;${fieldNames.join(',')}"));
   }
@@ skipping 37 matching lines @@
     if (inInterceptor) {
       cache = interceptorClosureCache;
     } else {
       cache = boundClosureCache;
     }
     List<String> fieldNames = <String>[];
     compiler.boundClosureClass.forEachInstanceField((_, Element field) {
       fieldNames.add(namer.getName(field));
     });
 
-    Iterable<Element> typedefChecks =
-        getTypedefChecksOn(member.computeType(compiler));
-    bool hasTypedefChecks = !typedefChecks.isEmpty;
+    DartType memberType = member.computeType(compiler);
+    Map<FunctionType, bool> functionTypeChecks =
+        getFunctionTypeChecksOn(memberType);
+    bool hasFunctionTypeChecks = !functionTypeChecks.isEmpty;
 
-    bool canBeShared = !hasOptionalParameters && !hasTypedefChecks;
+    bool canBeShared = !hasOptionalParameters && !hasFunctionTypeChecks;
 
+    ClassElement classElement = member.getEnclosingClass();
     String closureClass = canBeShared ? cache[parameterCount] : null;
     if (closureClass == null) {
       // Either the class was not cached yet, or there are optional parameters.
       // Create a new closure class.
       String name;
       if (canBeShared) {
         if (inInterceptor) {
           name = 'BoundClosure\$i${parameterCount}';
         } else {
           name = 'BoundClosure\$${parameterCount}';
@@ skipping 35 matching lines @@
         arguments.add(js(name));
       }
 
       jsAst.Expression fun = js.fun(
           parameters,
           js.return_(
               js('this')[fieldNames[0]][js('this')[fieldNames[1]]](arguments)));
       boundClosureBuilder.addProperty(invocationName, fun);
 
       addParameterStubs(callElement, boundClosureBuilder.addProperty);
-      typedefChecks.forEach((Element typedef) {
-        String operator = namer.operatorIs(typedef);
-        boundClosureBuilder.addProperty(operator, js('true'));
-      });
+
+      void emitFunctionTypeSignature(Element method, FunctionType methodType) {
+        String encoding = backend.rti.getSignatureEncoding(
+            methodType, () => 'this.${fieldNames[0]}');
+        String operatorSignature = namer.operatorSignature();
+        boundClosureBuilder.addProperty(operatorSignature,
+            new jsAst.LiteralExpression(encoding));
+      }
+
+      void emitIsFunctionTypeTest(FunctionType functionType) {
+        String operator = namer.operatorIsType(functionType);
+        boundClosureBuilder.addProperty(operator,
+            new jsAst.LiteralBool(true));
+      }
+
+      generateFunctionTypeTests(member, memberType, functionTypeChecks,
+          emitFunctionTypeSignature, emitIsFunctionTypeTest);
 
       boundClosures.add(
           js('$classesCollector.$mangledName = #',
               boundClosureBuilder.toObjectInitializer()));
 
       closureClass = namer.isolateAccess(closureClassElement);
 
       // Cache it.
       if (canBeShared) {
         cache[parameterCount] = closureClass;
@@ skipping 11 matching lines @@
     if (inInterceptor) {
       String receiverArg = fieldNames[2];
       parameters.add(receiverArg);
       arguments.add(js(receiverArg));
     } else {
       // Put null in the intercepted receiver field.
       arguments.add(new jsAst.LiteralNull());
     }
 
     jsAst.Expression getterFunction = js.fun(
-        parameters,
-        js.return_(js(closureClass).newWith(arguments)));
+        parameters, js.return_(js(closureClass).newWith(arguments)));
 
     defineStub(getterName, getterFunction);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [member] must be a declaration element.
    */
   void emitCallStubForGetter(Element member,
@@ skipping 19 matching lines @@
             ? member.fixedBackendName()
             : namer.instanceFieldName(member);
         return js('this')[fieldName];
       }
     }
 
     // Two selectors may match but differ only in type.  To avoid generating
     // identical stubs for each we track untyped selectors which already have
     // stubs.
     Set<Selector> generatedSelectors = new Set<Selector>();
-
     for (Selector selector in selectors) {
       if (selector.applies(member, compiler)) {
         selector = selector.asUntyped;
         if (generatedSelectors.contains(selector)) continue;
         generatedSelectors.add(selector);
 
         String invocationName = namer.invocationName(selector);
         Selector callSelector = new Selector.callClosureFrom(selector);
         String closureCallName = namer.invocationName(callSelector);
 
@@ skipping 584 matching lines @@
     });
 
     // 3b. Add classes that are referenced by substitutions in object checks and
     //     their superclasses.
     TypeChecks requiredChecks =
         backend.rti.computeChecks(neededClasses, checkedClasses);
     Set<ClassElement> classesUsedInSubstitutions =
         rti.getClassesUsedInSubstitutions(backend, requiredChecks);
     addClassesWithSuperclasses(classesUsedInSubstitutions);
 
+    // 3c. Add classes that contain checked generic function types. These are
+    //     needed to store the signature encoding.
+    for (FunctionType type in checkedFunctionTypes) {
+      ClassElement contextClass = Types.getClassContext(type);
+      if (contextClass != null) {
+        neededClasses.add(contextClass);
+      }
+    }
+
     // 4. Finally, sort the classes.
     List<ClassElement> sortedClasses = Elements.sortedByPosition(neededClasses);
 
     // If we need noSuchMethod support, we run through all needed
     // classes to figure out if we need the support on any native
     // class. If so, we let the native emitter deal with it.
     if (compiler.enabledNoSuchMethod) {
       SourceString noSuchMethodName = Compiler.NO_SUCH_METHOD;
       Selector noSuchMethodSelector = compiler.noSuchMethodSelector;
       for (ClassElement element in sortedClasses) {
@@ skipping 631 matching lines @@
 
 const String HOOKS_API_USAGE = """
 // The code supports the following hooks:
 // dartPrint(message)   - if this function is defined it is called
 //                        instead of the Dart [print] method.
 // dartMainRunner(main) - if this function is defined, the Dart [main]
 //                        method will not be invoked directly.
 //                        Instead, a closure that will invoke [main] is
 //                        passed to [dartMainRunner].
 """;