dart2js cps: Introduce GetStatic/SetStatic.

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, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
@@ skipping 855 matching lines @@
   Expression object;
   Element field;
   Expression value;
 
   SetField(this.object, this.field, this.value);
 
   accept(ExpressionVisitor visitor) => visitor.visitSetField(this);
   accept1(ExpressionVisitor1 visitor, arg) => visitor.visitSetField(this, arg);
 }
 
+class GetStatic extends Expression {
+  Element element;
+  SourceInformation sourceInformation;
+
+  GetStatic(this.element, this.sourceInformation);
+
+  accept(ExpressionVisitor visitor) => visitor.visitGetStatic(this);
+  accept1(ExpressionVisitor1 visitor, arg) => visitor.visitGetStatic(this, arg);
+}
+
+
+class SetStatic extends Expression {
+  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 ReifyRuntimeType extends Expression implements JsSpecificNode {
   Expression value;
 
   ReifyRuntimeType(this.value);
 
   accept(ExpressionVisitor visitor) {
     return visitor.visitReifyRuntimeType(this);
   }
 
   accept1(ExpressionVisitor1 visitor, arg) {
@@ skipping 62 matching lines @@
   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 visitGetField(GetField node);
+  E visitSetField(SetField node);
+  E visitGetStatic(GetStatic node);
+  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 visitSetField(SetField node);
   E visitCreateInvocationMirror(CreateInvocationMirror 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);
   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 visitGetField(GetField node, A arg);
+  E visitSetField(SetField node, A arg);
+  E visitGetStatic(GetStatic node, A arg);
+  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 visitSetField(SetField node, A arg);
   E visitCreateInvocationMirror(CreateInvocationMirror 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);
@@ skipping 187 matching lines @@
 
   visitGetField(GetField node) {
     visitExpression(node.object);
   }
 
   visitSetField(SetField node) {
     visitExpression(node.object);
     visitExpression(node.value);
   }
 
+  visitGetStatic(GetStatic node) {
+  }
+
+  visitSetStatic(SetStatic node) {
+    visitExpression(node.value);
+  }
+
   visitCreateBox(CreateBox node) {
   }
 
   visitCreateInstance(CreateInstance node) {
     node.arguments.forEach(visitExpression);
     node.typeInformation.forEach(visitExpression);
   }
 
   visitReifyRuntimeType(ReifyRuntimeType node) {
     visitExpression(node.value);
@@ skipping 178 matching lines @@
     node.object = visitExpression(node.object);
     return node;
   }
 
   visitSetField(SetField node) {
     node.object = visitExpression(node.object);
     node.value = visitExpression(node.value);
     return node;
   }
 
+  visitGetStatic(GetStatic node) => node;
+
+  visitSetStatic(SetStatic node) {
+    node.value = visitExpression(node.value);
+    return node;
+  }
+
   visitCreateBox(CreateBox node) => node;
 
   visitCreateInstance(CreateInstance node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 
   visitReifyRuntimeType(ReifyRuntimeType node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
   visitReadTypeVariable(ReadTypeVariable node) {
     node.target = visitExpression(node.target);
     return node;
   }
 
   visitTypeExpression(TypeExpression node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 
   visitCreateInvocationMirror(CreateInvocationMirror node) {
     _replaceExpressions(node.arguments);
     return node;
   }
 }