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

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/expressions.dart';
 import '../constants/values.dart' as values;
-import '../dart_types.dart' show DartType, GenericType, TypeVariableType;
+import '../dart_types.dart' show DartType, GenericType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
 import '../io/source_information.dart' show SourceInformation;
 import '../universe/universe.dart';
 import '../universe/universe.dart' show Selector;
 import 'optimization/optimization.dart';
 
 // The Tree language is the target of translation out of the CPS-based IR.
 //
 // The translation from CPS to Dart consists of several stages.  Among the
 // stages are translation to direct style, translation out of SSA, eliminating
@@ skipping 195 matching lines @@
 class InvokeConstructor extends Expression implements Invoke {
   final DartType type;
   final FunctionElement target;
   final List<Expression> arguments;
   final Selector selector;
   /// TODO(karlklose): get rid of this field.  Instead use the constant's
   /// expression to find the constructor to be called in dart2dart.
   final values.ConstantValue constant;
 
   InvokeConstructor(this.type, this.target, this.selector, this.arguments,
-      [this.constant]);
+                    [this.constant]);
 
   ClassElement get targetClass => target.enclosingElement;
 
-  accept(ExpressionVisitor visitor) => visitor.visitInvokeConstructor(this);
+  accept(ExpressionVisitor visitor) {
+    return visitor.visitInvokeConstructor(this);
+  }
+
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitInvokeConstructor(this, arg);
   }
 }
 
 /// Calls [toString] on each argument and concatenates the results.
 class ConcatenateStrings extends Expression {
   final List<Expression> arguments;
 
   ConcatenateStrings(this.arguments);
@@ skipping 485 matching lines @@
 abstract class DartSpecificNode implements Node {}
 
 class CreateBox extends Expression implements JsSpecificNode {
   accept(ExpressionVisitor visitor) => visitor.visitCreateBox(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitCreateBox(this, arg);
 }
 
 class CreateInstance extends Expression implements JsSpecificNode {
   ClassElement classElement;
   List<Expression> arguments;
+  List<Expression> typeInformation;
 
-  CreateInstance(this.classElement, this.arguments);
+  CreateInstance(this.classElement, this.arguments, this.typeInformation);
 
   accept(ExpressionVisitor visitor) => visitor.visitCreateInstance(this);
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitCreateInstance(this, arg);
   }
 }
 
 class GetField extends Expression implements JsSpecificNode {
   Expression object;
   Element field;
@@ skipping 38 matching lines @@
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitReadTypeVariable(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
     return visitor.visitReadTypeVariable(this, arg);
   }
 }
 
+/// 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;
+
+  TypeExpression(this.dartType, this.arguments);
+
+  accept(ExpressionVisitor visitor) {
+    return visitor.visitTypeExpression(this);
+  }
+
+  accept1(ExpressionVisitor1 visitor, arg) {
+    return visitor.visitTypeExpression(this, arg);
+  }
+}
+
 abstract class ExpressionVisitor<E> {
   E visitExpression(Expression e) => e.accept(this);
   E visitVariableUse(VariableUse node);
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitConcatenateStrings(ConcatenateStrings node);
   E visitConstant(Constant node);
   E visitThis(This node);
   E visitReifyTypeVar(ReifyTypeVar node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
   E visitTypeOperator(TypeOperator node);
   E visitFunctionExpression(FunctionExpression node);
   E visitFieldInitializer(FieldInitializer node);
   E visitSuperInitializer(SuperInitializer node);
   E visitGetField(GetField node);
   E visitCreateBox(CreateBox node);
   E visitCreateInstance(CreateInstance node);
   E visitReifyRuntimeType(ReifyRuntimeType node);
   E visitReadTypeVariable(ReadTypeVariable node);
+  E visitTypeExpression(TypeExpression node);
 }
 
 abstract class ExpressionVisitor1<E, A> {
   E visitExpression(Expression e, A arg) => e.accept1(this, arg);
   E visitVariableUse(VariableUse node, A arg);
   E visitInvokeStatic(InvokeStatic node, A arg);
   E visitInvokeMethod(InvokeMethod node, A arg);
   E visitInvokeMethodDirectly(InvokeMethodDirectly node, A arg);
   E visitInvokeConstructor(InvokeConstructor node, A arg);
   E visitConcatenateStrings(ConcatenateStrings node, A arg);
   E visitConstant(Constant node, A arg);
   E visitThis(This node, A arg);
   E visitReifyTypeVar(ReifyTypeVar node, A arg);
   E visitConditional(Conditional node, A arg);
   E visitLogicalOperator(LogicalOperator node, A arg);
   E visitNot(Not node, A arg);
   E visitLiteralList(LiteralList node, A arg);
   E visitLiteralMap(LiteralMap node, A arg);
   E visitTypeOperator(TypeOperator node, A arg);
   E visitFunctionExpression(FunctionExpression node, A arg);
   E visitFieldInitializer(FieldInitializer node, A arg);
   E visitSuperInitializer(SuperInitializer node, A arg);
   E visitGetField(GetField node, A arg);
   E visitCreateBox(CreateBox node, A arg);
   E visitCreateInstance(CreateInstance node, A arg);
-  E visitReifyRuntimeType(ReifyRuntimeType reifyRuntimeType, A arg);
-  E visitReadTypeVariable(ReadTypeVariable readTypeVariable, A arg);
+  E visitReifyRuntimeType(ReifyRuntimeType node, A arg);
+  E visitReadTypeVariable(ReadTypeVariable node, A arg);
+  E visitTypeExpression(TypeExpression node, A arg);
 }
 
 abstract class StatementVisitor<S> {
   S visitStatement(Statement s) => s.accept(this);
   S visitLabeledStatement(LabeledStatement node);
   S visitAssign(Assign node);
   S visitReturn(Return node);
   S visitBreak(Break node);
   S visitContinue(Continue node);
   S visitIf(If node);
@@ skipping 210 matching lines @@
     node.arguments.forEach(visitExpression);
   }
 
   visitReifyRuntimeType(ReifyRuntimeType node) {
     visitExpression(node.value);
   }
 
   visitReadTypeVariable(ReadTypeVariable node) {
     visitExpression(node.target);
   }
+
+  @override
+  visitTypeExpression(TypeExpression node) {
+    node.arguments.forEach(visitExpression);

[asgerf, 2015/03/19 14:53:40]

Also visit the type information expressions.

This is probably why integrity checks fail because the integrity checker cannot
see the use of the variable, but still sees its reference count.

[karlklose, 2015/03/20 07:39:04]

Thanks for catching that!

+  }
 }