Fine-grain field, getter, setter, and function access in IrBuilder.

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 226 matching lines @@
 
   List<ir.Initializer> buildConstructorInitializers(
       ast.FunctionExpression function, ConstructorElement element) {
     List<ir.Initializer> result = <ir.Initializer>[];
     FunctionSignature signature = element.functionSignature;
 
     void tryAddInitializingFormal(ParameterElement parameterElement) {
       if (parameterElement.isInitializingFormal) {
         InitializingFormalElement initializingFormal = parameterElement;
         withBuilder(irBuilder.makeInitializerBuilder(), () {
-          ir.Primitive value = irBuilder.buildLocalGet(parameterElement);
+          ir.Primitive value =
+              irBuilder.buildLocalVariableGet(parameterElement);
           result.add(irBuilder.makeFieldInitializer(
               initializingFormal.fieldElement,
               irBuilder.makeRunnableBody(value)));
         });
       }
     }
 
     // TODO(sigurdm): Preserve initializing formals as initializing formals.
     signature.orderedForEachParameter(tryAddInitializingFormal);
 
@@ skipping 416 matching lines @@
   }
 
   @override
   ir.Primitive handleLocalGet(
       ast.Send node,
       LocalElement element,
       _) {
     if (element.isConst) {
       return translateConstant(node);
     }
-    return irBuilder.buildLocalGet(element);
+    return irBuilder.buildLocalVariableGet(element);
   }
 
   @override
+  ir.Primitive visitLocalFunctionGet(
+      ast.Send node,
+      LocalFunctionElement function,
+      _) {
+    return irBuilder.buildLocalFunctionGet(function);
+  }
+
+  @override
   ir.Primitive handleStaticFieldGet(
       ast.Send node,
       FieldElement field,
       _) {
     if (field.isConst) {
       return translateConstant(node);
     }
-    return irBuilder.buildStaticGet(field,
+    return irBuilder.buildStaticFieldGet(field,
         sourceInformation: sourceInformationBuilder.buildGet(node));
   }
 
   @override
   ir.Primitive handleStaticFunctionGet(
       ast.Send node,
       MethodElement function,
       _) {
     // TODO(karlklose): support foreign functions.
     if (function.isForeign(compiler.backend)) {
       return giveup(node, 'handleStaticFunctionGet: foreign: $function');
     }
     return translateConstant(node);
   }
 
   @override
   ir.Primitive handleStaticGetterGet(
       ast.Send node,
       FunctionElement getter,
       _) {
-    return irBuilder.buildStaticInvocation(getter,
-        new Selector.getter(getter.name, getter.library), const []);
+    return irBuilder.buildStaticGetterGet(getter);
   }
 
   @override
   ir.Primitive visitSuperFieldGet(
       ast.Send node,
       FieldElement field,
       _) {
-    return irBuilder.buildSuperGet(field);
+    return irBuilder.buildSuperFieldGet(field);
   }
 
   @override
   ir.Primitive visitSuperGetterGet(
       ast.Send node,
       FunctionElement getter,
       _) {
-    return irBuilder.buildSuperGet(getter);
+    return irBuilder.buildSuperGetterGet(getter);
   }
 
   @override
   ir.Primitive visitSuperMethodGet(
       ast.Send node,
       MethodElement method,
       _) {
-    return irBuilder.buildSuperGet(method);
+    return irBuilder.buildSuperMethodGet(method);
   }
 
   @override
   ir.Primitive visitThisGet(ast.Identifier node, _) {
     return irBuilder.buildThis();
   }
 
   ir.Primitive translateTypeVariableTypeLiteral(TypeVariableElement element) {
     return buildReifyTypeVariable(irBuilder.buildThis(), element.type);
   }
@@ skipping 90 matching lines @@
     arguments = normalizeDynamicArguments(selector, arguments);
     return irBuilder.buildDynamicInvocation(target, selector, arguments);
   }
 
   ir.Primitive translateSuperBinary(FunctionElement function,
                                     op.BinaryOperator operator,
                                     ast.Node argument) {
     Selector selector = new Selector.binaryOperator(operator.selectorName);
     List<ir.Primitive> arguments = <ir.Primitive>[visit(argument)];
     arguments = normalizeDynamicArguments(selector, arguments);
-    return irBuilder.buildSuperInvocation(function, selector, arguments);
+    return irBuilder.buildSuperMethodInvocation(function, selector, arguments);
   }
 
   @override
   ir.Primitive visitSuperBinary(
       ast.Send node,
       FunctionElement function,
       op.BinaryOperator operator,
       ast.Node argument,
       _) {
     return translateSuperBinary(function, operator, argument);
   }
 
   @override
   ir.Primitive visitSuperIndex(
       ast.Send node,
       FunctionElement function,
       ast.Node index,
       _) {
     Selector selector = new Selector.index();
     List<ir.Primitive> arguments = <ir.Primitive>[visit(index)];
     arguments = normalizeDynamicArguments(selector, arguments);
-    return irBuilder.buildSuperInvocation(function, selector, arguments);
+    return irBuilder.buildSuperMethodInvocation(function, selector, arguments);
   }
 
   @override
   ir.Primitive visitEquals(
       ast.Send node,
       ast.Node left,
       ast.Node right,
       _) {
     return translateBinary(left, op.BinaryOperator.EQ, right);
   }
@@ skipping 51 matching lines @@
   ir.Primitive visitSuperUnary(
       ast.Send node,
       op.UnaryOperator operator,
       FunctionElement function,
       _) {
     // TODO(johnniwinther): Clean up the creation of selectors.
     Selector selector = new Selector(
         SelectorKind.OPERATOR,
         new PublicName(operator.selectorName),
         CallStructure.NO_ARGS);
-    return irBuilder.buildSuperInvocation(function, selector, const []);
+    return irBuilder.buildSuperMethodInvocation(function, selector, const []);
   }
 
   // TODO(johnniwinther): Handle this in the [IrBuilder] to ensure the correct
   // semantic correlation between arguments and invocation.
   List<ir.Primitive> translateDynamicArguments(ast.NodeList nodeList,
                                                Selector selector) {
     List<ir.Primitive> arguments = nodeList.nodes.mapToList(visit);
     return normalizeDynamicArguments(selector, arguments);
   }
 
@@ skipping 44 matching lines @@
         translateReceiver(receiver), selector,
         translateDynamicArguments(arguments, selector));
   }
 
   ir.Primitive handleLocalInvoke(
       ast.Send node,
       LocalElement element,
       ast.NodeList arguments,
       Selector selector,
       _) {
-    return irBuilder.buildLocalInvocation(element, selector,
+    return irBuilder.buildLocalVariableInvocation(element, selector,
         translateDynamicArguments(arguments, selector));
   }
 
+  @override
+  ir.Primitive visitLocalFunctionInvoke(
+      ast.Send node,
+      LocalFunctionElement function,
+      ast.NodeList arguments,
+      Selector selector,
+      _) {
+    return irBuilder.buildLocalFunctionInvocation(function, selector,
+        translateDynamicArguments(arguments, selector));
+  }
+
   @override
   ir.Primitive handleStaticFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList arguments,
       Selector selector,
       _) {
-    return translateCallInvoke(
-        irBuilder.buildStaticGet(field),
-        arguments, selector);
+    return irBuilder.buildStaticFieldInvocation(field, selector,
+        translateDynamicArguments(arguments, selector));
   }
 
   @override
   ir.Primitive handleStaticFunctionInvoke(
       ast.Send node,
       MethodElement function,
       ast.NodeList arguments,
       Selector selector,
       _) {
     // TODO(karlklose): support foreign functions.
     if (function.isForeign(compiler.backend)) {
       return giveup(node, 'handleStaticFunctionInvoke: foreign: $function');
     }
-    return irBuilder.buildStaticInvocation(function, selector,
+    return irBuilder.buildStaticFunctionInvocation(function, selector,
         translateStaticArguments(arguments, function, selector.callStructure),
         sourceInformation: sourceInformationBuilder.buildCall(node));
   }
 
   @override
   ir.Primitive handleStaticGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       Selector selector,
       _) {
-    return translateCallInvoke(
-        irBuilder.buildStaticGet(getter),
-        arguments, selector);
+    return irBuilder.buildStaticGetterInvocation(getter, selector,
+        translateDynamicArguments(arguments, selector));
   }
 
   @override
   ir.Primitive visitSuperFieldInvoke(
       ast.Send node,
       FieldElement field,
       ast.NodeList arguments,
       Selector selector,
       _) {
-    return translateCallInvoke(
-        irBuilder.buildSuperGet(field),
-        arguments, selector);
+    return irBuilder.buildSuperFieldInvocation(field, selector,
+        translateDynamicArguments(arguments, selector));
   }
 
   @override
   ir.Primitive visitSuperGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList arguments,
       Selector selector,
       _) {
-    return translateCallInvoke(
-        irBuilder.buildSuperGet(getter),
-        arguments, selector);
+    return irBuilder.buildSuperGetterInvocation(getter, selector,
+        translateDynamicArguments(arguments, selector));
   }
 
   @override
   ir.Primitive visitSuperMethodInvoke(
       ast.Send node,
       MethodElement method,
       ast.NodeList arguments,
       Selector selector,
       _) {
-    return irBuilder.buildSuperInvocation(method, selector,
+    return irBuilder.buildSuperMethodInvocation(method, selector,
         translateDynamicArguments(arguments, selector));
   }
 
   @override
   ir.Primitive visitThisInvoke(
       ast.Send node,
       ast.NodeList arguments,
       Selector selector,
       _) {
     return translateCallInvoke(irBuilder.buildThis(), arguments, selector);
@@ skipping 78 matching lines @@
       ast.Node index,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
     ir.Primitive indexValue = visit(index);
     return translateCompound(
         getValue: () {
           Selector selector = new Selector.index();
           List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
           arguments = normalizeDynamicArguments(selector, arguments);
-          return irBuilder.buildSuperInvocation(getter, selector, arguments);
+          return irBuilder.buildSuperMethodInvocation(
+              getter, selector, arguments);
         },
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
           irBuilder.buildSuperIndexSet(setter, indexValue, result);
         });
   }
 
   ir.Primitive translatePrefixPostfix(
       {ir.Primitive getValue(),
@@ skipping 80 matching lines @@
   }
 
   @override
   ir.Primitive handleLocalCompound(
       ast.Send node,
       LocalElement element,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
     return translateCompound(
-        getValue: () => irBuilder.buildLocalGet(element),
+        getValue: () => irBuilder.buildLocalVariableGet(element),
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
-          irBuilder.buildLocalSet(element, result);
+          irBuilder.buildLocalVariableSet(element, result);
         });
   }
 
   @override
   ir.Primitive handleLocalPostfixPrefix(
       ast.Send node,
       LocalElement element,
       op.IncDecOperator operator,
       arg,
       {bool isPrefix}) {
     return translatePrefixPostfix(
-        getValue: () => irBuilder.buildLocalGet(element),
+        getValue: () => irBuilder.buildLocalVariableGet(element),
         operator: operator,
         setValue: (ir.Primitive result) {
-          irBuilder.buildLocalSet(element, result);
+          irBuilder.buildLocalVariableSet(element, result);
         },
         isPrefix: isPrefix);
   }
 
   @override
   ir.Primitive handleLocalSet(
       ast.SendSet node,
       LocalElement element,
       ast.Node rhs,
       _) {
-    return irBuilder.buildLocalSet(element, visit(rhs));
+    return irBuilder.buildLocalVariableSet(element, visit(rhs));
   }
 
   @override
   ir.Primitive handleStaticFieldCompound(
       ast.Send node,
       FieldElement field,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
     return translateCompound(
-        getValue: () => irBuilder.buildStaticGet(field),
+        getValue: () => irBuilder.buildStaticFieldGet(field),
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
-          irBuilder.buildStaticSet(field, result);
+          irBuilder.buildStaticFieldSet(field, result);
         });
   }
 
   @override
   ir.Primitive handleStaticFieldPostfixPrefix(
       ast.Send node,
       FieldElement field,
       op.IncDecOperator operator,
       arg,
       {bool isPrefix}) {
     return translatePrefixPostfix(
-        getValue: () => irBuilder.buildStaticGet(field),
+        getValue: () => irBuilder.buildStaticFieldGet(field),
         operator: operator,
         setValue: (ir.Primitive result) {
-          irBuilder.buildStaticSet(field, result);
+          irBuilder.buildStaticFieldSet(field, result);
         },
         isPrefix: isPrefix);
   }
 
   @override
   ir.Primitive handleStaticFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs,
       _) {
-    return irBuilder.buildStaticSet(field, visit(rhs));
+    return irBuilder.buildStaticFieldSet(field, visit(rhs));
   }
 
   @override
   ir.Primitive visitSuperFieldSet(
       ast.SendSet node,
       FieldElement field,
       ast.Node rhs,
       _) {
-    return irBuilder.buildSuperSet(field, visit(rhs));
+    return irBuilder.buildSuperFieldSet(field, visit(rhs));
   }
 
   @override
   ir.Primitive visitSuperSetterSet(
       ast.SendSet node,
       FunctionElement setter,
       ast.Node rhs,
       _) {
-    return irBuilder.buildSuperSet(setter, visit(rhs));
+    return irBuilder.buildSuperSetterSet(setter, visit(rhs));
   }
 
   @override
   ir.Primitive handleStaticGetterSetterCompound(
       ast.Send node,
       FunctionElement getter,
       FunctionElement setter,
       op.AssignmentOperator operator,
       ast.Node rhs,
       _) {
     return translateCompound(
-        getValue: () => irBuilder.buildStaticGet(getter),
+        getValue: () => irBuilder.buildStaticGetterGet(getter),
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
-          irBuilder.buildStaticSet(setter, 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.buildSuperGet(readField),
+        getValue: () => irBuilder.buildSuperFieldGet(readField),
         operator: operator,
         setValue: (ir.Primitive result) {
-          irBuilder.buildSuperSet(writtenField, 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.buildSuperGet(field),
+        getValue: () => irBuilder.buildSuperFieldGet(field),
         operator: operator,
         setValue: (ir.Primitive result) {
-          irBuilder.buildSuperSet(setter, 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.buildSuperGet(getter),
+        getValue: () => irBuilder.buildSuperGetterGet(getter),
         operator: operator,
         setValue: (ir.Primitive result) {
-          irBuilder.buildSuperSet(field, 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.buildSuperGet(getter),
+        getValue: () => irBuilder.buildSuperGetterGet(getter),
         operator: operator,
         setValue: (ir.Primitive result) {
-          irBuilder.buildSuperSet(setter, 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.buildSuperGet(method),
+        getValue: () => irBuilder.buildSuperMethodGet(method),
         operator: operator,
         setValue: (ir.Primitive result) {
-          irBuilder.buildSuperSet(setter, 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.buildStaticGet(getter),
+        getValue: () => irBuilder.buildStaticGetterGet(getter),
         operator: operator,
         setValue: (ir.Primitive result) {
-          irBuilder.buildStaticSet(setter, 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.buildStaticGet(method),
+        getValue: () => irBuilder.buildStaticFunctionGet(method),
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
-          irBuilder.buildStaticSet(setter, 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.buildStaticGet(getter),
+        getValue: () => irBuilder.buildStaticFunctionGet(getter),
         operator: operator,
         setValue: (ir.Primitive result) {
-          irBuilder.buildStaticSet(setter, result);
+          irBuilder.buildStaticSetterSet(setter, result);
         },
         isPrefix: isPrefix);
   }
 
   @override
   ir.Primitive handleDynamicIndexPostfixPrefix(
       ast.Send node,
       ast.Node receiver,
       ast.Node index,
       op.IncDecOperator operator,
@@ skipping 26 matching lines @@
       ast.Node index,
       op.IncDecOperator operator,
       arg,
       {bool isPrefix}) {
     ir.Primitive indexValue = visit(index);
     return translatePrefixPostfix(
         getValue: () {
           Selector selector = new Selector.index();
           List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
           arguments = normalizeDynamicArguments(selector, arguments);
-          return irBuilder.buildSuperInvocation(
+          return irBuilder.buildSuperMethodInvocation(
               indexFunction, selector, arguments);
         },
         operator: operator,
         setValue: (ir.Primitive result) {
           Selector selector = new Selector.indexSet();
           List<ir.Primitive> arguments = <ir.Primitive>[indexValue, result];
           arguments = normalizeDynamicArguments(selector, arguments);
-          irBuilder.buildSuperInvocation(
+          irBuilder.buildSuperMethodInvocation(
               indexSetFunction, selector, arguments);
         },
         isPrefix: isPrefix);
   }
 
   @override
   ir.Primitive handleStaticSetterSet(
       ast.SendSet node,
       FunctionElement setter,
       ast.Node rhs,
       _) {
-    return irBuilder.buildStaticSet(setter, visit(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.buildSuperGet(field),
+        getValue: () => irBuilder.buildSuperFieldGet(field),
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
-          irBuilder.buildSuperSet(field, result);
+          irBuilder.buildSuperFieldSet(field, result);
         });
   }
 
   @override
   ir.Primitive visitSuperFieldFieldPostfix(
       ast.Send node,
       FieldElement readField,
       FieldElement writtenField,
       op.IncDecOperator operator,
       _) {
     return translatePrefixPostfix(
-        getValue: () => irBuilder.buildSuperGet(readField),
+        getValue: () => irBuilder.buildSuperFieldGet(readField),
         operator: operator,
         setValue: (ir.Primitive result) {
-          irBuilder.buildSuperSet(writtenField, 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.buildSuperGet(readField),
+        getValue: () => irBuilder.buildSuperFieldGet(readField),
         operator: operator,
         setValue: (ir.Primitive result) {
-          irBuilder.buildSuperSet(writtenField, 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.buildSuperGet(field),
+        getValue: () => irBuilder.buildSuperFieldGet(field),
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
-          irBuilder.buildSuperSet(setter, 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.buildSuperGet(getter),
+        getValue: () => irBuilder.buildSuperGetterGet(getter),
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
-          irBuilder.buildSuperSet(field, 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.buildSuperGet(getter),
+        getValue: () => irBuilder.buildSuperGetterGet(getter),
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
-          irBuilder.buildSuperSet(setter, 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.buildSuperGet(method),
+        getValue: () => irBuilder.buildSuperMethodGet(method),
         operator: operator,
         rhs: rhs,
         setValue: (ir.Primitive result) {
-          irBuilder.buildSuperSet(setter, result);
+          irBuilder.buildSuperSetterSet(setter, result);
         });
   }
 
   @override
   ir.Primitive handleConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
       ast.NodeList arguments,
       Selector selector, _) {
@@ skipping 610 matching lines @@
           fieldValues[field] = irBuilder.buildNullLiteral();
         }
       }
     });
     // Evaluate initializing parameters, e.g. `Foo(this.x)`.
     constructor.functionSignature.orderedForEachParameter(
         (ParameterElement parameter) {
       if (parameter.isInitializingFormal) {
         InitializingFormalElement fieldParameter = parameter;
         fieldValues[fieldParameter.fieldElement] =
-            irBuilder.buildLocalGet(parameter);
+            irBuilder.buildLocalVariableGet(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 310 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }