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

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

 // Copyright (c) 2013, 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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' as values show ConstantValue;
@@ skipping 342 matching lines @@
            (selector.kind == SelectorKind.SETTER && arguments.length == 1) ||
            (selector.kind == SelectorKind.INDEX && arguments.length == 1) ||
            (selector.kind == SelectorKind.INDEX && arguments.length == 2));
   }
 
   accept(Visitor visitor) => visitor.visitInvokeMethodDirectly(this);
 }
 
 /// 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`
   /// and `type.element`.
   ClassElement get targetClass => target.enclosingElement;
 
   /// 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) {
+        arguments = _referenceList(args),
+        typeArguments = const <Reference<Primitive>>[] {
+    assert(dart2js.invariant(target,
+        target.isErroneous ||
+        type.isDynamic ||
+        type.element == target.enclosingClass.declaration,
+        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."));
-    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}."));
   }
 
   accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
 }
 
 /// "as" casts and "is" checks.
 // We might want to turn "is"-checks into a [Primitive] as it can never diverge.
 // But then we need to special-case for is-checks with an erroneous .type as
 // these will throw.
 class TypeOperator extends Expression {
@@ skipping 486 matching lines @@
 class ReadTypeVariable extends Primitive implements JsSpecificNode {
   final TypeVariableType variable;
   final Reference<Primitive> target;
 
   ReadTypeVariable(this.variable, Primitive target)
       : this.target = new Reference<Primitive>(target);
 
   @override
   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();
 }
 
 abstract class Visitor<T> {
   const Visitor();
 
   T visit(Node node);
 
   // Concrete classes.
@@ skipping 43 matching lines @@
   T visitSetField(SetField node);
 
   // Definitions.
   T visitIdentical(Identical node);
   T visitInterceptor(Interceptor node);
   T visitCreateInstance(CreateInstance node);
   T visitGetField(GetField node);
   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*`
 /// (i.e. `processLetPrim`) functions in pre-order.
 class RecursiveVisitor implements Visitor {
   const RecursiveVisitor();
 
   visit(Node node) => node.accept(this);
 
   processReference(Reference ref) {}
@@ skipping 101 matching lines @@
     processReference(node.receiver);
     processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
   processInvokeConstructor(InvokeConstructor node) {}
   visitInvokeConstructor(InvokeConstructor node) {
     processInvokeConstructor(node);
     processReference(node.continuation);
     node.arguments.forEach(processReference);
+    node.typeArguments.forEach(processReference);
   }
 
   processConcatenateStrings(ConcatenateStrings node) {}
   visitConcatenateStrings(ConcatenateStrings node) {
     processConcatenateStrings(node);
     processReference(node.continuation);
     node.arguments.forEach(processReference);
   }
 
   processBranch(Branch node) {}
@@ skipping 131 matching lines @@
   visitReifyRuntimeType(ReifyRuntimeType node) {
     processReifyRuntimeType(node);
     processReference(node.value);
   }
 
   processReadTypeVariable(ReadTypeVariable node) {}
   visitReadTypeVariable(ReadTypeVariable node) {
     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.
 class RegisterArray {
   int nextIndex = 0;
   final List<int> freeStack = <int>[];
 
   /// Returns an index that is currently unused.
   int makeIndex() {
     if (freeStack.isEmpty) {
@@ skipping 140 matching lines @@
     node.arguments.forEach(visitReference);
   }
 
   void visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     visitReference(node.receiver);
     node.arguments.forEach(visitReference);
   }
 
   void visitInvokeConstructor(InvokeConstructor node) {
     node.arguments.forEach(visitReference);
+    node.typeArguments.forEach(visitReference);
   }
 
   void visitConcatenateStrings(ConcatenateStrings node) {
     node.arguments.forEach(visitReference);
   }
 
   void visitBranch(Branch node) {
     visit(node.condition);
   }
 
@@ skipping 92 matching lines @@
     visitReference(node.input);
   }
 
   void visitReifyRuntimeType(ReifyRuntimeType node) {
     visitReference(node.value);
   }
 
   void visitReadTypeVariable(ReadTypeVariable node) {
     visitReference(node.target);
   }
+
+  @override
+  visitTypeExpression(TypeExpression node) {
+    node.arguments.forEach(visitReference);
+  }
 }