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>,
-         BaseImplementationOfSuperIncDecsMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfNewMixin<ir.Primitive, dynamic>
+         BaseImplementationOfNewMixin<ir.Primitive, dynamic>,
+         BaseImplementationOfCompoundsMixin<ir.Primitive, dynamic>,
+         BaseImplementationOfIndexCompoundsMixin<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));
   }
 
-  @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 translateCompounds(
       {ir.Primitive getValue(),
-       op.IncDecOperator operator,
-       void setValue(ir.Primitive value),
-       bool isPrefix}) {
+       CompoundRhs rhs,
+       void setValue(ir.Primitive value)}) {
     ir.Primitive value = getValue();
     Selector operatorSelector =
-        new Selector.binaryOperator(operator.selectorName);
-    List<ir.Primitive> arguments =
-        <ir.Primitive>[irBuilder.buildIntegerConstant(1)];
+        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];
     arguments = normalizeDynamicArguments(
         operatorSelector.callStructure, arguments);
     ir.Primitive result =
         irBuilder.buildDynamicInvocation(value, operatorSelector, arguments);
     setValue(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;
+    return rhs.kind == CompoundKind.POSTFIX ? value : 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 handleStaticGetterSetterCompound(
+  ir.Primitive visitUnresolvedSuperIndexSet(
       ast.Send node,
-      FunctionElement getter,
+      Element element,
+      ast.Node index,
+      ast.Node rhs,
+      arg) {
+    return giveup(node, 'visitUnresolvedSuperIndexSet');
+  }
+
+  @override
+  ir.Primitive handleStaticSetterSet(
+      ast.SendSet node,
       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(
+    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(
       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,
-      op.IncDecOperator operator,
-      arg,
-      {bool isPrefix}) {
+      CompoundRhs rhs,
+      arg) {
     ir.Primitive target = visit(receiver);
     ir.Primitive indexValue = visit(index);
-    return translatePrefixPostfix(
+    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);
         },
-        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,
+        rhs: rhs,
+        setValue: (ir.Primitive result) {
+          irBuilder.buildDynamicIndexSet(target, indexValue, result);
+        });
+  }
+
+  @override
+  ir.Primitive handleSuperIndexCompounds(
+      ast.SendSet node,
+      Element indexFunction,
+      Element indexSetFunction,
       ast.Node index,
-      op.IncDecOperator operator,
+      CompoundRhs rhs,
       arg,
-      {bool isPrefix}) {
+      {bool isGetterValid,
+       bool isSetterValid}) {
     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,
-      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);
-        });
-  }
-
+    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]);
+          }
+        });
+  }
+
   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 errorUnresolvedCompound(
+  ir.Primitive visitUnresolvedCompound(
       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();
   }
 }