typeInformation in CreateInstance is a kind of TypeExpression

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.
 library dart2js.ir_nodes;
 
 import 'dart:collection';
 import 'cps_fragment.dart' show CpsFragment;
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
@@ skipping 1428 matching lines @@
 
   /// Initial values for the fields on the class.
   /// The order corresponds to the order of fields on the class.
   final List<Reference<Primitive>> arguments;
 
   /// The runtime type information structure which contains the type arguments.
   ///
   /// 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);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   toString() => 'CreateInstance($classElement)';
 
   void setParentPointers() {
     _setParentsOnList(arguments, this);
-    if (typeInformation != null) _setParentsOnList(typeInformation, this);
+    if (typeInformation != null) typeInformation.parent = this;
   }
 }
 
 /// Obtains the interceptor for the given value.  This is a method table
 /// corresponding to the Dart class of the value.
 ///
 /// All values are either intercepted or self-intercepted.  The interceptor for
 /// an "intercepted value" is one of the subclasses of Interceptor.
 /// The interceptor for a "self-intercepted value" is the value itself.
 ///
@@ skipping 268 matching lines @@
 ///
 /// The resulting value is constructed from [dartType] by replacing the type
 /// variables with consecutive values from [arguments], in the order generated
 /// by [DartType.forEachTypeVariable].  The type variables in [dartType] are
 /// treated as 'holes' in the term, which means that it must be ensured at
 /// construction, that duplicate occurences of a type variable in [dartType]
 /// are assigned the same value.
 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
   accept(Visitor visitor) {
     return visitor.visitTypeExpression(this);
   }
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
@@ skipping 369 matching lines @@
   processInterceptor(Interceptor node) {}
   visitInterceptor(Interceptor node) {
     processInterceptor(node);
     processReference(node.input);
   }
 
   processCreateInstance(CreateInstance node) {}
   visitCreateInstance(CreateInstance node) {
     processCreateInstance(node);
     node.arguments.forEach(processReference);
-    node.typeInformation.forEach(processReference);
+    if (node.typeInformation != null) processReference(node.typeInformation);
   }
 
   processSetField(SetField node) {}
   visitSetField(SetField node) {
     processSetField(node);
     processReference(node.object);
     processReference(node.value);
   }
 
   processGetField(GetField node) {}
@@ skipping 391 matching lines @@
   Definition visitGetStatic(GetStatic node) {
     return new GetStatic(node.element, node.sourceInformation);
   }
 
   Definition visitInterceptor(Interceptor node) {
     return new Interceptor(getCopy(node.input), node.sourceInformation)
         ..interceptedClasses.addAll(node.interceptedClasses);
   }
 
   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);
   }
 
   Definition visitGetField(GetField node) {
     return new GetField(getCopy(node.object), node.field);
   }
 
   Definition visitCreateBox(CreateBox node) {
     return new CreateBox();
   }
 
   Definition visitReifyRuntimeType(ReifyRuntimeType node) {
     return new ReifyRuntimeType(getCopy(node.value), node.sourceInformation);
   }
 
   Definition visitReadTypeVariable(ReadTypeVariable node) {
     return new ReadTypeVariable(node.variable, getCopy(node.target),
         node.sourceInformation);
   }
 
   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) {
     return new CreateInvocationMirror(node.selector, getList(node.arguments));
   }
 
   Definition visitTypeTest(TypeTest node) {
     return new TypeTest(getCopy(node.value), node.dartType,
         getList(node.typeArguments));
   }
@@ skipping 191 matching lines @@
     plug(new Branch.loose(_definitions.getCopy(node.condition),
         _copies[node.trueContinuation.definition],
         _copies[node.falseContinuation.definition])
       ..isStrictCheck = node.isStrictCheck);
   }
 
   visitUnreachable(Unreachable node) {
     plug(new Unreachable());
   }
 }