Remove HRuntimeType scheme for function types.

pkg/compiler/lib/src/js_backend/checked_mode_helpers.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.
 
 import '../common.dart';
 import '../core_types.dart';
 import '../elements/elements.dart' show ErroneousElement;
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart' show MalformedType;
 import '../elements/types.dart';
@@ skipping 71 matching lines @@
   CallStructure get callStructure => CallStructure.TWO_ARGS;
 
   void generateAdditionalArguments(SsaCodeGenerator codegen,
       HTypeConversion node, List<jsAst.Expression> arguments) {
     assert(node.typeExpression.isTypeVariable);
     codegen.use(node.typeRepresentation);
     arguments.add(codegen.pop());
   }
 }
 
+class FunctionTypeRepresentationCheckedModeHelper extends CheckedModeHelper {
+  const FunctionTypeRepresentationCheckedModeHelper(String name) : super(name);
+
+  CallStructure get callStructure => CallStructure.TWO_ARGS;
+
+  void generateAdditionalArguments(SsaCodeGenerator codegen,
+      HTypeConversion node, List<jsAst.Expression> arguments) {
+    codegen.use(node.typeRepresentation);
+    arguments.add(codegen.pop());
+  }
+}
+
 class SubtypeCheckedModeHelper extends CheckedModeHelper {
   const SubtypeCheckedModeHelper(String name) : super(name);
 
   CallStructure get callStructure => const CallStructure.unnamed(4);
 
   void generateAdditionalArguments(SsaCodeGenerator codegen,
       HTypeConversion node, List<jsAst.Expression> arguments) {
+    // TODO(sra): Move these calls into the SSA graph so that the arguments can
+    // be optimized, e,g, GVNed.
     InterfaceType type = node.typeExpression;
     ClassEntity element = type.element;
     jsAst.Name isField = codegen.backend.namer.operatorIs(element);
     arguments.add(js.quoteName(isField));
     codegen.use(node.typeRepresentation);
     arguments.add(codegen.pop());
     jsAst.Name asField = codegen.backend.namer.substitutionName(element);
     arguments.add(js.quoteName(asField));
   }
 }
@@ skipping 33 matching lines @@
     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 PropertyCheckedModeHelper('propertyTypeCast'),
     const PropertyCheckedModeHelper('propertyTypeCheck'),
+    const FunctionTypeRepresentationCheckedModeHelper('functionTypeCast'),
+    const FunctionTypeRepresentationCheckedModeHelper('functionTypeCheck'),
   ];
 
   // Checked mode helpers indexed by name.
   static final Map<String, CheckedModeHelper> checkedModeHelperByName =
       new Map<String, CheckedModeHelper>.fromIterable(helpers,
           key: (helper) => helper.name);
 
   /**
    * Returns the checked mode helper that will be needed to do a type check/type
    * cast on [type] at runtime. Note that this method is being called both by
@@ skipping 43 matching lines @@
       if (nativeCheckOnly) return null;
       return 'voidTypeCheck';
     }
 
     if (type.isTypeVariable) {
       return typeCast
           ? 'subtypeOfRuntimeTypeCast'
           : 'assertSubtypeOfRuntimeType';
     }
 
-    if (type.isFunctionType) return null;
+    if (type.isFunctionType) {
+      return typeCast ? 'functionTypeCast' : 'functionTypeCheck';
+    }
 
     assert(invariant(NO_LOCATION_SPANNABLE, type.isInterfaceType,
         message: "Unexpected type: $type"));
     InterfaceType interfaceType = type;
     ClassEntity element = interfaceType.element;
     bool nativeCheck = true;
     // TODO(13955), TODO(9731).  The test for non-primitive types should use an
     // interceptor.  The interceptor should be an argument to HTypeConversion so
     // that it can be optimized by standard interceptor optimizations.
     //  nativeCheckOnly || emitter.nativeEmitter.requiresNativeIsCheck(element);
@@ skipping 59 matching lines @@
 
     if (nativeCheck) {
       // TODO(karlklose): can we get rid of this branch when we use
       // interceptors?
       return 'intercepted$suffix';
     } else {
       return 'property$suffix';
     }
   }
 }