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 2274 matching lines @@
         // implementation.
         assert(invariant(
             member, isNativeUpgradeFactory || compiler.compilationFailed));
       } else {
         fields.add(member);
         DartType type = localsHandler.substInContext(member.type);
         constructorArguments.add(potentiallyCheckOrTrustType(value, type));
       }
     }, includeSuperAndInjectedMembers: true);
 
-    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);
-      if (function != null) {
-        // 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 (backend.classNeedsRti(classElement)) {
       // 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].
@@ skipping 46 matching lines @@
       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);
+        // TODO(sra): Make this an instruction.
+        js.Template code = js.js.parseForeignJS(r'#.$ti');
+        HInstruction typeInfo = new HForeignCode(
+            code, backend.stringType,
+            <HInstruction>[source],
+            nativeBehavior: native.NativeBehavior.PURE);
+        add(typeInfo);
+        constructorArguments.add(typeInfo);
       } else {
-        newObject =
-            callSetRuntimeTypeInfo(classElement, typeArguments, newObject);
+        HInstruction typeInfo = buildLiteralList(typeArguments);
+        add(typeInfo);
+        constructorArguments.add(typeInfo);
       }
     }
 
+    InterfaceType type = classElement.thisType;

[Siggi Cherem (dart-lang), 2016/08/19 16:39:46]

just to make sure I didn't miss anything: this code here and below just moved
from above, but otherwise is the same, correct?

[sra1, 2017/02/23 23:46:41]

Yes. Since the type arguments are now a parameter, the code needed to be done
before creating the call, instead of after.

+    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);
+      if (function != null) {
+        // 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);
+
+
     // 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) {
         if (interceptor == null) {
@@ skipping 2438 matching lines @@
 
   void copyRuntimeTypeInfo(HInstruction source, HInstruction target) {
     Element copyHelper = helpers.copyTypeArguments;
     pushInvokeStatic(null, copyHelper, [source, target],
         sourceInformation: target.sourceInformation);
     pop();
   }
 
   HInstruction callSetRuntimeTypeInfo(ClassElement element,
       List<HInstruction> rtiInputs, HInstruction newObject) {
-    if (!backend.classNeedsRti(element) || element.typeVariables.isEmpty) {
+    if (!backend.classNeedsRti(element)) {
       return newObject;
     }
 
     HInstruction typeInfo = buildLiteralList(rtiInputs);
     add(typeInfo);
 
     // Set the runtime type information on the object.
     Element typeInfoSetterElement = helpers.setRuntimeTypeInfo;
     pushInvokeStatic(
         null, typeInfoSetterElement, <HInstruction>[newObject, typeInfo],
@@ skipping 226 matching lines @@
         pop();
         stack.add(checked);
       }
     }
   }
 
   void potentiallyAddTypeArguments(
       List<HInstruction> inputs, ClassElement cls, InterfaceType expectedType,
       {SourceInformation sourceInformation}) {
     if (!backend.classNeedsRti(cls)) return;
-    assert(expectedType.typeArguments.isEmpty ||
-        cls.typeVariables.length == expectedType.typeArguments.length);
+    assert(cls.typeVariables.length == expectedType.typeArguments.length);
     expectedType.typeArguments.forEach((DartType argument) {
       inputs.add(
           analyzeTypeArgument(argument, sourceInformation: sourceInformation));
     });
   }
 
   /// In checked mode checks the [type] of [node] to be well-bounded. The method
   /// returns [:true:] if an error can be statically determined.
   bool checkTypeVariableBounds(ast.NewExpression node, InterfaceType type) {
     if (!compiler.options.enableTypeAssertions) return false;
@@ skipping 3541 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;
 }