Fix source locations for inlined and patched functions.

lib/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 828 matching lines @@
   List<HInstruction> stack;
 
   // The current block to add instructions to. Might be null, if we are
   // visiting dead code.
   HBasicBlock current;
   // The most recently opened block. Has the same value as [current] while
   // the block is open, but unlike [current], it isn't cleared when the current
   // block is closed.
   HBasicBlock lastOpenedBlock;
 
+  List<Element> sourceElementStack;
+
   LibraryElement get currentLibrary => work.element.getLibrary();
   Element get currentElement => work.element;
   Compiler get compiler => builder.compiler;
   CodeEmitterTask get emitter => builder.emitter;
 
   SsaBuilder(this.constantSystem, SsaBuilderTask builder, WorkItem work)
     : this.builder = builder,
       this.backend = builder.backend,
       this.work = work,
       interceptors = builder.interceptors,
       methodInterceptionEnabled = true,
       graph = new HGraph(),
       stack = new List<HInstruction>(),
       activationVariables = new Map<Element, HLocalValue>(),
       jumpTargets = new Map<TargetElement, JumpHandler>(),
       parameters = new Map<Element, HParameterValue>(),
+      sourceElementStack = <Element>[work.element],
       inliningStack = <InliningState>[],
       super(work.resolutionTree) {
     localsHandler = new LocalsHandler(this);
   }
 
   static const MAX_INLINING_DEPTH = 3;
   static const MAX_INLINING_SOURCE_SIZE = 100;
   List<InliningState> inliningStack;
   Element returnElement = null;
 
@@ skipping 78 matching lines @@
     List<HInstruction> compiledArguments = new List<HInstruction>();
     bool succeeded = addStaticSendArgumentsToList(selector,
                                                   arguments,
                                                   function,
                                                   compiledArguments);
     assert(succeeded);
 
     InliningState state =
         new InliningState(function, returnElement, elements, stack);
     inliningStack.add(state);
+    sourceElementStack.add(function);
     stack = <HInstruction>[];
     returnElement = new Element(const SourceString("result"),
                                 ElementKind.VARIABLE,
                                 function);
     localsHandler.updateLocal(returnElement,
                               graph.addConstantNull(constantSystem));
     elements = compiler.enqueuer.resolution.getCachedElements(function);
     FunctionSignature signature = function.computeSignature(compiler);
     int index = 0;
     signature.forEachParameter((Element parameter) {
       HInstruction argument = compiledArguments[index++];
       localsHandler.updateLocal(parameter, argument);
       potentiallyCheckType(argument, parameter);
     });
     return state;
   }
 
   void leaveInlinedMethod(InliningState state) {
     InliningState poppedState = inliningStack.removeLast();
     assert(state == poppedState);
+    FunctionElement poppedElement = sourceElementStack.removeLast();
+    assert(poppedElement == poppedState.function);
     elements = state.oldElements;
     stack.add(localsHandler.readLocal(returnElement));
     returnElement = state.oldReturnElement;
     assert(stack.length == 1);
     state.oldStack.add(stack[0]);
     stack = state.oldStack;
   }
 
   bool tryInlineMethod(Element element,
                        Selector selector,
@@ skipping 107 matching lines @@
           Selector selector = elements.getSelector(call);
           Link<Node> arguments = call.arguments;
           inlineSuperOrRedirect(target, selector, arguments, constructors,
                                 fieldValues);
           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();
         }
       }
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
       ClassElement enclosingClass = constructor.getEnclosingClass();
       ClassElement superClass = enclosingClass.superclass;
@@ skipping 313 matching lines @@
     stack.add(stack.last());
   }
 
   HBoolify popBoolified() {
     HBoolify boolified = new HBoolify(pop());
     add(boolified);
     return boolified;
   }
 
   HInstruction attachPosition(HInstruction target, Node node) {
-    target.sourcePosition = node.getBeginToken();
+    target.sourcePosition = sourceFileLocationForToken(node.getBeginToken());
     return target;
   }
 
+  SourceFileLocation sourceFileLocationForToken(Token token) {
+    Element element = sourceElementStack.last();
+    // TODO(johnniwinther): remove the 'element.patch' hack.
+    if (element is FunctionElement) {
+      FunctionElement functionElement = element;
+      if (functionElement.patch != null) element = functionElement.patch;
+    }
+    SourceFile sourceFile = element.getCompilationUnit().script.file;
+    return new SourceFileLocation(sourceFile, token);
+  }
+
   void visit(Node node) {
     if (node !== null) node.accept(this);
   }
 
   visitBlock(Block node) {
     for (Link<Node> link = node.statements.nodes;
          !link.isEmpty();
          link = link.tail) {
       visit(link.head);
       if (isAborted()) {
@@ skipping 178 matching lines @@
     endLoop(conditionBlock, conditionExitBlock, jumpHandler, savedLocals);
     HLoopBlockInformation info =
         new HLoopBlockInformation(
             HLoopBlockInformation.loopType(loop),
             wrapExpressionGraph(initializerGraph),
             wrapExpressionGraph(conditionExpression),
             wrapStatementGraph(bodyGraph),
             wrapExpressionGraph(updateGraph),
             conditionBlock.loopInformation.target,
             conditionBlock.loopInformation.labels,
-            loop);
+            sourceFileLocationForToken(loop.getBeginToken()),
+            sourceFileLocationForToken(loop.getEndToken()));
 
     startBlock.setBlockFlow(info, current);
     loopInfo.loopBlockInformation = info;
   }
 
   visitFor(For node) {
     assert(node.body !== null);
     void buildInitializer() {
       if (node.initializer === null) return;
       Node initializer = node.initializer;
@@ skipping 107 matching lines @@
 
     HLoopBlockInformation loopBlockInfo =
         new HLoopBlockInformation(
             HLoopBlockInformation.DO_WHILE_LOOP,
             null,
             wrapExpressionGraph(conditionExpression),
             wrapStatementGraph(bodyGraph),
             null,
             loopEntryBlock.loopInformation.target,
             loopEntryBlock.loopInformation.labels,
-            node);
+            sourceFileLocationForToken(node.getBeginToken()),
+            sourceFileLocationForToken(node.getEndToken()));
     loopEntryBlock.setBlockFlow(loopBlockInfo, current);
     loopInfo.loopBlockInformation = loopBlockInfo;
   }
 
   visitFunctionExpression(FunctionExpression node) {
     ClosureClassMap nestedClosureData =
         compiler.closureToClassMapper.getMappingForNestedFunction(node);
     assert(nestedClosureData !== null);
     assert(nestedClosureData.closureClassElement !== null);
     ClassElement closureClassElement =
@@ skipping 925 matching lines @@
     Element helper = interceptors.getThrowRuntimeError();
     pushInvokeHelper1(helper, errorMessage);
   }
 
   void generateThrowNoSuchMethod(Node diagnosticNode,
                                  String methodName,
                                  [Link<Node> argumentNodes,
                                   List<HInstruction> argumentValues]) {
     Element helper =
         compiler.findHelper(const SourceString('throwNoSuchMethod'));
-    Constant receiverConstant = 
+    Constant receiverConstant =
         constantSystem.createString(new DartString.empty(), diagnosticNode);
     HInstruction receiver = graph.addConstant(receiverConstant);
     DartString dartString = new DartString.literal(methodName);
     Constant nameConstant =
         constantSystem.createString(dartString, diagnosticNode);
     HInstruction name = graph.addConstant(nameConstant);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
         visit(argumentNode);
@@ skipping 1341 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;
   }
 }