dart2js cps: Support function types in 'is' and 'as' operators.

pkg/compiler/lib/src/js_backend/codegen/codegen.dart

 // Copyright (c) 2014, 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.
 
 library code_generator;
 
 import 'glue.dart';
 
 import '../../tree_ir/tree_ir_nodes.dart' as tree_ir;
 import '../../tree_ir/tree_ir_nodes.dart' show BuiltinOperator;
 import '../../js/js.dart' as js;
 import '../../elements/elements.dart';
 import '../../io/source_information.dart' show SourceInformation;
 import '../../util/maplet.dart';
 import '../../constants/values.dart';
 import '../../dart2jslib.dart';
 import '../../dart_types.dart';
+import '../../closure.dart' show ClosureClassElement;
 
 class CodegenBailout {
   final tree_ir.Node node;
   final String reason;
   CodegenBailout(this.node, this.reason);
   String get message {
     return 'bailout${node != null ? " on $node" : ""}: $reason';
   }
 }
 
@@ skipping 350 matching lines @@
           ? new js.ArrayInitializer(typeArguments)
           : new js.LiteralNull();
 
       js.Expression asT = glue.hasStrictSubtype(clazz)
           ? js.string(glue.getTypeSubstitutionTag(clazz))
           : new js.LiteralNull();
 
       return buildStaticHelperInvocation(
           function,
           <js.Expression>[value, isT, typeArgumentArray, asT]);
-    } else if (type is TypeVariableType) {
+    } else if (type is TypeVariableType || type is FunctionType) {
       glue.registerIsCheck(type, registry);
 
       Element function = node.isTypeTest
           ? glue.getCheckSubtypeOfRuntimeType()
           : glue.getSubtypeOfRuntimeTypeCast();
 
       // The only type argument is the type held in the type variable.
       js.Expression typeValue = typeArguments.single;
 
       return buildStaticHelperInvocation(
@@ skipping 169 matching lines @@
     accumulator.add(new js.Try(tryBlock, catchPart, null));
   }
 
   @override
   js.Expression visitCreateBox(tree_ir.CreateBox node) {
     return new js.ObjectInitializer(const <js.Property>[]);
   }
 
   @override
   js.Expression visitCreateInstance(tree_ir.CreateInstance node) {
-    ClassElement cls = node.classElement;
+    ClassElement classElement = node.classElement;
     // TODO(asgerf): To allow inlining of InvokeConstructor, CreateInstance must
     //               carry a DartType so we can register the instantiated type
     //               with its type arguments. Otherwise dataflow analysis is
     //               needed to reconstruct the instantiated type.
-    registry.registerInstantiatedClass(cls);
+    registry.registerInstantiatedClass(classElement);
+    if (classElement is ClosureClassElement) {
+      registry.registerInstantiatedClosure(classElement.methodElement);
+    }
     js.Expression instance = new js.New(
-        glue.constructorAccess(cls),
+        glue.constructorAccess(classElement),
         visitExpressionList(node.arguments));
 
     List<tree_ir.Expression> typeInformation = node.typeInformation;
     assert(typeInformation.isEmpty ||
-        typeInformation.length == cls.typeVariables.length);
+        typeInformation.length == classElement.typeVariables.length);
     if (typeInformation.isNotEmpty) {
       FunctionElement helper = glue.getAddRuntimeTypeInformation();
       js.Expression typeArguments = new js.ArrayInitializer(
           visitExpressionList(typeInformation));
       return buildStaticHelperInvocation(helper,
           <js.Expression>[instance, typeArguments]);
     } else {
       return instance;
     }
   }
@@ skipping 131 matching lines @@
         return new js.Prefix('!', args[0]);
     }
   }
 
   visitFunctionExpression(tree_ir.FunctionExpression node) {
     // FunctionExpressions are currently unused.
     // We might need them if we want to emit raw JS nested functions.
     throw 'FunctionExpressions should not be used';
   }
 }