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

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

 // Copyright (c) 2013, 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 dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 346 matching lines @@
                     List<Primitive> args,
                     Continuation cont)
       : arguments = _referenceList(args),
         continuation = new Reference<Continuation>(cont);
 
   accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
 }
 
 /// An "is" type test.
 ///
-/// Returns `true` if [value] not `null` and is an instance of [type].
+/// Returns `true` if [value] is an instance of [type].
 ///
 /// [type] must not be the [Object], `dynamic` or [Null] types (though it might
 /// be a type variable containing one of these types). This design is chosen
 /// to simplify code generation for type tests.
 class TypeTest extends Primitive {
   Reference<Primitive> value;
   final DartType type;
 
   /// If [type] is an [InterfaceType], this holds the internal representation of
   /// the type arguments to [type]. Since these may reference type variables
   /// from the enclosing class, they are not constant.
   ///
   /// If [type] is a [TypeVariableType], this is a singleton list with
   /// the internal representation of the type held in that type variable.
   ///
+  /// If [type] is a [FunctionType], this is a singleton list with the
+  /// internal representation of that type,
+  ///
   /// Otherwise the list is empty.
   final List<Reference<Primitive>> typeArguments;
 
   TypeTest(Primitive value,
            this.type,
            List<Primitive> typeArguments)
   : this.value = new Reference<Primitive>(value),
     this.typeArguments = _referenceList(typeArguments);
 
   accept(Visitor visitor) => visitor.visitTypeTest(this);
 }
 
 /// An "as" type cast.
 ///
 /// If [value] is `null` or is an instance of [type], [continuation] is invoked
 /// with [value] as argument. Otherwise, a [CastError] is thrown.
 ///
 /// Discussion:
 /// The parameter to [continuation] is redundant since it will always equal
 /// [value], which is typically in scope in the continuation. However, it might
 /// simplify type propagation, since a better type can be computed for the
 /// continuation parameter without needing flow-sensitive analysis.
 class TypeCast extends Expression {
   Reference<Primitive> value;
   final DartType type;
 
-  /// If [type] is an [InterfaceType], this holds the internal representation of
-  /// the type arguments to [type]. Since these may reference type variables
-  /// from the enclosing class, they are not constant.
-  ///
-  /// If [type] is a [TypeVariableType], this is a singleton list with
-  /// the internal representation of the type held in that type variable.
-  ///
-  /// Otherwise the list is empty.
+  /// See the corresponding field on [TypeTest].
   final List<Reference<Primitive>> typeArguments;
   final Reference<Continuation> continuation;
 
   TypeCast(Primitive value,
            this.type,
            List<Primitive> typeArguments,
            Continuation cont)
       : this.value = new Reference<Primitive>(value),
         this.typeArguments = _referenceList(typeArguments),
         this.continuation = new Reference<Continuation>(cont);
@@ skipping 833 matching lines @@
   const RemovalVisitor();
 
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (const RemovalVisitor()).visit(node);
   }
 }