typeInformation in CreateInstance is a kind of TypeExpression

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 aaf7baf8e48ad7012daff9dc7b3365697c78826a..08ea8bac0c1e070ade74d32e89f754e473115942 100644
--- a/pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart
+++ b/pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart
@@ -1446,15 +1446,17 @@ class CreateInstance extends Primitive {
   /// May be `null` to indicate that no type information is needed because the
   /// compiler determined that the type information for instances of this class
   /// is not needed at runtime.
-  final List<Reference<Primitive>> typeInformation;
+  final Reference<Primitive> typeInformation;
 
   final SourceInformation sourceInformation;
 
   CreateInstance(this.classElement, List<Primitive> arguments,
-      List<Primitive> typeInformation,
+      Primitive typeInformation,
       this.sourceInformation)
       : this.arguments = _referenceList(arguments),
-        this.typeInformation = _referenceList(typeInformation);
+        this.typeInformation = typeInformation == null
+            ? null
+            : new Reference<Primitive>(typeInformation);
 
   accept(Visitor visitor) => visitor.visitCreateInstance(this);
 
@@ -1466,7 +1468,7 @@ class CreateInstance extends Primitive {
 
   void setParentPointers() {
     _setParentsOnList(arguments, this);
-    if (typeInformation != null) _setParentsOnList(typeInformation, this);
+    if (typeInformation != null) typeInformation.parent = this;
   }
 }
 
@@ -1755,9 +1757,11 @@ class ReadTypeVariable extends Primitive {
 class TypeExpression extends Primitive {
   final DartType dartType;
   final List<Reference<Primitive>> arguments;
+  final bool isForInstance;  // Expression on instance has 'headless' form.

[asgerf, 2016/01/26 10:30:00]

The name and comment are obscure without more details.

For a long time I thought 'headless' meant just the head of the outermost term
was omitted. For example:

List<Map<X, Y>> => [Map, X, Y]
Map<X, List<Y>> => [X, [List, Y]]

But it's really just [X, Y] in both cases.

Since dartType is unused, I think it's better to set dartType to null and
replace 'isForInstance' with a getter if it is still needed.

Also update the doc comment for the class to indicate that if dartType is
omitted, it just returns the arguments in a new array.

[sra1, 2016/01/26 22:21:08]

It is flat because the dartType is always the 'thisType' which has a fixed list
of type parameters.
I'm going to keep the dartType because it will be needed for constant folding.
Longer term I want to rewrite the type getters in terms of reading the type
information  and doing other TypeExpression operations. We will be able to
store-forward the type info and constant fold it for the new use (e.g. inlining
WhereIterable<T> -> WhereIterator<T>).

Currently we need the instance and the vector of type parameters to answer many
questions. Eventually I think the stored type should be in a form that is not
'headless', so the type operations can be performed without instances.

[asgerf, 2016/01/27 14:53:26]

CreateInstance is not always going to create the 'this' type of something.
Inlining of generic constructors will change that
(https://codereview.chromium.org/1584543002).

So the term "headless flat" bothers me, because they are not the same, and we
can't pretend they are the same forever.

I would much rather have an instruction that takes a list of values and puts
them in an immutable array.  Simple as that, a list of types, no magic
interpretation.  We could have a separate TypeVector instruction for that, or a
variant of TypeExpression could do it.

That is how the INSTANCE form seems to work right now, but the documentation
suggests something more complex is going on, and then there is this dartType
that is unused, but somehow still needed for something?

At the very least add an assertion in codegen to check that the dartType indeed
has the required form, and add a TODO explaining that the restriction is
something we want to remove eventually.  Otherwise it's going to manifest itself
as a bug later on.

(The bool field is still there btw, it should be removed).

[sra1, 2016/01/27 19:20:03]

After inlining, the TypeExpression(INSTANCE) will have a different dartType to
the CreateInstance
This is OK - the arguments to TypeExpression(INSTANCE) will be changed if
necessary to TypeExpression(COMPLETE) (composition) or
ReadTypeVariable(instance, tv) (decomposition).
Done

 
   TypeExpression(this.dartType,
-                 [List<Primitive> arguments = const <Primitive>[]])
+                 List<Primitive> arguments,
+                 this.isForInstance)
       : this.arguments = _referenceList(arguments);
 
   @override
@@ -2147,7 +2151,7 @@ class DeepRecursiveVisitor implements Visitor {
   visitCreateInstance(CreateInstance node) {
     processCreateInstance(node);
     node.arguments.forEach(processReference);
-    node.typeInformation.forEach(processReference);
+    if (node.typeInformation != null) processReference(node.typeInformation);
   }
 
   processSetField(SetField node) {}
@@ -2559,8 +2563,10 @@ class DefinitionCopyingVisitor extends Visitor<Definition> {
   }
 
   Definition visitCreateInstance(CreateInstance node) {
-    return new CreateInstance(node.classElement, getList(node.arguments),
-        getList(node.typeInformation),
+    return new CreateInstance(
+        node.classElement,
+        getList(node.arguments),
+        node.typeInformation == null ? null : getCopy(node.typeInformation),
         node.sourceInformation);
   }
 
@@ -2582,7 +2588,8 @@ class DefinitionCopyingVisitor extends Visitor<Definition> {
   }
 
   Definition visitTypeExpression(TypeExpression node) {
-    return new TypeExpression(node.dartType, getList(node.arguments));
+    return new TypeExpression(
+        node.dartType, getList(node.arguments), node.isForInstance);
   }
 
   Definition visitCreateInvocationMirror(CreateInvocationMirror node) {