dart2js: Pass type information to constructor rather than add later.

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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 1476 matching lines @@
     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 HCreate(
-          classElement, constructorArguments, ssaType, instantiatedTypes);
+      // Create the runtime type information, if needed.
+      bool hasRtiInput = false;
+      if (backend.classNeedsRtiField(classElement)) {
+        // Read the values of the type arguments and create a
+        // HTypeInfoExpression to set on the newly create object.
+        hasRtiInput = true;
+        List<HInstruction> typeArguments = <HInstruction>[];
+        classElement.typeVariables.forEach((TypeVariableType typeVariable) {
+            HInstruction argument = localsHandler
+                .readLocal(localsHandler.getTypeVariableAsLocal(typeVariable));
+            typeArguments.add(argument);
+          });
+
+        HInstruction typeInfo = new HTypeInfoExpression(
+            TypeInfoExpressionKind.INSTANCE,
+            classElement.thisType,
+            typeArguments,
+            backend.dynamicType);
+        add(typeInfo);
+        constructorArguments.add(typeInfo);
+      }
+
+      newObject = new HCreate(classElement, constructorArguments, ssaType,
+          instantiatedTypes: instantiatedTypes, hasRtiInput: hasRtiInput);
       if (function != null) {
-        // TODO(johnniwinther): Provide source information for creation
-        // through synthetic constructors.
+        // TODO(johnniwinther): Provide source information for creation through
+        // synthetic constructors.
         newObject.sourceInformation =
             sourceInformationBuilder.buildCreate(function);
       }
       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 (classElement.typeVariables.isNotEmpty &&
-        backend.classNeedsRti(classElement)) {
-      // Read the values of the type arguments and create a HTypeInfoExpression
-      // to set on the newly create object.
-      List<HInstruction> typeArguments = <HInstruction>[];
-      classElement.typeVariables.forEach((TypeVariableType typeVariable) {
-        HInstruction argument = localsHandler
-            .readLocal(localsHandler.getTypeVariableAsLocal(typeVariable));
-        typeArguments.add(argument);
-      });
-
-      HInstruction typeInfo = new HTypeInfoExpression(
-          TypeInfoExpressionKind.INSTANCE,
-          classElement.thisType,
-          typeArguments,
-          backend.dynamicType);
-      add(typeInfo);
-      newObject = callSetRuntimeTypeInfo(typeInfo, newObject);
-    }
 
     // Generate calls to the constructor bodies.
     HInstruction interceptor = null;
     for (int index = constructorResolvedAsts.length - 1; index >= 0; index--) {
       ResolvedAst constructorResolvedAst = constructorResolvedAsts[index];
       ConstructorBodyElement body = getConstructorBody(constructorResolvedAst);
       if (body == null) continue;
 
       List bodyCallInputs = <HInstruction>[];
       if (isNativeUpgradeFactory) {
@@ skipping 6005 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }