Fix source information positions for deserialized patched elements.

pkg/compiler/lib/src/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.
 
 import 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 1116 matching lines @@
       : this.compiler = backend.compiler,
         this.infoReporter = backend.compiler.dumpInfoTask,
         this.backend = backend,
         this.constantSystem = backend.constantSystem,
         this.rti = backend.rti {
     assert(target.isImplementation);
     graph.element = target;
     localsHandler = new LocalsHandler(this, target, null);
     sourceElementStack.add(target);
     sourceInformationBuilder =
-        sourceInformationFactory.createBuilderForContext(target);
+        sourceInformationFactory.createBuilderForContext(resolvedAst);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
   }
 
   BackendHelpers get helpers => backend.helpers;
 
   RuntimeTypesEncoder get rtiEncoder => backend.rtiEncoder;
 
   DiagnosticReporter get reporter => compiler.reporter;
 
@@ skipping 380 matching lines @@
           (mask == null || mask.isNullable)) {
         addWithPosition(
             new HFieldGet(null, providedArguments[0], backend.dynamicType,
                 isAssignable: false),
             currentNode);
       }
       List<HInstruction> compiledArguments = completeSendArgumentsList(
           function, selector, providedArguments, currentNode);
       enterInlinedMethod(function, functionResolvedAst, compiledArguments,
           instanceType: instanceType);
-      inlinedFrom(function, () {
+      inlinedFrom(functionResolvedAst, () {
         if (!isReachable) {
           emitReturn(graph.addConstantNull(compiler), null);
         } else {
           doInline(functionResolvedAst);
         }
       });
       leaveInlinedMethod();
     }
 
     if (meetsHardConstraints() && heuristicSayGoodToGo()) {
@@ skipping 16 matching lines @@
       return false;
     }
     TypesInferrer inferrer = compiler.typesTask.typesInferrer;
     return inferrer.isCalledOnce(element);
   }
 
   bool isCalledOnce(Element element) {
     return allInlinedFunctionsCalledOnce && isFunctionCalledOnce(element);
   }
 
-  inlinedFrom(Element element, f()) {
+  inlinedFrom(ResolvedAst resolvedAst, f()) {
+    Element element = resolvedAst.element;
     assert(element is FunctionElement || element is VariableElement);
-    return reporter.withCurrentElement(element, () {
+    return reporter.withCurrentElement(element.implementation, () {
       // The [sourceElementStack] contains declaration elements.
       SourceInformationBuilder oldSourceInformationBuilder =
           sourceInformationBuilder;
       sourceInformationBuilder =
-          sourceInformationBuilder.forContext(element.implementation);
+          sourceInformationBuilder.forContext(resolvedAst);
       sourceElementStack.add(element.declaration);
       var result = f();
       sourceInformationBuilder = oldSourceInformationBuilder;
       sourceElementStack.removeLast();
       return result;
     });
   }
 
   /**
    * Return null so it is simple to remove the optional parameters completely
@@ skipping 392 matching lines @@
             localsHandler.updateLocal(
                 localsHandler.getTypeVariableAsLocal(variable),
                 graph.addConstantNull(compiler));
           }
         }
       }
 
       // For redirecting constructors, the fields will be initialized later
       // by the effective target.
       if (!callee.isRedirectingGenerative) {
-        inlinedFrom(callee, () {
+        inlinedFrom(constructorRecolvedAst, () {
           buildFieldInitializers(
               callee.enclosingClass.implementation, fieldValues);
         });
       }
 
       int index = 0;
       FunctionSignature params = callee.functionSignature;
       params.orderedForEachParameter((ParameterElement parameter) {
         HInstruction argument = compiledArguments[index++];
         // Because we are inlining the initializer, we must update
@@ skipping 107 matching lines @@
           // A super initializer or constructor redirection.
           foundSuperOrRedirect = true;
           ast.Send call = link.head;
           assert(ast.Initializers.isSuperConstructorCall(call) ||
               ast.Initializers.isConstructorRedirect(call));
           FunctionElement target = elements[call].implementation;
           CallStructure callStructure =
               elements.getSelector(call).callStructure;
           Link<ast.Node> arguments = call.arguments;
           List<HInstruction> compiledArguments;
-          inlinedFrom(constructor, () {
+          inlinedFrom(resolvedAst, () {
             compiledArguments =
                 makeStaticArgumentList(callStructure, arguments, target);
           });
           inlineSuperOrRedirect(
               backend.frontend.getResolvedAst(target.declaration),
               compiledArguments,
               constructorResolvedAsts,
               fieldValues,
               constructor);
         } else {
           // A field initializer.
           ast.SendSet init = link.head;
           Link<ast.Node> arguments = init.arguments;
           assert(!arguments.isEmpty && arguments.tail.isEmpty);
-          inlinedFrom(constructor, () {
+          inlinedFrom(resolvedAst, () {
             visit(arguments.head);
           });
           fieldValues[elements[init]] = pop();
         }
       }
     }
 
     if (!foundSuperOrRedirect) {
       // No super initializer found. Try to find the default constructor if
       // the class is not Object.
@@ skipping 46 matching lines @@
             fieldValues[member] = graph.addConstantNull(compiler);
           }
         } else {
           ast.Node right = initializer;
           ResolvedAst savedResolvedAst = resolvedAst;
           resolvedAst = fieldResolvedAst;
           // In case the field initializer uses closures, run the
           // closure to class mapper.
           compiler.closureToClassMapper
               .computeClosureToClassMapping(resolvedAst);
-          inlinedFrom(member, () => right.accept(this));
+          inlinedFrom(fieldResolvedAst, () => right.accept(this));
           resolvedAst = savedResolvedAst;
           fieldValues[member] = pop();
         }
       });
     });
   }
 
   /**
    * Build the factory function corresponding to the constructor
    * [functionElement]:
@@ skipping 6383 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }