record originating elements for Kernel nodes

pkg/compiler/lib/src/kernel/kernel_visitor.dart

 // Copyright (c) 2016, 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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
@@ skipping 180 matching lines @@
 
   final Map<JumpTarget, ir.LabeledStatement> breakTargets =
       <JumpTarget, ir.LabeledStatement>{};
 
   final Map<LocalElement, ir.VariableDeclaration> locals =
       <LocalElement, ir.VariableDeclaration>{};
 
   final Map<CascadeReceiver, ir.VariableGet> cascadeReceivers =
       <CascadeReceiver, ir.VariableGet>{};
 
+  final Map<ir.Node, Element> nodeToElement = <ir.Node, Element>{};
+
+  ir.Node associate(ir.Node node, Element element) {
+    nodeToElement[node] = element;
+    return node;
+  }
+
   bool isVoidContext = false;
 
   KernelVisitor(this.currentElement, this.elements, this.kernel);
 
   KernelVisitor get sendVisitor => this;
 
   KernelVisitor get declVisitor => this;
 
   ir.TreeNode visitForValue(Expression node) {
     bool wasVoidContext = isVoidContext;
@@ skipping 1693 matching lines @@
     if (setterKind == CompoundSetter.INVALID) {
       setter = null;
     }
     return buildStaticAccessor(getter, setter).buildNullAwareAssignment(
         visitForValue(rhs),
         voidContext: isVoidContext);
   }
 
   ir.VariableDeclaration getLocal(LocalElement local) {
     return locals.putIfAbsent(local, () {
-      return new ir.VariableDeclaration(local.name,
-          initializer: null,
-          type: typeToIrHack(local.type),
-          isFinal: local.isFinal,
-          isConst: local.isConst);
+      return associate(
+          new ir.VariableDeclaration(local.name,
+              initializer: null,
+              type: typeToIrHack(local.type),
+              isFinal: local.isFinal,
+              isConst: local.isConst),
+          local);
     });
   }
 
   ir.FunctionNode buildFunctionNode(FunctionElement function, Node bodyNode) {
     List<ir.TypeParameter> typeParameters =
         kernel.typeParametersNotImplemented();
     List<ir.VariableDeclaration> positionalParameters =
         <ir.VariableDeclaration>[];
     List<ir.VariableDeclaration> namedParameters = <ir.VariableDeclaration>[];
     int requiredParameterCount = 0;
@@ skipping 49 matching lines @@
           break;
 
         default:
           internalError(
               function, "Unknown async maker: ${function.asyncMarker}");
           break;
       }
     }
     ir.Statement body =
         (bodyNode == null) ? null : buildStatementInBlock(bodyNode);
-    return new ir.FunctionNode(body,
-        asyncMarker: asyncMarker,
-        returnType: returnType,
-        typeParameters: typeParameters,
-        positionalParameters: positionalParameters,
-        namedParameters: namedParameters,
-        requiredParameterCount: requiredParameterCount);
+    return associate(
+        new ir.FunctionNode(body,
+            asyncMarker: asyncMarker,
+            returnType: returnType,
+            typeParameters: typeParameters,
+            positionalParameters: positionalParameters,
+            namedParameters: namedParameters,
+            requiredParameterCount: requiredParameterCount),
+        function);
   }
 
   @override
   IrFunction visitStaticFunctionDeclaration(FunctionExpression node,
       MethodElement function, NodeList parameters, Node body, _) {
     return buildIrFunction(ir.ProcedureKind.Method, function, body);
   }
 
   ir.ProcedureKind computeInstanceMethodKind(MethodElement method) {
     assert(method.isFunction);
@@ skipping 689 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }