Remove HRuntimeType implementation

pkg/compiler/lib/src/ssa/builder.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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 283 matching lines @@
       reporter.internalError(target, 'Unexpected element kind $target.');
     }
     assert(result.isValid());
     return result;
   }
 
   void addWithPosition(HInstruction instruction, ast.Node node) {
     add(attachPosition(instruction, node));
   }
 
-  HTypeConversion buildFunctionTypeConversion(
-      HInstruction original, ResolutionDartType type, int kind) {
-    HInstruction reifiedType = buildFunctionType(type);
-    return new HTypeConversion.viaMethodOnType(
-        type, kind, original.instructionType, reifiedType, original);
-  }
-
   /**
    * Returns a complete argument list for a call of [function].
    */
   List<HInstruction> completeSendArgumentsList(
       FunctionElement function,
       Selector selector,
       List<HInstruction> providedArguments,
       ast.Node currentNode) {
     assert(invariant(function, function.isImplementation));
     assert(providedArguments != null);
@@ skipping 2086 matching lines @@
             "so they cannot be tested with an `is` expression.";
       } else {
         assert(type is MalformedType);
         ErroneousElement element = type.element;
         message = element.message;
       }
       generateTypeError(node, message);
       HInstruction call = pop();
       return new HIs.compound(type, expression, call, commonMasks.boolType);
     } else if (type.isFunctionType) {
-      List arguments = [buildFunctionType(type), expression];
-      pushInvokeDynamic(
-          node,
-          new Selector.call(new PrivateName('_isTest', helpers.jsHelperLibrary),
-              CallStructure.ONE_ARG),
-          null,
-          arguments);
-      return new HIs.compound(type, expression, pop(), commonMasks.boolType);
+      HInstruction representation =
+          typeBuilder.analyzeTypeArgument(type, sourceElement);
+      List<HInstruction> inputs = <HInstruction>[
+        expression,
+        representation,
+      ];
+      pushInvokeStatic(node, helpers.functionTypeTest, inputs,
+          typeMask: commonMasks.boolType);
+      HInstruction call = pop();
+      return new HIs.compound(type, expression, call, commonMasks.boolType);
     } else if (type.isTypeVariable) {
       HInstruction runtimeType =
           typeBuilder.addTypeVariableReference(type, sourceElement);
       MethodElement helper = helpers.checkSubtypeOfRuntimeType;
       List<HInstruction> inputs = <HInstruction>[expression, runtimeType];
       pushInvokeStatic(null, helper, inputs, typeMask: commonMasks.boolType);
       HInstruction call = pop();
       return new HIs.variable(type, expression, call, commonMasks.boolType);
     } else if (RuntimeTypes.hasTypeArguments(type)) {
       ClassElement element = type.element;
@@ skipping 4297 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }