cps-ir: Set runtime type information for new objects that require it.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

Index: pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart
diff --git a/pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart b/pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart
index 1510315ede7eaabeb732eeebadcf722b4dd8ab3a..49d94ea2fef66cb83cf2ad665e9b968034d0702f 100644
--- a/pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart
+++ b/pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart
@@ -361,10 +361,14 @@ class InvokeMethodDirectly extends Expression implements Invoke {
 /// Non-const call to a constructor. The [target] may be a generative
 /// constructor, factory, or redirecting factory.
 class InvokeConstructor extends Expression implements Invoke {

[karlklose, 2015/03/18 08:44:51]

Alternatively, we could split this into two backend specific classes.

[asgerf, 2015/03/18 10:18:06]

Following my comment in codegen, I think constructor calls should be translated
to InvokeStatic where the type arguments are passed as ordinary arguments.

+  /// [type] encodes the instantiated type for the [DartBackend]; it must be
+  /// `null` in the [JavaScriptBackend].
   final DartType type;
   final FunctionElement target;
   final Reference<Continuation> continuation;
   final List<Reference<Primitive>> arguments;
+  /// The type arguments are used in the [JavaScriptBackend].
+  final List<Reference<Primitive>> typeArguments;
   final Selector selector;
 
   /// The class being instantiated. This is the same as `target.enclosingClass`
@@ -374,23 +378,35 @@ class InvokeConstructor extends Expression implements Invoke {
   /// True if this is an invocation of a factory constructor.
   bool get isFactory => target.isFactoryConstructor;
 
-  InvokeConstructor(this.type,
-                    this.target,
-                    this.selector,
-                    Continuation cont,
-                    List<Primitive> args)
+  InvokeConstructor.byType(this.type,
+                           this.target,
+                           this.selector,
+                           Continuation cont,
+                           List<Primitive> args)
       : continuation = new Reference<Continuation>(cont),
-        arguments = _referenceList(args) {
-    assert(dart2js.invariant(target,
-        target.isErroneous || target.isConstructor,
-        message: "Constructor invocation target is not a constructor: "
-                 "$target."));
+        arguments = _referenceList(args),
+        typeArguments = const <Reference<Primitive>>[] {
     assert(dart2js.invariant(target,
         target.isErroneous ||
         type.isDynamic ||
         type.element == target.enclosingClass.declaration,
-        message: "Constructor invocation type ${type} does not match enclosing "
-                 "class of target ${target}."));
+        message: "Constructor invocation target is not a constructor: "
+                 "$target."));
+  }
+
+  InvokeConstructor.withTypeArguments(this.target,
+                                      this.selector,
+                                      Continuation cont,
+                                      List<Primitive> args,
+                                      List<Primitive> typeArguments)
+      : type = null,
+        continuation = new Reference<Continuation>(cont),
+        arguments = _referenceList(args),
+        typeArguments = _referenceList(typeArguments) {
+    assert(dart2js.invariant(target,
+        target.isErroneous || target.isConstructor,
+        message: "Constructor invocation target is not a constructor: "
+                 "$target."));
   }
 
   accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
@@ -898,6 +914,22 @@ class ReadTypeVariable extends Primitive implements JsSpecificNode {
   accept(Visitor visitor) => visitor.visitReadTypeVariable(this);
 }
 

[asgerf, 2015/03/18 10:18:06]

It's not clear to me what dartType should be.

If I want to build List<String>, should I use List and String as argument, or do
I use List<String> and no arguments?

And what if I want to build Map<X, Map<Y, X>>? Do I build it recursively, like,

let Z = Map<Y, X> in Map<X, Z>

or can I build it with a single TypeExpression with dartType=Map<X, Map<Y, X>>?

In the latter case, how do I know the order of the type arguments, do I pass [Y,
X] or [X, Y]?

If it's the first case, it would be more clear if we just have a ClassElement
instead of DartType; then the arguments are just the type arguments in the order
declared in that class.

+/// Denotes the internal representation of [dartType], where all type variables
+/// are replaced by the values in [arguments].
+class TypeExpression extends Primitive implements JsSpecificNode {
+  final DartType dartType;
+  final List<Reference<Primitive>> arguments;
+
+  TypeExpression(this.dartType,
+                 [List<Primitive> arguments = const <Primitive>[]])
+      : this.arguments = _referenceList(arguments);
+
+  @override
+  accept(Visitor visitor) {
+    return visitor.visitTypeExpression(this);
+  }
+}
+
 List<Reference<Primitive>> _referenceList(Iterable<Primitive> definitions) {
   return definitions.map((e) => new Reference<Primitive>(e)).toList();
 }
@@ -961,6 +993,7 @@ abstract class Visitor<T> {
   T visitCreateBox(CreateBox node);
   T visitReifyRuntimeType(ReifyRuntimeType node);
   T visitReadTypeVariable(ReadTypeVariable node);
+  T visitTypeExpression(TypeExpression node);
 }
 
 /// Recursively visits the entire CPS term, and calls abstract `process*`
@@ -1082,6 +1115,7 @@ class RecursiveVisitor implements Visitor {
     processInvokeConstructor(node);
     processReference(node.continuation);
     node.arguments.forEach(processReference);
+    node.typeArguments.forEach(processReference);
   }
 
   processConcatenateStrings(ConcatenateStrings node) {}
@@ -1233,6 +1267,13 @@ class RecursiveVisitor implements Visitor {
     processReadTypeVariable(node);
     processReference(node.target);
   }
+
+  processTypeExpression(TypeExpression node) {}
+  @override
+  visitTypeExpression(TypeExpression node) {
+    processTypeExpression(node);
+    node.arguments.forEach(processReference);
+  }
 }
 
 /// Keeps track of currently unused register indices.
@@ -1393,6 +1434,7 @@ class RegisterAllocator implements Visitor {
 
   void visitInvokeConstructor(InvokeConstructor node) {
     node.arguments.forEach(visitReference);
+    node.typeArguments.forEach(visitReference);
   }
 
   void visitConcatenateStrings(ConcatenateStrings node) {
@@ -1505,4 +1547,9 @@ class RegisterAllocator implements Visitor {
   void visitReadTypeVariable(ReadTypeVariable node) {
     visitReference(node.target);
   }
+
+  @override
+  visitTypeExpression(TypeExpression node) {
+    node.arguments.forEach(visitReference);
+  }
 }