Handle super calls to fields or getters that look like method calls.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.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.
 
 part of dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 740 matching lines @@
       assert(selector.isCall);
       assert(element is FunctionElement);
       List<ir.Primitive> arguments = node.arguments.mapToList(visit);
       arguments = normalizeStaticArguments(selector, element, arguments);
       return irBuilder.buildStaticInvocation(element, selector, arguments);
     }
   }
 
   ir.Primitive visitSuperSend(ast.Send node) {
     assert(irBuilder.isOpen);
-    if (node.isPropertyAccess) {
-      return visitGetterSend(node);
+    Selector selector = elements.getSelector(node);
+    Element target = elements[node];
+
+    if (selector.isCall && (target.isGetter || target.isField)) {
+      // We are invoking a field or getter as if it was a method, e.g:
+      //
+      //     class A { get foo => {..} }
+      //     class B extends A {
+      //         m() {
+      //           super.foo(1, 2, 3);  }
+      //         }
+      //     }
+      //
+      // We invoke the getter of 'foo' and then invoke the 'call' method on
+      // the result, using the given arguments.
+      Selector getter = new Selector.getterFrom(selector);
+      Selector call = new Selector.callClosureFrom(selector);
+      ir.Primitive receiver =
+          irBuilder.buildSuperInvocation(target, getter, []);
+      List<ir.Primitive> arguments = node.arguments.mapToList(visit);
+      arguments = normalizeDynamicArguments(selector, arguments);
+      return irBuilder.buildCallInvocation(receiver, call, arguments);
+    } else if (selector.isCall) {
+      // We are invoking a method.
+      assert(target is FunctionElement);
+      List<ir.Primitive> arguments = node.arguments.mapToList(visit);
+      arguments = normalizeStaticArguments(selector, target, arguments);
+      return irBuilder.buildSuperInvocation(target, selector, arguments);
     } else {
-      Selector selector = elements.getSelector(node);
-      Element target = elements[node];
-      List<ir.Primitive> arguments = node.arguments.mapToList(visit);
-      if (selector.isCall) {
-        arguments = normalizeStaticArguments(selector, target, arguments);
-      }
+      // We are invoking a getter, operator, indexer, etc.
+      List<ir.Primitive> arguments = node.argumentsNode == null
+          ? <ir.Primitive>[]
+          : node.arguments.mapToList(visit);
       return irBuilder.buildSuperInvocation(target, selector, arguments);
     }
   }
 
   visitTypePrefixSend(ast.Send node) {
     compiler.internalError(node, "visitTypePrefixSend should not be called.");
   }
 
   ir.Primitive visitTypeLiteralSend(ast.Send node) {
     assert(irBuilder.isOpen);
@@ skipping 903 matching lines @@
     for (String argName in selector.getOrderedNamedArguments()) {
       int nameIndex = selector.namedArguments.indexOf(argName);
       int translatedIndex = selector.positionalArgumentCount + nameIndex;
       result.add(arguments[translatedIndex]);
     }
     return result;
   }
 
 }