Support runtime check of function types.

sdk/lib/_internal/compiler/implementation/ssa/codegen.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 ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 2226 matching lines @@
     push(new js.Binary('||',
                        functionTest,
                        new js.Binary('&&', objectTest, pop())));
   }
 
   void checkType(HInstruction input, DartType type, {bool negative: false}) {
     assert(invariant(input, !type.isMalformed,
                      message: 'Attempt to check malformed type $type'));
     world.registerIsCheck(type, work.resolutionTree);
     Element element = type.element;
+    String operatorIs = backend.namer.operatorIsType(type);
     use(input);
     js.PropertyAccess field =
-        new js.PropertyAccess.field(pop(), backend.namer.operatorIs(element));
+        new js.PropertyAccess.field(pop(), operatorIs);
     if (backend.emitter.nativeEmitter.requiresNativeIsCheck(element)) {
       push(new js.Call(field, <js.Expression>[]));
       if (negative) push(new js.Prefix('!', pop()));
     } else {
       // We always negate at least once so that the result is boolified.
       push(new js.Prefix('!', field));
       // If the result is not negated, put another '!' in front.
       if (!negative) push(new js.Prefix('!', pop()));
     }
   }
@@ skipping 159 matching lines @@
       use(node.checkedInput);
       arguments.add(pop());
       int parameterCount =
           helperElement.computeSignature(compiler).parameterCount;
       // TODO(johnniwinther): Refactor this to avoid using the parameter count
       // to determine how the helper should be called.
       if (parameterCount == 2) {
         // 2 arguments implies that the method is either [propertyTypeCheck]
         // or [propertyTypeCast].
         assert(!type.isMalformed);
-        String additionalArgument = backend.namer.operatorIs(type.element);
+        String additionalArgument = backend.namer.operatorIsType(type);
         arguments.add(js.string(additionalArgument));
       } else if (parameterCount == 3) {
         // 3 arguments implies that the method is [malformedTypeCheck].
         assert(type.isMalformed);
         String reasons = Types.fetchReasonsFromMalformedType(type);
         arguments.add(js.string('$type'));
         // TODO(johnniwinther): Handle escaping correctly.
         arguments.add(js.string(reasons));
       } else {
         assert(!type.isMalformed);
@@ skipping 523 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }