typeInformation in CreateInstance is a kind of TypeExpression

pkg/compiler/lib/src/tree_ir/tree_ir_nodes.dart

 // Copyright (c) 2014, 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 tree_ir_nodes;
 
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
@@ skipping 96 matching lines @@
   int writeCount = 0;
 
   /// True if an inner JS function might access this variable through a
   /// [ForeignCode] node.
   bool isCaptured = false;
 
   Variable(this.host, this.element) {
     assert(host != null);
   }
 
-  String toString() => element == null ? 'Variable' : element.toString();
+  String toString() => element == null ? 'Variable.${hashCode}' : element.toString();
 }
 
 /// Read the value of a variable.
 class VariableUse extends Expression {
   Variable variable;
 
   /// Creates a use of [variable] and updates its `readCount`.
   VariableUse(this.variable) {
     variable.readCount++;
   }
@@ skipping 534 matching lines @@
 }
 
 class CreateBox extends Expression {
   accept(ExpressionVisitor visitor) => visitor.visitCreateBox(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitCreateBox(this, arg);
 }
 
 class CreateInstance extends Expression {
   ClassElement classElement;
   List<Expression> arguments;
-  List<Expression> typeInformation;
+  Expression typeInformation;
   SourceInformation sourceInformation;
 
   CreateInstance(this.classElement, this.arguments,
                  this.typeInformation, this.sourceInformation);
 
   accept(ExpressionVisitor visitor) => visitor.visitCreateInstance(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitCreateInstance(this, arg);
   }
 }
@@ skipping 214 matching lines @@
   @override
   void set next(Statement s) => throw 'UNREACHABLE';
 }
 
 /// Denotes the internal representation of [dartType], where all type variables
 /// are replaced by the values in [arguments].
 /// (See documentation on the TypeExpression CPS node for more details.)
 class TypeExpression extends Expression {
   final DartType dartType;
   final List<Expression> arguments;
+  final bool isForInstance;
 
-  TypeExpression(this.dartType, this.arguments);
+  TypeExpression(this.dartType, this.arguments, this.isForInstance);
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitTypeExpression(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitTypeExpression(this, arg);
   }
 }
 
@@ skipping 290 matching lines @@
 
   visitGetTypeTestProperty(GetTypeTestProperty node) {
     visitExpression(node.object);
   }
 
   visitCreateBox(CreateBox node) {
   }
 
   visitCreateInstance(CreateInstance node) {
     node.arguments.forEach(visitExpression);
-    node.typeInformation.forEach(visitExpression);
+    if (node.typeInformation != null) visitExpression(node.typeInformation);
   }
 
   visitReifyRuntimeType(ReifyRuntimeType node) {
     visitExpression(node.value);
   }
 
   visitReadTypeVariable(ReadTypeVariable node) {
     visitExpression(node.target);
   }
 
@@ skipping 220 matching lines @@
 
   visitGetTypeTestProperty(GetTypeTestProperty node) {
     node.object = visitExpression(node.object);
     return node;
   }
 
   visitCreateBox(CreateBox node) => node;
 
   visitCreateInstance(CreateInstance node) {
     _replaceExpressions(node.arguments);
-    _replaceExpressions(node.typeInformation);
+    if (node.typeInformation != null)
+      node.typeInformation = visitExpression(node.typeInformation);

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

I have been told we need {} around the body of multi-line if.

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

Done.

     return node;
   }
 
   visitReifyRuntimeType(ReifyRuntimeType node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
   visitReadTypeVariable(ReadTypeVariable node) {
     node.target = visitExpression(node.target);
@@ skipping 107 matching lines @@
 
   /// Number of uses of the current fallthrough target.
   int get useCount => _stack.last.useCount;
 
   /// Indicate that a statement will fall through to the current fallthrough
   /// target.
   void use() {
     ++_stack.last.useCount;
   }
 }