Extend the {+,-,/,*}= support by allowing non-constants on the right side.

lib/compiler/implementation/ssa/nodes.dart

 // Copyright (c) 2011, 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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 739 matching lines @@
   bool isReadableArray() => propagatedType.isReadableArray();
   bool isMutableArray() => propagatedType.isMutableArray();
   bool isExtendableArray() => propagatedType.isExtendableArray();
   bool isBoolean() => propagatedType.isBoolean();
   bool isInteger() => propagatedType.isInteger();
   bool isDouble() => propagatedType.isDouble();
   bool isNumber() => propagatedType.isNumber();
   bool isString() => propagatedType.isString();
   bool isTypeUnknown() => propagatedType.isUnknown();
   bool isIndexablePrimitive() => propagatedType.isIndexablePrimitive();
+  bool isPrimitive() => propagatedType.isPrimitive();
   bool canBePrimitive() => propagatedType.canBePrimitive();
 
   /**
    * This is the type the instruction is guaranteed to have. It does not
    * take any propagation into account.
    */
   HType guaranteedType = HType.UNKNOWN;
   bool hasGuaranteedType() => !guaranteedType.isUnknown();
 
   /**
@@ skipping 766 matching lines @@
 
 // TODO(floitsch): Should HBinaryArithmetic really be the super class of
 // HBinaryBitOp?
 class HBinaryBitOp extends HBinaryArithmetic {
   HBinaryBitOp(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
   bool get builtin() => left.isInteger() && right.isInteger();
 
   HType computeTypeFromInputTypes() {
-    if (left.isInteger()) return HType.INTEGER;
+    // All bitwise operations on primitive types either produce an
+    // integer or throw an error.
+    if (left.isPrimitive()) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     // If the outgoing type should be a number we can get that only if both
     // inputs are integers. If we don't know the outgoing type we try to make
     // it an integer.
     if (propagatedType.isUnknown() || propagatedType.isNumber()) {
       return HType.INTEGER;
     }
@@ skipping 114 matching lines @@
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitNot extends HInvokeUnary {
   HBitNot(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitBitNot(this);
 
   bool get builtin() => operand.isInteger();
 
   HType computeTypeFromInputTypes() {
-    HType operandType = operand.propagatedType;
-    if (operandType.isInteger()) return HType.INTEGER;
+    // All bitwise operations on primitive types either produce an
+    // integer or throw an error.
+    if (operand.isPrimitive()) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input) {
     // Bit operations only work on integers. If there is no desired output
     // type or if it as a number we want to get an integer as input.
     if (propagatedType.isUnknown() || propagatedType.isNumber()) {
       return HType.INTEGER;
     }
     return HType.UNKNOWN;
@@ skipping 896 matching lines @@
   HBasicBlock get start() => expression.start;
   HBasicBlock get end() {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty());
     return statements.last().end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }