Support runtime check of function types.

sdk/lib/_internal/compiler/implementation/js_backend/backend.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;
 
 typedef void Recompile(Element element);
 
 class ReturnInfo {
   HType returnType;
@@ skipping 1052 matching lines @@
   }
 
   void registerSetRuntimeType(TreeElements elements) {
     enqueueInResolution(getSetRuntimeTypeInfo(), elements);
   }
 
   void registerGetRuntimeTypeArgument(TreeElements elements) {
     enqueueInResolution(getGetRuntimeTypeArgument(), elements);
   }
 
+  void registerGenericClosure(Enqueuer enqueuer, TreeElements elements) {
+    enqueue(enqueuer, getSetRuntimeTypeInfo(), elements);
+    enqueue(enqueuer, getGetRuntimeTypeInfo(), elements);
+    enqueue(enqueuer, getForwardRuntimeTypeInfo(), elements);
+    enqueuer.registerInstantiatedClass(compiler.listClass, elements);
+  }
+
   void registerRuntimeType(TreeElements elements) {
     enqueueInResolution(getSetRuntimeTypeInfo(), elements);
     enqueueInResolution(getGetRuntimeTypeInfo(), elements);
     enqueueInResolution(getGetRuntimeTypeArgument(), elements);
     compiler.enqueuer.resolution.registerInstantiatedClass(
         compiler.listClass, elements);
   }
 
   void registerTypeVariableExpression(TreeElements elements) {
     registerRuntimeType(elements);
     enqueueInResolution(getRuntimeTypeToString(), elements);
     enqueueInResolution(getCreateRuntimeType(), elements);
   }
 
   void registerIsCheck(DartType type, Enqueuer world, TreeElements elements) {
+    if (type.isMalformed) {
+      registerThrowRuntimeError(elements);
+      return;
+    }
     world.registerInstantiatedClass(compiler.boolClass, elements);
     bool isTypeVariable = type.kind == TypeKind.TYPE_VARIABLE;
-    if (!type.isRaw || isTypeVariable) {
+    if (!type.isRaw || type.containsTypeVariables) {
       enqueueInResolution(getSetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeInfo(), elements);
       enqueueInResolution(getGetRuntimeTypeArgument(), elements);
       enqueueInResolution(getCheckArguments(), elements);
       if (isTypeVariable) {
         enqueueInResolution(getGetObjectIsSubtype(), elements);
       }
       world.registerInstantiatedClass(compiler.listClass, elements);
     }
+    if (type is FunctionType) {
+      enqueueInResolution(getCheckFunctionSubtype(), elements);
+    }
     // [registerIsCheck] is also called for checked mode checks, so we
     // need to register checked mode helpers.
     if (compiler.enableTypeAssertions) {
       Element e = getCheckedModeHelper(type, typeCast: false);
       if (e != null) world.addToWorkList(e);
       // We also need the native variant of the check (for DOM types).
       e = getNativeCheckedModeHelper(type, typeCast: false);
       if (e != null) world.addToWorkList(e);
     }
     if (type.element.isNative()) {
@@ skipping 31 matching lines @@
 
   void registerSuperNoSuchMethod(TreeElements elements) {
     enqueueInResolution(getCreateInvocationMirror(), elements);
     enqueueInResolution(
         compiler.objectClass.lookupLocalMember(Compiler.NO_SUCH_METHOD),
         elements);
     compiler.enqueuer.resolution.registerInstantiatedClass(
         compiler.listClass, elements);
   }
 
+  void enqueue(Enqueuer enqueuer, Element e, TreeElements elements) {
+    enqueuer.addToWorkList(e);
+    elements.registerDependency(e);
+  }
+
   void enqueueInResolution(Element e, TreeElements elements) {
     if (e == null) return;
     ResolutionEnqueuer enqueuer = compiler.enqueuer.resolution;
-    enqueuer.addToWorkList(e);
-    elements.registerDependency(e);
+    enqueue(enqueuer, e, elements);
   }
 
   void registerConstantMap(TreeElements elements) {
     Element e = compiler.findHelper(const SourceString('ConstantMap'));
     if (e != null) {
       compiler.enqueuer.resolution.registerInstantiatedClass(e, elements);
     }
     e = compiler.findHelper(const SourceString('ConstantProtoMap'));
     if (e != null) {
       compiler.enqueuer.resolution.registerInstantiatedClass(e, elements);
@@ skipping 374 matching lines @@
   }
 
   Element getMapMaker() {
     return compiler.findHelper(const SourceString('makeLiteralMap'));
   }
 
   Element getSetRuntimeTypeInfo() {
     return compiler.findHelper(const SourceString('setRuntimeTypeInfo'));
   }
 
+  Element getForwardRuntimeTypeInfo() {
+    return compiler.findHelper(const SourceString('forwardRuntimeTypeInfo'));
+  }
+
   Element getGetRuntimeTypeInfo() {
     return compiler.findHelper(const SourceString('getRuntimeTypeInfo'));
   }
 
   Element getGetRuntimeTypeArgument() {
     return compiler.findHelper(const SourceString('getRuntimeTypeArgument'));
   }
 
   Element getRuntimeTypeToString() {
     return compiler.findHelper(const SourceString('runtimeTypeToString'));
   }
 
   Element getCheckArguments() {
     return compiler.findHelper(const SourceString('checkArguments'));
   }
 
   Element getGetObjectIsSubtype() {
     return compiler.findHelper(const SourceString('objectIsSubtype'));
   }
 
+  Element getCheckFunctionSubtype() {
+    return compiler.findHelper(const SourceString('checkFunctionSubtype'));
+  }
+
   Element getThrowNoSuchMethod() {
     return compiler.findHelper(const SourceString('throwNoSuchMethod'));
   }
 
   Element getCreateRuntimeType() {
     return compiler.findHelper(const SourceString('createRuntimeType'));
   }
 
   Element getFallThroughError() {
     return compiler.findHelper(const SourceString("getFallThroughError"));
@@ skipping 32 matching lines @@
   ClassElement get constListImplementation => jsArrayClass;
   ClassElement get fixedListImplementation => jsFixedArrayClass;
   ClassElement get growableListImplementation => jsExtendableArrayClass;
   ClassElement get mapImplementation => mapLiteralClass;
   ClassElement get constMapImplementation => constMapLiteralClass;
   ClassElement get functionImplementation => jsFunctionClass;
   ClassElement get typeImplementation => typeLiteralClass;
   ClassElement get boolImplementation => jsBoolClass;
   ClassElement get nullImplementation => jsNullClass;
 }