Implement super operators.

pkg/front_end/lib/src/fasta/kernel/body_builder.dart

 // Copyright (c) 2016, 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 fasta.body_builder;
 
 import 'package:front_end/src/fasta/parser/parser.dart' show
     FormalParameterType,
     optional;
 
@@ skipping 85 matching lines @@
 final Name leftShiftName = new Name("<<");
 
 final Name rightShiftName = new Name(">>");
 
 final Name caretName = new Name("^");
 
 final Name barName = new Name("|");
 
 final Name mustacheName = new Name("~/");
 
+final Name indexGetName = new Name("[]");
+
+final Name indexSetName = new Name("[]=");
+
 class BodyBuilder extends ScopeListener<JumpTarget> implements BuilderHelper {
   final KernelLibraryBuilder library;
 
   final MemberBuilder member;
 
   final KernelClassBuilder classBuilder;
 
   final ClassHierarchy hierarchy;
 
   @override
@@ skipping 1321 matching lines @@
   void handleNoExpression(Token token) {
     debugEvent("NoExpression");
     push(NullValue.Expression);
   }
 
   @override
   void handleIndexedExpression(
       Token openCurlyBracket, Token closeCurlyBracket) {
     debugEvent("IndexedExpression");
     Expression index = popForValue();
-    Expression receiver = popForValue();
-    push(IndexAccessor.make(this, openCurlyBracket.charOffset, receiver, index,
-            null, null));
+    var receiver = pop();

[karlklose, 2017/02/20 13:10:41]

Keep the type annotation?

[ahe, 2017/02/20 13:18:42]

The annotation doesn't work anymore because Accessors aren't Expressions.

The idea is that there are Expression or Accessor on the stack, and you normally
use popForValue() to automatically convert an Accessor to an expression.
However, ThisAccessor with isSuper true can't be converted to an expression.

+    if (receiver is ThisAccessor && receiver.isSuper) {
+      push(new SuperIndexAccessor(
+              this, receiver.charOffset, index,
+              lookupSuperMember(indexGetName),
+              lookupSuperMember(indexSetName)));
+    } else {
+      push(IndexAccessor.make(this, openCurlyBracket.charOffset,
+              toValue(receiver), index, null, null));
+    }
   }
 
   @override
   void handleUnaryPrefixExpression(Token token) {
     debugEvent("UnaryPrefixExpression");
-    Expression expression = popForValue();
+    var receiver = pop();
     if (optional("!", token)) {
-      push(new Not(expression));
+      push(new Not(toValue(receiver)));
     } else {
       String operator = token.stringValue;
       if (optional("-", token)) {
         operator = "unary-";
       }
-      push(buildMethodInvocation(expression, new Name(operator),
-              new Arguments.empty(), token.charOffset));
+      if (receiver is ThisAccessor && receiver.isSuper) {
+        push(toSuperMethodInvocation(buildMethodInvocation(
+            new ThisExpression()..fileOffset = receiver.charOffset,
+            new Name(operator), new Arguments.empty(), token.charOffset)));
+      } else {
+        push(buildMethodInvocation(toValue(receiver), new Name(operator),
+                new Arguments.empty(), token.charOffset));
+      }
     }
   }
 
   Name incrementOperator(Token token) {
     if (optional("++", token)) return plusName;
     if (optional("--", token)) return minusName;
     return internalError("Unknown increment operator: ${token.value}");
   }
 
   @override
@@ skipping 1204 matching lines @@
   } else if (node is TypeDeclarationBuilder) {
     return node.name;
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisPropertyAccessor) {
     return node.name.name;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }