Ensure we're looking at the correct resolved AST when initializing fields in constructors.

pkg/compiler/lib/src/ssa/kernel_ast_adapter.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 file.
 
 import 'package:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
+import 'dart:collection' show Queue;
+
 import '../common.dart';
 import '../common/names.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend_helpers.dart';
@@ skipping 11 matching lines @@
 import '../world.dart';
 import 'locals_handler.dart';
 import 'types.dart';
 
 /// A helper class that abstracts all accesses of the AST from Kernel nodes.
 ///
 /// The goal is to remove all need for the AST from the Kernel SSA builder.
 class KernelAstAdapter {
   final Kernel kernel;
   final JavaScriptBackend _backend;
-  final ResolvedAst _resolvedAst;
   final Map<ir.Node, ast.Node> _nodeToAst;
   final Map<ir.Node, Element> _nodeToElement;
   final Map<ir.VariableDeclaration, SyntheticLocal> _syntheticLocals =
       <ir.VariableDeclaration, SyntheticLocal>{};
   final Map<ir.LabeledStatement, KernelJumpTarget> _jumpTargets =
       <ir.LabeledStatement, KernelJumpTarget>{};
   DartTypeConverter _typeConverter;
+  ResolvedAst _resolvedAst;
+
+  /// Sometimes for resolution the resolved AST element needs to change (for
+  /// example, if we're inlining, or if we're in a constructor, but then also
+  /// constructing the field values). We keep track of this with a stack.

[Siggi Cherem (dart-lang), 2017/01/05 23:23:31]

constructing => initializing

[Emily Fortuna, 2017/01/06 00:19:25]

oops yes

+  Queue<ResolvedAst> _resolvedAstStack;

[Siggi Cherem (dart-lang), 2017/01/05 23:23:31]

side comment: We have a tendency in dart2js to use Link<> (from
lib/src/util/link.dart) instead of Queue<> or List<>. That might have been
historical, and in this specific use case I'm guessing it doesn't matter, so I'm
OK keeping it as it is. I'll double check to see if there are any reasons to
continue using Link in this case.

[Emily Fortuna, 2017/01/06 00:19:25]

Acknowledged.

 
   KernelAstAdapter(this.kernel, this._backend, this._resolvedAst,
       this._nodeToAst, this._nodeToElement) {
     // TODO(het): Maybe just use all of the kernel maps directly?
     for (FieldElement fieldElement in kernel.fields.keys) {
       _nodeToElement[kernel.fields[fieldElement]] = fieldElement;
     }
     for (FunctionElement functionElement in kernel.functions.keys) {
       _nodeToElement[kernel.functions[functionElement]] = functionElement;
     }
     for (ClassElement classElement in kernel.classes.keys) {
       _nodeToElement[kernel.classes[classElement]] = classElement;
     }
     for (LibraryElement libraryElement in kernel.libraries.keys) {
       _nodeToElement[kernel.libraries[libraryElement]] = libraryElement;
     }
     for (LocalFunctionElement localFunction in kernel.localFunctions.keys) {
       _nodeToElement[kernel.localFunctions[localFunction]] = localFunction;
     }
     for (TypeVariableElement typeVariable in kernel.typeParameters.keys) {
       _nodeToElement[kernel.typeParameters[typeVariable]] = typeVariable;
     }
     _typeConverter = new DartTypeConverter(this);
+    _resolvedAstStack = new Queue<ResolvedAst>();
+  }
+
+  /// Push the existing resolved AST on the stack and shift the current resolved
+  /// AST to the AST that this kernel node points to.
+  void pushResolvedAst(ir.Node node) {
+    _resolvedAstStack.addLast(_resolvedAst);
+    _resolvedAst = getElement(node).resolvedAst;
+  }
+
+  /// Pop the resolved AST stack to reset it to the previous resolved AST node.
+  void popResolvedAstStack() {
+    assert(_resolvedAstStack.isNotEmpty);
+    _resolvedAst = _resolvedAstStack.removeLast();
   }
 
   Compiler get _compiler => _backend.compiler;
   TreeElements get elements => _resolvedAst.elements;
   DiagnosticReporter get reporter => _compiler.reporter;
   Element get _target => _resolvedAst.element;
 
   GlobalTypeInferenceResults get _globalInferenceResults =>
       _compiler.globalInference.results;
 
@@ skipping 861 matching lines @@
 
   @override
   String get name => null;
 
   @override
   int get nestingLevel => 1;
 
   @override
   ast.Node get statement => null;
 }