Add support for superSend to the new IR and dart backend.

sdk/lib/_internal/compiler/implementation/ir/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 'ir_nodes.dart' as ir;
 import '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
@@ skipping 794 matching lines @@
 
   ir.Primitive visitLiteralSymbol(ast.LiteralSymbol node) {
     assert(isOpen);
     ir.Constant constant = new ir.Constant(getConstantForNode(node));
     add(new ir.LetPrim(constant));
     return constant;
   }
 
   ir.Primitive visitIdentifier(ast.Identifier node) {
     assert(isOpen);
-    assert(node.isThis());
-    return lookupThis();
+    if (node.isThis()) {
+      return lookupThis();
+    } else if (node.isSuper()) {
+      return lookupSuper();
+    } else {
+      // super and this are the only identifiers that should be met by the
+      // visitor.
+      assert(false);
+      return null;
+    }
   }
 
   ir.Primitive visitParenthesizedExpression(
       ast.ParenthesizedExpression node) {
     assert(isOpen);
     return visit(node.expression);
   }
 
   // Stores the result of visiting a CascadeReceiver, so we can return it from
   // its enclosing Cascade.
@@ skipping 14 matching lines @@
     _currentCascadeReceiver = oldCascadeReceiver;
     return receiver;
   }
 
   ir.Primitive lookupThis() {
     ir.Primitive result = new ir.This();
     add(new ir.LetPrim(result));
     return result;
   }
 
+  ir.Primitive lookupSuper() {
+    ir.Primitive result = new ir.Super();
+    add(new ir.LetPrim(result));
+    return result;
+  }
+
   ir.Primitive lookupLocal(Element element) {
     int index = variableIndex[element];
     ir.Primitive value = assignedVars[index];
     return value == null ? freeVars[index] : value;
   }
 
   // ==== Sends ====
   ir.Primitive visitAssert(ast.Send node) {
     assert(isOpen);
     return giveup(node, 'Assert');
@@ skipping 28 matching lines @@
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression invoke =
         new ir.InvokeMethod(closureTarget, namedCallSelector, k, arguments);
     add(new ir.LetCont(k, invoke));
     return v;
   }
 
   ir.Primitive visitDynamicSend(ast.Send node) {
     assert(isOpen);
-    if (node.receiver == null || node.receiver.isSuper()) {
-      return giveup(node, 'DynamicSend without receiver, or super receiver');
+    if (node.receiver == null) {
+      return giveup(node, 'DynamicSend without receiver');
     }
     Selector selector = elements.getSelector(node);
     ir.Primitive receiver = visit(node.receiver);
     List<ir.Primitive> arguments = new List<ir.Primitive>();
     for (ast.Node n in node.arguments) {
       arguments.add(visit(n));
     }
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression invoke =
@@ skipping 204 matching lines @@
     ir.Parameter v = new ir.Parameter(null);
     ir.Continuation k = new ir.Continuation([v]);
     ir.Expression invoke =
         new ir.InvokeStatic(element, selector, k, arguments);
     add(new ir.LetCont(k, invoke));
     return v;
   }
 
   ir.Primitive visitSuperSend(ast.Send node) {
     assert(isOpen);
-    return giveup(node, 'SuperSend');
+    if (node.isPropertyAccess) {
+      return visitGetterSend(node);
+    } else {
+      return visitDynamicSend(node);
+    }
   }
 
   ir.Primitive visitTypeReferenceSend(ast.Send node) {
     assert(isOpen);
     if (node.argumentsNode != null) {
       // May happen in strange, invalid code.
       // TODO(asgerf): Generate code that throws a runtime error.
       return giveup(node, 'TypeReferenceSend: has argument');
     }
     Element element = elements[node];
@@ skipping 38 matching lines @@
             new ir.InvokeStatic(element, selector, k, [arg]);
         add(new ir.LetCont(k, invoke));
         return arg;
       } else if (node.receiver == null) {
         // Nodes that fall in this case:
         // - Unresolved top-level
         // - Assignment to final variable (will not be resolved)
         return giveup(node, 'SendSet: non-local, non-static, but no receiver');
       } else {
         if (element != null && Elements.isUnresolved(element)) {
-          return giveup(node);
+          return giveup(node, 'SendSet: non-local, non-static, unresolved');
         }
 
         // Setter or index-setter invocation
         assert(node.receiver != null);
 
         if (node.receiver.isSuper()) return giveup(node, 'Super SendSet');
 
         ir.Primitive receiver = node.receiver == null
             ? lookupThis()
             : visit(node.receiver);
@@ skipping 106 matching lines @@
 
   static final String ABORT_IRNODE_BUILDER = "IrNode builder aborted";
 
   ir.Primitive giveup(ast.Node node, [String reason]) {
     throw ABORT_IRNODE_BUILDER;
   }
 
   ir.FunctionDefinition nullIfGiveup(ir.FunctionDefinition action()) {
     try {
       return action();
-    } catch(e) {
-      if (e == ABORT_IRNODE_BUILDER) return null;
+    } catch(e, tr) {
+      if (e == ABORT_IRNODE_BUILDER) {
+        return null;
+      }
       rethrow;
     }
   }
 
   void internalError(String reason, {ast.Node node}) {
     giveup(node);
   }
 }