dart2js cps: Streamline expressions and primitives.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

 // Copyright (c) 2013, 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 dart2js.ir_nodes;
 
 import '../constants/values.dart' as values show ConstantValue;
 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;
@@ skipping 561 matching lines @@
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => false;
 }
 
 /// Assign a [MutableVariable].
 ///
 /// [MutableVariable]s can be seen as ref cells that are not first-class
 /// values.  This can be seen as a dereferencing assignment:
 ///
 ///   { [variable] := [value]; [body] }
-class SetMutableVariable extends InteriorExpression {
+class SetMutableVariable extends Primitive {
   final Reference<MutableVariable> variable;
   final Reference<Primitive> value;
-  Expression body;
 
   SetMutableVariable(MutableVariable variable, Primitive value)
       : this.variable = new Reference<MutableVariable>(variable),
         this.value = new Reference<Primitive>(value);
 
   accept(Visitor visitor) => visitor.visitSetMutableVariable(this);
 
-  Expression plug(Expression expr) {
-    assert(body == null);
-    return body = expr;
-  }
+  bool get isSafeForElimination => false;
+  bool get isSafeForReordering => false;
 }
 
 /// Invoke a continuation in tail position.
 class InvokeContinuation extends TailExpression {
   Reference<Continuation> continuation;
   List<Reference<Primitive>> arguments;
   SourceInformation sourceInformation;
 
   // An invocation of a continuation is recursive if it occurs in the body of
   // the continuation itself.
@@ skipping 48 matching lines @@
   final Reference<Continuation> falseContinuation;
 
   Branch(this.condition, Continuation trueCont, Continuation falseCont)
       : trueContinuation = new Reference<Continuation>(trueCont),
         falseContinuation = new Reference<Continuation>(falseCont);
 
   accept(Visitor visitor) => visitor.visitBranch(this);
 }
 
 /// Directly assigns to a field on a given object.
-class SetField extends InteriorExpression {
+class SetField extends Primitive {
   final Reference<Primitive> object;
   FieldElement field;
   final Reference<Primitive> value;
-  Expression body;
 
   SetField(Primitive object, this.field, Primitive value)
       : this.object = new Reference<Primitive>(object),
         this.value = new Reference<Primitive>(value);
 
-  Expression plug(Expression expr) {
-    assert(body == null);
-    return body = expr;
-  }
-
   accept(Visitor visitor) => visitor.visitSetField(this);
+  
+  bool get isSafeForElimination => false;
+  bool get isSafeForReordering => false;
 }
 
 /// Directly reads from a field on a given object.
 ///
 /// The [object] must either be `null` or an object that has [field].
 class GetField extends Primitive {
   final Reference<Primitive> object;
   FieldElement field;
 
   /// True if the object is known not to be null.
@@ skipping 80 matching lines @@
 
   bool get isSafeForElimination {
     return true;
   }
   bool get isSafeForReordering {
     return element is FunctionElement || element.isFinal;
   }
 }
 
 /// Sets the value of a static field.
-class SetStatic extends InteriorExpression {
+class SetStatic extends Primitive {
   final FieldElement element;
   final Reference<Primitive> value;
-  Expression body;
   final SourceInformation sourceInformation;
 
   SetStatic(this.element, Primitive value, [this.sourceInformation])
       : this.value = new Reference<Primitive>(value);
 
-  Expression plug(Expression expr) {
-    assert(body == null);
-    return body = expr;
-  }
+  accept(Visitor visitor) => visitor.visitSetStatic(this);
 
-  accept(Visitor visitor) => visitor.visitSetStatic(this);
+  bool get isSafeForElimination => false;
+  bool get isSafeForReordering => false;
 }
 
 /// Reads the value of a lazily initialized static field.
 ///
 /// If the field has not yet been initialized, its initializer is evaluated
 /// and assigned to the field.
 ///
 /// [continuation] is then invoked with the value of the field as argument.
 class GetLazyStatic extends CallExpression {
   final FieldElement element;
@@ skipping 475 matching lines @@
     processTypeTest(node);
     processReference(node.value);
     node.typeArguments.forEach(processReference);
   }
 
   processSetMutableVariable(SetMutableVariable node) {}
   visitSetMutableVariable(SetMutableVariable node) {
     processSetMutableVariable(node);
     processReference(node.variable);
     processReference(node.value);
-    visit(node.body);
   }
 
   processGetLazyStatic(GetLazyStatic node) {}
   visitGetLazyStatic(GetLazyStatic node) {
     processGetLazyStatic(node);
     processReference(node.continuation);
   }
 
   processLiteralList(LiteralList node) {}
   visitLiteralList(LiteralList node) {
@@ skipping 61 matching lines @@
     processCreateInstance(node);
     node.arguments.forEach(processReference);
     node.typeInformation.forEach(processReference);
   }
 
   processSetField(SetField node) {}
   visitSetField(SetField node) {
     processSetField(node);
     processReference(node.object);
     processReference(node.value);
-    visit(node.body);
   }
 
   processGetField(GetField node) {}
   visitGetField(GetField node) {
     processGetField(node);
     processReference(node.object);
   }
 
   processGetStatic(GetStatic node) {}
   visitGetStatic(GetStatic node) {
     processGetStatic(node);
   }
 
   processSetStatic(SetStatic node) {}
   visitSetStatic(SetStatic node) {
     processSetStatic(node);
     processReference(node.value);
-    visit(node.body);
   }
 
   processCreateBox(CreateBox node) {}
   visitCreateBox(CreateBox node) {
     processCreateBox(node);
   }
 
   processReifyRuntimeType(ReifyRuntimeType node) {}
   visitReifyRuntimeType(ReifyRuntimeType node) {
     processReifyRuntimeType(node);
@@ skipping 71 matching lines @@
   const RemovalVisitor();
 
   processReference(Reference reference) {
     reference.unlink();
   }
 
   static void remove(Node node) {
     (const RemovalVisitor()).visit(node);
   }
 }