dart2js: Simplification of the IrBuilderVisitor.

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 closure;
 import '../common.dart';
 import '../common/names.dart' show
     Names,
@@ skipping 627 matching lines @@
     if (enclosingClass.isMixinApplication) {
       forwardSynthesizedMixinConstructor(constructor, supers, fieldValues);
       return;
     }
     // Evaluate initializing parameters, e.g. `Foo(this.x)`.
     constructor.functionSignature.orderedForEachParameter(
         (ParameterElement parameter) {
       if (parameter.isInitializingFormal) {
         InitializingFormalElement fieldParameter = parameter;
         fieldValues[fieldParameter.fieldElement] =
-            irBuilder.buildLocalVariableGet(parameter);
+            irBuilder.buildLocalGet(parameter);
       }
     });
     // Evaluate constructor initializers, e.g. `Foo() : x = 50`.
     ast.FunctionExpression node = constructor.node;
     bool hasConstructorCall = false; // Has this() or super() initializer?
     if (node != null && node.initializers != null) {
       for(ast.Node initializer in node.initializers) {
         if (initializer is ast.SendSet) {
           // Field initializer.
           FieldElement field = elements[initializer];
@@ skipping 203 matching lines @@
         callStructure.getOrderedNamedArguments());
   }
 
   /// Read the value of [field].
   ir.Primitive buildStaticFieldGet(FieldElement field, SourceInformation src) {
     ConstantValue constant = getConstantForVariable(field);
     if (constant != null && !field.isAssignable) {
       typeMaskSystem.associateConstantValueWithElement(constant, field);
       return irBuilder.buildConstant(constant, sourceInformation: src);
     } else if (backend.constants.lazyStatics.contains(field)) {
-      return irBuilder.buildStaticFieldLazyGet(field, src);
+      return irBuilder.addPrimitive(new ir.GetLazyStatic(field, src));
     } else {
-      return irBuilder.buildStaticFieldGet(field, src);
+      return irBuilder.addPrimitive(new ir.GetStatic(field, src));
     }
   }
 
   ir.FunctionDefinition _makeFunctionBody(FunctionElement element,
                                           ast.FunctionExpression node) {
     FunctionSignature signature = element.functionSignature;
     List<Local> parameters = <Local>[];
     signature.orderedForEachParameter(
         (LocalParameterElement e) => parameters.add(e));
 
@@ skipping 438 matching lines @@
     if (node.isConst) {
       return translateConstant(node);
     }
     List<ir.Primitive> values = node.elements.nodes.mapToList(visit);
     InterfaceType type = elements.getType(node);
     return irBuilder.buildListLiteral(type, values,
         allocationSiteType: getAllocationSiteType(node));
   }
 
   ir.Primitive visitLiteralMap(ast.LiteralMap node) {
+    assert(irBuilder.isOpen);
     if (node.isConst) {
       return translateConstant(node);
     }
     InterfaceType type = elements.getType(node);
-    return irBuilder.buildMapLiteral(
-        type,
-        node.entries.nodes.map((e) => e.key),
-        node.entries.nodes.map((e) => e.value),
-        build);
+    List<ir.LiteralMapEntry> entries =
+        node.entries.nodes.mapToList((ast.LiteralMapEntry e) {
+          return new ir.LiteralMapEntry(visit(e.key), visit(e.value));
+        });
+    return irBuilder.addPrimitive(new ir.LiteralMap(type, entries));
   }
 
   ir.Primitive visitLiteralSymbol(ast.LiteralSymbol node) {
     assert(irBuilder.isOpen);
     return translateConstant(node);
   }
 
   ir.Primitive visitParenthesizedExpression(
       ast.ParenthesizedExpression node) {
     assert(irBuilder.isOpen);
@@ skipping 131 matching lines @@
   }
 
   @override
   ir.Primitive visitLocalVariableGet(
       ast.Send node,
       LocalVariableElement element,
       _) {
     return element.isConst
         ? irBuilder.buildConstant(getConstantForVariable(element),
             sourceInformation: sourceInformationBuilder.buildGet(node))
-        : irBuilder.buildLocalVariableGet(element);
+        : irBuilder.buildLocalGet(element);
   }
 
-  @override
   ir.Primitive handleLocalGet(
       ast.Send node,
       LocalElement element,
       _) {
-    return irBuilder.buildLocalVariableGet(element);
+    return irBuilder.buildLocalGet(element);
   }
 
   @override
-  ir.Primitive visitLocalFunctionGet(
-      ast.Send node,
-      LocalFunctionElement function,
-      _) {
-    return irBuilder.buildLocalFunctionGet(function);
-  }
-
-  @override
   ir.Primitive handleStaticFunctionGet(
       ast.Send node,
       MethodElement function,
       _) {
-    return irBuilder.buildStaticFunctionGet(function);
+    return irBuilder.addPrimitive(new ir.GetStatic(function));
   }
 
   @override
   ir.Primitive handleStaticGetterGet(
       ast.Send node,
       FunctionElement getter,
       _) {
     return buildStaticGetterGet(getter, node);
   }
 
@@ skipping 410 matching lines @@
               arguments);
         }));
   }
 
   ir.Primitive handleLocalInvoke(
       ast.Send node,
       LocalElement element,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
+    ir.Primitive function = irBuilder.buildLocalGet(element);
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
-    return irBuilder.buildLocalVariableInvocation(
-        element,
-        callStructure,
-        arguments,
-        callSourceInformation:
+    return irBuilder.buildCallInvocation(function, callStructure, arguments,
+        sourceInformation:
             sourceInformationBuilder.buildCall(node, argumentsNode));
   }
 
   @override
-  ir.Primitive visitLocalFunctionInvoke(
-      ast.Send node,
-      LocalFunctionElement function,
-      ast.NodeList argumentsNode,
-      CallStructure callStructure,
-      _) {
-    List<ir.Primitive> arguments = <ir.Primitive>[];
-    callStructure =
-        translateDynamicArguments(argumentsNode, callStructure, arguments);
-    return irBuilder.buildLocalFunctionInvocation(
-        function,
-        callStructure,
-        arguments,
-        sourceInformationBuilder.buildCall(node, argumentsNode));
-  }
-
-  @override
   ir.Primitive handleStaticFieldGet(ast.Send node, FieldElement field, _) {
     return buildStaticFieldGet(field, sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive handleStaticFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
@@ skipping 192 matching lines @@
       ast.SendSet node,
       FunctionElement function,
       ast.Node index,
       ast.Node rhs,
       _) {
     return irBuilder.buildSuperIndexSet(function, visit(index), visit(rhs));
   }
 
   ir.Primitive translateCompounds(
       ast.SendSet node,
-      {ir.Primitive getValue(),
-       CompoundRhs rhs,
-       void setValue(ir.Primitive value)}) {
-    ir.Primitive value = getValue();
+      ir.Primitive value,

[asgerf, 2016/01/11 21:16:36]

I think this was better before, but I don't feel strongly it has to be one way
or the other.

[Kevin Millikin (Google), 2016/01/12 15:58:47]

I guess I can see that.  I've changed it back (but not returning a Primitive
from the void function setValue).

+      CompoundRhs rhs,
+      void setValue(ir.Primitive value)) {
     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;
       }));
     }
@@ skipping 19 matching lines @@
             callStructure),
         operatorTypeMask,
         arguments,
         sourceInformation: operatorSourceInformation);
     setValue(result);
     return rhs.kind == CompoundKind.POSTFIX ? value : result;
   }
 
   ir.Primitive translateSetIfNull(
       ast.SendSet node,
-      {ir.Primitive getValue(),
-       ast.Node rhs,
-       void setValue(ir.Primitive value)}) {
-    ir.Primitive value = getValue();
+      ir.Primitive value,
+      ast.Node rhs,
+      void setValue(ir.Primitive value)) {
     // Unlike other compound operators if-null conditionally will not do the
     // assignment operation.
     return irBuilder.buildIfNull(value, nested(() {
       ir.Primitive newValue = build(rhs);
       setValue(newValue);
       return newValue;
     }));
   }
 
   @override
@@ skipping 37 matching lines @@
     value = checkTypeVsElement(value, element);
     return irBuilder.buildLocalVariableSet(element, value);
   }
 
   @override
   ir.Primitive handleStaticFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs,
       _) {
-    return irBuilder.buildStaticFieldSet(field, visit(rhs));
+    ir.Primitive value = visit(rhs);
+    irBuilder.addPrimitive(new ir.SetStatic(field, value));
+    return value;
   }
 
   @override
   ir.Primitive visitSuperFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs,
       _) {
     return irBuilder.buildSuperFieldSet(field, visit(rhs));
   }
@@ skipping 25 matching lines @@
       _) {
     return irBuilder.buildStaticSetterSet(setter, visit(rhs));
   }
 
   @override
   ir.Primitive handleTypeLiteralConstantCompounds(
       ast.SendSet node,
       ConstantExpression constant,
       CompoundRhs rhs,
       arg) {
-    return translateCompounds(
-        node,
-        getValue: () {
-          return buildConstantExpression(constant,
-            sourceInformationBuilder.buildGet(node));
-        },
-        rhs: rhs,
-        setValue: (value) {}); // The binary operator will throw before this.
+    ir.Primitive value = buildConstantExpression(constant,
+        sourceInformationBuilder.buildGet(node));
+    return translateCompounds(node, value, rhs, (ir.Primitive value) {
+      // The binary operator will throw before this.
+    });
   }
 
   @override
   ir.Primitive handleTypeLiteralConstantSetIfNulls(
       ast.SendSet node,
       ConstantExpression constant,
       ast.Node rhs,
       _) {
     // The type literal is never `null`.
     return buildConstantExpression(constant,
         sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive handleDynamicCompounds(
       ast.SendSet node,
       ast.Node receiver,
       Name name,
       CompoundRhs rhs,
       arg) {
     ir.Primitive target = translateReceiver(receiver);
     ir.Primitive helper() {
-      return translateCompounds(
-          node,
-          getValue: () => irBuilder.buildDynamicGet(
-              target,
-              new Selector.getter(name),
-              elements.getGetterTypeMaskInComplexSendSet(node),
-              sourceInformationBuilder.buildGet(node)),
-          rhs: rhs,
-          setValue: (ir.Primitive result) {
-            irBuilder.buildDynamicSet(
-                target,
-                new Selector.setter(name),
-                elements.getTypeMask(node),
-                result);
-          });
+      ir.Primitive value = irBuilder.buildDynamicGet(
+          target,
+          new Selector.getter(name),
+          elements.getGetterTypeMaskInComplexSendSet(node),
+          sourceInformationBuilder.buildGet(node));
+      return translateCompounds(node, value, rhs, (ir.Primitive result) {
+        irBuilder.buildDynamicSet(
+            target,
+            new Selector.setter(name),
+            elements.getTypeMask(node),
+            result);
+      });
     }
     return node.isConditional
         ? irBuilder.buildIfNotNullSend(target, nested(helper))
         : helper();
   }
 
   @override
   ir.Primitive handleDynamicSetIfNulls(
       ast.Send node,
       ast.Node receiver,
       Name name,
       ast.Node rhs,
       _) {
     ir.Primitive target = translateReceiver(receiver);
     ir.Primitive helper() {
-      return translateSetIfNull(
-          node,
-          getValue: () => irBuilder.buildDynamicGet(
-              target,
-              new Selector.getter(name),
-              elements.getGetterTypeMaskInComplexSendSet(node),
-              sourceInformationBuilder.buildGet(node)),
-          rhs: rhs,
-          setValue: (ir.Primitive result) {
-            irBuilder.buildDynamicSet(
-                target,
-                new Selector.setter(name),
-                elements.getTypeMask(node),
-                result);
-          });
+      ir.Primitive value = irBuilder.buildDynamicGet(
+          target,
+          new Selector.getter(name),
+          elements.getGetterTypeMaskInComplexSendSet(node),
+          sourceInformationBuilder.buildGet(node));
+      return translateSetIfNull(node, value, rhs, (ir.Primitive result) {
+        irBuilder.buildDynamicSet(
+            target,
+            new Selector.setter(name),
+            elements.getTypeMask(node),
+            result);
+      });
     }
     return node.isConditional
         ? irBuilder.buildIfNotNullSend(target, nested(helper))
         : helper();
   }
 
   ir.Primitive buildLocalNoSuchSetter(LocalElement local, ir.Primitive value) {
     Selector selector = new Selector.setter(
         new Name(local.name, local.library, isSetter: true));
     return irBuilder.buildStaticNoSuchMethod(selector, [value]);
   }
 
   @override
   ir.Primitive handleLocalCompounds(
       ast.SendSet node,
       LocalElement local,
       CompoundRhs rhs,
       arg,
       {bool isSetterValid}) {
-    return translateCompounds(
-        node,
-        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 value = irBuilder.buildLocalGet(local);
+    return translateCompounds(node, value, rhs, (ir.Primitive result) {
+      if (isSetterValid) {
+        irBuilder.buildLocalVariableSet(local, result);
+      } else {
+        Selector selector = new Selector.setter(
+            new Name(local.name, local.library, isSetter: true));
+        irBuilder.buildStaticNoSuchMethod(selector, <ir.Primitive>[result]);
+      }
+    });
   }
 
   @override
   ir.Primitive handleLocalSetIfNulls(
       ast.SendSet node,
       LocalElement local,
       ast.Node rhs,
       _,
       {bool isSetterValid}) {
-    return translateSetIfNull(
-        node,
-        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 irBuilder.buildStaticNoSuchMethod(
-        new Selector.getter(new Name(element.name, element.library)),
-        const <ir.Primitive>[]);
-  }
-
-  ir.Primitive buildStaticNoSuchSetter(Element element, ir.Primitive value) {
-    return irBuilder.buildStaticNoSuchMethod(
-        new Selector.setter(new Name(element.name, element.library)),
-        <ir.Primitive>[value]);
+    ir.Primitive value = irBuilder.buildLocalGet(local);
+    return translateSetIfNull(node, value, rhs, (ir.Primitive result) {
+      if (isSetterValid) {
+        irBuilder.buildLocalVariableSet(local, result);
+      } else {
+        Selector selector = new Selector.setter(
+            new Name(local.name, local.library, isSetter: true));
+        irBuilder.buildStaticNoSuchMethod(selector, <ir.Primitive>[result]);
+      }
+    });
   }
 
   @override
   ir.Primitive handleStaticCompounds(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       arg) {
-    return translateCompounds(
-        node,
-        getValue: () {
-          switch (getterKind) {
-            case CompoundGetter.FIELD:
-              SourceInformation src = sourceInformationBuilder.buildGet(node);
-              return buildStaticFieldGet(getter, src);
-            case CompoundGetter.GETTER:
-              return buildStaticGetterGet(getter, node);
-            case CompoundGetter.METHOD:
-              return irBuilder.buildStaticFunctionGet(getter);
-            case CompoundGetter.UNRESOLVED:
-              return buildStaticNoSuchGetter(getter);

[asgerf, 2016/01/11 21:16:36]

The buildStaticNoSuchGetter seemed kind of convenient to have for code like
this.

-          }
-        },
-        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:
-              return buildStaticNoSuchSetter(setter, result);
-          }
-        });
+    ir.Primitive value;
+    switch (getterKind) {
+      case CompoundGetter.FIELD:
+        SourceInformation src = sourceInformationBuilder.buildGet(node);
+        value = buildStaticFieldGet(getter, src);
+        break;
+      case CompoundGetter.GETTER:
+        value = buildStaticGetterGet(getter, node);
+        break;
+      case CompoundGetter.METHOD:
+        value = irBuilder.addPrimitive(new ir.GetStatic(getter));
+        break;
+      case CompoundGetter.UNRESOLVED:
+        value = irBuilder.buildStaticNoSuchMethod(
+            new Selector.getter(new Name(getter.name, getter.library)),
+            <ir.Primitive>[]);
+        break;
+    }
+    return translateCompounds(node, value, rhs, (ir.Primitive result) {
+      switch (setterKind) {
+        case CompoundSetter.FIELD:
+          irBuilder.addPrimitive(new ir.SetStatic(setter, result));
+          break;
+        case CompoundSetter.SETTER:
+          irBuilder.buildStaticSetterSet(setter, result);
+          break;
+        case CompoundSetter.INVALID:
+          irBuilder.buildStaticNoSuchMethod(
+              new Selector.setter(new Name(setter.name, setter.library)),
+              <ir.Primitive>[result]);
+          break;
+      }
+    });
   }
 
   @override
   ir.Primitive handleStaticSetIfNulls(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       ast.Node rhs,
       _) {
-    return translateSetIfNull(
-        node,
-        getValue: () {
-          switch (getterKind) {
-            case CompoundGetter.FIELD:
-              SourceInformation src = sourceInformationBuilder.buildGet(node);
-              return buildStaticFieldGet(getter, src);
-            case CompoundGetter.GETTER:
-              return buildStaticGetterGet(getter, node);
-            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:
-              return buildStaticNoSuchSetter(setter, result);
-          }
-        });
+    ir.Primitive value;
+    switch (getterKind) {
+      case CompoundGetter.FIELD:
+        SourceInformation src = sourceInformationBuilder.buildGet(node);
+        value = buildStaticFieldGet(getter, src);
+        break;
+      case CompoundGetter.GETTER:
+        value = buildStaticGetterGet(getter, node);
+        break;
+      case CompoundGetter.METHOD:
+        value = irBuilder.addPrimitive(new ir.GetStatic(getter));
+        break;
+      case CompoundGetter.UNRESOLVED:
+        value = irBuilder.buildStaticNoSuchMethod(
+            new Selector.getter(new Name(getter.name, getter.library)),
+            <ir.Primitive>[]);
+        break;
+    }
+    return translateSetIfNull(node, value, rhs, (ir.Primitive result) {
+      switch (setterKind) {
+        case CompoundSetter.FIELD:
+          irBuilder.addPrimitive(new ir.SetStatic(setter, result));
+          break;
+        case CompoundSetter.SETTER:
+          irBuilder.buildStaticSetterSet(setter, result);
+          break;
+        case CompoundSetter.INVALID:
+          irBuilder.buildStaticNoSuchMethod(
+              new Selector.setter(new Name(setter.name, setter.library)),
+              <ir.Primitive>[result]);
+          break;
+      }
+    });
   }
 
   ir.Primitive buildSuperNoSuchGetter(Element element, TypeMask mask) {
     return buildInstanceNoSuchMethod(
         new Selector.getter(new Name(element.name, element.library)),
         mask,
         const <ir.Primitive>[]);
   }
 
   ir.Primitive buildSuperNoSuchSetter(Element element,
                                       TypeMask mask,
                                       ir.Primitive value) {
     return buildInstanceNoSuchMethod(
         new Selector.setter(new Name(element.name, element.library)),
         mask,
         <ir.Primitive>[value]);
   }
 
   @override
   ir.Primitive handleSuperCompounds(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       CompoundRhs rhs,
       arg) {
-    return translateCompounds(
-        node,
-        getValue: () {
-          switch (getterKind) {
-            case CompoundGetter.FIELD:
-              return irBuilder.buildSuperFieldGet(getter);
-            case CompoundGetter.GETTER:
-              return irBuilder.buildSuperGetterGet(
-                  getter, sourceInformationBuilder.buildGet(node));
-            case CompoundGetter.METHOD:
-              return irBuilder.buildSuperMethodGet(getter);
-            case CompoundGetter.UNRESOLVED:
-              return buildSuperNoSuchGetter(
-                  getter,
-                  elements.getGetterTypeMaskInComplexSendSet(node));
-          }
-        },
-        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, elements.getTypeMask(node), result);
-          }
-        });
+    ir.Primitive value;
+    switch (getterKind) {
+      case CompoundGetter.FIELD:
+        value = irBuilder.buildSuperFieldGet(getter);
+        break;
+      case CompoundGetter.GETTER:
+        value = irBuilder.buildSuperGetterGet(
+            getter, sourceInformationBuilder.buildGet(node));
+        break;
+      case CompoundGetter.METHOD:
+        value = irBuilder.buildSuperMethodGet(getter);
+        break;
+      case CompoundGetter.UNRESOLVED:
+        value = buildSuperNoSuchGetter(
+            getter, elements.getGetterTypeMaskInComplexSendSet(node));
+        break;
+    }
+    return translateCompounds(node, value, rhs, (ir.Primitive result) {
+      switch (setterKind) {
+        case CompoundSetter.FIELD:
+          irBuilder.buildSuperFieldSet(setter, result);
+          break;
+        case CompoundSetter.SETTER:
+          irBuilder.buildSuperSetterSet(setter, result);
+          break;
+        case CompoundSetter.INVALID:
+          buildSuperNoSuchSetter(
+              setter, elements.getTypeMask(node), result);
+          break;
+      }
+    });
   }
 
   @override
   ir.Primitive handleSuperSetIfNulls(
       ast.SendSet node,
       Element getter,
       CompoundGetter getterKind,
       Element setter,
       CompoundSetter setterKind,
       ast.Node rhs,
       _) {
-    return translateSetIfNull(
-        node,
-        getValue: () {
-          switch (getterKind) {
-            case CompoundGetter.FIELD:
-              return irBuilder.buildSuperFieldGet(getter);
-            case CompoundGetter.GETTER:
-              return irBuilder.buildSuperGetterGet(
-                  getter, sourceInformationBuilder.buildGet(node));
-            case CompoundGetter.METHOD:
-              return irBuilder.buildSuperMethodGet(getter);
-            case CompoundGetter.UNRESOLVED:
-              return buildSuperNoSuchGetter(
-                  getter,
-                  elements.getGetterTypeMaskInComplexSendSet(node));
-          }
-        },
-        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, elements.getTypeMask(node), result);
-          }
-        });
+    ir.Primitive value;
+    switch (getterKind) {
+      case CompoundGetter.FIELD:
+        value = irBuilder.buildSuperFieldGet(getter);
+        break;
+      case CompoundGetter.GETTER:
+        value = irBuilder.buildSuperGetterGet(
+            getter, sourceInformationBuilder.buildGet(node));
+        break;
+      case CompoundGetter.METHOD:
+        value = irBuilder.buildSuperMethodGet(getter);
+        break;
+      case CompoundGetter.UNRESOLVED:
+        value = buildSuperNoSuchGetter(
+            getter,
+            elements.getGetterTypeMaskInComplexSendSet(node));
+        break;
+    }
+    return translateSetIfNull(node, value, rhs, (ir.Primitive result) {
+      switch (setterKind) {
+        case CompoundSetter.FIELD:
+          irBuilder.buildSuperFieldSet(setter, result);
+          break;
+        case CompoundSetter.SETTER:
+          irBuilder.buildSuperSetterSet(setter, result);
+          break;
+        case CompoundSetter.INVALID:
+          buildSuperNoSuchSetter(
+              setter, elements.getTypeMask(node), result);
+          break;
+      }
+    });
   }
 
   @override
   ir.Primitive handleTypeVariableTypeLiteralCompounds(
       ast.SendSet node,
       TypeVariableElement typeVariable,
       CompoundRhs rhs,
       arg) {
-    return translateCompounds(
-        node,
-        getValue: () {
-          return irBuilder.buildReifyTypeVariable(
-            typeVariable.type,
-            sourceInformationBuilder.buildGet(node));
-        },
-        rhs: rhs,
-        setValue: (value) {}); // The binary operator will throw before this.
+    ir.Primitive value = irBuilder.buildReifyTypeVariable(
+        typeVariable.type,
+        sourceInformationBuilder.buildGet(node));
+    return translateCompounds(node, value, rhs, (ir.Primitive value) {
+      // The binary operator will throw before this.
+    });
   }
 
   @override
   ir.Primitive visitTypeVariableTypeLiteralSetIfNull(
       ast.Send node,
       TypeVariableElement element,
       ast.Node rhs,
       _) {
     // The type variable is never `null`.
     return translateTypeVariableTypeLiteral(element,
         sourceInformationBuilder.buildGet(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(
-        node,
-        getValue: () {
-          Selector selector = new Selector.index();
-          List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
-          CallStructure callStructure =
-              normalizeDynamicArguments(selector.callStructure, arguments);
-          return irBuilder.buildDynamicInvocation(
-              target,
-              new Selector(selector.kind, selector.memberName, callStructure),
-              elements.getGetterTypeMaskInComplexSendSet(node),
-              arguments,
-              sourceInformation:
-                  sourceInformationBuilder.buildCall(receiver, node));
-        },
-        rhs: rhs,
-        setValue: (ir.Primitive result) {
-          irBuilder.buildDynamicIndexSet(
-              target,
-              elements.getTypeMask(node),
-              indexValue,
-              result);
-        });
+    Selector selector = new Selector.index();
+    List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
+    CallStructure callStructure =
+    normalizeDynamicArguments(selector.callStructure, arguments);
+    ir.Primitive value = irBuilder.buildDynamicInvocation(
+        target,
+        new Selector(selector.kind, selector.memberName, callStructure),
+        elements.getGetterTypeMaskInComplexSendSet(node),
+        arguments,
+        sourceInformation:
+        sourceInformationBuilder.buildCall(receiver, node));
+    return translateCompounds(node, value, rhs, (ir.Primitive result) {
+      irBuilder.buildDynamicIndexSet(
+          target,
+          elements.getTypeMask(node),
+          indexValue,
+          result);
+    });
   }
 
   @override
   ir.Primitive handleSuperIndexCompounds(
       ast.SendSet node,
       Element indexFunction,
       Element indexSetFunction,
       ast.Node index,
       CompoundRhs rhs,
       arg,
       {bool isGetterValid,
        bool isSetterValid}) {
     ir.Primitive indexValue = visit(index);
-    return translateCompounds(
-        node,
-        getValue: () {
-          if (isGetterValid) {
-            return irBuilder.buildSuperIndex(indexFunction, indexValue);
-          } else {
-            return buildInstanceNoSuchMethod(
-                new Selector.index(),
-                elements.getGetterTypeMaskInComplexSendSet(node),
-                <ir.Primitive>[indexValue]);
-          }
-        },
-        rhs: rhs,
-        setValue: (ir.Primitive result) {
-          if (isSetterValid) {
-            irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result);
-          } else {
-            buildInstanceNoSuchMethod(
-                new Selector.indexSet(),
-                elements.getTypeMask(node),
-                <ir.Primitive>[indexValue, result]);
-          }
-        });
+    ir.Primitive value = isGetterValid
+        ? irBuilder.buildSuperIndex(indexFunction, indexValue)
+        : buildInstanceNoSuchMethod(
+              new Selector.index(),
+              elements.getGetterTypeMaskInComplexSendSet(node),
+              <ir.Primitive>[indexValue]);
+    return translateCompounds(node, value, rhs, (ir.Primitive result) {
+      if (isSetterValid) {
+        irBuilder.buildSuperIndexSet(indexSetFunction, indexValue, result);
+      } else {
+        buildInstanceNoSuchMethod(
+            new Selector.indexSet(),
+            elements.getTypeMask(node),
+            <ir.Primitive>[indexValue, result]);
+      }
+    });
   }
 
   /// Build code to handle foreign code, that is, native JavaScript code, or
   /// builtin values and operations of the backend.
   ir.Primitive handleForeignCode(ast.Send node,
       MethodElement function,
       ast.NodeList argumentList,
       CallStructure callStructure) {
 
     void validateArgumentCount({int minimum, int exactly}) {
@@ skipping 847 matching lines @@
   }
 
   Element get closureConverter {
     return _backend.helpers.closureConverter;
   }
 
   void addNativeMethod(FunctionElement function) {
     _backend.emitter.nativeEmitter.nativeMethods.add(function);
   }
 }