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

sdk/lib/_internal/compiler/implementation/dart_backend/dart_tree.dart

 // Copyright (c) 2014, 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 dart_tree;
 
 import '../dart2jslib.dart' as dart2js;
 import '../elements/elements.dart'
     show Element, FunctionElement, FunctionSignature, ParameterElement,
          ClassElement;
@@ skipping 117 matching lines @@
   final Selector selector;
   final List<Expression> arguments;
 
   InvokeMethod(this.receiver, this.selector, this.arguments) {
     assert(receiver != null);
   }
 
   accept(ExpressionVisitor visitor) => visitor.visitInvokeMethod(this);
 }
 
+class InvokeSuperMethod extends Expression implements Invoke {
+  Expression receiver;

[asgerf, 2014/06/26 07:44:40]

There should be no receiver

+  final Selector selector;
+  final List<Expression> arguments;
+
+  InvokeSuperMethod(this.selector, this.arguments) ;
+
+  accept(Visitor visitor) => visitor.visitInvokeSuperMethod(this);
+}
+
 /**
  * Call to a factory or generative constructor.
  */
 class InvokeConstructor extends Expression implements Invoke {
   final GenericType type;
   final FunctionElement target;
   final List<Expression> arguments;
   final Selector selector;
   final dart2js.Constant constant;
 
@@ skipping 267 matching lines @@
   Statement body;
 
   FunctionDefinition(this.parameters, this.body);
 }
 
 abstract class ExpressionVisitor<E> {
   E visitExpression(Expression e) => e.accept(this);
   E visitVariable(Variable node);
   E visitInvokeStatic(InvokeStatic node);
   E visitInvokeMethod(InvokeMethod node);
+  E visitInvokeSuperMethod(InvokeSuperMethod node);
   E visitInvokeConstructor(InvokeConstructor node);
   E visitConcatenateStrings(ConcatenateStrings node);
   E visitConstant(Constant node);
   E visitThis(This node);
   E visitConditional(Conditional node);
   E visitLogicalOperator(LogicalOperator node);
   E visitNot(Not node);
   E visitLiteralList(LiteralList node);
   E visitLiteralMap(LiteralMap node);
 }
@@ skipping 277 matching lines @@
     if (cont == returnContinuation) {
       return new Return(invoke);
     } else {
       assert(cont.hasExactlyOneUse);
       assert(cont.parameters.length == 1);
       return buildContinuationAssignment(cont.parameters.single, invoke,
           () => visit(cont.body));
     }
   }
 
+  Statement visitInvokeSuperMethod(ir.InvokeSuperMethod node) {
+    List<Expression> arguments = translateArguments(node.arguments);
+    Expression invoke = new InvokeSuperMethod(node.selector, arguments);
+    ir.Continuation cont = node.continuation.definition;
+    if (cont == returnContinuation) {
+      return new Return(invoke);
+    } else {
+      assert(cont.hasExactlyOneUse);
+      assert(cont.parameters.length == 1);
+      return buildContinuationAssignment(cont.parameters.single, invoke,
+          () => visit(cont.body));
+    }
+  }
+
   Statement visitConcatenateStrings(ir.ConcatenateStrings node) {
     List<Expression> arguments = translateArguments(node.arguments);
     Expression concat = new ConcatenateStrings(arguments);
     ir.Continuation cont = node.continuation.definition;
     if (cont == returnContinuation) {
       return new Return(concat);
     } else {
       assert(cont.hasExactlyOneUse);
       assert(cont.parameters.length == 1);
       return buildContinuationAssignment(cont.parameters.single, concat,
@@ skipping 210 matching lines @@
   // The binding environment.  The rightmost element of the list is the nearest
   // available enclosing binding.
   List<Assign> environment;
 
   /// Substitution map for labels. Any break to a label L should be substituted
   /// for a break to L' if L maps to L'.
   Map<Label, Jump> labelRedirects = <Label, Jump>{};
 
   /// Returns the redirect target of [label] or [label] itself if it should not
   /// be redirected.
-  Jump redirect(Break jump) {
+  Jump redirect(Jump jump) {
     Jump newJump = labelRedirects[jump.target];
     return newJump != null ? newJump : jump;
   }
 
   void rewrite(FunctionDefinition definition) {
     environment = <Assign>[];
     definition.body = visitStatement(definition.body);
 
     // TODO(kmillikin):  Allow definitions that are not propagated.  Here,
     // this means rebuilding the binding with a recursively unnamed definition,
@@ skipping 43 matching lines @@
   }
 
   Expression visitInvokeMethod(InvokeMethod node) {
     for (int i = node.arguments.length - 1; i >= 0; --i) {
       node.arguments[i] = visitExpression(node.arguments[i]);
     }
     node.receiver = visitExpression(node.receiver);
     return node;
   }
 
+  Expression visitInvokeSuperMethod(InvokeSuperMethod node) {
+    for (int i = node.arguments.length - 1; i >= 0; --i) {
+      node.arguments[i] = visitExpression(node.arguments[i]);
+    }
+    return node;
+  }
+
   Expression visitInvokeConstructor(InvokeConstructor node) {
     for (int i = node.arguments.length - 1; i >= 0; --i) {
       node.arguments[i] = visitExpression(node.arguments[i]);
     }
     return node;
   }
 
   Expression visitConcatenateStrings(ConcatenateStrings node) {
     for (int i = node.arguments.length - 1; i >= 0; --i) {
       node.arguments[i] = visitExpression(node.arguments[i]);
@@ skipping 33 matching lines @@
   Statement visitReturn(Return node) {
     node.value = visitExpression(node.value);
     return node;
   }
 
 
   Statement visitBreak(Break node) {
     // Redirect through chain of breaks.
     // Note that useCount was accounted for at visitLabeledStatement.
     // Note redirect may return either a Break or Continue statement.
-    node = redirect(node);
-    if (node is Break && node.target.useCount == 1) {
-      --node.target.useCount;
-      return visitStatement(node.target.binding.next);
+    Jump jump = redirect(node);
+    if (jump is Break && jump.target.useCount == 1) {
+      --jump.target.useCount;
+      return visitStatement(jump.target.binding.next);
     }
-    return node;
+    return jump;
   }
 
   Statement visitContinue(Continue node) {
     return node;
   }
 
   Statement visitLabeledStatement(LabeledStatement node) {
     if (node.next is Jump) {
       // Eliminate label if next is a break or continue statement
       // Breaks to this label are redirected to the outer label.
@@ skipping 563 matching lines @@
     _rewriteList(node.arguments);
     return node;
   }
 
   Expression visitInvokeMethod(InvokeMethod node) {
     node.receiver = visitExpression(node.receiver);
     _rewriteList(node.arguments);
     return node;
   }
 
+  Expression visitInvokeSuperMethod(InvokeSuperMethod node) {
+    _rewriteList(node.arguments);
+    return node;
+  }
+
   Expression visitInvokeConstructor(InvokeConstructor node) {
     _rewriteList(node.arguments);
     return node;
   }
 
   Expression visitConcatenateStrings(ConcatenateStrings node) {
     _rewriteList(node.arguments);
     return node;
   }
 
@@ skipping 226 matching lines @@
     }
   }
 
   /// Destructively updates each entry of [l] with the result of visiting it.
   void _rewriteList(List<Expression> l) {
     for (int i = 0; i < l.length; i++) {
       l[i] = visitExpression(l[i]);
     }
   }
 }