Revert "Refactor handling of compounds."

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 125 matching lines @@
  */
 // TODO(johnniwinther): Implement [SemanticDeclVisitor].
 abstract class IrBuilderVisitor extends ast.Visitor<ir.Primitive>
     with IrBuilderMixin<ast.Node>,
          SemanticSendResolvedMixin<ir.Primitive, dynamic>,
          SendResolverMixin,
          BaseImplementationOfStaticsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfLocalsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfDynamicsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfConstantsMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfNewMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfCompoundsMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfIndexCompoundsMixin<ir.Primitive, dynamic>
+         BaseImplementationOfSuperIncDecsMixin<ir.Primitive, dynamic>,
+         BaseImplementationOfNewMixin<ir.Primitive, dynamic>
     implements SemanticSendVisitor<ir.Primitive, dynamic> {
   final TreeElements elements;
   final Compiler compiler;
   final SourceInformationBuilder sourceInformationBuilder;
 
   /// A map from try statements in the source to analysis information about
   /// them.
   ///
   /// The analysis information includes the set of variables that must be
   /// copied into [ir.MutableVariable]s on entry to the try and copied out on
@@ skipping 1081 matching lines @@
   @override
   ir.Primitive visitSuperIndexSet(
       ast.SendSet node,
       FunctionElement function,
       ast.Node index,
       ast.Node rhs,
       _) {
     return irBuilder.buildSuperIndexSet(function, visit(index), visit(rhs));
   }
 
-  ir.Primitive translateCompounds(
+  @override
+  ir.Primitive visitCompoundIndexSet(
+      ast.SendSet node,
+      ast.Node receiver,
+      ast.Node index,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      _) {
+    ir.Primitive target = visit(receiver);
+    ir.Primitive indexValue = visit(index);
+    return translateCompound(
+        getValue: () {
+          Selector selector = new Selector.index();
+          List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
+          arguments =
+              normalizeDynamicArguments(selector.callStructure, arguments);
+          return irBuilder.buildDynamicInvocation(target, selector, arguments);
+        },
+        operator: operator,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildDynamicIndexSet(target, indexValue, result);
+        });
+  }
+
+  @override
+  ir.Primitive visitSuperCompoundIndexSet(
+      ast.SendSet node,
+      FunctionElement getter,
+      FunctionElement setter,
+      ast.Node index,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      _) {
+    ir.Primitive indexValue = visit(index);
+    return translateCompound(
+        getValue: () {
+          return irBuilder.buildSuperIndex(getter, indexValue);
+        },
+        operator: operator,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperIndexSet(setter, indexValue, result);
+        });
+  }
+
+  ir.Primitive translatePrefixPostfix(
       {ir.Primitive getValue(),
-       CompoundRhs rhs,
-       void setValue(ir.Primitive value)}) {
+       op.IncDecOperator operator,
+       void setValue(ir.Primitive value),
+       bool isPrefix}) {
     ir.Primitive value = getValue();
     Selector operatorSelector =
-        new Selector.binaryOperator(rhs.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];
+        new Selector.binaryOperator(operator.selectorName);
+    List<ir.Primitive> arguments =
+        <ir.Primitive>[irBuilder.buildIntegerConstant(1)];
     arguments = normalizeDynamicArguments(
         operatorSelector.callStructure, arguments);
     ir.Primitive result =
         irBuilder.buildDynamicInvocation(value, operatorSelector, arguments);
     setValue(result);
-    return rhs.kind == CompoundKind.POSTFIX ? value : result;
+    return isPrefix ? result : value;
+  }
+
+  ir.Primitive translateCompound(
+      {ir.Primitive getValue(),
+       op.AssignmentOperator operator,
+       ast.Node rhs,
+       void setValue(ir.Primitive value)}) {
+    ir.Primitive value = getValue();
+    Selector operatorSelector =
+        new Selector.binaryOperator(operator.selectorName);
+    List<ir.Primitive> arguments = <ir.Primitive>[visit(rhs)];
+    arguments = normalizeDynamicArguments(
+        operatorSelector.callStructure, arguments);
+    ir.Primitive result =
+        irBuilder.buildDynamicInvocation(value, operatorSelector, arguments);
+    setValue(result);
+    return result;
   }
 
   @override
+  ir.Primitive handleDynamicCompound(
+      ast.Send node,
+      ast.Node receiver,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      Selector getterSelector,
+      Selector setterSelector,
+      _) {
+    ir.Primitive target = translateReceiver(receiver);
+    return translateCompound(
+        getValue: () => irBuilder.buildDynamicGet(target, getterSelector),
+        operator: operator,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildDynamicSet(target, setterSelector, result);
+        });
+  }
+
+  @override
+  ir.Primitive handleDynamicPostfixPrefix(
+      ast.Send node,
+      ast.Node receiver,
+      op.IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
+      arg,
+      {bool isPrefix}) {
+    ir.Primitive target = translateReceiver(receiver);
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildDynamicGet(target, getterSelector),
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildDynamicSet(target, setterSelector, result);
+        },
+        isPrefix: isPrefix);
+  }
+
+  @override
   ir.Primitive handleDynamicSet(
       ast.SendSet node,
       ast.Node receiver,
       Selector selector,
       ast.Node rhs,
       _) {
     return irBuilder.buildDynamicSet(
         translateReceiver(receiver),
         selector,
         visit(rhs));
   }
 
   @override
+  ir.Primitive handleLocalCompound(
+      ast.Send node,
+      LocalElement element,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildLocalVariableGet(element),
+        operator: operator,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildLocalVariableSet(element, result);
+        });
+  }
+
+  @override
+  ir.Primitive handleLocalPostfixPrefix(
+      ast.Send node,
+      LocalElement element,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildLocalVariableGet(element),
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildLocalVariableSet(element, result);
+        },
+        isPrefix: isPrefix);
+  }
+
+  @override
   ir.Primitive handleLocalSet(
       ast.SendSet node,
       LocalElement element,
       ast.Node rhs,
       _) {
     return irBuilder.buildLocalVariableSet(element, visit(rhs));
   }
 
   @override
+  ir.Primitive handleStaticFieldCompound(
+      ast.Send node,
+      FieldElement field,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      _) {
+    SourceInformation src = sourceInformationBuilder.buildGet(node);
+    return translateCompound(
+        getValue: () => buildStaticFieldGet(field, src),
+        operator: operator,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildStaticFieldSet(field, result);
+        });
+  }
+
+  @override
+  ir.Primitive handleStaticFieldPostfixPrefix(
+      ast.Send node,
+      FieldElement field,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
+    SourceInformation src = sourceInformationBuilder.buildGet(node);
+    return translatePrefixPostfix(
+        getValue: () => buildStaticFieldGet(field, src),
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildStaticFieldSet(field, result);
+        },
+        isPrefix: isPrefix);
+  }
+
+  @override
   ir.Primitive handleStaticFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs,
       _) {
     return irBuilder.buildStaticFieldSet(field, visit(rhs));
   }
 
   @override
   ir.Primitive visitSuperFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs,
       _) {
     return irBuilder.buildSuperFieldSet(field, visit(rhs));
   }
 
   @override
   ir.Primitive visitSuperSetterSet(
       ast.SendSet node,
       FunctionElement setter,
       ast.Node rhs,
       _) {
     return irBuilder.buildSuperSetterSet(setter, visit(rhs));
   }
 
   @override
-  ir.Primitive visitUnresolvedSuperIndexSet(
-      ast.Send node,
-      Element element,
-      ast.Node index,
-      ast.Node rhs,
-      arg) {
-    return giveup(node, 'visitUnresolvedSuperIndexSet');
-  }
-
-  @override
-  ir.Primitive handleStaticSetterSet(
-      ast.SendSet node,
-      FunctionElement setter,
-      ast.Node rhs,
-      _) {
-    return irBuilder.buildStaticSetterSet(setter, visit(rhs));
-  }
-
-  @override
-  ir.Primitive handleTypeLiteralConstantCompounds(
-      ast.SendSet node,
-      ConstantExpression constant,
-      CompoundRhs rhs,
-      arg) {
-    return translateCompounds(
-        getValue: () => irBuilder.buildConstant(constant),
-        rhs: rhs,
-        setValue: (value) {}); // The binary operator will throw before this.
-  }
-
-  @override
-  ir.Primitive handleDynamicCompounds(
+  ir.Primitive handleStaticGetterSetterCompound(
+      ast.Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildStaticGetterGet(getter),
+        operator: operator,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildStaticSetterSet(setter, result);
+        });
+  }
+
+  @override
+  ir.Primitive handleSuperFieldFieldPostfixPrefix(
+      ast.Send node,
+      FieldElement readField,
+      FieldElement writtenField,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildSuperFieldGet(readField),
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperFieldSet(writtenField, result);
+        },
+        isPrefix: isPrefix);
+  }
+
+  @override
+  ir.Primitive handleSuperFieldSetterPostfixPrefix(
+      ast.Send node,
+      FieldElement field,
+      FunctionElement setter,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildSuperFieldGet(field),
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperSetterSet(setter, result);
+        },
+        isPrefix: isPrefix);
+  }
+
+  @override
+  ir.Primitive handleSuperGetterFieldPostfixPrefix(
+      ast.Send node,
+      FunctionElement getter,
+      FieldElement field,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildSuperGetterGet(getter),
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperFieldSet(field, result);
+        },
+        isPrefix: isPrefix);
+  }
+
+  @override
+  ir.Primitive handleSuperGetterSetterPostfixPrefix(
+      ast.Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildSuperGetterGet(getter),
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperSetterSet(setter, result);
+        },
+        isPrefix: isPrefix);
+  }
+
+  @override
+  ir.Primitive handleSuperMethodSetterPostfixPrefix(
+      ast.Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildSuperMethodGet(method),
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperSetterSet(setter, result);
+        },
+        isPrefix: isPrefix);
+  }
+
+  @override
+  ir.Primitive handleStaticGetterSetterPostfixPrefix(
+      ast.Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildStaticGetterGet(getter),
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildStaticSetterSet(setter, result);
+        },
+        isPrefix: isPrefix);
+  }
+
+  @override
+  ir.Primitive handleStaticMethodSetterCompound(
+      ast.Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildStaticFunctionGet(method),
+        operator: operator,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildStaticSetterSet(setter, result);
+        });
+  }
+
+  @override
+  ir.Primitive handleStaticMethodSetterPostfixPrefix(
+      ast.Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildStaticFunctionGet(getter),
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildStaticSetterSet(setter, result);
+        },
+        isPrefix: isPrefix);
+  }
+
+  @override
+  ir.Primitive handleDynamicIndexPostfixPrefix(
       ast.Send node,
       ast.Node receiver,
-      CompoundRhs rhs,
-      Selector getterSelector,
-      Selector setterSelector,
-      arg) {
-    ir.Primitive target = translateReceiver(receiver);
-    return translateCompounds(
-        getValue: () => irBuilder.buildDynamicGet(target, getterSelector),
-        rhs: rhs,
-        setValue: (ir.Primitive result) {
-          irBuilder.buildDynamicSet(target, setterSelector, result);
-        });
-  }
-
-  ir.Primitive buildLocalNoSuchSetter(Local local, ir.Primitive value) {
-    Selector selector = new Selector.setter(local.name, null);
-    return buildStaticNoSuchMethod(selector, [value]);
-  }
-
-  @override
-  ir.Primitive handleLocalCompounds(
-      ast.SendSet node,
-      LocalElement local,
-      CompoundRhs rhs,
-      arg,
-      {bool isSetterValid}) {
-    return translateCompounds(
-        getValue: () {
-          if (local.isFunction) {
-            return irBuilder.buildLocalFunctionGet(local);
-          } else {
-            return irBuilder.buildLocalVariableGet(local);
-          }
-        },
-        rhs: rhs,
-        setValue: (ir.Primitive result) {
-          if (isSetterValid) {
-            irBuilder.buildLocalVariableSet(local, result);
-          } else {
-            return buildLocalNoSuchSetter(local, result);
-          }
-        });
-  }
-
-  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(
-        new Selector.setter(element.name, element.library),
-        <ir.Primitive>[value]);
-  }
-
-  @override
-  ir.Primitive handleStaticCompounds(
-      ast.SendSet node,
-      Element getter,
-      CompoundGetter getterKind,
-      Element setter,
-      CompoundSetter setterKind,
-      CompoundRhs rhs,
-      arg) {
-    return translateCompounds(
-        getValue: () {
-          switch (getterKind) {
-            case CompoundGetter.FIELD:
-              SourceInformation src = sourceInformationBuilder.buildGet(node);
-              return irBuilder.buildStaticFieldGet(getter, src);
-            case CompoundGetter.GETTER:
-              return irBuilder.buildStaticGetterGet(getter);
-            case CompoundGetter.METHOD:
-              return irBuilder.buildStaticFunctionGet(getter);
-            case CompoundGetter.UNRESOLVED:
-              return buildStaticNoSuchGetter(getter);
-          }
-        },
-        rhs: rhs,
-        setValue: (ir.Primitive result) {
-          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);
-          }
-        });
-  }
-
-  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(
-        new Selector.setter(element.name, element.library),
-        <ir.Primitive>[value]);
-  }
-
-  @override
-  ir.Primitive handleSuperCompounds(
-      ast.SendSet node,
-      Element getter,
-      CompoundGetter getterKind,
-      Element setter,
-      CompoundSetter setterKind,
-      CompoundRhs rhs,
-      arg) {
-    return translateCompounds(
-        getValue: () {
-          switch (getterKind) {
-            case CompoundGetter.FIELD:
-              return irBuilder.buildSuperFieldGet(getter);
-            case CompoundGetter.GETTER:
-              return irBuilder.buildSuperGetterGet(getter);
-            case CompoundGetter.METHOD:
-              return irBuilder.buildSuperMethodGet(getter);
-            case CompoundGetter.UNRESOLVED:
-              // TODO(johnniwinther): Ensure [getter] is not null.
-              return buildSuperNoSuchGetter(getter != null ? getter : setter);
-          }
-        },
-        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);
-          }
-        });
-  }
-
-  @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.
-  }
-
-  @override
-  ir.Primitive handleIndexCompounds(
-      ast.SendSet node,
-      ast.Node receiver,
-      ast.Node index,
-      CompoundRhs rhs,
-      arg) {
+      ast.Node index,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
     ir.Primitive target = visit(receiver);
     ir.Primitive indexValue = visit(index);
-    return translateCompounds(
+    return translatePrefixPostfix(
         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);
-        });
-  }
-
-  @override
-  ir.Primitive handleSuperIndexCompounds(
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          Selector selector = new Selector.indexSet();
+          List<ir.Primitive> arguments = <ir.Primitive>[indexValue, result];
+          arguments =
+              normalizeDynamicArguments(selector.callStructure, arguments);
+          irBuilder.buildDynamicInvocation(target, selector, arguments);
+        },
+        isPrefix: isPrefix);
+  }
+
+  @override
+  ir.Primitive handleSuperIndexPostfixPrefix(
+      ast.Send node,
+      FunctionElement indexFunction,
+      FunctionElement indexSetFunction,
+      ast.Node index,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
+    ir.Primitive indexValue = visit(index);
+    return translatePrefixPostfix(
+        getValue: () {
+          return irBuilder.buildSuperIndex(indexFunction, indexValue);
+        },
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result);
+        },
+        isPrefix: isPrefix);
+  }
+
+  @override
+  ir.Primitive handleUnresolvedSuperGetterIndexPostfixPrefix(
+      ast.Send node,
+      Element element,
+      ast.Node index,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
+    return giveup(node, 'handleSuperUnresolvedGetterIndexPostfixPrefix');
+  }
+
+  @override
+  ir.Primitive handleUnresolvedSuperSetterIndexPostfixPrefix(
+      ast.Send node,
+      FunctionElement indexFunction,
+      Element element,
+      ast.Node index,
+      op.IncDecOperator operator,
+      arg,
+      {bool isPrefix}) {
+    return giveup(node, 'handleSuperUnresolvedGetterIndexPostfixPrefix');
+  }
+
+  @override
+  ir.Primitive visitUnresolvedSuperGetterCompoundIndexSet(
+      ast.Send node,
+      Element element,
+      ast.Node index,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      arg) {
+    return giveup(node, 'visitUnresolvedSuperGetterCompoundIndexSet');
+  }
+
+  @override
+  ir.Primitive visitUnresolvedSuperIndexSet(
+      ast.Send node,
+      Element element,
+      ast.Node index,
+      ast.Node rhs,
+      arg) {
+    return giveup(node, 'visitUnresolvedSuperIndexSet');
+  }
+
+  @override
+  ir.Primitive visitUnresolvedSuperSetterCompoundIndexSet(
+      ast.Send node,
+      MethodElement getter,
+      Element element,
+      ast.Node index,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      arg) {
+    return giveup(node, 'visitUnresolvedSuperSetterCompoundIndexSet');
+  }
+
+  @override
+  ir.Primitive handleStaticSetterSet(
       ast.SendSet node,
-      Element indexFunction,
-      Element indexSetFunction,
-      ast.Node index,
-      CompoundRhs rhs,
-      arg,
-      {bool isGetterValid,
-       bool isSetterValid}) {
-    ir.Primitive indexValue = visit(index);
-    return translateCompounds(
-        getValue: () {
-          if (isGetterValid) {
-            return irBuilder.buildSuperIndex(indexFunction, indexValue);
-          } else {
-            return buildInstanceNoSuchMethod(
-                new Selector.index(), <ir.Primitive>[indexValue]);
-          }
-        },
-        rhs: rhs,
-        setValue: (ir.Primitive result) {
-          if (isSetterValid) {
-            irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result);
-          } else {
-            buildInstanceNoSuchMethod(
-                new Selector.indexSet(), <ir.Primitive>[indexValue, result]);
-          }
-        });
-  }
-
+      FunctionElement setter,
+      ast.Node rhs,
+      _) {
+    return irBuilder.buildStaticSetterSet(setter, visit(rhs));
+  }
+
+  @override
+  ir.Primitive visitSuperFieldCompound(
+      ast.Send node,
+      FieldElement field,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildSuperFieldGet(field),
+        operator: operator,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperFieldSet(field, result);
+        });
+  }
+
+  @override
+  ir.Primitive visitSuperFieldFieldPostfix(
+      ast.Send node,
+      FieldElement readField,
+      FieldElement writtenField,
+      op.IncDecOperator operator,
+      _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildSuperFieldGet(readField),
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperFieldSet(writtenField, result);
+        },
+        isPrefix: false);
+  }
+
+  @override
+  ir.Primitive visitSuperFieldFieldPrefix(
+      ast.Send node,
+      FieldElement readField,
+      FieldElement writtenField,
+      op.IncDecOperator operator,
+      _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildSuperFieldGet(readField),
+        operator: operator,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperFieldSet(writtenField, result);
+        },
+        isPrefix: true);
+  }
+
+  @override
+  ir.Primitive visitSuperFieldSetterCompound(
+      ast.Send node,
+      FieldElement field,
+      FunctionElement setter,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildSuperFieldGet(field),
+        operator: operator,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperSetterSet(setter, result);
+        });
+  }
+
+  @override
+  ir.Primitive visitSuperGetterFieldCompound(
+      ast.Send node,
+      FunctionElement getter,
+      FieldElement field,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildSuperGetterGet(getter),
+        operator: operator,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperFieldSet(field, result);
+        });
+  }
+
+  @override
+  ir.Primitive visitSuperGetterSetterCompound(
+      ast.Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildSuperGetterGet(getter),
+        operator: operator,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperSetterSet(setter, result);
+        });
+  }
+
+  @override
+  ir.Primitive visitSuperMethodSetterCompound(
+      ast.Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      op.AssignmentOperator operator,
+      ast.Node rhs,
+      _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildSuperMethodGet(method),
+        operator: operator,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildSuperSetterSet(setter, result);
+        });
+  }
+
   ir.Primitive visitStringJuxtaposition(ast.StringJuxtaposition node) {
     assert(irBuilder.isOpen);
     ir.Primitive first = visit(node.first);
     ir.Primitive second = visit(node.second);
     return irBuilder.buildStringConcatenation([first, second]);
   }
 
   ir.Primitive visitStringInterpolation(ast.StringInterpolation node) {
     assert(irBuilder.isOpen);
     List<ir.Primitive> arguments = [];
@@ skipping 36 matching lines @@
       ast.Send node,
       ast.NodeList arguments, _) {
     if (compiler.enableUserAssertions) {
       return giveup(node, 'Assert');
     } else {
       return irBuilder.buildNullConstant();
     }
   }
 
   @override
-  ir.Primitive visitUnresolvedCompound(
+  ir.Primitive errorUnresolvedCompound(
       ast.Send node,
       Element element,
       op.AssignmentOperator operator,
       ast.Node rhs, _) {
     // TODO(asgerf): What is unresolved? The getter and/or the setter?
     //               If it was the setter, we must evaluate the right-hand side.
     return buildStaticNoSuchMethod(elements.getSelector(node), []);
   }
 
   @override
@@ skipping 41 matching lines @@
   ir.Primitive visitUnresolvedInvoke(
       ast.Send node,
       Element element,
       ast.NodeList arguments,
       Selector selector, _) {
     return buildStaticNoSuchMethod(elements.getSelector(node),
         arguments.nodes.mapToList(visit));
   }
 
   @override
+  ir.Primitive errorUnresolvedPostfix(
+      ast.Send node,
+      Element element,
+      op.IncDecOperator operator, _) {
+    // TODO(asgerf): Which ones are missing? The getter and/or the setter?
+    return buildStaticNoSuchMethod(elements.getSelector(node), []);
+  }
+
+  @override
+  ir.Primitive errorUnresolvedPrefix(
+      ast.Send node,
+      Element element,
+      op.IncDecOperator operator, _) {
+    // TODO(asgerf): Which ones are missing? The getter and/or the setter?
+    return buildStaticNoSuchMethod(elements.getSelector(node), []);
+  }
+
+  @override
   ir.Primitive visitUnresolvedRedirectingFactoryConstructorInvoke(
        ast.NewExpression node,
        ConstructorElement constructor,
        InterfaceType type,
        ast.NodeList arguments,
        CallStructure callStructure, _) {
     String nameString = Elements.reconstructConstructorName(constructor);
     Name name = new Name(nameString, constructor.library);
     return buildStaticNoSuchMethod(
         new Selector(SelectorKind.CALL, name, callStructure),
         translateDynamicArguments(arguments, callStructure));
   }
 
   @override
   ir.Primitive errorUnresolvedSet(
       ast.Send node,
       Element element,
       ast.Node rhs, _) {
     return buildStaticNoSuchMethod(elements.getSelector(node), [visit(rhs)]);
   }
 
   @override
+  ir.Primitive errorUnresolvedSuperCompoundIndexSet(
+      ast.SendSet node,
+      Element element,
+      ast.Node index,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    // Assume the index getter is missing.
+    Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
+    return buildInstanceNoSuchMethod(selector, [visit(index)]);
+  }
+
+  @override
   ir.Primitive visitUnresolvedSuperIndex(
       ast.Send node,
       Element function,
       ast.Node index, _) {
     // Assume the index getter is missing.
     Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
     return buildInstanceNoSuchMethod(selector, [visit(index)]);
   }
 
   @override
+  ir.Primitive errorUnresolvedSuperIndexPostfix(
+      ast.Send node,
+      Element function,
+      ast.Node index,
+      op.IncDecOperator operator, _) {
+    // Assume the index getter is missing.
+    Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
+    return buildInstanceNoSuchMethod(selector, [visit(index)]);
+  }
+
+  @override
+  ir.Primitive errorUnresolvedSuperIndexPrefix(
+      ast.Send node,
+      Element function,
+      ast.Node index,
+      op.IncDecOperator operator, _) {
+    // Assume the index getter is missing.
+    Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
+    return buildInstanceNoSuchMethod(selector, [visit(index)]);
+  }
+
+  @override
+  ir.Primitive errorUnresolvedSuperIndexSet(
+      ast.SendSet node,
+      Element element,
+      ast.Node index,
+      ast.Node rhs, _) {
+    Selector selector = useSelectorTypeOfNode(new Selector.index(), node);
+    return buildInstanceNoSuchMethod(
+        selector,
+        [visit(index), visit(rhs)]);
+  }
+
+  @override
   ir.Primitive visitUnresolvedSuperBinary(
       ast.Send node,
       Element element,
       op.BinaryOperator operator,
       ast.Node argument, _) {
     return buildInstanceNoSuchMethod(
         elements.getSelector(node),
         [visit(argument)]);
   }
 
@@ skipping 106 matching lines @@
   ir.Primitive visitAbstractClassConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement element,
       InterfaceType type,
       ast.NodeList arguments,
       CallStructure callStructure, _) {
     return buildAbstractClassInstantiationError(element.enclosingClass);
   }
 
   @override
+  ir.Primitive errorClassTypeLiteralCompound(
+      ast.Send node,
+      ConstantExpression constant,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) {}); // The binary operator will throw before this.
+  }
+
+  @override
+  ir.Primitive errorClassTypeLiteralPostfix(
+      ast.Send node,
+      ConstantExpression constant,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+      getValue: () => irBuilder.buildConstant(constant),
+      operator: operator,
+      setValue: (value) {}, // The binary operator will throw before this.
+      isPrefix: false);
+  }
+
+  @override
+  ir.Primitive errorClassTypeLiteralPrefix(
+      ast.Send node,
+      ConstantExpression constant,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+      getValue: () => irBuilder.buildConstant(constant),
+      operator: operator,
+      setValue: (value) {}, // The binary operator will throw before this.
+      isPrefix: true);
+  }
+
+  @override
+  ir.Primitive errorDynamicTypeLiteralCompound(
+      ast.Send node,
+      ConstantExpression constant,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) {}); // The binary operator will throw before this.
+  }
+
+  @override
+  ir.Primitive errorDynamicTypeLiteralPostfix(
+      ast.Send node,
+      ConstantExpression constant,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        setValue: (value) {}, // The binary operator will throw before this.
+        isPrefix: false);
+  }
+
+  @override
+  ir.Primitive errorDynamicTypeLiteralPrefix(
+      ast.Send node,
+      ConstantExpression constant,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        setValue: (value) {}, // The binary operator will throw before this.
+        isPrefix: true);
+  }
+
+  @override
+  ir.Primitive errorFinalLocalVariableCompound(
+      ast.Send node,
+      LocalVariableElement variable,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    Selector selector = new Selector.setter(variable.name, null);
+    return translateCompound(
+        getValue: () => irBuilder.buildLocalVariableGet(variable),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) => buildStaticNoSuchMethod(selector, [value]));
+  }
+
+  @override
   ir.Primitive errorFinalLocalVariableSet(
       ast.SendSet node,
       LocalVariableElement variable,
       ast.Node rhs, _) {
     Selector selector = new Selector.setter(variable.name, null);
     return buildStaticNoSuchMethod(selector, [visit(rhs)]);
   }
 
   @override
+  ir.Primitive errorFinalParameterCompound(
+      ast.Send node,
+      ParameterElement parameter,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    Selector selector = new Selector.setter(parameter.name, null);
+    return translateCompound(
+        getValue: () => irBuilder.buildLocalVariableGet(parameter),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) => buildStaticNoSuchMethod(selector, [value]));
+  }
+
+  @override
   ir.Primitive errorFinalParameterSet(
       ast.SendSet node,
       ParameterElement parameter,
       ast.Node rhs, _) {
     Selector selector = new Selector.setter(parameter.name, null);
     return buildStaticNoSuchMethod(selector, [visit(rhs)]);
   }
 
   @override
+  ir.Primitive errorFinalStaticFieldCompound(
+      ast.Send node,
+      FieldElement field,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    SourceInformation src = sourceInformationBuilder.buildGet(node);
+    return translateCompound(
+        getValue: () => buildStaticFieldGet(field, src),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) => buildStaticNoSuchMethod(
+            new Selector.setter(field.name, field.library), [value]));
+  }
+
+  @override
   ir.Primitive errorFinalStaticFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs, _) {
     // TODO(asgerf): Include class name somehow?
     return buildStaticNoSuchMethod(
         new Selector.setter(field.name, field.library),
         [visit(rhs)]);
   }
 
   @override
+  ir.Primitive errorFinalSuperFieldCompound(
+      ast.Send node,
+      FieldElement field,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    Selector selector = useSelectorTypeOfNode(
+        new Selector.setter(field.name, field.library),
+        node);
+    return translateCompound(
+        getValue: () => irBuilder.buildSuperFieldGet(field),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) => buildInstanceNoSuchMethod(selector, [value]));
+  }
+
+  @override
   ir.Primitive errorFinalSuperFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs, _) {
     Selector selector = useSelectorTypeOfNode(
         new Selector.setter(field.name, field.library),
         node);
     return buildInstanceNoSuchMethod(selector, [visit(rhs)]);
   }
 
   @override
+  ir.Primitive errorFinalTopLevelFieldCompound(
+      ast.Send node,
+      FieldElement field,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    SourceInformation src = sourceInformationBuilder.buildGet(node);
+    return translateCompound(
+        getValue: () => buildStaticFieldGet(field, src),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) => buildStaticNoSuchMethod(
+            new Selector.setter(field.name, field.library), [value]));
+  }
+
+  @override
   ir.Primitive errorFinalTopLevelFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs, _) {
     return buildStaticNoSuchMethod(
         new Selector.setter(field.name, field.library),
         [visit(rhs)]);
   }
 
   @override
+  ir.Primitive errorLocalFunctionCompound(
+      ast.Send node,
+      LocalFunctionElement function,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildLocalFunctionGet(function),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) {}); // Binary operator will throw before this.
+  }
+
+  @override
+  ir.Primitive errorLocalFunctionPostfix(
+      ast.Send node,
+      LocalFunctionElement function,
+      op.IncDecOperator operator,
+      _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildLocalFunctionGet(function),
+        operator: operator,
+        setValue: (value) {}, // Binary operator will throw before this.
+        isPrefix: false);
+  }
+
+  @override
+  ir.Primitive errorLocalFunctionPrefix(
+      ast.Send node,
+      LocalFunctionElement function,
+      op.IncDecOperator operator,
+      _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildLocalFunctionGet(function),
+        operator: operator,
+        setValue: (value) {}, // Binary operator will throw before this.
+        isPrefix: true);
+  }
+
+  @override
   ir.Primitive errorLocalFunctionSet(
       ast.SendSet node,
       LocalFunctionElement function,
       ast.Node rhs, _) {
     return buildStaticNoSuchMethod(
         new Selector.setter(function.name, null),
         [visit(rhs)]);
   }
 
   @override
@@ skipping 84 matching lines @@
       CallStructure callStructure, _) {
     List<ir.Primitive> args =
         translateDynamicArguments(arguments, callStructure);
     Name name = new Name(setter.name, setter.library);
     Selector selector = useSelectorTypeOfNode(
         new Selector(SelectorKind.CALL, name, callStructure),
         node);
     return buildInstanceNoSuchMethod(selector, args);
   }
 
+  @override
+  ir.Primitive errorTypeVariableTypeLiteralCompound(
+      ast.Send node,
+      TypeVariableElement element,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildReifyTypeVariable(element.type),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) {}); // The binary operator will throw before this.
+  }
+
+  @override
+  ir.Primitive errorTypeVariableTypeLiteralPostfix(
+      ast.Send node,
+      TypeVariableElement element,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildReifyTypeVariable(element.type),
+        operator: operator,
+        setValue: (value) {}, // The binary operator will throw before this.
+        isPrefix: false);
+  }
+
+  @override
+  ir.Primitive errorTypeVariableTypeLiteralPrefix(
+      ast.Send node,
+      TypeVariableElement element,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildReifyTypeVariable(element.type),
+        operator: operator,
+        setValue: (value) {}, // The binary operator will throw before this.
+        isPrefix: true);
+  }
+
+  @override
+  ir.Primitive errorTypedefTypeLiteralCompound(
+      ast.Send node,
+      ConstantExpression constant,
+      op.AssignmentOperator operator,
+      ast.Node rhs, _) {
+    return translateCompound(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        rhs: rhs,
+        setValue: (value) {}); // The binary operator will throw before this.
+  }
+
+  @override
+  ir.Primitive errorTypedefTypeLiteralPostfix(
+      ast.Send node,
+      ConstantExpression constant,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        setValue: (value) {}, // The binary operator will throw before this.
+        isPrefix: false);
+  }
+
+  @override
+  ir.Primitive errorTypedefTypeLiteralPrefix(
+      ast.Send node,
+      TypeConstantExpression constant,
+      op.IncDecOperator operator, _) {
+    return translatePrefixPostfix(
+        getValue: () => irBuilder.buildConstant(constant),
+        operator: operator,
+        setValue: (value) {}, // The binary operator will throw before this.
+        isPrefix: true);
+  }
+
   ir.RootNode nullIfGiveup(ir.RootNode action()) {
     try {
       return action();
     } catch(e) {
       if (e == ABORT_IRNODE_BUILDER) {
         return null;
       }
       rethrow;
     }
   }
@@ skipping 1135 matching lines @@
     node.body = replacementFor(node.body);
   }
 }
 
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends ir.RecursiveVisitor {
   processReference(ir.Reference reference) {
     reference.unlink();
   }
 }