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

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 143 matching lines @@
   /// Call [enterTry] before translating a try block and call this function
   /// after translating it.
   void leaveTry() {
     _boxedTryVariables.removeLast();
   }
 
   void _buildTryExit(IrBuilder builder) {
     for (Iterable<LocalVariableElement> boxedOnEntry in _boxedTryVariables) {
       for (LocalVariableElement variable in boxedOnEntry) {
         assert(builder.isInMutableVariable(variable));
-        ir.Primitive value = builder.buildLocalGet(variable);
+        ir.Primitive value = builder.buildLocalVariableGet(variable);
         builder.environment.update(variable, value);
       }
     }
   }
 }
 
 /// A class to collect 'forward' jumps.
 ///
 /// A forward jump to a continuation in the sense of the CPS translation is
 /// a jump where the jump is emitted before any code in the body of the
@@ skipping 467 matching lines @@
                                  List<ir.Primitive> arguments) {
     assert(target.isInstanceMember);
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeMethodDirectly(
             buildThis(), target, selector, k, arguments));
   }
 
   ir.Primitive _buildInvokeDynamic(ir.Primitive receiver,
                                    Selector selector,
-                                   List<ir.Primitive> arguments) {
+                                   List<ir.Primitive> arguments,
+                                   {SourceInformation sourceInformation}) {
     assert(isOpen);
     return _continueWithExpression(
-        (k) => new ir.InvokeMethod(receiver, selector, k, arguments));
+        (k) => new ir.InvokeMethod(receiver, selector, k, arguments,
+            sourceInformation: sourceInformation));
   }
 
   ir.Primitive _buildInvokeCall(ir.Primitive target,
                                 Selector selector,
-                                List<ir.Definition> arguments) {
+                                List<ir.Definition> arguments,
+                                {SourceInformation sourceInformation}) {
     Selector callSelector = new Selector.callClosureFrom(selector);
-    return _buildInvokeDynamic(target, callSelector, arguments);
+    return _buildInvokeDynamic(target, callSelector, arguments,
+        sourceInformation: sourceInformation);
   }
 
 
   /// Create a constant literal from [constant].
   ir.Constant buildConstantLiteral(ConstantExpression constant) {
     assert(isOpen);
     return addPrimitive(new ir.Constant(constant));
   }
 
   // Helper for building primitive literals.
@@ skipping 194 matching lines @@
 
   ir.ConstructorDefinition makeConstructorDefinition(
       List<ConstantExpression> defaults, List<ir.Initializer> initializers) {
     FunctionElement element = state.currentElement;
     ir.RunnableBody body = makeRunnableBody();
     return new ir.ConstructorDefinition(
         element, state.thisParameter, state.functionParameters, body, initializers,
         state.localConstants, defaults);
   }
 
-  /// Create a super invocation where the method name and the argument structure
-  /// are defined by [selector] and the argument values are defined by
+  /// Create a invocation of the [method] on the super class where the call
+  /// structure is defined [selector] and the argument values are defined by
   /// [arguments].
-  ir.Primitive buildSuperInvocation(Element target,
-                                    Selector selector,
-                                    List<ir.Primitive> arguments);
-
-  /// Create a getter invocation of the [target] on the super class.
-  ir.Primitive buildSuperGet(Element target) {
-    Selector selector = new Selector.getter(target.name, target.library);
-    return buildSuperInvocation(target, selector, const <ir.Primitive>[]);
+  ir.Primitive buildSuperMethodInvocation(MethodElement method,
+                                          Selector selector,
+                                          List<ir.Primitive> arguments) {
+    return _buildInvokeSuper(method, selector, arguments);
   }
 
-  /// Create a setter invocation of the [target] on the super class of with
-  /// [value].
-  ir.Primitive buildSuperSet(Element target, ir.Primitive value) {
-    Selector selector = new Selector.setter(target.name, target.library);
-    buildSuperInvocation(target, selector, [value]);
+  /// Create a call invocation on the value of [field] on the super class where
+  /// the call structure is defined [selector] and the argument values are
+  /// defined by [arguments].
+  ir.Primitive buildSuperFieldInvocation(FieldElement field,
+                                         Selector selector,
+                                         List<ir.Primitive> arguments) {
+    // TODO(johnniwinther): Maybe this should have its own ir node.
+    return buildCallInvocation(
+        buildSuperFieldGet(field),
+        selector,
+        arguments);
+  }
+
+  /// Create a call invocation on the value returned from the [getter] on the
+  /// super class where the call structure is defined [selector] and the
+  /// argument values are defined by [arguments].
+  ir.Primitive buildSuperGetterInvocation(MethodElement getter,
+                                          Selector selector,
+                                          List<ir.Primitive> arguments) {
+    // TODO(johnniwinther): Maybe this should have its own ir node.
+    return buildCallInvocation(
+        buildSuperGetterGet(getter),
+        selector,
+        arguments);
+  }
+
+  /// Create a read access of the [field] on the super class.
+  ir.Primitive buildSuperFieldGet(FieldElement field) {
+    // TODO(johnniwinther): This should have its own ir node.
+    return _buildInvokeSuper(
+        field,
+        new Selector.getter(field.name, field.library),
+        const <ir.Primitive>[]);
+  }
+
+  /// Create a read access of the [method] on the super class, i.e. a
+  /// closurization of [method].
+  ir.Primitive buildSuperMethodGet(MethodElement method) {
+    // TODO(johnniwinther): This should have its own ir node.
+    return _buildInvokeSuper(
+        method,
+        new Selector.getter(method.name, method.library),
+        const <ir.Primitive>[]);
+  }
+
+  /// Create a getter invocation of the [getter] on the super class.
+  ir.Primitive buildSuperGetterGet(MethodElement getter) {
+    // TODO(johnniwinther): This should have its own ir node.
+    return _buildInvokeSuper(
+        getter,
+        new Selector.getter(getter.name, getter.library),
+        const <ir.Primitive>[]);
+  }
+
+  /// Create a write access to the [field] on the super class of with [value].
+  ir.Primitive buildSuperFieldSet(Element field, ir.Primitive value) {
+    // TODO(johnniwinther): This should have its own ir node.
+    _buildInvokeSuper(
+        field,
+        new Selector.setter(field.name, field.library),
+        <ir.Primitive>[value]);
     return value;
   }
 
-  /// Create an index set invocation on the super class with the provided
-  /// [index] and [value].
-  ir.Primitive buildSuperIndexSet(Element target,
+  /// Create an setter invocation of the [setter] on the super class with
+  /// [value].
+  ir.Primitive buildSuperSetterSet(MethodElement setter,
+                                          ir.Primitive value) {
+    // TODO(johnniwinther): This should have its own ir node.
+    _buildInvokeSuper(
+        setter,
+        new Selector.setter(setter.name, setter.library),
+        <ir.Primitive>[value]);
+    return value;
+  }
+
+  /// Create an invocation of the index set [method] on the super class with
+  /// the provided [index] and [value].
+  ir.Primitive buildSuperIndexSet(MethodElement method,
                                   ir.Primitive index,
                                   ir.Primitive value) {
-    _buildInvokeSuper(target, new Selector.indexSet(),
+    _buildInvokeSuper(method, new Selector.indexSet(),
         <ir.Primitive>[index, value]);
     return value;
   }
 
   /// Create a dynamic invocation on [receiver] where the method name and
   /// argument structure are defined by [selector] and the argument values are
   /// defined by [arguments].
   ir.Primitive buildDynamicInvocation(ir.Primitive receiver,
                                       Selector selector,
                                       List<ir.Primitive> arguments) {
@@ skipping 20 matching lines @@
   /// Create a dynamic index set invocation on [receiver] with the provided
   /// [index] and [value].
   ir.Primitive  buildDynamicIndexSet(ir.Primitive receiver,
                                      ir.Primitive index,
                                      ir.Primitive value) {
     _buildInvokeDynamic(
         receiver, new Selector.indexSet(), <ir.Primitive>[index, value]);
     return value;
   }
 
-  /// Create a read access of [local].
-  ir.Primitive buildLocalGet(LocalElement element);
+  ir.Primitive _buildLocalGet(LocalElement element);
 
-  /// Create a write access to [local] with the provided [value].
-  ir.Primitive buildLocalSet(LocalElement element, ir.Primitive value);
-
-  /// Create an invocation of the local [element] where argument structure is
-  /// defined by [selector] and the argument values are defined by [arguments].
-  ir.Primitive buildLocalInvocation(LocalElement element,
-                                    Selector selector,
-                                    List<ir.Primitive> arguments) {
-    return buildCallInvocation(buildLocalGet(element), selector, arguments);
+  /// Create a read access of the [local] variable or parameter.
+  ir.Primitive buildLocalVariableGet(LocalElement local) {
+    // TODO(johnniwinther): Separate function access from variable access.
+    return _buildLocalGet(local);
   }
 
-  /// Create a static invocation of [element] where argument structure is
-  /// defined by [selector] and the argument values are defined by [arguments].
-  ir.Primitive buildStaticInvocation(Element element,
-                                     Selector selector,
-                                     List<ir.Primitive> arguments,
-                                     {SourceInformation sourceInformation}) {
-    return _buildInvokeStatic(element, selector, arguments, sourceInformation);
+  /// Create a read access of the local [function], i.e. closurization of
+  /// [function].
+  ir.Primitive buildLocalFunctionGet(LocalFunctionElement function) {
+    // TODO(johnniwinther): Separate function access from variable access.
+    return _buildLocalGet(function);
   }
 
-  /// Create a static getter invocation of [element] where the getter name is
-  /// defined by [selector].
-  ir.Primitive buildStaticGet(Element element,
-                              {SourceInformation sourceInformation}) {
-    Selector selector = new Selector.getter(element.name, element.library);
+  /// Create a write access to the [local] variable or parameter with the
+  /// provided [value].
+  ir.Primitive buildLocalVariableSet(LocalElement local, ir.Primitive value);
+
+  /// Create an invocation of the the [local] variable or parameter where
+  /// argument structure is defined by [selector] and the argument values are
+  /// defined by [arguments].
+  ir.Primitive buildLocalVariableInvocation(LocalVariableElement local,
+                                            Selector selector,
+                                            List<ir.Primitive> arguments) {
+    return buildCallInvocation(
+        buildLocalVariableGet(local), selector, arguments);
+  }
+
+  /// Create an invocation of the local [function] where argument structure is
+  /// defined by [selector] and the argument values are defined by [arguments].
+  ir.Primitive buildLocalFunctionInvocation(
+      LocalFunctionElement function,
+      Selector selector,
+      List<ir.Primitive> arguments) {
+    // TODO(johnniwinther): Maybe this should have its own ir node.
+    return buildCallInvocation(
+        buildLocalFunctionGet(function), selector, arguments);
+  }
+
+  /// Create a static invocation of [function] where argument structure is
+  /// defined by [selector] and the argument values are defined by [arguments].
+  ir.Primitive buildStaticFunctionInvocation(
+      MethodElement function,
+      Selector selector,
+      List<ir.Primitive> arguments,
+      {SourceInformation sourceInformation}) {
+    return _buildInvokeStatic(function, selector, arguments, sourceInformation);
+  }
+
+  /// Create a call invocation of the value of the static [field] where argument
+  /// structure is defined by [selector] and the argument values are defined by
+  /// [arguments].
+  ir.Primitive buildStaticFieldInvocation(
+      FieldElement field,
+      Selector selector,
+      List<ir.Primitive> arguments,
+      {SourceInformation sourceInformation}) {
+    // TODO(johnniwinther): Maybe this should have its own node.
+    return buildCallInvocation(
+        buildStaticFieldGet(field),
+        selector,
+        arguments,
+        sourceInformation: sourceInformation);
+  }
+
+  /// Create a call invocation of the result of calling the static [getter]
+  /// where argument structure is defined by [selector] and the argument values
+  /// are defined by [arguments].
+  ir.Primitive buildStaticGetterInvocation(
+      MethodElement getter,
+      Selector selector,
+      List<ir.Primitive> arguments,
+      {SourceInformation sourceInformation}) {
+    // TODO(johnniwinther): Maybe this should have its own node.
+    return buildCallInvocation(
+        buildStaticGetterGet(getter),
+        selector,
+        arguments,
+        sourceInformation: sourceInformation);
+  }
+
+  /// Create a read access of the static [field].
+  ir.Primitive buildStaticFieldGet(FieldElement field,
+                                   {SourceInformation sourceInformation}) {
+    Selector selector = new Selector.getter(field.name, field.library);
     // TODO(karlklose,sigurdm): build different nodes for getters.
     return _buildInvokeStatic(
-        element, selector, const <ir.Primitive>[], sourceInformation);
+        field, selector, const <ir.Primitive>[], sourceInformation);
   }
 
-  /// Create a static setter invocation of [element] where the setter name and
-  /// argument are defined by [selector] and [value], respectively.
-  ir.Primitive buildStaticSet(Element element,
-                              ir.Primitive value,
-                              {SourceInformation sourceInformation}) {
-    Selector selector = new Selector.setter(element.name, element.library);
+  /// Create a getter invocation of the static [getter].
+  ir.Primitive buildStaticGetterGet(MethodElement getter,
+                                    {SourceInformation sourceInformation}) {
+    Selector selector = new Selector.getter(getter.name, getter.library);
+    // TODO(karlklose,sigurdm): build different nodes for getters.
+    return _buildInvokeStatic(
+        getter, selector, const <ir.Primitive>[], sourceInformation);
+  }
+
+  /// Create a read access of the static [function], i.e. a closurization of
+  /// [function].
+  ir.Primitive buildStaticFunctionGet(MethodElement function,
+                                      {SourceInformation sourceInformation}) {
+    Selector selector =
+        new Selector.getter(function.name, function.library);
+    // TODO(karlklose,sigurdm): build different nodes for getters.
+    return _buildInvokeStatic(
+        function, selector, const <ir.Primitive>[], sourceInformation);
+  }
+
+  /// Create a write access to the static [field] with the [value].
+  ir.Primitive buildStaticFieldSet(FieldElement field,
+                                   ir.Primitive value,
+                                   {SourceInformation sourceInformation}) {
+    Selector selector = new Selector.setter(field.name, field.library);
     // TODO(karlklose,sigurdm): build different nodes for setters.
     _buildInvokeStatic(
-        element, selector, <ir.Primitive>[value], sourceInformation);
+        field, selector, <ir.Primitive>[value], sourceInformation);
     return value;
   }
 
+  /// Create a setter invocation of the static [setter] with the [value].
+  ir.Primitive buildStaticSetterSet(MethodElement setter,
+                                    ir.Primitive value,
+                                    {SourceInformation sourceInformation}) {
+    Selector selector = new Selector.setter(setter.name, setter.library);
+    // TODO(karlklose,sigurdm): build different nodes for setters.
+    _buildInvokeStatic(
+        setter, selector, <ir.Primitive>[value], sourceInformation);
+    return value;
+  }
+
+  /// Create an erroneous invocation where argument structure is defined by
+  /// [selector] and the argument values are defined by [arguments].
+  // TODO(johnniwinther): Make this more fine-grained.
+  ir.Primitive buildErroneousInvocation(
+      Element element,
+      Selector selector,
+      List<ir.Primitive> arguments) {
+    // TODO(johnniwinther): This should have its own ir node.
+    return _buildInvokeStatic( element, selector, arguments, null);
+  }
+
   /// Create a constructor invocation of [element] on [type] where the
   /// constructor name and argument structure are defined by [selector] and the
   /// argument values are defined by [arguments].
   ir.Primitive buildConstructorInvocation(FunctionElement element,
                                           Selector selector,
                                           DartType type,
                                           List<ir.Primitive> arguments);
 
   /// Create a string concatenation of the [arguments].
   ir.Primitive buildStringConcatenation(List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.ConcatenateStrings(k, arguments));
   }
 
   /// Create an invocation of the `call` method of [functionExpression], where
   /// the named arguments are given by [selector].
   ir.Primitive buildCallInvocation(
       ir.Primitive functionExpression,
       Selector selector,
-      List<ir.Definition> arguments) {
-    return _buildInvokeCall(functionExpression, selector, arguments);
+      List<ir.Definition> arguments,
+      {SourceInformation sourceInformation}) {
+    return _buildInvokeCall(functionExpression, selector, arguments,
+        sourceInformation: sourceInformation);
   }
 
   /// Creates an if-then-else statement with the provided [condition] where the
   /// then and else branches are created through the [buildThenPart] and
   /// [buildElsePart] functions, respectively.
   ///
   /// An if-then statement is created if [buildElsePart] is a no-op.
   // TODO(johnniwinther): Unify implementation with [buildConditional] and
   // [_buildLogicalOperator].
   void buildIf(ir.Primitive condition,
@@ skipping 295 matching lines @@
     if (buildVariableDeclaration != null) {
       buildVariableDeclaration(bodyBuilder);
     }
     ir.Parameter currentValue = new ir.Parameter(null);
     ir.Continuation currentInvoked = new ir.Continuation([currentValue]);
     bodyBuilder.add(new ir.LetCont(currentInvoked,
         new ir.InvokeMethod(iterator, new Selector.getter("current", null),
             currentInvoked, emptyArguments)));
     // TODO(sra): Does this cover all cases? The general setter case include
     // super.
+    // TODO(johnniwinther): Extract this as a provided strategy.
     if (Elements.isLocal(variableElement)) {
-      bodyBuilder.buildLocalSet(variableElement, currentValue);
-    } else if (Elements.isStaticOrTopLevel(variableElement) ||
-               Elements.isErroneous(variableElement)) {
-      bodyBuilder.buildStaticSet(variableElement, currentValue);
+      bodyBuilder.buildLocalVariableSet(variableElement, currentValue);
+    } else if (Elements.isErroneous(variableElement)) {
+      bodyBuilder.buildErroneousInvocation(variableElement,
+          new Selector.setter(variableElement.name, variableElement.library),
+          <ir.Primitive>[currentValue]);
+    } else if (Elements.isStaticOrTopLevel(variableElement)) {
+      if (variableElement.isField) {
+        bodyBuilder.buildStaticFieldSet(variableElement, currentValue);
+      } else {
+        bodyBuilder.buildStaticSetterSet(variableElement, currentValue);
+      }
     } else {
       ir.Primitive receiver = bodyBuilder.buildThis();
       assert(receiver != null);
       bodyBuilder.buildDynamicSet(receiver, variableSelector, currentValue);
     }
 
     // Translate the body in the hole in the delimited term above, and add
     // a jump to the loop if control flow is live after the body.
     JumpCollector breakCollector =
         new ForwardJumpCollector(environment, target: target);
@@ skipping 251 matching lines @@
     // entry to any try block.  They are not filtered out before this because
     // we can not identify all of them in the same pass where we identify the
     // variables assigned in the try (they may be captured by a closure after
     // the try statement).
     Iterable<LocalVariableElement> boxedOnEntry =
         tryStatementInfo.boxedOnEntry.where((LocalVariableElement variable) {
       return !tryCatchBuilder.mutableCapturedVariables.contains(variable);
     });
     for (LocalVariableElement variable in boxedOnEntry) {
       assert(!tryCatchBuilder.isInMutableVariable(variable));
-      ir.Primitive value = tryCatchBuilder.buildLocalGet(variable);
+      ir.Primitive value = tryCatchBuilder.buildLocalVariableGet(variable);
       tryCatchBuilder.makeMutableVariable(variable);
       tryCatchBuilder.declareLocalVariable(variable, initialValue: value);
     }
 
     IrBuilder tryBuilder = tryCatchBuilder.makeDelimitedBuilder();
 
     void interceptJumps(JumpCollector collector) {
       collector.enterTry(boxedOnEntry);
     }
     void restoreJumps(JumpCollector collector) {
       collector.leaveTry();
     }
     tryBuilder.state.breakCollectors.forEach(interceptJumps);
     tryBuilder.state.continueCollectors.forEach(interceptJumps);
     buildTryBlock(tryBuilder);
     if (tryBuilder.isOpen) {
       interceptJumps(join);
       tryBuilder.jumpTo(join);
       restoreJumps(join);
     }
     tryBuilder.state.breakCollectors.forEach(restoreJumps);
     tryBuilder.state.continueCollectors.forEach(restoreJumps);
 
     IrBuilder catchBuilder = tryCatchBuilder.makeDelimitedBuilder();
     for (LocalVariableElement variable in boxedOnEntry) {
       assert(catchBuilder.isInMutableVariable(variable));
-      ir.Primitive value = catchBuilder.buildLocalGet(variable);
+      ir.Primitive value = catchBuilder.buildLocalVariableGet(variable);
       // Note that we remove the variable from the set of mutable variables
       // here (and not above for the try body).  This is because the set of
       // mutable variables is global for the whole function and not local to
       // a delimited builder.
       catchBuilder.removeMutableVariable(variable);
       catchBuilder.environment.update(variable, value);
     }
 
     // TODO(kmillikin): Handle multiple catch clauses.
     assert(catchClauseInfos.length == 1);
@@ skipping 437 matching lines @@
       prim.useElementAsHint(functionElement);
     }
   }
 
   /// Create a function expression from [definition].
   ir.Primitive buildFunctionExpression(ir.FunctionDefinition definition) {
     return addPrimitive(new ir.CreateFunction(definition));
   }
 
   /// Create a read access of [local].
-  ir.Primitive buildLocalGet(LocalElement local) {
+  @override
+  ir.Primitive _buildLocalGet(LocalElement local) {
     assert(isOpen);
     if (isInMutableVariable(local)) {
       // Do not use [local] as a hint on [result]. The variable should always
       // be inlined, but the hint prevents it.
       return addPrimitive(new ir.GetMutableVariable(getMutableVariable(local)));
     } else {
       return environment.lookup(local);
     }
   }
 
   /// Create a write access to [local] with the provided [value].
-  ir.Primitive buildLocalSet(LocalElement local, ir.Primitive value) {
+  @override
+  ir.Primitive buildLocalVariableSet(LocalElement local, ir.Primitive value) {
     assert(isOpen);
     if (isInMutableVariable(local)) {
       add(new ir.SetMutableVariable(getMutableVariable(local), value));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
     return value;
   }
 
   ir.Primitive buildThis() {
     return state.enclosingMethodThisParameter;
   }
 
-  ir.Primitive buildSuperInvocation(Element target,
-                                    Selector selector,
-                                    List<ir.Primitive> arguments) {
-    return _buildInvokeSuper(target, selector, arguments);
-  }
-
   @override
   ir.Primitive buildConstructorInvocation(FunctionElement element,
                                           Selector selector,
                                           DartType type,
                                           List<ir.Primitive> arguments) {
     assert(isOpen);
     return _continueWithExpression(
         (k) => new ir.InvokeConstructor(type, element, selector, k,
             arguments));
   }
@@ skipping 151 matching lines @@
       // so treat that specially.
       ir.Primitive value = field.local is ThisLocal
           ? buildThis()
           : environment.lookup(field.local);
       arguments.add(value);
     }
     return addPrimitive(
         new ir.CreateInstance(classElement, arguments, const <ir.Primitive>[]));
   }
 
-  /// Create a read access of [local].
-  ir.Primitive buildLocalGet(LocalElement local) {
+  /// Create a read access of [local] variable or parameter.
+  @override
+  ir.Primitive _buildLocalGet(LocalElement local) {
     assert(isOpen);
     ClosureLocation location = jsState.boxedVariables[local];
     if (location != null) {
       ir.Primitive result = new ir.GetField(environment.lookup(location.box),
                                             location.field);
       result.useElementAsHint(local);
       return addPrimitive(result);
     } else {
       return environment.lookup(local);
     }
   }
 
-  /// Create a write access to [local] with the provided [value].
-  ir.Primitive buildLocalSet(LocalElement local, ir.Primitive value) {
+  /// Create a write access to [local] variable or parameter with the provided
+  /// [value].
+  @override
+  ir.Primitive buildLocalVariableSet(LocalElement local, ir.Primitive value) {
     assert(isOpen);
     ClosureLocation location = jsState.boxedVariables[local];
     if (location != null) {
       add(new ir.SetField(environment.lookup(location.box),
                           location.field,
                           value));
     } else {
       value.useElementAsHint(local);
       environment.update(local, value);
     }
@@ skipping 33 matching lines @@
       add(new ir.SetField(newBox, location.field, value));
     }
     environment.update(scope.box, newBox);
   }
 
   ir.Primitive buildThis() {
     if (jsState.receiver != null) return jsState.receiver;
     return state.thisParameter;
   }
 
-  ir.Primitive buildSuperInvocation(Element target,
-                                    Selector selector,
-                                    List<ir.Primitive> arguments) {
-    // Direct calls to FieldElements are currently problematic because the
-    // backend will not issue a getter for the field unless it finds a dynamic
-    // access that matches its getter.
-    // As a workaround, we generate GetField for this case, although ideally
-    // this should be the result of inlining the field's getter.
-    if (target is FieldElement) {
-      if (selector.isGetter) {
-        return addPrimitive(new ir.GetField(buildThis(), target));
-      } else {
-        assert(selector.isSetter);
-        add(new ir.SetField(buildThis(), target, arguments.single));
-        return arguments.single;
-      }
-    } else {
-      return _buildInvokeSuper(target, selector, arguments);
-    }
+  @override
+  ir.Primitive buildSuperFieldGet(FieldElement target) {
+    return addPrimitive(new ir.GetField(buildThis(), target));
+  }
+
+  @override
+  ir.Primitive buildSuperFieldSet(FieldElement target, ir.Primitive value) {
+    add(new ir.SetField(buildThis(), target, value));
+    return value;
   }
 
   ir.Primitive buildInvokeDirectly(FunctionElement target,
                                    ir.Primitive receiver,
                                    List<ir.Primitive> arguments) {
     assert(isOpen);
     Selector selector =
         new Selector.call(target.name, target.library, arguments.length);
     return _continueWithExpression(
         (k) => new ir.InvokeMethodDirectly(
@@ skipping 147 matching lines @@
 }
 
 /// Synthetic parameter to a JavaScript factory method that takes the type
 /// argument given for the type variable [variable].
 class TypeInformationParameter implements Local {
   final TypeVariableElement variable;
   final ExecutableElement executableContext;
   TypeInformationParameter(this.variable, this.executableContext);
   String get name => variable.name;
 }