Fix for issue 4921: ad the generic type info to a List when we create it.

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 1221 matching lines @@
 
     // 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]));
+      callSetRuntimeTypeInfo(typeVariables, rtiInputs, newObject);
     }
 
     // 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;
@@ skipping 1358 matching lines @@
         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);
     }
   }
 
+  void handleListConstructor(InterfaceType type,
+                             Node currentNode,
+                             HInstruction newObject) {
+    if (type.arguments.isEmpty()) return;
+    List<HInstruction> inputs = <HInstruction>[];
+    type.arguments.forEach((DartType argument) {
+      inputs.add(analyzeTypeArgument(argument, currentNode));
+    });
+
+    List<String> typeVariables = <String>[];
+    type.element.typeVariables.forEach((TypeVariableType typeVariable) {
+      typeVariables.add("'$typeVariable': #");
+    });
+
+    callSetRuntimeTypeInfo(typeVariables, inputs, newObject);
+  }
+
+  void callSetRuntimeTypeInfo(List<String> typeVariables,
+                              List<HInstruction> inputs,
+                              HInstruction newObject) {
+    String jsCode = '{ ${Strings.join(typeVariables, ', ')} }';

[kasperl, 2012/09/12 12:19:04]

Somehow the decoupling of the way you turn the type variables into an object
(split between callSetRuntimeTypeInfo and the callers of it) seems complicated.
Would it be terrible to pass in the list of TypeVariableTypes and convert them
to an object literal in a string inside callSetRuntimeTypeInfo?

[ngeoffray, 2012/09/12 12:30:39]

Done.

+    HInstruction typeInfo = new HForeign(new LiteralDartString(jsCode),
+                                         new LiteralDartString('Object'),
+                                         inputs);
+    add(typeInfo);
+    Element typeInfoSetterElement = interceptors.getSetRuntimeTypeInfo();
+    HInstruction typeInfoSetter = new HStatic(typeInfoSetterElement);
+    add(typeInfoSetter);
+    add(new HInvokeStatic(<HInstruction>[typeInfoSetter, newObject, typeInfo]));
+  }
+
   visitNewSend(Send node) {
+    bool isListConstructor = false;
     computeType(element) {
       Element originalElement = elements[node];
       if (originalElement.getEnclosingClass() === compiler.listClass) {
+        isListConstructor = true;
         if (node.arguments.isEmpty()) {
           return HType.EXTENDABLE_ARRAY;
         } else {
           return HType.MUTABLE_ARRAY;
         }
       } else if (element.isGenerativeConstructor()) {
         ClassElement cls = element.getEnclosingClass();
         return new HBoundedType.exact(cls.type);
       } else {
         return HType.UNKNOWN;
@@ skipping 24 matching lines @@
       compiler.internalError("malformed send in new expression");
     }
     InterfaceType type = elements.getType(annotation);
     type.arguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(argument, node));
     });
 
     HType elementType = computeType(constructor);
     HInstruction newInstance = new HInvokeStatic(inputs, elementType);
     pushWithPosition(newInstance, node);
+
+    // The List constructor forwards to a Dart static method that does
+    // not know about the type argument. Therefore we special case
+    // this constructor to have the setRuntimeTypeInfo called where
+    // the 'new' is done.
+    if (isListConstructor) {
+      handleListConstructor(type, node, newInstance);
+    }
   }
 
   visitStaticSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (element.isErroneous()) {
       generateThrowNoSuchMethod(node, getTargetName(element), node.arguments);
       return;
     }
     if (element === compiler.assertMethod && !compiler.enableUserAssertions) {
@@ skipping 1452 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;
   }
 }