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 119 matching lines @@
 
   SourceFile elementSourceFile(Element element) {
     if (element is FunctionElement) {
       FunctionElement functionElement = element;
       if (functionElement.patch != null) element = functionElement.patch;
     }
     return element.compilationUnit.script.file;
   }
 }
 
+class _GetterElements {
+  ir.Primitive result;
+  ir.Primitive index;
+  ir.Primitive receiver;
+
+  _GetterElements({this.result, this.index, this.receiver}) ;
+}
+
 /**
  * A tree visitor that builds [IrNodes]. The visit methods add statements using
  * to the [builder] and return the last added statement for trees that represent
  * an expression.
  */
 class IrBuilder extends ResolvedVisitor<ir.Primitive> {
   final SourceFile sourceFile;
   final ir.Continuation returnContinuation;
   final List<ir.Parameter> parameters;
 
@@ skipping 670 matching lines @@
     return result;
   }
 
   ir.Primitive visitLiteralSymbol(ast.LiteralSymbol node) {
     assert(isOpen);
     return translateConstant(node);
   }
 
   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 66 matching lines @@
       closureTarget = visit(node.selector);
     } else {
       assert(Elements.isLocal(element));
       closureTarget = lookupLocal(element);
     }
     Selector closureSelector = elements.getSelector(node);
     return translateClosureCall(closureTarget, closureSelector,
         node.argumentsNode);
   }
 
+  /// 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;
   }
 
+  _GetterElements translateGetter(ast.Send node, Selector selector) {
+    Element element = elements[node];
+    ir.Primitive result;
+    ir.Primitive receiver;
+    ir.Primitive index;
+
+    if (Elements.isErroneousElement(element)) {
+      giveup(node, 'Erroneous element on GetterSend');
+      return null;
+    }
+
+    if (element != null && element.isConst) {
+      // Reference to constant local, top-level or static field
+
+      result = translateConstant(node);
+    } else if (Elements.isLocal(element)) {
+      // Reference to local variable
+
+      result = lookupLocal(element);
+    } else if (element == null ||
+               Elements.isInstanceField(element) ||
+               Elements.isInstanceMethod(element) ||
+               selector.isIndex ||
+               node.isSuperCall) {
+    // Dynamic dispatch to a getter. Sometimes resolution will suggest a target
+    // element, but in these cases we must still emit a dynamic dispatch. The
+    // target element may be an instance method in case we are converting a
+    // method to a function object.
+
+      receiver = visitReceiver(node.receiver);
+      List<ir.Primitive> arguments = new List<ir.Primitive>();
+      if (selector.isIndex) {
+        index = visit(node.arguments.head);
+        arguments.add(index);
+      }
+
+      ir.Parameter v = new ir.Parameter(null);
+      ir.Continuation k = new ir.Continuation([v]);
+      assert(selector.kind == SelectorKind.GETTER ||
+             selector.kind == SelectorKind.INDEX);
+      ir.Expression invoke =
+          createDynamicInvoke(node, selector, receiver, k, arguments);
+      add(new ir.LetCont(k, invoke));
+      result = v;
+    } else if (element.isField || element.isGetter ||
+        // Access to a static field or getter (non-static case handled above).
+        // Even if there is only a setter, we compile as if it was a getter,
+        // so the vm can fail at runtime.
+
+        element.isSetter) {
+      ir.Parameter v = new ir.Parameter(null);
+      ir.Continuation k = new ir.Continuation([v]);
+      assert(selector.kind == SelectorKind.GETTER ||
+             selector.kind == SelectorKind.SETTER);
+      ir.Expression invoke =
+          new ir.InvokeStatic(element, selector, k, []);
+      add(new ir.LetCont(k, invoke));
+      result = v;
+    } else if (Elements.isStaticOrTopLevelFunction(element)) {
+      // Convert a top-level or static function to a function object.
+
+      result = translateConstant(node);
+    } else {
+      throw "Unexpected SendSet getter: $node, $element";
+    }
+    return new _GetterElements(
+        result: result,index: index, receiver: receiver);
+  }
+
   ir.Primitive visitGetterSend(ast.Send node) {
     assert(isOpen);
-    Element element = elements[node];
+    return translateGetter(node, elements.getSelector(node)).result;
 
-    // TODO(asgerf): Generate code for erroneous getter access
-    if (Elements.isErroneousElement(element)) {
-      return giveup(node, 'Erroneous element on GetterSend');
-    }
-
-    // Reference to constant local, top-level or static field
-    if (element != null && element.isConst) {
-      return translateConstant(node);
-    }
-
-    // Reference to local variable
-    if (Elements.isLocal(element)) {
-      return lookupLocal(element);
-    }
-
-    // Dynamic dispatch to a getter. Sometimes resolution will suggest a target
-    // element, but in these cases we must still emit a dynamic dispatch.
-    // The target element may be an instance method in case we are converting
-    // a method to a function object.
-    if (element == null ||
-        Elements.isInstanceField(element) ||
-        Elements.isInstanceMethod(element)) {
-      ir.Primitive receiver = node.receiver == null
-          ? lookupThis()
-          : visit(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, []);
-      add(new ir.LetCont(k, invoke));
-      return v;
-    }
-
-    // Access to a static field or getter (non-static case handled above).
-    if (element.isField || element.isGetter) {
-      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;
-    }
-
-    // Convert a top-level or static function to a function object.
-    if (Elements.isStaticOrTopLevelFunction(element)) {
-      return translateConstant(node);
-    }
-
-    throw "Unexpected GetterSend: $node, $element";
   }
 
   ir.Primitive buildNegation(ir.Primitive condition) {
     // ! e is translated as e ? false : true
 
     // Add a continuation parameter for the result of the expression.
     ir.Parameter resultParameter = new ir.Parameter(null);
 
     ir.Continuation joinContinuation = new ir.Continuation([resultParameter]);
     ir.Continuation thenContinuation = new ir.Continuation([]);
@@ skipping 174 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);
     Element element = elements[node];
     assert(element is TypeDeclarationElement || element.isTypeVariable);
 
     // If the user is trying to invoke the type literal or variable,
     // it must be treated as a function call.
     if (node.argumentsNode != null) {
       return visitDynamicSend(node);
     }
 
     if (element is TypeDeclarationElement) {
       return translateConstant(node);
     } else {
       ir.Primitive prim = new ir.ReifyTypeVar(element);
       add(new ir.LetPrim(prim));
       return prim;
     }
   }
 
   ir.Primitive visitSendSet(ast.SendSet node) {
     assert(isOpen);
     Element element = elements[node];
     ast.Operator op = node.assignmentOperator;
-    ir.Primitive result;
-    ir.Primitive getter;
-    if (op.source == '=') {
-      if (Elements.isLocal(element)) {
-        // Exactly one argument expected for a simple assignment.
-        assert(!node.arguments.isEmpty);
-        assert(node.arguments.tail.isEmpty);
-        result = visit(node.arguments.head);
-        result.useElementAsHint(element);
-        assignedVars[variableIndex[element]] = result;
-        return result;
-      } else if (Elements.isStaticOrTopLevel(element)) {
-        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);
-        }
+    // For complex operators, this is the result of getting (before assigning)
+    ir.Primitive originalValue;
+    // For []+= style operators, this saves the index.
+    ir.Primitive index;
+    ir.Primitive receiver;
+    // This is what gets assigned.
+    ir.Primitive valueToStore;
+    Selector selector = elements.getSelector(node);
+    Selector operatorSelector =
+        elements.getOperatorSelectorInComplexSendSet(node);
+    Selector getterSelector =
+        elements.getGetterSelectorInComplexSendSet(node);
+    assert(
+        // Indexing send-sets have an argument for the index.
+        (selector.isIndexSet ? 1 : 0) +
+        // Non-increment send-sets have one more argument.
+        (ast.Operator.INCREMENT_OPERATORS.contains(op.source) ? 0 : 1)
+            == node.argumentCount());
 
-        // Setter or index-setter invocation
-        assert(node.receiver != null);
+    ast.Node assignArg = selector.isIndexSet
+        ? node.arguments.tail.head
+        : node.arguments.head;
 
-        if (node.receiver.isSuper()) return giveup(node, 'Super SendSet');
+    // Get the value into valueToStore
+    if (op.source == "=") {
+      if (selector.isIndexSet) {
+        receiver = visitReceiver(node.receiver);
+        index = visit(node.arguments.head);
+      } else if (element == null || Elements.isInstanceField(element)) {
+        receiver = visitReceiver(node.receiver);
+      }
+      valueToStore = visit(assignArg);
+    } else {
+      // Get the original value into getter
+      assert(ast.Operator.COMPLEX_OPERATORS.contains(op.source));
 
-        ir.Primitive receiver = node.receiver == null
-            ? lookupThis()
-            : visit(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,
-                                                            growable:false);
-        ir.InvokeMethod invoke =
-            new ir.InvokeMethod(receiver, selector, k, args);
-        add(new ir.LetCont(k, invoke));
-        return args.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');
-      }
+      _GetterElements getterResult = translateGetter(node, getterSelector);
+      index = getterResult.index;
+      receiver = getterResult.receiver;
+      originalValue = getterResult.result;
 
-      Selector selector = elements.getOperatorSelectorInComplexSendSet(node);
-      getter = lookupLocal(selectorElement);
-
+      // Do the modification of the value in getter.
       ir.Primitive arg;
       if (ast.Operator.INCREMENT_OPERATORS.contains(op.source)) {
-        assert(node.arguments.isEmpty);
         arg = makePrimConst(constantSystem.createInt(1));
         add(new ir.LetPrim(arg));
       } else {
-        assert(!node.arguments.isEmpty);
-        assert(node.arguments.tail.isEmpty);
-        arg = visit(node.arguments.head);
+        arg = visit(assignArg);
       }
-      arg.useElementAsHint(element);
-      result = new ir.Parameter(null);
-      ir.Continuation k = new ir.Continuation([result]);
-      ir.Expression invoke = new ir.InvokeMethod(getter, selector, k, [arg]);
+      valueToStore = new ir.Parameter(null);
+      ir.Continuation k = new ir.Continuation([valueToStore]);
+      ir.Expression invoke =
+          new ir.InvokeMethod(originalValue, operatorSelector, k, [arg]);
       add(new ir.LetCont(k, invoke));
+    }
 
-      assignedVars[variableIndex[element]] = result;
+    // Set the value
+    if (Elements.isLocal(element)) {
+      valueToStore.useElementAsHint(element);
+      assignedVars[variableIndex[element]] = valueToStore;
+    } else if (Elements.isStaticOrTopLevel(element)) {
+      assert(element.isField || element.isSetter);
+      ir.Parameter v = new ir.Parameter(null);
+      ir.Continuation k = new ir.Continuation([v]);
+      Selector selector = elements.getSelector(node);
+      ir.InvokeStatic invoke =
+          new ir.InvokeStatic(element, selector, k, [valueToStore]);
+      add(new ir.LetCont(k, invoke));
+    } else {
+      if (element != null && Elements.isUnresolved(element)) {
+        return giveup(node, 'SendSet: non-local, non-static, unresolved');
+      }
+      // Setter or index-setter invocation
+      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> arguments = selector.isIndexSet
+          ? [index, valueToStore]
+          : [valueToStore];
+      ir.Expression invoke =
+          createDynamicInvoke(node, selector, receiver, k, arguments);
+      add(new ir.LetCont(k, invoke));
+    }
 
-      if (ast.Operator.INCREMENT_OPERATORS.contains(op.source) &&
-          !node.isPrefix) {
-        assert(getter != null);
-        return getter;
-      } else {
-        return result;
-      }
+    if (node.isPostfix) {
+      assert(originalValue != null);
+      return originalValue;
     } else {
-      compiler.internalError(node, "Unknown assignment operator ${op.source}");
-      return null;
+      return valueToStore;
     }
   }
 
   ir.Primitive visitNewExpression(ast.NewExpression node) {
     assert(isOpen);
     if (node.isConst) {
       return translateConstant(node);
     }
     FunctionElement element = elements[node.send];
     if (Elements.isUnresolved(element)) {
@@ skipping 53 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);
   }
 }
 
 /// Translates constant expressions from the AST to the [ConstExp] language.
@@ skipping 144 matching lines @@
   ConstExp visitConditional(ast.Conditional node) {
     BoolConstant condition = computeConstant(node.condition);
     return visit(condition.isTrue ? node.thenExpression : node.elseExpression);
   }
 
   ConstExp visitNode(ast.Node node) {
     throw "Unexpected constant: $node";
   }
 
 }