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 2228 matching lines @@
     world.registerStaticUse(helper);
     String helperName = backend.namer.isolateAccess(helper);
     push(new js.Call(new js.VariableUse(helperName), arguments));
     if (negative) push(new js.Prefix('!', pop()));
   }
 
   void checkType(HInstruction input, DartType type, {bool negative: false}) {
     assert(invariant(input, !type.isMalformed,
                      message: 'Attempt to check malformed type $type'));
     Element element = type.element;
-
     if (element == backend.jsArrayClass) {
       checkArray(input, negative ? '!==': '===');
       return;
     } else if (element == backend.jsMutableArrayClass) {
       if (negative) {
         checkImmutableArray(input);
       } else {
         checkMutableArray(input);
       }
       return;
@@ skipping 282 matching lines @@
     assert(node.isCheckedModeCheck || node.isCastTypeCheck);
     DartType type = node.typeExpression;
     if (type.kind == TypeKind.FUNCTION) {
       // TODO(5022): We currently generate $isFunction checks for
       // function types.
       world.registerIsCheck(
           compiler.functionClass.computeType(compiler), work.resolutionTree);
     }
     world.registerIsCheck(type, work.resolutionTree);
 
+    CheckedModeHelper helper;
     FunctionElement helperElement;
     if (node.isBooleanConversionCheck) {
-      helperElement =
-          compiler.findHelper(const SourceString('boolConversionCheck'));
+      helper =
+          const CheckedModeHelper(const SourceString('boolConversionCheck'));
     } else {
-      helperElement = backend.getCheckedModeHelper(type,
-          typeCast: node.isCastTypeCheck);
+      helper =
+          backend.getCheckedModeHelper(type, typeCast: node.isCastTypeCheck);
     }
-    world.registerStaticUse(helperElement);
+
+    push(helper.generateCall(this, node));
+    /*world.registerStaticUse(helper.getElement(compiler));
     List<js.Expression> arguments = <js.Expression>[];
     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 (node.typeExpression.kind == TypeKind.TYPE_VARIABLE) {
       assert(parameterCount == 2);
       use(node.typeRepresentation);
       arguments.add(pop());
     } else if (parameterCount == 2) {
       // 2 arguments implies that the method is either [propertyTypeCheck],
       // [propertyTypeCast] or [assertObjectIsSubtype].
       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 if (parameterCount == 4) {
       Element element = type.element;
       String isField = backend.namer.operatorIs(element);
       arguments.add(js.string(isField));
       use(node.typeRepresentation);
       arguments.add(pop());
       String asField = backend.namer.substitutionName(element);
       arguments.add(js.string(asField));
     } else {
       assert(!type.isMalformed);
       // No additional arguments needed.
     }
     String helperName = backend.namer.isolateAccess(helperElement);
-    push(new js.Call(new js.VariableUse(helperName), arguments));
+    push(new js.Call(new js.VariableUse(helperName), arguments));*/
   }
 }
 
 class SsaOptimizedCodeGenerator extends SsaCodeGenerator {
   SsaOptimizedCodeGenerator(backend, work) : super(backend, work);
 
   HBasicBlock beginGraph(HGraph graph) {
     return graph.entry;
   }
 
@@ skipping 427 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }