Emit read-modify-write of fields as assignment op.

sdk/lib/_internal/compiler/implementation/ssa/nodes.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
@@ skipping 36 matching lines @@
   R visitLocalSet(HLocalSet node);
   R visitLocalValue(HLocalValue node);
   R visitLoopBranch(HLoopBranch node);
   R visitMultiply(HMultiply node);
   R visitNegate(HNegate node);
   R visitNot(HNot node);
   R visitOneShotInterceptor(HOneShotInterceptor node);
   R visitParameterValue(HParameterValue node);
   R visitPhi(HPhi node);
   R visitRangeConversion(HRangeConversion node);
+  R visitReadModifyWrite(HReadModifyWrite node);
   R visitReturn(HReturn node);
   R visitShiftLeft(HShiftLeft node);
   R visitShiftRight(HShiftRight node);
   R visitStatic(HStatic node);
   R visitStaticStore(HStaticStore node);
   R visitStringConcat(HStringConcat node);
   R visitStringify(HStringify node);
   R visitSubtract(HSubtract node);
   R visitSwitch(HSwitch node);
   R visitThis(HThis node);
@@ skipping 247 matching lines @@
   visitLocalValue(HLocalValue node) => visitInstruction(node);
   visitLoopBranch(HLoopBranch node) => visitConditionalBranch(node);
   visitNegate(HNegate node) => visitInvokeUnary(node);
   visitNot(HNot node) => visitInstruction(node);
   visitOneShotInterceptor(HOneShotInterceptor node)
       => visitInvokeDynamic(node);
   visitPhi(HPhi node) => visitInstruction(node);
   visitMultiply(HMultiply node) => visitBinaryArithmetic(node);
   visitParameterValue(HParameterValue node) => visitLocalValue(node);
   visitRangeConversion(HRangeConversion node) => visitCheck(node);
+  visitReadModifyWrite(HReadModifyWrite node) => visitInstruction(node);
   visitReturn(HReturn node) => visitControlFlow(node);
   visitShiftLeft(HShiftLeft node) => visitBinaryBitOp(node);
   visitShiftRight(HShiftRight node) => visitBinaryBitOp(node);
   visitSubtract(HSubtract node) => visitBinaryArithmetic(node);
   visitSwitch(HSwitch node) => visitControlFlow(node);
   visitStatic(HStatic node) => visitInstruction(node);
   visitStaticStore(HStaticStore node) => visitInstruction(node);
   visitStringConcat(HStringConcat node) => visitInstruction(node);
   visitStringify(HStringify node) => visitInstruction(node);
   visitThis(HThis node) => visitParameterValue(node);
@@ skipping 1221 matching lines @@
   HInstruction getDartReceiver(Compiler compiler) => receiver;
   bool onlyThrowsNSM() => true;
 
   HInstruction get value => inputs[1];
   accept(HVisitor visitor) => visitor.visitFieldSet(this);
 
   bool isJsStatement() => true;
   String toString() => "FieldSet $element";
 }
 
+/**
+ * HReadModifyWrite is a late stage instruction for a field (property) update
+ * via an assignment operation or pre- or post-increment.
+ */
+class HReadModifyWrite extends HLateInstruction {
+  static const ASSIGN_OP = 0;
+  static const PRE_OP = 1;
+  static const POST_OP = 2;
+  final Element element;
+  final String jsOp;
+  final int opKind;
+
+   HReadModifyWrite._(Element this.element, this.jsOp, this.opKind,
+      List<HInstruction> inputs, TypeMask type)
+      : super(inputs, type) {
+    sideEffects.clearAllSideEffects();
+    sideEffects.clearAllDependencies();
+    sideEffects.setChangesInstanceProperty();
+    sideEffects.setDependsOnInstancePropertyStore();
+  }
+
+  HReadModifyWrite.assignOp(Element element, String jsOp,
+      HInstruction receiver, HInstruction operand, TypeMask type)
+      : this._(element, jsOp, ASSIGN_OP,
+               <HInstruction>[receiver, operand], type);
+
+  HReadModifyWrite.preOp(Element element, String jsOp,
+      HInstruction receiver, TypeMask type)
+      : this._(element, jsOp, PRE_OP, <HInstruction>[receiver], type);
+
+  HReadModifyWrite.postOp(Element element, String jsOp,
+      HInstruction receiver, TypeMask type)
+      : this._(element, jsOp, POST_OP, <HInstruction>[receiver], type);
+
+  HInstruction get receiver => inputs[0];
+
+  bool get isPreOp => opKind == PRE_OP;
+  bool get isPostOp => opKind == POST_OP;
+  bool get isAssignOp => opKind == ASSIGN_OP;
+
+  bool canThrow() => receiver.canBeNull();
+
+  HInstruction getDartReceiver(Compiler compiler) => receiver;
+  bool onlyThrowsNSM() => true;
+
+  HInstruction get value => inputs[1];
+  accept(HVisitor visitor) => visitor.visitReadModifyWrite(this);
+
+  bool isJsStatement() => isAssignOp;
+  String toString() => "ReadModifyWrite $jsOp $opKind $element";
+}
+
 class HLocalGet extends HFieldAccess {
   // No need to use GVN for a [HLocalGet], it is just a local
   // access.
   HLocalGet(Element element, HLocalValue local, TypeMask type)
       : super(element, <HInstruction>[local], type);
 
   accept(HVisitor visitor) => visitor.visitLocalGet(this);
 
   HLocalValue get local => inputs[0];
 }
@@ skipping 1396 matching lines @@
 class HDynamicType extends HRuntimeType {
   HDynamicType(DynamicType dartType, TypeMask instructionType)
       : super(const <HInstruction>[], dartType, instructionType);
 
   accept(HVisitor visitor) => visitor.visitDynamicType(this);
 
   int typeCode() => HInstruction.DYNAMIC_TYPE_TYPECODE;
 
   bool typeEquals(HInstruction other) => other is HDynamicType;
 }