dart2js-kernel: associate more compound assignment inner nodes

pkg/compiler/lib/src/kernel/kernel_visitor.dart

 // Copyright (c) 2016, 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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
@@ skipping 1212 matching lines @@
       ir.FunctionExpression function =
           new ir.FunctionExpression(buildFunctionNode(closure, body));
       kernel.localFunctions[closure] = function;
       return function;
     });
   }
 
   @override
   ir.Expression visitCompoundIndexSet(SendSet node, Node receiver, Node index,
       AssignmentOperator operator, Node rhs, _) {
-    // TODO(sra): Find binary operator.
-    return buildIndexAccessor(receiver, index).buildCompoundAssignment(
+    return buildCompoundAssignment(
+        node,
+        buildIndexAccessor(receiver, index),
         kernel.irName(operator.selectorName, currentElement),
-        visitForValue(rhs),
-        voidContext: isVoidContext);
+        visitForValue(rhs));
   }
 
   @override
   ir.InvocationExpression visitConstConstructorInvoke(
       NewExpression node, ConstructedConstantExpression constant, _) {
     return buildConstructorInvoke(node, isConst: true);
   }
 
   @override
   visitConstantGet(Send node, ConstantExpression constant, _) {
@@ skipping 328 matching lines @@
     return IndexAccessor.make(
         visitForValue(receiver), visitForValue(index), null, null);
   }
 
   @override
   ir.Expression visitIndex(Send node, Node receiver, Node index, _) {
     return associateNode(
         buildIndexAccessor(receiver, index).buildSimpleRead(), node);
   }
 
-  ir.Expression buildIndexPostfix(Accessor accessor, IncDecOperator operator) {
+  ir.Expression buildIndexPostfix(
+      Send node, Accessor accessor, IncDecOperator operator) {
     ir.Name name = kernel.irName(operator.selectorName, currentElement);
-    return accessor.buildPostfixIncrement(name, voidContext: isVoidContext);
+    return buildPostfixIncrement(node, accessor, name);
   }
 
   @override
   ir.Expression visitIndexPostfix(
       Send node, Node receiver, Node index, IncDecOperator operator, _) {
-    return buildIndexPostfix(buildIndexAccessor(receiver, index), operator);
+    return buildIndexPostfix(
+        node, buildIndexAccessor(receiver, index), operator);
   }
 
-  ir.Expression buildIndexPrefix(Accessor accessor, IncDecOperator operator) {
+  ir.Expression buildIndexPrefix(
+      Send node, Accessor accessor, IncDecOperator operator) {
     ir.Name name = kernel.irName(operator.selectorName, currentElement);
-    return accessor.buildPrefixIncrement(name, voidContext: isVoidContext);
+    return buildPrefixIncrement(node, accessor, name);
   }
 
   @override
   ir.Expression visitIndexPrefix(
       Send node, Node receiver, Node index, IncDecOperator operator, _) {
-    return buildIndexPrefix(buildIndexAccessor(receiver, index), operator);
+    return buildIndexPrefix(
+        node, buildIndexAccessor(receiver, index), operator);
   }
 
   @override
   ir.Expression visitIndexSet(
       SendSet node, Node receiver, Node index, Node rhs, _) {
     return associateNode(
         buildIndexAccessor(receiver, index)
             .buildAssignment(visitForValue(rhs), voidContext: isVoidContext),
         node);
   }
@@ skipping 102 matching lines @@
   }
 
   @override
   ir.VariableGet handleLocalGet(Send node, LocalElement element, _) {
     return buildLocalGet(element);
   }
 
   ir.Expression buildCompound(
       Accessor accessor, CompoundRhs rhs, SendSet node) {
     ir.Name name = kernel.irName(rhs.operator.selectorName, currentElement);
-    ir.Expression result;
     switch (rhs.kind) {
       case CompoundKind.POSTFIX:
-        result =
-            accessor.buildPostfixIncrement(name, voidContext: isVoidContext);
-        break;
+        return buildPostfixIncrement(node, accessor, name);
 
       case CompoundKind.PREFIX:
-        result =
-            accessor.buildPrefixIncrement(name, voidContext: isVoidContext);
-        break;
+        return buildPrefixIncrement(node, accessor, name);
 
       case CompoundKind.ASSIGNMENT:
-        result = accessor.buildCompoundAssignment(name, visitForValue(rhs.rhs),
-            voidContext: isVoidContext);
-        break;
+        return buildCompoundAssignment(
+            node, accessor, name, visitForValue(rhs.rhs));
     }
+  }
+
+  ir.Expression buildCompoundAssignment(
+      SendSet node, Accessor accessor, ir.Name name, ir.Expression rhs) {
+    ir.Expression result =
+        accessor.buildCompoundAssignment(name, rhs, voidContext: isVoidContext);
+    associateCompoundComponents(accessor, node);
+    return result;
+  }
+
+  ir.Expression buildPrefixIncrement(
+      SendSet node, Accessor accessor, ir.Name name) {
+    ir.Expression result =
+        accessor.buildPrefixIncrement(name, voidContext: isVoidContext);
+    associateCompoundComponents(accessor, node);
+    return result;
+  }
+
+  ir.Expression buildPostfixIncrement(
+      SendSet node, Accessor accessor, ir.Name name) {
+    ir.Expression result =
+        accessor.buildPostfixIncrement(name, voidContext: isVoidContext);
+    associateCompoundComponents(accessor, node);
+    return result;
+  }
+
+  void associateCompoundComponents(Accessor accessor, Node node) {
     assert(accessor.builtBinary != null);
     kernel.nodeToAstOperator[accessor.builtBinary] = node;
     if (accessor.builtGetter != null) {
       kernel.nodeToAst[accessor.builtGetter] = node;
     }
-    return result;
   }
 
   @override
   ir.Expression handleLocalCompounds(
       SendSet node, LocalElement local, CompoundRhs rhs, _,
       {bool isSetterValid}) {
     ir.Expression compound =
         buildCompound(new VariableAccessor(getLocal(local)), rhs, node);
     if (compound is ir.VariableSet) {
       associateNode(compound.value, node);
@@ skipping 484 matching lines @@
 
   @override
   ir.Expression visitSuperCompoundIndexSet(
       SendSet node,
       MethodElement getter,
       MethodElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       _) {
-    // TODO(sra): Find binary operator.
-    return buildSuperIndexAccessor(index, getter, setter)
-        .buildCompoundAssignment(
-            kernel.irName(operator.selectorName, currentElement),
-            visitForValue(rhs),
-            voidContext: isVoidContext);
+    return buildCompoundAssignment(
+        node,
+        buildSuperIndexAccessor(index, getter, setter),
+        kernel.irName(operator.selectorName, currentElement),
+        visitForValue(rhs));
   }
 
   @override
   ir.Initializer visitSuperConstructorInvoke(
       Send node,
       ConstructorElement superConstructor,
       InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       _) {
@@ skipping 158 matching lines @@
   ir.SuperMethodInvocation visitSuperIndex(
       Send node, FunctionElement function, Node index, _) {
     return buildSuperIndexAccessor(index, function).buildSimpleRead();
   }
 
   @override
   ir.Expression visitSuperIndexPostfix(Send node, MethodElement indexFunction,
       MethodElement indexSetFunction, Node index, IncDecOperator operator, _) {
     Accessor accessor =
         buildSuperIndexAccessor(index, indexFunction, indexSetFunction);
-    return buildIndexPostfix(accessor, operator);
+    return buildIndexPostfix(node, accessor, operator);
   }
 
   @override
   ir.Expression visitSuperIndexPrefix(Send node, MethodElement indexFunction,
       MethodElement indexSetFunction, Node index, IncDecOperator operator, _) {
     Accessor accessor =
         buildSuperIndexAccessor(index, indexFunction, indexSetFunction);
-    return buildIndexPrefix(accessor, operator);
+    return buildIndexPrefix(node, accessor, operator);
   }
 
   @override
   ir.Expression visitSuperIndexSet(
       SendSet node, FunctionElement function, Node index, Node rhs, _) {
     return buildSuperIndexAccessor(index, null, function)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
@@ skipping 359 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }