Implement dynamic function checks.

dart/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 2506 matching lines @@
     assert(type.kind != TypeKind.TYPEDEF);
     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) {
       helper =
           const CheckedModeHelper('boolConversionCheck');
     } else {
       helper =
           backend.getCheckedModeHelper(type, typeCast: node.isCastTypeCheck);
     }
 
-    push(helper.generateCall(this, node));
+    if (helper == null) {
+      assert(type.kind == TypeKind.FUNCTION);
+      use(node.inputs[0]);
+    } else {
+      push(helper.generateCall(this, node));
+    }
   }
 
   void visitTypeKnown(HTypeKnown node) {
     // [HTypeKnown] instructions are removed before generating code.
     assert(false);
   }
+
+  void visitFunctionType(HFunctionType node) {
+    FunctionType type = node.dartType;
+    int inputCount = 0;
+    use(node.inputs[inputCount++]);
+    js.Expression returnType = pop();
+
+    List<js.Expression> parameterTypes = <js.Expression>[];
+    for (var _ in type.parameterTypes) {
+      use(node.inputs[inputCount++]);
+      parameterTypes.add(pop());
+    }
+
+    List<js.Expression> optionalParameterTypes = <js.Expression>[];
+    for (var _ in type.optionalParameterTypes) {
+      use(node.inputs[inputCount++]);
+      optionalParameterTypes.add(pop());
+    }
+
+    List<js.Property> namedParameters = <js.Property>[];
+    for (var _ in type.namedParameters) {
+      use(node.inputs[inputCount++]);
+      js.Expression name = pop();
+      use(node.inputs[inputCount++]);
+      namedParameters.add(new js.Property(name, pop()));
+    }
+
+    if (namedParameters.isEmpty) {
+      var arguments = [returnType];
+      if (!parameterTypes.isEmpty || !optionalParameterTypes.isEmpty) {
+        arguments.add(new js.ArrayInitializer.from(parameterTypes));
+      }
+      if (!optionalParameterTypes.isEmpty) {
+        arguments.add(new js.ArrayInitializer.from(optionalParameterTypes));
+      }
+      push(accessHelper('buildFunctionType')(arguments));
+    } else {
+      var arguments = [
+          returnType,
+          new js.ArrayInitializer.from(parameterTypes),
+          new js.ObjectInitializer(namedParameters)];
+      push(accessHelper('buildNamedFunctionType')(arguments));
+    }
+  }
+
+  void visitReadTypeVariable(HReadTypeVariable node) {
+    TypeVariableElement element = node.dartType.element;
+    Element helperElement = compiler.findHelper('convertRtiToRuntimeType');
+    world.registerStaticUse(helperElement);
+
+    use(node.inputs[0]);
+    if (node.hasReceiver) {
+      if (backend.isInterceptorClass(element.getEnclosingClass())) {
+        int index = RuntimeTypes.getTypeVariableIndex(element);
+        js.Expression receiver = pop();
+        js.Expression helper = backend.namer.elementAccess(helperElement);
+        push(helper(js.js(r'#.$builtinTypeInfo && #.$builtinTypeInfo[#]',
+                          [receiver, receiver, js.js.toExpression(index)])));
+      } else {
+        backend.emitter.registerReadTypeVariable(element);
+        push(
+            js.js('#.${backend.namer.readTypeVariableName(element)}()', pop()));
+      }
+    } else {
+      push(
+          backend.namer.elementAccess(
+              compiler.findHelper('convertRtiToRuntimeType'))(pop()));
+    }
+  }
+
+  void visitInterfaceType(HInterfaceType node) {
+    List<js.Expression> typeArguments = <js.Expression>[];
+    for (HInstruction type in node.inputs) {
+      use(type);
+      typeArguments.add(pop());
+    }
+
+    ClassElement cls = node.dartType.element;
+    var arguments = [
+        backend.namer.elementAccess(backend.getImplementationClass(cls))];
+    if (!typeArguments.isEmpty) {
+      arguments.add(new js.ArrayInitializer.from(typeArguments));
+    }
+    push(accessHelper('buildInterfaceType')(arguments));
+  }
+
+  void visitVoidType(HVoidType node) {
+    push(accessHelper('getVoidRuntimeType')());
+  }
+
+  void visitDynamicType(HDynamicType node) {
+    push(accessHelper('getDynamicRuntimeType')());
+  }
+
+  js.PropertyAccess accessHelper(String name) {
+    Element helper = compiler.findHelper(name);
+    if (helper == null) {
+      // For mocked-up tests.
+      return js.js('(void 0).$name');
+    }
+    world.registerStaticUse(helper);
+    return backend.namer.elementAccess(helper);
+  }
 }
 
 String singleIdentityComparison(HInstruction left,
                                 HInstruction right,
                                 Compiler compiler) {
   // Returns the single identity comparison (== or ===) or null if a more
   // complex expression is required.
   if ((left.isConstant() && left.isConstantSentinel()) ||
       (right.isConstant() && right.isConstantSentinel())) return '===';
   if (left.canBeNull() && right.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (left.isPrimitive(compiler) &&
          left.instructionType == right.instructionType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }