Implement complex super assignment.

sdk/lib/_internal/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 3028 matching lines @@
       stack.add(addConstantString(node, backend.namer.operatorIsPrefix()));
     } else if (name == const SourceString('JS_OPERATOR_AS_PREFIX')) {
       stack.add(addConstantString(node, backend.namer.operatorAsPrefix()));
     } else if (name == const SourceString('JS_DART_OBJECT_CONSTRUCTOR')) {
       handleForeignDartObjectJsConstructorFunction(node);
     } else {
       throw "Unknown foreign: ${selector}";
     }
   }
 
-  generateSuperNoSuchMethodSend(Send node) {
-    Selector selector = elements.getSelector(node);
+  generateSuperNoSuchMethodSend(Send node,
+                                Selector selector,
+                                List<HInstruction> arguments) {
     SourceString name = selector.name;
 
     ClassElement cls = currentElement.getEnclosingClass();
     Element element = cls.lookupSuperMember(Compiler.NO_SUCH_METHOD);
     if (element.enclosingElement.declaration != compiler.objectClass) {
       // Register the call as dynamic if [:noSuchMethod:] on the super class
-      // is _not_ the default implementation from [:Object:].
-      compiler.enqueuer.codegen.registerDynamicInvocation(name, selector);
-    }
+      // is _not_ the default implementation from [:Object:], in case
+      // the [:noSuchMethod:] implementation does an [:invokeOn:] on
+      // the invocation mirror.
+      if (selector.isGetter()) {

[kasperl, 2013/03/05 07:32:36]

Could this logic be moved to the enqueuer? If we had something like
registerSelectorUse(selector) wouldn't that be enough? Maybe that would be
useful in other places too.

[ngeoffray, 2013/03/05 08:46:25]

Done.

+        compiler.enqueuer.codegen.registerDynamicGetter(name, selector);
+      } else if (selector.isSetter()) {
+        compiler.enqueuer.codegen.registerDynamicSetter(name, selector);
+      } else {
+        compiler.enqueuer.codegen.registerDynamicInvocation(name, selector);
+      }
+    }   
     HStatic target = new HStatic(element);
     add(target);
     HInstruction self = localsHandler.readThis();
     Constant nameConstant = constantSystem.createString(
         new DartString.literal(name.slowToString()), node);
 
     String internalName = backend.namer.invocationName(selector);
     Constant internalNameConstant =
         constantSystem.createString(new DartString.literal(internalName), node);
 
     Element createInvocationMirror = backend.getCreateInvocationMirror();
-
-    var arguments = new List<HInstruction>();
-    if (node.argumentsNode != null) {
-      addGenericSendArgumentsToList(node.arguments, arguments);
-    }
     var argumentsInstruction = new HLiteralList(arguments);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (SourceString argumentName in selector.namedArguments) {
       Constant argumentNameConstant =
           constantSystem.createString(new DartString.literal(
               argumentName.slowToString()), node);
       argumentNames.add(graph.addConstant(argumentNameConstant));
     }
@@ skipping 24 matching lines @@
     if (element != null && identical(element, currentElement)) {
       graph.isRecursiveMethod = true;
     }
     super.visitSend(node);
   }
 
   visitSuperSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (Elements.isUnresolved(element)) {
-      return generateSuperNoSuchMethodSend(node);
+      List<HInstruction> arguments = <HInstruction>[];
+      if (!node.isPropertyAccess) {
+        addGenericSendArgumentsToList(node.arguments, arguments);
+      }
+      return generateSuperNoSuchMethodSend(node, selector, arguments);
     }
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
     HInstruction target = new HStatic(element.declaration);
     HInstruction context = localsHandler.readThis();
     add(target);
     var inputs = <HInstruction>[target, context];
     if (backend.isInterceptedMethod(element)) {
       inputs.add(context);
     }
@@ skipping 450 matching lines @@
 
   visitSendSet(SendSet node) {
     Element element = elements[node];
     if (!Elements.isUnresolved(element) && element.impliesType()) {
       Identifier selector = node.selector;
       generateThrowNoSuchMethod(node, selector.source.slowToString(),
                                 argumentNodes: node.arguments);
       return;
     }
     Operator op = node.assignmentOperator;
     if (node.isSuperCall) {

[kasperl, 2013/03/05 07:32:36]

Think about if some of this could be shared with the non-super variant of the
same thing.

+      HInstruction toPush;

[kasperl, 2013/03/05 07:32:36]

I'd call this the value/result or something like that. That we happen to want to
push that at the end seems like a detail.

[ngeoffray, 2013/03/05 08:46:25]

Done.

+      List<HInstruction> setterInputs = <HInstruction>[];
+      HInstruction context = localsHandler.readThis();
+      if (!Elements.isUnresolved(element)) {
+        HInstruction target = new HStatic(element);

[kasperl, 2013/03/05 07:32:36]

Is any of this refactorable? The resolved target/getterTarget handling seems to
share some structure.

[ngeoffray, 2013/03/05 08:46:25]

Done.

+        add(target);
+        setterInputs.add(target);
+        setterInputs.add(context);
+        if (backend.isInterceptedMethod(element)) {
+          setterInputs.add(context);
+        }
+      }
+      if (identical(node.assignmentOperator.source.stringValue, '=')) {
+        addDynamicSendArgumentsToList(node, setterInputs);
+        toPush = setterInputs.last;
+      } else {
+        Element getter = elements[node.selector];
+        List<HInstruction> getterInputs = <HInstruction>[];
+        if (!Elements.isUnresolved(getter)) {
+          HInstruction getterTarget = new HStatic(getter);
+          add(getterTarget);
+          getterInputs.add(getterTarget);
+          getterInputs.add(context);
+          if (backend.isInterceptedMethod(getter)) {
+            getterInputs.add(context);
+          }
+        }
+        Link<Node> arguments = node.arguments;

[kasperl, 2013/03/05 07:32:36]

Add a comment that explains what you're dealing with here.

[ngeoffray, 2013/03/05 08:46:25]

Done.

+        if (node.isIndex) {
+          visit(arguments.head);
+          arguments = arguments.tail;
+          HInstruction index = pop();
+          getterInputs.add(index);
+          setterInputs.add(index);
+        }
+        HInstruction getterInstruction;

[kasperl, 2013/03/05 07:32:36]

Could this (the computation of the getterInstruction) be put in a separate
method?

[ngeoffray, 2013/03/05 08:46:25]

Done.

+        if (Elements.isUnresolved(getter)) {
+          generateSuperNoSuchMethodSend(
+              node,
+              elements.getGetterSelectorInComplexSendSet(node),
+              getterInputs);
+          getterInstruction = pop();
+        } else {
+          getterInstruction = new HInvokeSuper(getterInputs);
+          add(getterInstruction);
+        }
+        HInstruction rhs;

[kasperl, 2013/03/05 07:32:36]

Do we have code like this elsewhere in the builder?

[ngeoffray, 2013/03/05 08:46:25]

Yes, refactored.

+        if (node.isPrefix || node.isPostfix) {
+          rhs = graph.addConstantInt(1, constantSystem);
+        } else {
+          visit(arguments.head);
+          assert(arguments.tail.isEmpty);
+          rhs = pop();
+        }
+        visitBinary(getterInstruction, op, rhs,
+                    elements.getOperatorSelectorInComplexSendSet(node), node);
+        setterInputs.add(pop());
+
+        if (node.isPostfix) {
+          toPush = getterInstruction;
+        } else {
+          toPush = setterInputs.last;
+        }
+      }
       if (Elements.isUnresolved(element)) {
-        return generateSuperNoSuchMethodSend(node);
+        generateSuperNoSuchMethodSend(
+            node, elements.getSelector(node), setterInputs);
+        pop();
+      } else {
+        add(new HInvokeSuper(setterInputs, isSetter: true));
       }
-      HInstruction target = new HStatic(element);
-      HInstruction context = localsHandler.readThis();
-      add(target);
-      var inputs = <HInstruction>[target, context];
-      addDynamicSendArgumentsToList(node, inputs);
-      if (!identical(node.assignmentOperator.source.stringValue, '=')) {
-        compiler.unimplemented('complex super assignment',
-                               node: node.assignmentOperator);
-      }
-      push(new HInvokeSuper(inputs, isSetter: true));
+      stack.add(toPush);
     } else if (node.isIndex) {
       if (const SourceString("=") == op.source) {
         // TODO(kasperl): We temporarily disable inlining because the
         // code here cannot deal with it yet.
         visitDynamicSend(node, inline: false);
         HInvokeDynamicMethod method = pop();
         // Push the value.
         stack.add(method.inputs.last);
       } else {
         visit(node.receiver);
@@ skipping 1420 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }