dart2js cps: Direct access on JS arrays.

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, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
@@ skipping 699 matching lines @@
   Element element;
   Expression value;
   SourceInformation sourceInformation;
 
   SetStatic(this.element, this.value, this.sourceInformation);
 
   accept(ExpressionVisitor visitor) => visitor.visitSetStatic(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitSetStatic(this, arg);
 }
 
+class GetLength extends Expression {
+  Expression object;
+
+  GetLength(this.object);
+
+  accept(ExpressionVisitor v) => v.visitGetLength(this);
+  accept1(ExpressionVisitor1 v, arg) => v.visitGetLength(this, arg);
+}
+
+class GetIndex extends Expression {
+  Expression object;
+  Expression index;
+
+  GetIndex(this.object, this.index);
+
+  accept(ExpressionVisitor v) => v.visitGetIndex(this);
+  accept1(ExpressionVisitor1 v, arg) => v.visitGetIndex(this, arg);
+}
+
+class SetIndex extends Expression {
+  Expression object;
+  Expression index;
+  Expression value;
+
+  SetIndex(this.object, this.index, this.value);
+
+  accept(ExpressionVisitor v) => v.visitSetIndex(this);
+  accept1(ExpressionVisitor1 v, arg) => v.visitSetIndex(this, arg);
+}
+
 class ReifyRuntimeType extends Expression {
   Expression value;
 
   ReifyRuntimeType(this.value);
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitReifyRuntimeType(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
@@ skipping 136 matching lines @@
   E visitSetStatic(SetStatic node);
   E visitCreateBox(CreateBox node);
   E visitCreateInstance(CreateInstance node);
   E visitReifyRuntimeType(ReifyRuntimeType node);
   E visitReadTypeVariable(ReadTypeVariable node);
   E visitTypeExpression(TypeExpression node);
   E visitCreateInvocationMirror(CreateInvocationMirror node);
   E visitInterceptor(Interceptor node);
   E visitApplyBuiltinOperator(ApplyBuiltinOperator node);
   E visitForeignExpression(ForeignExpression node);
+  E visitGetLength(GetLength node);
+  E visitGetIndex(GetIndex node);
+  E visitSetIndex(SetIndex node);
 }
 
 abstract class ExpressionVisitor1<E, A> {
   E visitExpression(Expression node, A arg) => node.accept1(this, arg);
   E visitVariableUse(VariableUse node, A arg);
   E visitAssign(Assign 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);
@@ skipping 12 matching lines @@
   E visitSetStatic(SetStatic node, A arg);
   E visitCreateBox(CreateBox node, A arg);
   E visitCreateInstance(CreateInstance node, A arg);
   E visitReifyRuntimeType(ReifyRuntimeType node, A arg);
   E visitReadTypeVariable(ReadTypeVariable node, A arg);
   E visitTypeExpression(TypeExpression node, A arg);
   E visitCreateInvocationMirror(CreateInvocationMirror node, A arg);
   E visitInterceptor(Interceptor node, A arg);
   E visitApplyBuiltinOperator(ApplyBuiltinOperator node, A arg);
   E visitForeignExpression(ForeignExpression node, A arg);
+  E visitGetLength(GetLength node, A arg);
+  E visitGetIndex(GetIndex node, A arg);
+  E visitSetIndex(SetIndex node, A arg);
 }
 
 abstract class StatementVisitor<S> {
   S visitStatement(Statement node) => node.accept(this);
   S visitLabeledStatement(LabeledStatement node);
   S visitReturn(Return node);
   S visitThrow(Throw node);
   S visitRethrow(Rethrow node);
   S visitBreak(Break node);
   S visitContinue(Continue node);
@@ skipping 192 matching lines @@
   visitInterceptor(Interceptor node) {
     visitExpression(node.input);
   }
 
   visitForeignCode(ForeignCode node) {
     node.arguments.forEach(visitExpression);
   }
 
   visitForeignExpression(ForeignExpression node) => visitForeignCode(node);
   visitForeignStatement(ForeignStatement node) => visitForeignCode(node);
+
+  visitGetLength(GetLength node) {
+    visitExpression(node.object);
+  }
+
+  visitGetIndex(GetIndex node) {
+    visitExpression(node.object);
+    visitExpression(node.index);
+  }
+
+  visitSetIndex(SetIndex node) {
+    visitExpression(node.object);
+    visitExpression(node.index);
+    visitExpression(node.value);
+  }
 }
 
 abstract class Transformer implements ExpressionVisitor<Expression>,
                                       StatementVisitor<Statement> {
    Expression visitExpression(Expression e) => e.accept(this);
    Statement visitStatement(Statement s) => s.accept(this);
 }
 
 class RecursiveTransformer extends Transformer {
   void visitInnerFunction(FunctionDefinition node) {
@@ skipping 195 matching lines @@
 
   visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 
   visitInterceptor(Interceptor node) {
     node.input = visitExpression(node.input);
     return node;
   }
+
+  visitGetLength(GetLength node) {
+    node.object = visitExpression(node.object);
+    return node;
+  }
+
+  visitGetIndex(GetIndex node) {
+    node.object = visitExpression(node.object);
+    node.index = visitExpression(node.index);
+    return node;
+  }
+
+  visitSetIndex(SetIndex node) {
+    node.object = visitExpression(node.object);
+    node.index = visitExpression(node.index);
+    node.value = visitExpression(node.value);
+    return node;
+  }
 }
 
 class FallthroughTarget {
   final Statement target;
   int useCount = 0;
 
   FallthroughTarget(this.target);
 }
 
 /// A stack machine for tracking fallthrough while traversing the Tree IR.
@@ skipping 17 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;
   }
 }