Track the origin element of inlined arguments to super constructor.

dart/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;
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
@@ skipping 1125 matching lines @@
     if (!InlineWeeder.canBeInlined(functionExpression, newElements)) {
       return false;
     }
 
     InliningState state = enterInlinedMethod(function, selector, arguments);
     functionExpression.body.accept(this);
     leaveInlinedMethod(state);
     return true;
   }
 
+  inlinedFrom(Element element, f()) {
+    return compiler.withCurrentElement(element, () {
+      sourceElementStack.add(element);
+      var result = f();
+      sourceElementStack.removeLast();
+      return result;
+    });
+  }
+
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructor] and [constructors] must all be implementation
    * elements.
    */
   void inlineSuperOrRedirect(FunctionElement constructor,
                              Selector selector,
                              Link<Node> arguments,
                              List<FunctionElement> constructors,
-                             Map<Element, HInstruction> fieldValues) {
+                             Map<Element, HInstruction> fieldValues,
+                             FunctionElement inlinedFromElement) {
     compiler.withCurrentElement(constructor, () {
       assert(invariant(constructor, constructor.isImplementation));
       constructors.addLast(constructor);
 
       List<HInstruction> compiledArguments = new List<HInstruction>();
-      bool succeeded = addStaticSendArgumentsToList(selector,
-                                                    arguments,
-                                                    constructor,
-                                                    compiledArguments);
+      bool succeeded =
+          inlinedFrom(inlinedFromElement,
+                       () => addStaticSendArgumentsToList(selector,
+                                                          arguments,
+                                                          constructor,
+                                                          compiledArguments));
       if (!succeeded) {
         // Non-matching super and redirects are compile-time errors and thus
         // checked by the resolver.
         compiler.internalError(
             "Parameters and arguments didn't match for super/redirect call",
             element: constructor);
       }
 
       sourceElementStack.add(constructor.enclosingElement);
       buildFieldInitializers(constructor.enclosingElement.implementation,
@@ skipping 64 matching lines @@
         assert(link.head is Send);
         if (link.head is !SendSet) {
           // A super initializer or constructor redirection.
           Send call = link.head;
           assert(Initializers.isSuperConstructorCall(call) ||
                  Initializers.isConstructorRedirect(call));
           FunctionElement target = elements[call];
           Selector selector = elements.getSelector(call);
           Link<Node> arguments = call.arguments;
           inlineSuperOrRedirect(target, selector, arguments, constructors,
-                                fieldValues);
+                                fieldValues, constructor);
           foundSuperOrRedirect = true;
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> arguments = init.arguments;
           assert(!arguments.isEmpty && arguments.tail.isEmpty);
           sourceElementStack.add(constructor);
           visit(arguments.head);
           sourceElementStack.removeLast();
           fieldValues[elements[init]] = pop();
@@ skipping 13 matching lines @@
             new Selector.callDefaultConstructor(enclosingClass.getLibrary());
         // TODO(johnniwinther): Should we find injected constructors as well?
         FunctionElement target = superClass.lookupConstructor(selector);
         if (target == null) {
           compiler.internalError("no default constructor available");
         }
         inlineSuperOrRedirect(target.implementation,
                               selector,
                               const Link<Node>(),
                               constructors,
-                              fieldValues);
+                              fieldValues,
+                              constructor);
       }
     }
   }
 
   /**
    * Run through the fields of [cls] and add their potential
    * initializers.
    *
    * Invariant: [classElement] must be an implementation element.
    */
@@ skipping 3465 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;
   }
 }