Fix bad diagnostic positions when inlining super constructors.

dart/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 1078 matching lines @@
    * 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) {
-    assert(invariant(constructor, constructor.isImplementation));
-    constructors.addLast(constructor);
+    compiler.withCurrentElement(constructor, () {
+      assert(invariant(constructor, constructor.isImplementation));
+      constructors.addLast(constructor);
 
-    List<HInstruction> compiledArguments = new List<HInstruction>();
-    bool succeeded = 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);
-    }
+      List<HInstruction> compiledArguments = new List<HInstruction>();
+      bool succeeded = 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);
+      }
 
-    buildFieldInitializers(constructor.enclosingElement, fieldValues);
+      buildFieldInitializers(constructor.enclosingElement, fieldValues);
 
-    int index = 0;
-    FunctionSignature params = constructor.computeSignature(compiler);
-    params.forEachParameter((Element parameter) {
-      HInstruction argument = compiledArguments[index++];
-      localsHandler.updateLocal(parameter, argument);
-      // Don't forget to update the field, if the parameter is of the
-      // form [:this.x:].
-      if (parameter.kind == ElementKind.FIELD_PARAMETER) {
-        FieldParameterElement fieldParameterElement = parameter;
-        fieldValues[fieldParameterElement.fieldElement] = argument;
-      }
+      int index = 0;
+      FunctionSignature params = constructor.computeSignature(compiler);
+      params.forEachParameter((Element parameter) {
+        HInstruction argument = compiledArguments[index++];
+        localsHandler.updateLocal(parameter, argument);
+        // Don't forget to update the field, if the parameter is of the
+        // form [:this.x:].
+        if (parameter.kind == ElementKind.FIELD_PARAMETER) {
+          FieldParameterElement fieldParameterElement = parameter;
+          fieldValues[fieldParameterElement.fieldElement] = argument;
+        }
+      });
+
+      // Build the initializers in the context of the new constructor.
+      TreeElements oldElements = elements;
+      elements = compiler.resolver.resolveMethodElement(constructor);
+      buildInitializers(constructor, constructors, fieldValues);
+      elements = oldElements;
     });
-
-    // Build the initializers in the context of the new constructor.
-    TreeElements oldElements = elements;
-    elements = compiler.resolver.resolveMethodElement(constructor);
-    buildInitializers(constructor, constructors, fieldValues);
-    elements = oldElements;
   }
 
   /**
    * Run through the initializers and inline all field initializers. Recursively
    * inlines super initializers.
    *
    * The constructors of the inlined initializers is added to [constructors]
    * with sub constructors having a lower index than super constructors.
    *
    * Invariant: The [constructor] and elements in [constructors] must all be
@@ skipping 3197 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;
   }
 }