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

pkg/compiler/lib/src/ssa/builder_kernel.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:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart';
 import '../constants/values.dart'
     show
         ConstantValue,
         InterceptorConstantValue,
         StringConstantValue,
         TypeConstantValue;
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
 import '../native/native.dart' as native;
+import '../resolution/tree_elements.dart';
 import '../tree/dartstring.dart';
 import '../tree/nodes.dart' show Node, BreakStatement;
 import '../types/masks.dart';
 import '../universe/call_structure.dart' show CallStructure;
 import '../universe/selector.dart';
 import '../universe/side_effects.dart' show SideEffects;
 import '../universe/use.dart' show StaticUse;
 import '../world.dart';
 import 'graph_builder.dart';
 import 'jump_handler.dart';
@@ skipping 71 matching lines @@
   // TODO(karlklose): consider removing this and keeping the (substituted) types
   // of the type variables in an environment (like the [LocalsHandler]).
   final List<ResolutionDartType> currentImplicitInstantiations =
       <ResolutionDartType>[];
 
   HInstruction rethrowableException;
 
   @override
   JavaScriptBackend get backend => compiler.backend;
 
+  @override
+  TreeElements get elements => resolvedAst.elements;
+
   SourceInformationBuilder sourceInformationBuilder;
   KernelAstAdapter astAdapter;
   LoopHandler<ir.Node> loopHandler;
   TypeBuilder typeBuilder;
 
   final Map<ir.VariableDeclaration, HInstruction> letBindings =
       <ir.VariableDeclaration, HInstruction>{};
 
   /// True if we are visiting the expression of a throw statement; we assume
   /// this is a slow path.
@@ skipping 160 matching lines @@
   }
 
   /// Maps the fields of a class to their SSA values.
   Map<ir.Field, HInstruction> _collectFieldValues(ir.Class clazz) {
     final fieldValues = <ir.Field, HInstruction>{};
 
     for (var field in clazz.fields) {
       if (field.initializer == null) {
         fieldValues[field] = graph.addConstantNull(closedWorld);
       } else {
-        // Gotta update the resolvedAst when we're looking at field values
-        // outside the constructor.
-        astAdapter.pushResolvedAst(field);
         field.initializer.accept(this);
         fieldValues[field] = pop();
-        astAdapter.popResolvedAstStack();
       }
     }
 
     return fieldValues;
   }
 
   /// Collects field initializers all the way up the inheritance chain.
   void _buildInitializers(
       ir.Constructor constructor, Map<ir.Field, HInstruction> fieldValues) {
     var foundSuperOrRedirectCall = false;
@@ skipping 66 matching lines @@
           assert(invariant(element, constantValue != null,
               message: 'No constant computed for $element'));
           builtArguments.add(graph.addConstant(constantValue, closedWorld));
         }
       });
     }
 
     return builtArguments;
   }
 
-  /// Inlines the given super [constructor]'s initializers by collecting its
+  /// Inlines the given super [constructor]'s initializers by collecting it's
   /// field values and building its constructor initializers. We visit super
   /// constructors all the way up to the [Object] constructor.
   void _buildInlinedInitializers(ir.Constructor constructor,
       List<HInstruction> arguments, Map<ir.Field, HInstruction> fieldValues) {
     // TODO(het): Handle RTI if class needs it
     fieldValues.addAll(_collectFieldValues(constructor.enclosingClass));
 
     var signature = astAdapter.getFunctionSignature(constructor.function);
     var index = 0;
     signature.orderedForEachParameter((ParameterElement parameter) {
@@ skipping 386 matching lines @@
   @override
   visitDoStatement(ir.DoStatement doStatement) {
     // TODO(efortuna): I think this can be rewritten using
     // LoopHandler.handleLoop with some tricks about when the "update" happens.
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     localsHandler.startLoop(astAdapter.getNode(doStatement));
     JumpHandler jumpHandler = loopHandler.beginLoopHeader(doStatement);
     HLoopInformation loopInfo = current.loopInformation;
     HBasicBlock loopEntryBlock = current;
     HBasicBlock bodyEntryBlock = current;
-    JumpTarget target = astAdapter.elements
-        .getTargetDefinition(astAdapter.getNode(doStatement));
+    JumpTarget target =
+        elements.getTargetDefinition(astAdapter.getNode(doStatement));
     bool hasContinues = target != null && target.isContinueTarget;
     if (hasContinues) {
       // Add extra block to hang labels on.
       // It doesn't currently work if they are on the same block as the
       // HLoopInfo. The handling of HLabeledBlockInformation will visit a
       // SubGraph that starts at the same block again, so the HLoopInfo is
       // either handled twice, or it's handled after the labeled block info,
       // both of which generate the wrong code.
       // Using a separate block is just a simple workaround.
       bodyEntryBlock = openNewBlock();
@@ skipping 91 matching lines @@
       loopEntryBlock.loopInformation = null;
 
       if (jumpHandler.hasAnyBreak()) {
         // Null branchBlock because the body of the do-while loop always aborts,
         // so we never get to the condition.
         loopHandler.endLoop(loopEntryBlock, null, jumpHandler, localsHandler);
 
         // Since the body of the loop has a break, we attach a synthesized label
         // to the body.
         SubGraph bodyGraph = new SubGraph(bodyEntryBlock, bodyExitBlock);
-        JumpTarget target = astAdapter.elements
-            .getTargetDefinition(astAdapter.getNode(doStatement));
+        JumpTarget target =
+            elements.getTargetDefinition(astAdapter.getNode(doStatement));
         LabelDefinition label = target.addLabel(null, 'loop');
         label.setBreakTarget();
         HLabeledBlockInformation info = new HLabeledBlockInformation(
             new HSubGraphBlockInformation(bodyGraph), <LabelDefinition>[label]);
         loopEntryBlock.setBlockFlow(info, current);
         jumpHandler.forEachBreak((HBreak breakInstruction, _) {
           HBasicBlock block = breakInstruction.block;
           block.addAtExit(new HBreak.toLabel(label));
           block.remove(breakInstruction);
         });
@@ skipping 1559 matching lines @@
     kernelBuilder.open(exitBlock);
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
   }
 }