dart2js cps: Get typed selectors for compound operators.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 1151 matching lines @@
       FunctionElement function,
       ast.Node index,
       ast.Node rhs,
       _) {
     return irBuilder.buildSuperIndexSet(function, visit(index), visit(rhs));
   }
 
   ir.Primitive translateCompounds(
       {ir.Primitive getValue(),
        CompoundRhs rhs,
-       void setValue(ir.Primitive value)}) {
+       void setValue(ir.Primitive value),
+       Selector operatorSelector}) {
     ir.Primitive value = getValue();
     op.BinaryOperator operator = rhs.operator;
     if (operator.kind == op.BinaryOperatorKind.IF_NULL) {
       // Unlike other compound operators if-null conditionally will not do the
       // assignment operation.
       return irBuilder.buildIfNull(value, nested(() {
         ir.Primitive newValue = build(rhs.rhs);
         setValue(newValue);
         return newValue;
       }));
     }
 
-    Selector operatorSelector =
-        new Selector.binaryOperator(operator.selectorName);
+    if (operatorSelector == null) {
+        operatorSelector = new Selector.binaryOperator(operator.selectorName);
+    }
     ir.Primitive rhsValue;
     if (rhs.kind == CompoundKind.ASSIGNMENT) {
       rhsValue = visit(rhs.rhs);
     } else {
       rhsValue = irBuilder.buildIntegerConstant(1);
     }
     List<ir.Primitive> arguments = <ir.Primitive>[rhsValue];
     arguments = normalizeDynamicArguments(
         operatorSelector.callStructure, arguments);
     ir.Primitive result =
@@ skipping 85 matching lines @@
 
   @override
   ir.Primitive handleTypeLiteralConstantCompounds(
       ast.SendSet node,
       ConstantExpression constant,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
         getValue: () => buildConstantExpression(constant),
         rhs: rhs,
-        setValue: (value) {}); // The binary operator will throw before this.
+        setValue: (value) {}, // The binary operator will throw before this.
+        operatorSelector: elements.getOperatorSelectorInComplexSendSet(node));
   }
 
   @override
   ir.Primitive handleDynamicCompounds(
       ast.Send node,
       ast.Node receiver,
       CompoundRhs rhs,
       Selector getterSelector,
       Selector setterSelector,
       arg) {
     ir.Primitive target = translateReceiver(receiver);
     ir.Primitive helper() {
       return translateCompounds(
           getValue: () => irBuilder.buildDynamicGet(target, getterSelector),
           rhs: rhs,
           setValue: (ir.Primitive result) {
             irBuilder.buildDynamicSet(target, setterSelector, result);
-          });
+          },
+          operatorSelector: elements.getOperatorSelectorInComplexSendSet(node));
     }
     return node.isConditional
         ? irBuilder.buildIfNotNullSend(target, nested(helper))
         : helper();
   }
 
   ir.Primitive buildLocalNoSuchSetter(Local local, ir.Primitive value) {
     Selector selector = new Selector.setter(local.name, null);
     return buildStaticNoSuchMethod(selector, [value]);
   }
@@ skipping 13 matching lines @@
             return irBuilder.buildLocalVariableGet(local);
           }
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           if (isSetterValid) {
             irBuilder.buildLocalVariableSet(local, result);
           } else {
             return buildLocalNoSuchSetter(local, result);
           }
-        });
+        },
+        operatorSelector: elements.getOperatorSelectorInComplexSendSet(node));
   }
 
   ir.Primitive buildStaticNoSuchGetter(Element element) {
     return buildStaticNoSuchMethod(
         new Selector.getter(element.name, element.library),
         const <ir.Primitive>[]);
   }
 
   ir.Primitive buildStaticNoSuchSetter(Element element, ir.Primitive value) {
     return buildStaticNoSuchMethod(
@@ skipping 29 matching lines @@
           switch (setterKind) {
             case CompoundSetter.FIELD:
               return irBuilder.buildStaticFieldSet(setter, result);
             case CompoundSetter.SETTER:
               return irBuilder.buildStaticSetterSet(setter, result);
             case CompoundSetter.INVALID:
               // TODO(johnniwinther): Ensure [setter] is non null.
               return buildStaticNoSuchSetter(
                   setter != null ? setter : getter, result);
           }
-        });
+        },
+        operatorSelector: elements.getOperatorSelectorInComplexSendSet(node));
   }
 
   ir.Primitive buildSuperNoSuchGetter(Element element) {
     return buildInstanceNoSuchMethod(
         new Selector.getter(element.name, element.library),
         const <ir.Primitive>[]);
   }
 
   ir.Primitive buildSuperNoSuchSetter(Element element, ir.Primitive value) {
     return buildInstanceNoSuchMethod(
@@ skipping 27 matching lines @@
         rhs: rhs,
         setValue: (ir.Primitive result) {
           switch (setterKind) {
             case CompoundSetter.FIELD:
               return irBuilder.buildSuperFieldSet(setter, result);
             case CompoundSetter.SETTER:
               return irBuilder.buildSuperSetterSet(setter, result);
             case CompoundSetter.INVALID:
               return buildSuperNoSuchSetter(setter, result);
           }
-        });
+        },
+        operatorSelector: elements.getOperatorSelectorInComplexSendSet(node));
   }
 
   @override
   ir.Primitive handleTypeVariableTypeLiteralCompounds(
       ast.SendSet node,
       TypeVariableElement typeVariable,
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
         getValue: () => irBuilder.buildReifyTypeVariable(typeVariable.type),
         rhs: rhs,
-        setValue: (value) {}); // The binary operator will throw before this.
+        setValue: (value) {}, // The binary operator will throw before this.
+        operatorSelector: elements.getOperatorSelectorInComplexSendSet(node));
   }
 
   @override
   ir.Primitive handleIndexCompounds(
       ast.SendSet node,
       ast.Node receiver,
       ast.Node index,
       CompoundRhs rhs,
       arg) {
     ir.Primitive target = visit(receiver);
     ir.Primitive indexValue = visit(index);
     return translateCompounds(
         getValue: () {
           Selector selector = new Selector.index();
           List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
           arguments =
               normalizeDynamicArguments(selector.callStructure, arguments);
           return irBuilder.buildDynamicInvocation(target, selector, arguments);
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           irBuilder.buildDynamicIndexSet(target, indexValue, result);
-        });
+        },
+        operatorSelector: elements.getOperatorSelectorInComplexSendSet(node));
   }
 
   @override
   ir.Primitive handleSuperIndexCompounds(
       ast.SendSet node,
       Element indexFunction,
       Element indexSetFunction,
       ast.Node index,
       CompoundRhs rhs,
       arg,
@@ skipping 10 matching lines @@
           }
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           if (isSetterValid) {
             irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result);
           } else {
             buildInstanceNoSuchMethod(
                 new Selector.indexSet(), <ir.Primitive>[indexValue, result]);
           }
-        });
+        },
+        operatorSelector: elements.getOperatorSelectorInComplexSendSet(node));
   }
 
   /// Evaluates a string interpolation and appends each part to [accumulator]
   /// (after stringify conversion).
   void buildStringParts(ast.Node node, List<ir.Primitive> accumulator) {
     if (node is ast.StringJuxtaposition) {
       buildStringParts(node.first, accumulator);
       buildStringParts(node.second, accumulator);
     } else if (node is ast.StringInterpolation) {
       buildStringParts(node.string, accumulator);
@@ skipping 1657 matching lines @@
   }
 
   processSetStatic(ir.SetStatic node) {
     node.body = replacementFor(node.body);
   }
 
   processContinuation(ir.Continuation node) {
     node.body = replacementFor(node.body);
   }
 }