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);
+    // "this" is the only identifier that should be met by the visitor.
     assert(node.isThis());
     return lookupThis();
   }
 
   ir.Primitive visitParenthesizedExpression(
       ast.ParenthesizedExpression node) {
     assert(isOpen);
     return visit(node.expression);
   }
 
@@ skipping 62 matching lines @@
       arguments.add(visit(n));
     }
     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;
   }
 
+  /// If [node] is null, returns this.
+  /// If [node] is super, returns null (for special handling)
+  /// Otherwise visits [node] and returns the result.
+  ir.Primitive visitReceiver(ast.Expression node) {
+    if (node == null) return lookupThis();
+    if (node.isSuper()) return null;
+    return visit(node);
+  }
+
+  /// Makes an [InvokeMethod] unless [node.receiver.isSuper()], in that case
+  /// makes an [InvokeSuperMethod] ignoring [receiver].
+  ir.Expression createDynamicInvoke(ast.Send node,
+                             Selector selector,
+                             ir.Definition receiver,
+                             ir.Continuation k,
+                             List<ir.Definition> arguments) {
+    return node.receiver != null && node.receiver.isSuper()
+        ? new ir.InvokeSuperMethod(selector, k, arguments)
+        : new ir.InvokeMethod(receiver, selector, k, arguments);
+  }
+
   ir.Primitive visitDynamicSend(ast.Send node) {
     assert(isOpen);
-    if (node.receiver == null || node.receiver.isSuper()) {
-      return giveup(node, 'DynamicSend without receiver, or super receiver');
-    }
     Selector selector = elements.getSelector(node);
-    ir.Primitive receiver = visit(node.receiver);
+    ir.Primitive receiver = visitReceiver(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 =
-        new ir.InvokeMethod(receiver, selector, k, arguments);
+        createDynamicInvoke(node, selector, receiver, k, arguments);
     add(new ir.LetCont(k, invoke));
     return v;
   }
 
   ir.Primitive visitGetterSend(ast.Send node) {
     assert(isOpen);
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       return lookupLocal(element);
     } else if (element == null || Elements.isInstanceField(element)) {
-      ir.Primitive receiver = node.receiver == null
-          ? lookupThis()
-          : visit(node.receiver);
+      ir.Primitive receiver = visitReceiver(node.receiver);
       ir.Parameter v = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([v]);
       Selector selector = elements.getSelector(node);
       assert(selector.kind == SelectorKind.GETTER);
-      ir.InvokeMethod invoke = new ir.InvokeMethod(receiver, selector, k, []);
+      ir.Expression invoke =
+          createDynamicInvoke(node, selector, receiver, k, []);
       add(new ir.LetCont(k, invoke));
       return v;
     } else if (element.isField) {
       ir.Parameter v = new ir.Parameter(null);
       ir.Continuation k = new ir.Continuation([v]);
       Selector selector = elements.getSelector(node);
       assert(selector.kind == SelectorKind.GETTER);
       ir.InvokeStatic invoke = new ir.InvokeStatic(element, selector, k, []);
       add(new ir.LetCont(k, invoke));
       return v;
@@ skipping 175 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 31 matching lines @@
         assert(element.isField || element.isSetter);
         assert(!node.arguments.isEmpty && node.arguments.tail.isEmpty);
         ir.Parameter v = new ir.Parameter(null);
         ir.Continuation k = new ir.Continuation([v]);
         Selector selector = elements.getSelector(node);
         ir.Definition arg = visit(node.arguments.head);
         ir.InvokeStatic invoke =
             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);
+        ir.Primitive receiver = visitReceiver(node.receiver);
         ir.Parameter v = new ir.Parameter(null);
         ir.Continuation k = new ir.Continuation([v]);
         Selector selector = elements.getSelector(node);
         assert(selector.kind == SelectorKind.SETTER ||
             selector.kind == SelectorKind.INDEX);
-        List<ir.Definition> args = node.arguments.mapToList(visit,
+        List<ir.Definition> arguments = node.arguments.mapToList(visit,
                                                             growable:false);
-        ir.InvokeMethod invoke =
-            new ir.InvokeMethod(receiver, selector, k, args);
+        ir.Expression invoke =
+            createDynamicInvoke(node, selector, receiver, k, arguments);
         add(new ir.LetCont(k, invoke));
-        return args.last;
+        return arguments.last;
       }
     } else if (ast.Operator.COMPLEX_OPERATORS.contains(op.source)) {
       Element selectorElement = elements[node.selector];
       if (selectorElement != null && !selectorElement.isAssignable) {
         return giveup(node, 'Unresolved or non-assignable compound assignment');
       }
       if (!Elements.isLocal(selectorElement)) {
         return giveup(node, 'Non-local compound assignment');
       }
 
@@ skipping 85 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);
   }
 }