Change how runtime type information is being set in the backend.

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 1164 matching lines @@
     List<HInstruction> constructorArguments = <HInstruction>[];
     classElement.forEachInstanceField(
         includeBackendMembers: true,
         includeSuperMembers: true,
         f: (ClassElement enclosingClass, Element member) {
       constructorArguments.add(fieldValues[member]);
     });
 
     HForeignNew newObject = new HForeignNew(classElement, constructorArguments);
     add(newObject);
+
+    // If the class has type variables, create the runtime type
+    // information with the type parameters provided.
+    if (!classElement.typeVariables.isEmpty()) {
+      List<String> typeVariables = <String>[];
+      List<HInstruction> rtiInputs = <HInstruction>[];
+      classElement.typeVariables.forEach((TypeVariableType typeVariable) {
+        typeVariables.add("'$typeVariable': #");
+        rtiInputs.add(localsHandler.directLocals[typeVariable.element]);
+      });
+      String jsCode = '{ ${Strings.join(typeVariables, ', ')} }';
+      HInstruction typeInfo = new HForeign(new LiteralDartString(jsCode),
+                                           new LiteralDartString('Object'),
+                                           rtiInputs);
+      add(typeInfo);
+      Element typeInfoSetterElement = interceptors.getSetRuntimeTypeInfo();
+      HInstruction typeInfoSetter = new HStatic(typeInfoSetterElement);
+      add(typeInfoSetter);
+      add(new HInvokeStatic(
+          <HInstruction>[typeInfoSetter, newObject, typeInfo]));
+    }
+
     // Generate calls to the constructor bodies.
     for (int index = constructors.length - 1; index >= 0; index--) {
       FunctionElement constructor = constructors[index];
       ConstructorBodyElement body = getConstructorBody(constructor);
       if (body === null) continue;
       List bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
       int arity = body.functionSignature.parameterCount;
       body.functionSignature.forEachParameter((parameter) {
         bodyCallInputs.add(localsHandler.readLocal(parameter));
@@ skipping 26 matching lines @@
     // Put the type checks in the first successor of the entry,
     // because that is where the type guards will also be inserted.
     // This way we ensure that a type guard will dominate the type
     // check.
     FunctionSignature params = functionElement.computeSignature(compiler);
     params.forEachParameter((Element element) {
       HInstruction newParameter = potentiallyCheckType(
           localsHandler.directLocals[element], element);
       localsHandler.directLocals[element] = newParameter;
     });
+
+    // Add the type parameters of the class as parameters of this
+    // method.
+    if (functionElement.isFactoryConstructor()
+        || functionElement.isGenerativeConstructor()) {
+      ClassElement cls = functionElement.enclosingElement;
+      cls.typeVariables.forEach((TypeVariableType typeVariable) {
+        HParameterValue param = new HParameterValue(typeVariable.element);
+        add(param);
+        localsHandler.directLocals[typeVariable.element] = param;
+      });
+    }
   }
 
   HInstruction potentiallyCheckType(HInstruction original,
                                     Element sourceElement) {
     if (!compiler.enableTypeAssertions) return original;
     return convertType(original, sourceElement,
                        HTypeConversion.CHECKED_MODE_CHECK);
   }
 
   HInstruction convertType(HInstruction original,
@@ skipping 1180 matching lines @@
       push(new HInvokeSuper(inputs));
     } else {
       target = new HInvokeSuper(inputs);
       add(target);
       inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
       push(new HInvokeClosure(selector, inputs));
     }
   }
 
+  HInstruction analyzeTypeArgument(Type argument, Node currentNode) {
+    if (argument.element.isTypeVariable()) {
+      if (work.element.isFactoryConstructor()
+          || work.element.isGenerativeConstructor()) {
+        // The type variable is stored in a parameter of the
+        // factory.
+        return localsHandler.readLocal(argument.element);
+      } else if (work.element.isInstanceMember()) {
+        // The type variable is stored in [this].
+        pushInvokeHelper1(interceptors.getGetRuntimeTypeInfo(),
+                          localsHandler.readThis());
+        HInstruction typeInfo = pop();
+        HInstruction foreign = new HForeign(
+            new LiteralDartString('#.$argument'),
+            new LiteralDartString('String'),
+            <HInstruction>[typeInfo]);
+        add(foreign);
+        return 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);
+    }
+  }
+
   visitNewSend(Send node) {
     computeType(element) {
       Element originalElement = elements[node];
       if (originalElement.getEnclosingClass() === compiler.listClass) {
         if (node.arguments.isEmpty()) {
           return HType.EXTENDABLE_ARRAY;
         } else {
           return HType.MUTABLE_ARRAY;
         }
       } else if (element.isGenerativeConstructor()) {
@@ skipping 16 matching lines @@
     var inputs = <HInstruction>[];
     inputs.add(target);
     bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                   element, inputs);
     if (!succeeded) {
       // TODO(ngeoffray): Match the VM behavior and throw an
       // exception at runtime.
       compiler.cancel('Unimplemented non-matching static call', node: node);
     }
 
+    TypeAnnotation annotation = getTypeAnnotationFromSend(node);
+    elements.getType(annotation).arguments.forEach((Type argument) {
+      inputs.add(analyzeTypeArgument(argument, node));
+    });
+
     HType elementType = computeType(element);
     HInstruction newInstance = new HInvokeStatic(inputs, elementType);
     pushWithPosition(newInstance, node);
-
-    TypeAnnotation annotation = getTypeAnnotationFromSend(node);
-    Type type = elements.getType(annotation);
-    generateSetRuntimeTypeInformation(newInstance, type);
-  }
-
-  generateSetRuntimeTypeInformation(HInstruction instance, Type type) {
-    if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
-      String typeString = compiler.codegenWorld.rti.asJsString(type);
-      HInstruction typeInfo = new HForeign(new LiteralDartString(typeString),
-                                           new LiteralDartString('Object'),
-                                           <HInstruction>[]);
-      add(typeInfo);
-      Element typeInfoSetterElement = interceptors.getSetRuntimeTypeInfo();
-      HInstruction typeInfoSetter = new HStatic(typeInfoSetterElement);
-      add(typeInfoSetter);
-      var inputs = <HInstruction>[typeInfoSetter, instance, typeInfo];
-      add(new HInvokeStatic(inputs));
-    }
   }
 
   visitStaticSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (element === compiler.assertMethod && !compiler.enableUserAssertions) {
       stack.add(graph.addConstantNull());
       return;
     }
     compiler.ensure(element.kind !== ElementKind.GENERATIVE_CONSTRUCTOR);
@@ skipping 1386 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;
   }
 }