Implement substitution for type variables.

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 2170 matching lines @@
   }
 
   void visitLogicalAndOr(Send node, Operator op) {
     SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
     branchBuilder.handleLogicalAndOrWithLeftNode(
         node.receiver,
         () { visit(node.argumentsNode); },
         isAnd: (const SourceString("&&") == op.source));
   }
 
-
   void visitLogicalNot(Send node) {
     assert(node.argumentsNode is Prefix);
     visit(node.receiver);
     HNot not = new HNot(popBoolified());
     pushWithPosition(not, node);
   }
 
   void visitUnary(Send node, Operator op) {
     if (node.isParameterCheck) {
       Element element = elements[node.receiver];
@@ skipping 447 matching lines @@
       if (type.element.isTypeVariable()) {
         // TODO(karlklose): remove this check when the backend can deal with
         // checks of the form [:o is T:] where [:T:] is a type variable.
         stack.add(graph.addConstantBool(true, constantSystem));
         return;
       }
 
       HInstruction instruction;
       if (type.element.isTypeVariable() ||
           RuntimeTypeInformation.hasTypeArguments(type)) {
-        HInstruction typeInfo = getRuntimeTypeInfo(expression);
-        // TODO(karlklose): make isSubtype a HInstruction to enable
-        // optimizations?
-        Element helper = compiler.findHelper(const SourceString('isSubtype'));
-        HInstruction isSubtype = new HStatic(helper);
-        add(isSubtype);
-        // Build a list of representations for the type arguments.
-        List<HInstruction> representations =
-            buildTypeArgumentRepresentations(type);
-        // For each type argument, build a call to isSubtype, with the type
-        // argument as first and the representation of the tested type as
-        // second argument.
-        List<HInstruction> checks = <HInstruction>[];
-        int index = 0;
-        representations.forEach((HInstruction representation) {
-          HInstruction position = graph.addConstantInt(index, constantSystem);
-          // Get the index'th type argument from the runtime type information.
-          HInstruction typeArgument =
-              createForeign('#[#]', HType.UNKNOWN, [typeInfo, position]);
-          add(typeArgument);
-          // Create the call to isSubtype.
-          List<HInstruction> inputs =
-              <HInstruction>[isSubtype, typeArgument, representation];
-          HInstruction call = new HInvokeStatic(inputs, HType.BOOLEAN);
-          add(call);
-          checks.add(call);
-          index++;
-        });
-        instruction = new HIs(type, <HInstruction>[expression]..addAll(checks));
+
+        void argumentsCheck() {

[karlklose, 2013/02/08 14:51:46]

@Nicolas: this is the main change to the previous version; I generate a
&&-control-flow here instead of the codegen. This simplifies handling in the
codegen and makes short-cutting work correctly, but the generated code is less
readable because our if-retranslation is not good enough.

+          HInstruction typeInfo = getRuntimeTypeInfo(expression);
+          Element helper =
+              compiler.findHelper(const SourceString('checkArguments'));
+          HInstruction helperCall = new HStatic(helper);
+          add(helperCall);
+          List<HInstruction> representations =
+              buildTypeArgumentRepresentations(type);
+          Element element = type.element;
+          String substitution = backend.namer.substitutionName(element);
+          if (backend.emitter.nativeEmitter.requiresNativeIsCheck(element)) {
+            substitution = '$substitution()';
+          }
+          HInstruction fieldGet =
+              createForeign('#.$substitution', HType.UNKNOWN, [expression]);
+          HInstruction representationList = new HLiteralList(representations);
+          add(fieldGet);
+          add(representationList);
+          List<HInstruction> inputs = <HInstruction>[helperCall,
+                                                     fieldGet,
+                                                     typeInfo,
+                                                     representationList];
+          push(new HInvokeStatic(inputs, HType.UNKNOWN));
+        }
+
+        void classCheck() { push(new HIs(type, <HInstruction>[expression])); }
+
+        SsaBranchBuilder branchBuilder = new SsaBranchBuilder(this, node);
+        branchBuilder.handleLogicalAndOr(classCheck, argumentsCheck, isAnd: true);
+        instruction = pop();
       } else {
         instruction = new HIs(type, <HInstruction>[expression]);
+        add(instruction);
       }
       if (isNot) {
+        instruction = new HNot(instruction);
         add(instruction);
-        instruction = new HNot(instruction);
       }
-      push(instruction);
+      stack.add(instruction);
     } else if (const SourceString("as") == op.source) {
       visit(node.receiver);
       HInstruction expression = pop();
       Node argument = node.arguments.head;
       TypeAnnotation typeAnnotation = argument.asTypeAnnotation();
       DartType type = elements.getType(typeAnnotation);
       HInstruction converted = expression.convertType(
           compiler, type, HTypeConversion.CAST_TYPE_CHECK);
       if (converted != expression) add(converted);
       stack.add(converted);
@@ skipping 317 matching lines @@
     } else if (name == const SourceString('DART_CLOSURE_TO_JS')) {
       handleForeignDartClosureToJs(node, 'DART_CLOSURE_TO_JS');
     } else if (name == const SourceString('RAW_DART_FUNCTION_REF')) {
       handleForeignRawFunctionRef(node, 'RAW_DART_FUNCTION_REF');
     } else if (name == const SourceString('JS_SET_CURRENT_ISOLATE')) {
       handleForeignSetCurrentIsolate(node);
     } else if (name == const SourceString('JS_CREATE_ISOLATE')) {
       handleForeignCreateIsolate(node);
     } else if (name == const SourceString('JS_OPERATOR_IS_PREFIX')) {
       stack.add(addConstantString(node, backend.namer.operatorIsPrefix()));
+    } else if (name == const SourceString('JS_OPERATOR_AS_PREFIX')) {
+      stack.add(addConstantString(node, backend.namer.operatorAsPrefix()));
     } else {
       throw "Unknown foreign: ${selector}";
     }
   }
 
   generateSuperNoSuchMethodSend(Send node) {
     Selector selector = elements.getSelector(node);
     SourceString name = selector.name;
 
     ClassElement cls = currentElement.getEnclosingClass();
@@ skipping 99 matching lines @@
    */
   HInstruction analyzeTypeArgument(DartType argument, Node currentNode) {
     assert(invariant(currentNode,
                      !compiler.enableTypeAssertions || !argument.isMalformed,
                      message: '$argument is malformed in checked mode'));
     if (argument == compiler.types.dynamicType || argument.isMalformed) {
       // Represent [dynamic] as [null].
       return graph.addConstantNull(constantSystem);
     }
 
-    // These variables are shared between invocations of the helper.
-    HInstruction typeInfo;
+    // The inputs are shared between invocations of the helper.
     List<HInstruction> inputs = <HInstruction>[];
 
     /**
      * Helper to create an instruction that gets the value of a type variable.
      */
-    void addTypeVariableReference(TypeVariableType type) {
+    String addTypeVariableReference(TypeVariableType type) {
       Element member = currentElement;
       if (member.enclosingElement.isClosure()) {
         ClosureClassElement closureClass = member.enclosingElement;
         member = closureClass.methodElement;
         member = member.getOutermostEnclosingMemberOrTopLevel();
       }
       if (member.isFactoryConstructor()) {
-        // The type variable is stored in a parameter of the factory.
+        // The type variable is stored in a parameter of the method.
         inputs.add(localsHandler.readLocal(type.element));
-      } else if (member.isInstanceMember()
-                 || member.isGenerativeConstructor()) {
+      } else if (member.isInstanceMember() ||
+          member.isGenerativeConstructor()) {
         // The type variable is stored in [this].
-        if (typeInfo == null) {
-          pushInvokeHelper1(backend.getGetRuntimeTypeInfo(),
-                            localsHandler.readThis(),
-                            HType.UNKNOWN);
-          typeInfo = pop();
-        }
         int index = RuntimeTypeInformation.getTypeVariableIndex(type);
-        HInstruction foreign = createForeign('#[$index]', HType.STRING,
-                                             <HInstruction>[typeInfo]);
-        add(foreign);
-        inputs.add(foreign);
+        pushInvokeHelper2(backend.getGetRuntimeTypeArgument(),
+                          localsHandler.readThis(),
+                          graph.addConstantInt(index, constantSystem),
+                          HType.UNKNOWN);
+        inputs.add(pop());
       } else {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented unresolved type variable',
                         node: currentNode);
       }
     }
 
     String template = rti.getTypeRepresentation(argument,
                                                 addTypeVariableReference);
     HInstruction result = createForeign(template, HType.STRING, inputs);
     add(result);
     return result;
   }
 
   void handleListConstructor(InterfaceType type,
                              Node currentNode,
                              HInstruction newObject) {
     if (!compiler.world.needsRti(type.element)) return;
-    List<HInstruction> inputs = <HInstruction>[];
     if (!type.isRaw) {
+      List<HInstruction> inputs = <HInstruction>[];
       type.typeArguments.forEach((DartType argument) {
         inputs.add(analyzeTypeArgument(argument, currentNode));
       });
+      callSetRuntimeTypeInfo(type.element, inputs, newObject);
     }
-    callSetRuntimeTypeInfo(type.element, inputs, newObject);
   }
 
   void callSetRuntimeTypeInfo(ClassElement element,
                               List<HInstruction> rtiInputs,
                               HInstruction newObject) {
     if (!compiler.world.needsRti(element) || element.typeVariables.isEmpty) {
       return;
     }
 
     HInstruction typeInfo = new HLiteralList(rtiInputs);
@@ skipping 1806 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;
   }
 }