Implement dynamic function checks.

dart/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;
 
 const VERBOSE_OPTIMIZER_HINTS = false;
 
 class JavaScriptItemCompilationContext extends ItemCompilationContext {
   final Set<HInstruction> boundsChecked = new Set<HInstruction>();
@@ skipping 71 matching lines @@
     Element element = type.element;
     String isField = codegen.backend.namer.operatorIs(element);
     arguments.add(js.string(isField));
     codegen.use(node.typeRepresentation);
     arguments.add(codegen.pop());
     String asField = codegen.backend.namer.substitutionName(element);
     arguments.add(js.string(asField));
   }
 }
 
-class FunctionTypeCheckedModeHelper extends CheckedModeHelper {
-  const FunctionTypeCheckedModeHelper(String name) : super(name);
-
-  void generateAdditionalArguments(SsaCodeGenerator codegen,
-                                   HTypeConversion node,
-                                   List<jsAst.Expression> arguments) {
-    DartType type = node.typeExpression;
-    String signatureName = codegen.backend.namer.getFunctionTypeName(type);
-    arguments.add(js.string(signatureName));
-
-    if (type.containsTypeVariables) {
-      ClassElement contextClass = Types.getClassContext(type);
-      // TODO(ahe): Creating a string here is unfortunate. It is slow (due to
-      // string concatenation in the implementation), and may prevent
-      // segmentation of '$'.
-      String contextName = codegen.backend.namer.getNameForRti(contextClass);
-      arguments.add(js.string(contextName));
-
-      if (node.contextIsTypeArguments) {
-        arguments.add(new jsAst.LiteralNull());
-        codegen.use(node.context);
-        arguments.add(codegen.pop());
-      } else {
-        codegen.use(node.context);
-        arguments.add(codegen.pop());
-      }
-    }
-  }
-}
-
 /*
  * Invariants:
  *   canInline(function) implies canInline(function, insideLoop:true)
  *   !canInline(function, insideLoop: true) implies !canInline(function)
  */
 class FunctionInlineCache {
   final Map<FunctionElement, bool> canBeInlined =
       new Map<FunctionElement, bool>();
 
   final Map<FunctionElement, bool> canBeInlinedInsideLoop =
@@ skipping 258 matching lines @@
       const PropertyCheckedModeHelper('listSuperNativeTypeCast'),
       const PropertyCheckedModeHelper('listSuperNativeTypeCheck'),
       const PropertyCheckedModeHelper('listSuperTypeCast'),
       const PropertyCheckedModeHelper('listSuperTypeCheck'),
       const PropertyCheckedModeHelper('interceptedTypeCast'),
       const PropertyCheckedModeHelper('interceptedTypeCheck'),
       const SubtypeCheckedModeHelper('subtypeCast'),
       const SubtypeCheckedModeHelper('assertSubtype'),
       const TypeVariableCheckedModeHelper('subtypeOfRuntimeTypeCast'),
       const TypeVariableCheckedModeHelper('assertSubtypeOfRuntimeType'),
-      const FunctionTypeCheckedModeHelper('functionSubtypeCast'),
-      const FunctionTypeCheckedModeHelper('assertFunctionSubtype'),
       const PropertyCheckedModeHelper('propertyTypeCast'),
       const PropertyCheckedModeHelper('propertyTypeCheck') ];
 
   // Checked mode helpers indexed by name.
   Map<String, CheckedModeHelper> checkedModeHelperByName =
       new Map<String, CheckedModeHelper>.fromIterable(
           checkedModeHelpers,
           key: (helper) => helper.name);
 
   TypeVariableHandler typeVariableHandler;
@@ skipping 647 matching lines @@
       enqueueInResolution(getCheckSubtype(), elements);
       if (isTypeVariable) {
         enqueueInResolution(getCheckSubtypeOfRuntimeType(), elements);
         if (inCheckedMode) {
           enqueueInResolution(getAssertSubtypeOfRuntimeType(), elements);
         }
       }
       enqueueClass(world, compiler.listClass, elements);
     }
     if (type is FunctionType) {
-      enqueueInResolution(getCheckFunctionSubtype(), elements);
+      enqueueInResolution(
+          compiler.findHelper('functionTypeTestMetaHelper'), elements);
     }
     if (type.element.isNative()) {
       // We will neeed to add the "$is" and "$as" properties on the
       // JavaScript object prototype, so we make sure
       // [:defineProperty:] is compiled.
       enqueue(world,
               compiler.findHelper('defineProperty'),
               elements);
     }
   }
@@ skipping 397 matching lines @@
       } else {
         if (type.kind == TypeKind.INTERFACE && !type.treatAsRaw) {
           return typeCast
               ? 'subtypeCast'
               : 'assertSubtype';
         } else if (type.kind == TypeKind.TYPE_VARIABLE) {
           return typeCast
               ? 'subtypeOfRuntimeTypeCast'
               : 'assertSubtypeOfRuntimeType';
         } else if (type.kind == TypeKind.FUNCTION) {
-          return typeCast
-              ? 'functionSubtypeCast'
-              : 'assertFunctionSubtype';
+          return null;
         } else {
           if (nativeCheck) {
             // TODO(karlklose): can we get rid of this branch when we use
             // interceptors?
             return typeCast
                 ? 'interceptedTypeCast'
                 : 'interceptedTypeCheck';
           } else {
             return typeCast
                 ? 'propertyTypeCast'
@@ skipping 114 matching lines @@
   }
 
   Element getCheckSubtypeOfRuntimeType() {
     return compiler.findHelper('checkSubtypeOfRuntimeType');
   }
 
   Element getAssertSubtypeOfRuntimeType() {
     return compiler.findHelper('assertSubtypeOfRuntimeType');
   }
 
-  Element getCheckFunctionSubtype() {
-    return compiler.findHelper('checkFunctionSubtype');
-  }
-
   Element getThrowNoSuchMethod() {
     return compiler.findHelper('throwNoSuchMethod');
   }
 
   Element getCreateRuntimeType() {
     return compiler.findHelper('createRuntimeType');
   }
 
   Element getFallThroughError() {
     return compiler.findHelper("getFallThroughError");
@@ skipping 358 matching lines @@
     copy(constant.values);
     copy(constant.protoValue);
     copy(constant);
   }
 
   void visitConstructed(ConstructedConstant constant) {
     copy(constant.fields);
     copy(constant);
   }
 }