Add type info to JSArray.

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;
 import '../types/types.dart' show TypeMask;
 import '../universe/selector.dart' show Selector;
 
 import '../cps_ir/builtin_operator.dart';
 export '../cps_ir/builtin_operator.dart';
+import '../cps_ir/cps_ir_nodes.dart' show TypeExpressionKind;
+export '../cps_ir/cps_ir_nodes.dart' show TypeExpressionKind;
 
 // These imports are only used for the JavaScript specific nodes.  If we want to
 // support more than one native backend, we should probably create better
 // abstractions for native code and its type and effect system.
 import '../js/js.dart' as js show Template;
 import '../native/native.dart' as native show NativeBehavior;
 import '../types/types.dart' as types show TypeMask;
 
 // The Tree language is the target of translation out of the CPS-based IR.
 //
@@ skipping 81 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 212 matching lines @@
   Statement get next => null;
 
   @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 TypeExpressionKind kind;
   final DartType dartType;
   final List<Expression> arguments;
 
-  TypeExpression(this.dartType, this.arguments);
+  TypeExpression(this.kind, this.dartType, this.arguments);
 
   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);
+    }
     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;
   }
 }