Share addTypeVariableReference between factory calls and is-checks.

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 2568 matching lines @@
     pushInvokeHelper1(backend.getGetRuntimeTypeInfo(), target, HType.UNKNOWN);
     return pop();
   }
 
   // TODO(karlklose): change construction of the representations to be GVN'able
   // (dartbug.com/7182).
   List<HInstruction> buildTypeArgumentRepresentations(DartType type) {
     HInstruction createForeignArray(String code, inputs) {
       return createForeign(code, HType.READABLE_ARRAY, inputs);
     }
-    HInstruction typeInfo;
-
-    /// Helper to create an instruction that contains the runtime value of
-    /// the type variable [variable].
-    HInstruction getTypeArgument(TypeVariableType variable) {
-      if (typeInfo == null) {
-        typeInfo = getRuntimeTypeInfo(localsHandler.readThis());
-      }
-      int intIndex = RuntimeTypeInformation.getTypeVariableIndex(variable);
-      HInstruction index = graph.addConstantInt(intIndex, constantSystem);
-      return createForeignArray('#[#]', <HInstruction>[typeInfo, index]);
-    }
 
     // Compute the representation of the type arguments, including access
     // to the runtime type information for type variables as instructions.
     HInstruction representations;
     if (type.element.isTypeVariable()) {
-      return <HInstruction>[getTypeArgument(type)];
+      return <HInstruction>[addTypeVariableReference(type)];
     } else {
       assert(type.element.isClass());
       List<HInstruction> arguments = <HInstruction>[];
       InterfaceType interface = type;
       for (DartType argument in interface.typeArguments) {
         List<HInstruction> inputs = <HInstruction>[];
         String template = rti.getTypeRepresentation(argument, (variable) {
-          HInstruction runtimeType = getTypeArgument(variable);
-          add(runtimeType);
+          HInstruction runtimeType = addTypeVariableReference(variable);
           inputs.add(runtimeType);
         });
         HInstruction representation = createForeignArray(template, inputs);
         add(representation);
         arguments.add(representation);
       }
       return arguments;
     }
   }
 
@@ skipping 518 matching lines @@
       target = new HInvokeSuper(inputs);
       add(target);
       inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
       Selector closureSelector = new Selector.callClosureFrom(selector);
       push(new HInvokeClosure(closureSelector, inputs));
     }
   }
 
   /**
+   * Helper to create an instruction that gets the value of a type variable.
+   */
+  HInstruction 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 method.
+      return localsHandler.readLocal(type.element);
+    } else if (member.isInstanceMember() ||
+               member.isGenerativeConstructor()) {
+      // The type variable is stored on the object.  Generate code to extract
+      // the type arguments from the object, substitute them as an instance
+      // of the type we are testing against (if necessary), and extract the
+      // type argument by the index of the variable in the list of type
+      // variables for that class.
+      int index = RuntimeTypeInformation.getTypeVariableIndex(type);
+      HInstruction thisObject = localsHandler.readThis();
+      String substitutionNameString =
+          backend.namer.substitutionName(member.getEnclosingClass());
+      HInstruction substitutionName = graph.addConstantString(
+          new LiteralDartString(substitutionNameString), null, constantSystem);
+      HInstruction substitution = createForeign('#[#]', HType.UNKNOWN,
+          <HInstruction>[thisObject, substitutionName]);
+      add(substitution);
+      pushInvokeHelper3(backend.getGetRuntimeTypeArgument(),
+                        thisObject,
+                        substitution,
+                        graph.addConstantInt(index, constantSystem),
+                        HType.UNKNOWN);
+      return pop();
+    } else {
+      // TODO(ngeoffray): Match the VM behavior and throw an
+      // exception at runtime.
+      compiler.cancel('Unimplemented unresolved type variable',
+                      element: type.element);
+    }
+  }
+
+  /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [argument] must not be malformed in checked mode.
    */
   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);
     }
 
-    // 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.
-     */
-    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 method.
-        inputs.add(localsHandler.readLocal(type.element));
-      } else if (member.isInstanceMember() ||
-                 member.isGenerativeConstructor()) {
-        // The type variable is stored on the object.  Generate code to extract
-        // the type arguments from the object, substitute them as an instance
-        // of the type we are testing against (if necessary), and extract the
-        // type argument by the index of the variable in the list of type
-        // variables for that class.
-        int index = RuntimeTypeInformation.getTypeVariableIndex(type);
-        HInstruction thisObject = localsHandler.readThis();
-        String substitutionNameString =
-            backend.namer.substitutionName(member.getEnclosingClass());
-        HInstruction substitutionName = graph.addConstantString(
-            new LiteralDartString(substitutionNameString), null, constantSystem);
-        HInstruction substitution = createForeign('#[#]', HType.UNKNOWN,
-            <HInstruction>[thisObject, substitutionName]);
-        add(substitution);
-        pushInvokeHelper3(backend.getGetRuntimeTypeArgument(),
-                          thisObject,
-                          substitution,
-                          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, (variable) {
+      inputs.add(addTypeVariableReference(variable));
+    });
 
-    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;
     if (!type.isRaw) {
@@ skipping 1837 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;
   }
 }