dart2js: add type arguments to constructor in case the class needs rti.

pkg/compiler/lib/src/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;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 2093 matching lines @@
 
     InterfaceType type = classElement.thisType;
     TypeMask ssaType =
         new TypeMask.nonNullExact(classElement.declaration, compiler.world);
     List<DartType> instantiatedTypes;
     addInlinedInstantiation(type);
     if (!currentInlinedInstantiations.isEmpty) {
       instantiatedTypes = new List<DartType>.from(currentInlinedInstantiations);
     }
 
-    HInstruction newObject;
-    if (!isNativeUpgradeFactory) {
-      newObject = new HForeignNew(classElement,
-          ssaType,
-          constructorArguments,
-          instantiatedTypes);
-      add(newObject);
-    } else {
-      // Bulk assign to the initialized fields.
-      newObject = graph.explicitReceiverParameter;
-      // Null guard ensures an error if we are being called from an explicit
-      // 'new' of the constructor instead of via an upgrade. It is optimized out
-      // if there are field initializers.
-      add(new HFieldGet(
-          null, newObject, backend.dynamicType, isAssignable: false));
-      for (int i = 0; i < fields.length; i++) {
-        add(new HFieldSet(fields[i], newObject, constructorArguments[i]));
-      }
-    }
-    removeInlinedInstantiation(type);
-    // Create the runtime type information, if needed.
-    if (backend.classNeedsRti(classElement)) {
+    /// Fills [typeArguments] with the values of type arguments to be set on
+    /// the newly created object. Returns the source if the arguments can
+    /// simply be copied over.
+    HThis computeSourceOrTypeArguments(ClassElement classElement,
+                                       List<HInstruction> typeArguments) {
       // Read the values of the type arguments and create a list to set on the
       // newly create object.  We can identify the case where the new list
       // would be of the form:
       //  [getTypeArgumentByIndex(this, 0), .., getTypeArgumentByIndex(this, k)]
       // and k is the number of type arguments of this.  If this is the case,
       // we can simply copy the list from this.
 
       // These locals are modified by [isIndexedTypeArgumentGet].
       HThis source;  // The source of the type arguments.
       bool allIndexed = true;
@@ skipping 33 matching lines @@
         // If there are no more type variables, then there are more type
         // arguments for the new object than the source has, and it can't be
         // a copy.  Otherwise remove one argument.
         if (remainingTypeVariables == 0) return false;
         remainingTypeVariables--;
         // Check that the index is the one we expect.
         IntConstantValue constant = index.constant;
         return constant.primitiveValue == expectedIndex++;
       }
 
-      List<HInstruction> typeArguments = <HInstruction>[];
       classElement.typeVariables.forEach((TypeVariableType typeVariable) {
         HInstruction argument = localsHandler.readLocal(
             localsHandler.getTypeVariableAsLocal(typeVariable));
         if (allIndexed && !isIndexedTypeArgumentGet(argument)) {
           allIndexed = false;
         }
         typeArguments.add(argument);
       });
 
       if (source != null && allIndexed && remainingTypeVariables == 0) {
-        copyRuntimeTypeInfo(source, newObject);
+        return source;
       } else {
-        newObject =
-            callSetRuntimeTypeInfo(classElement, typeArguments, newObject);
+        return null;
       }
     }
 
+    HInstruction newObject;
+    if (!isNativeUpgradeFactory) {
+      List<HInstruction> typeArguments = <HInstruction>[];
+      HThis source;
+      if (backend.classNeedsRti(classElement)) {
+        source = computeSourceOrTypeArguments(classElement, typeArguments);
+      }
+
+      // If the class needs rti and the type arguments cannot simply be copied
+      // over, we pass the type arguments to the constructor which will then set
+      // the type info on the object.
+      if (source == null && typeArguments.isNotEmpty) {
+        HInstruction typeArgumentsInstruction = buildLiteralList(typeArguments);
+        add(typeArgumentsInstruction);
+        constructorArguments..add(typeArgumentsInstruction);
+      }
+
+      newObject = new HForeignNew(classElement,
+          ssaType,
+          constructorArguments,
+          instantiatedTypes);
+      add(newObject);
+
+      if (source != null) {
+        copyRuntimeTypeInfo(source, newObject);
+      }
+    } else {
+      // Bulk assign to the initialized fields.
+      newObject = graph.explicitReceiverParameter;
+      // Null guard ensures an error if we are being called from an explicit
+      // 'new' of the constructor instead of via an upgrade. It is optimized out
+      // if there are field initializers.
+      add(new HFieldGet(
+          null, newObject, backend.dynamicType, isAssignable: false));
+      for (int i = 0; i < fields.length; i++) {
+        add(new HFieldSet(fields[i], newObject, constructorArguments[i]));
+      }
+
+      if (backend.classNeedsRti(classElement)) {
+        List<HInstruction> typeArguments = <HInstruction>[];
+        HThis source =
+            computeSourceOrTypeArguments(classElement, typeArguments);
+        if (source != null) {
+          copyRuntimeTypeInfo(source, newObject);
+        } else {
+          newObject = callSetRuntimeTypeInfo(classElement, typeArguments,
+                                             newObject);
+        }
+      }
+    }
+
+    removeInlinedInstantiation(type);
     // Generate calls to the constructor bodies.
     HInstruction interceptor = null;
     for (int index = constructors.length - 1; index >= 0; index--) {
       FunctionElement constructor = constructors[index];
       assert(invariant(functionElement, constructor.isImplementation));
       ConstructorBodyElement body = getConstructorBody(constructor);
       if (body == null) continue;
 
       List bodyCallInputs = <HInstruction>[];
       if (isNativeUpgradeFactory) {
@@ skipping 4787 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }