Support runtime check of function types.

sdk/lib/_internal/compiler/implementation/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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 2230 matching lines @@
       if (member.isField()) {
         Element capturedLocal = nestedClosureData.capturedFieldMapping[member];
         assert(capturedLocal != null);
         capturedVariables.add(localsHandler.readLocal(capturedLocal));
       }
     });
 
     HType type = new HType.nonNullExact(
         compiler.functionClass.computeType(compiler),
         compiler);
-    push(new HForeignNew(closureClassElement, type, capturedVariables));
+    HInstruction newClosure =
+        new HForeignNew(closureClassElement, type, capturedVariables);
+    ClassElement thisClass = work.element.getEnclosingClass();

[ngeoffray, 2013/03/13 09:30:46]

thisClass can be null right? Don't you need to check it?

[Johnni Winther, 2013/03/22 07:30:24]

Stale

+    if (compiler.world.needsRti(thisClass) &&
+        callElement.computeType(compiler).containsTypeVariables) {
+      add(newClosure);
+
+      Element forwardRuntimeTypeInfo = backend.getForwardRuntimeTypeInfo();
+      HInstruction forwardRuntimeTypeInfoCall =
+          new HStatic(forwardRuntimeTypeInfo);
+      add(forwardRuntimeTypeInfoCall);
+
+      String substitutionName = backend.namer.substitutionName(thisClass);
+      HInstruction substitution =
+          createForeign('this.$substitutionName', HType.UNKNOWN, []);

[ngeoffray, 2013/03/13 09:30:46]

Change "this" to use #.

[Johnni Winther, 2013/03/22 07:30:24]

Stale

+      add(substitution);
+
+      HInstruction context = new HThis(thisClass, HType.UNKNOWN);
+      add(context);
+
+      List<HInstruction> inputs = <HInstruction>[forwardRuntimeTypeInfoCall,
+                                                 newClosure,
+                                                 substitution,
+                                                 context];
+      push(new HInvokeStatic(inputs, HType.UNKNOWN));
+    } else {
+      push(newClosure);
+    }
   }
 
   visitFunctionDeclaration(FunctionDeclaration node) {
     visit(node.function);
     localsHandler.updateLocal(elements[node], pop());
   }
 
   visitIdentifier(Identifier node) {
     if (node.isThis()) {
       stack.add(localsHandler.readThis());
@@ skipping 376 matching lines @@
       Node argument = node.arguments.head;
       TypeAnnotation typeAnnotation = argument.asTypeAnnotation();
       bool isNot = false;
       // TODO(ngeoffray): Duplicating pattern in resolver. We should
       // add a new kind of node.
       if (typeAnnotation == null) {
         typeAnnotation = argument.asSend().receiver;
         isNot = true;
       }
       DartType type = elements.getType(typeAnnotation);
+      type = type.unalias(compiler);
       if (type.isMalformed) {
         String reasons = Types.fetchReasonsFromMalformedType(type);
         if (compiler.enableTypeAssertions) {
           generateMalformedSubtypeError(node, expression, type, reasons);
         } else {
           generateRuntimeError(node, '$type is malformed: $reasons');
         }
         return;
       }
 
       HInstruction instruction;
-      if (type.kind == TypeKind.TYPE_VARIABLE) {
+      if (type is FunctionType) {

[ngeoffray, 2013/03/13 09:30:46]

Use the kind instead?

[Johnni Winther, 2013/03/22 07:30:24]

Done.

+        compiler.enqueuer.codegen.registerIsCheck(type, work.resolutionTree);

[ngeoffray, 2013/03/13 09:30:46]

Add a TODO that this should be done in codegen.

[Johnni Winther, 2013/06/21 12:19:14]

Stale.

+
+        void functionTypeCheck() {
+          Element checkFunctionSubtype = backend.getCheckFunctionSubtype();
+          HInstruction isFuncSubtypeCall = new HStatic(checkFunctionSubtype);
+          add(isFuncSubtypeCall);
+
+          String typeSignatureName;
+          HInstruction context;
+          ClassElement contextClass = Types.getClassContext(type);

[ngeoffray, 2013/03/13 09:30:46]

What is this?

[Johnni Winther, 2013/03/22 07:30:24]

The class which declared the used type variables, if any.

+          if (contextClass != null) {
+            typeSignatureName = backend.namer.signatureName(type);
+            context = new HThis(contextClass, HType.UNKNOWN);

[ngeoffray, 2013/03/13 09:30:46]

What's this HThis? Why isn't it the one of the builder?

[Johnni Winther, 2013/03/22 07:30:24]

Changed.

+            add(context);
+          } else {
+            typeSignatureName = backend.namer.signatureName(type);
+            context = graph.addConstantNull(constantSystem);
+          }
+          HInstruction typeSignature =
+              createForeign('$typeSignatureName', HType.UNKNOWN, []);
+          add(typeSignature);
+
+          List<HInstruction> inputs = <HInstruction>[isFuncSubtypeCall,
+                                                     expression,
+                                                     typeSignature,
+                                                     context];
+          push(new HInvokeStatic(inputs, HType.UNKNOWN));
+        }
+
+        void classCheck() { push(new HIs(type, <HInstruction>[expression])); }
+
+        SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
+        branchBuilder.handleLogicalAndOr(
+            classCheck, functionTypeCheck, isAnd: true);
+        instruction = pop();
+      } else if (type.kind == TypeKind.TYPE_VARIABLE) {
         HInstruction runtimeType = addTypeVariableReference(type);
         Element helper = backend.getGetObjectIsSubtype();
         HInstruction helperCall = new HStatic(helper);
         add(helperCall);
         List<HInstruction> inputs = <HInstruction>[helperCall, expression,
                                                    runtimeType];
         instruction = new HInvokeStatic(inputs, HType.BOOLEAN);
         add(instruction);
         compiler.enqueuer.codegen.registerIsCheck(type, elements);
 
@@ skipping 2440 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }