Complete support for type variables in new expressions.

lib/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1302 matching lines @@
         f: (ClassElement enclosingClass, Element member) {
       constructorArguments.add(
           potentiallyCheckType(fieldValues[member], member));
     });
 
     HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
     add(newObject);
 
     // Create the runtime type information, if needed.
     InterfaceType type = classElement.computeType(compiler);
-      List<HInstruction> inputs = <HInstruction>[];
-      if (compiler.world.needsRti(classElement)) {
+    List<HInstruction> inputs = <HInstruction>[];
+    if (compiler.world.needsRti(classElement)) {
       classElement.typeVariables.forEach((TypeVariableType typeVariable) {
         inputs.add(localsHandler.directLocals[typeVariable.element]);
       });
       callSetRuntimeTypeInfo(classElement, inputs, newObject);
     }
 
     // Generate calls to the constructor bodies.
     for (int index = constructors.length - 1; index >= 0; index--) {
       FunctionElement constructor = constructors[index];
       assert(invariant(functionElement, constructor.isImplementation));
@@ skipping 1390 matching lines @@
     } else {
       target = new HInvokeSuper(inputs);
       add(target);
       inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
       push(new HInvokeClosure(selector, inputs));
     }
   }
 
   HInstruction analyzeTypeArgument(DartType argument, Node currentNode) {
-    if (argument.element.isTypeVariable()) {
+    // These variables are shared between invocations of the helper methods.
+    HInstruction typeInfo;
+    StringBuffer template = new StringBuffer();
+    List<HInstruction> inputs = <HInstruction>[];
+
+    /**
+     * Helper to create an instruction that gets the value of a type variable.
+     */
+    void addTypeVariableReference(TypeVariableType type) {
       Element member = work.element;
       if (member.enclosingElement.isClosure()) {
-        member = (member.enclosingElement as ClosureClassElement).methodElement;
+        ClosureClassElement closureClass = member.enclosingElement;
+        member = closureClass.methodElement;
         member = member.getOutermostEnclosingMemberOrTopLevel();
       }
       if (member.isFactoryConstructor()) {
-        // The type variable is stored in a parameter of the
-        // factory.
-        return localsHandler.readLocal(argument.element);
+        // The type variable is stored in a parameter of the factory.
+        inputs.add(localsHandler.readLocal(type.element));
       } else if (member.isInstanceMember()
                  || member.isGenerativeConstructor()) {
         // The type variable is stored in [this].
-        pushInvokeHelper1(interceptors.getGetRuntimeTypeInfo(),
-                          localsHandler.readThis());
-        HInstruction typeInfo = pop();
+        if (typeInfo == null) {
+          pushInvokeHelper1(interceptors.getGetRuntimeTypeInfo(),
+                            localsHandler.readThis());
+          typeInfo = pop();
+        }
         HInstruction foreign = new HForeign(
-            new LiteralDartString('#.$argument'),
+            new LiteralDartString('#.${type.name.slowToString()}'),
             new LiteralDartString('String'),
             <HInstruction>[typeInfo]);
         add(foreign);
-        return foreign;
+        inputs.add(foreign);
       } else {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
         compiler.cancel('Unimplemented unresolved type variable',
                         node: currentNode);
       }
-    } else {
-      // The type variable is a type (e.g. int).
-      return graph.addConstantString(
-          new LiteralDartString('$argument'), currentNode, constantSystem);
     }
+
+    /**
+     * Helper to build an instruction that builds the string representation for
+     * this type, where type variables are substituted by their runtime value.
+     *
+     * Examples:
+     *   Type            Template                Inputs
+     *   int             'int'                   []
+     *   C<int, int>     'C<int, int>'           []
+     *   Var             #                       [getRuntimeType(this).Var]
+     *   C<int, D<Var>>  'C<int, D<' + # + '>>'  [getRuntimeType(this).Var]
+     */
+    void buildTypeString(DartType type, {isInQuotes: false}) {

[ngeoffray, 2012/10/15 12:05:20]

Could you move the non-ssa parts of this helper in the rti library?

+      if (type is TypeVariableType) {
+        addTypeVariableReference(type);
+        template.add(isInQuotes ? "' + # +'" : "#");
+      } else if (type is InterfaceType) {
+        bool isFirstVariable = true;
+        InterfaceType interfaceType = type;
+        bool hasTypeArguments = !interfaceType.arguments.isEmpty();
+        if (!isInQuotes) template.add("'");
+        template.add("${type.element.name.slowToString()}");
+        if (hasTypeArguments) {
+          template.add("<");
+          for (DartType argument in interfaceType.arguments) {
+            if (!isFirstVariable) {
+              template.add(", ");
+            } else {
+              isFirstVariable = false;
+            }
+            buildTypeString(argument, isInQuotes: true);
+          }
+          template.add(">");
+        }
+        if (!isInQuotes) template.add("'");
+      } else {
+        assert(type is TypedefType);
+        if (!isInQuotes) template.add("'");
+        template.add(argument.toString());
+        if (!isInQuotes) template.add("'");
+      }
+    }
+
+    buildTypeString(argument, isInQuotes: false);
+    HInstruction result =
+        new HForeign(new LiteralDartString("$template"),
+            new LiteralDartString('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>[];
     type.arguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(argument, currentNode));
     });
@@ skipping 1620 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;
   }
 }