Refactor LoopHandler to avoid calling KernelAstAdapter.getNode

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;
 import '../common/names.dart';
@@ skipping 68 matching lines @@
 
   @override
   JavaScriptBackend get backend => compiler.backend;
 
   @override
   TreeElements get elements => astAdapter.elements;
 
   SourceInformationBuilder sourceInformationBuilder;
   final KernelToElementMap _elementMap;
   final KernelToTypeInferenceMap _typeInferenceMap;
-  final KernelToLocalsMap _localsMap;
+  final KernelToLocalsMap localsMap;
   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.
   bool _inExpressionOfThrow = false;
 
   KernelSsaBuilder(
       this.targetElement,
       ClassEntity contextClass,
       this.target,
       this.compiler,
       this._elementMap,
       this._typeInferenceMap,
-      this._localsMap,
+      this.localsMap,
       this.closedWorld,
       this._worldBuilder,
       this.registry,
       this.closureToClassMapper,
       // TODO(het): Should sourceInformationBuilder be in GraphBuilder?
       this.sourceInformationBuilder,
       this.functionNode,
       {bool targetIsConstructorBody: false})
       : this._targetIsConstructorBody = targetIsConstructorBody {
     this.loopHandler = new KernelLoopHandler(this);
     typeBuilder = new TypeBuilder(this);
     graph.element = targetElement;
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler = new LocalsHandler(this, targetElement, targetElement,
         contextClass, null, nativeData, interceptorData);
     _targetStack.add(targetElement);
   }
 
   @deprecated // Use [_elementMap] instead.
   KernelAstAdapter get astAdapter => _elementMap;
 
   CommonElements get _commonElements => _elementMap.commonElements;
 
   HGraph build() {
-    return reporter.withCurrentElement(_localsMap.currentMember, () {
+    return reporter.withCurrentElement(localsMap.currentMember, () {
       // TODO(het): no reason to do this here...
       HInstruction.idCounter = 0;
       if (target is ir.Procedure) {
         _targetFunction = (target as ir.Procedure).function;
         buildFunctionNode(_targetFunction);
       } else if (target is ir.Field) {
         buildField(target);
       } else if (target is ir.Constructor) {
         if (_targetIsConstructorBody) {
           buildConstructorBody(target);
@@ skipping 173 matching lines @@
       bodyCallInputs.add(newObject);
 
       // Pass uncaptured arguments first, captured arguments in a box, then type
       // arguments.
 
       ConstructorElement constructorElement = _elementMap.getConstructor(body);
       ClosureClassMap parameterClosureData =
           closureToClassMapper.getMemberMap(constructorElement);
 
       void handleParameter(ir.VariableDeclaration node) {
-        Local parameter = _localsMap.getLocal(node);
+        Local parameter = localsMap.getLocal(node);
         // If [parameter] is boxed, it will be a field in the box passed as the
         // last parameter. So no need to directly pass it.
         if (!localsHandler.isBoxed(parameter)) {
           bodyCallInputs.add(localsHandler.readLocal(parameter));
         }
       }
 
       // Provide the parameters to the generative constructor body.
       body.function.positionalParameters.forEach(handleParameter);
       body.function.namedParameters.toList()
@@ skipping 45 matching lines @@
   /// Sets context for generating code that is the result of inlining
   /// [inlinedTarget].
   inlinedFrom(MemberEntity inlinedTarget, f()) {
     reporter.withCurrentElement(inlinedTarget, () {
       SourceInformationBuilder oldSourceInformationBuilder =
           sourceInformationBuilder;
       // TODO(sra): Update sourceInformationBuilder to Kernel.
       // sourceInformationBuilder =
       //   sourceInformationBuilder.forContext(resolvedAst);
 
-      _localsMap.enterInlinedMember(inlinedTarget);
+      localsMap.enterInlinedMember(inlinedTarget);
       _targetStack.add(inlinedTarget);
       var result = f();
       sourceInformationBuilder = oldSourceInformationBuilder;
       _targetStack.removeLast();
-      _localsMap.leaveInlinedMember(inlinedTarget);
+      localsMap.leaveInlinedMember(inlinedTarget);
       return result;
     });
   }
 
   /// Maps the instance fields of a class to their SSA values.
   Map<FieldEntity, HInstruction> _collectFieldValues(ir.Class clazz) {
     Map<FieldEntity, HInstruction> fieldValues = <FieldEntity, HInstruction>{};
 
     for (ir.Field node in clazz.fields) {
       if (node.isInstanceMember) {
@@ skipping 12 matching lines @@
     }
 
     return fieldValues;
   }
 
   /// Collects field initializers all the way up the inheritance chain.
   void _buildInitializers(
       ir.Constructor constructor,
       List<ir.Constructor> constructorChain,
       Map<FieldEntity, HInstruction> fieldValues) {
-    assert(_elementMap.getConstructor(constructor) == _localsMap.currentMember);
+    assert(_elementMap.getConstructor(constructor) == localsMap.currentMember);
     constructorChain.add(constructor);
 
     var foundSuperOrRedirectCall = false;
     for (var initializer in constructor.initializers) {
       if (initializer is ir.FieldInitializer) {
         initializer.value.accept(this);
         fieldValues[_elementMap.getField(initializer.field)] = pop();
       } else if (initializer is ir.SuperInitializer) {
         assert(!foundSuperOrRedirectCall);
         foundSuperOrRedirectCall = true;
@@ skipping 131 matching lines @@
 
   void _inlineSuperOrRedirectCommon(
       ir.Initializer initializer,
       ir.Constructor constructor,
       List<HInstruction> arguments,
       List<ir.Constructor> constructorChain,
       Map<FieldEntity, HInstruction> fieldValues,
       ir.Constructor caller) {
     var index = 0;
     void handleParameter(ir.VariableDeclaration node) {
-      Local parameter = _localsMap.getLocal(node);
+      Local parameter = localsMap.getLocal(node);
       HInstruction argument = arguments[index++];
       // Because we are inlining the initializer, we must update
       // what was given as parameter. This will be used in case
       // there is a parameter check expression in the initializer.
       parameters[parameter] = argument;
       localsHandler.updateLocal(parameter, argument);
     }
 
     constructor.function.positionalParameters.forEach(handleParameter);
     constructor.function.namedParameters.toList()
@@ skipping 79 matching lines @@
   void removeImplicitInstantiation(DartType type) {
     if (type != null) {
       currentImplicitInstantiations.removeLast();
     }
   }
 
   void openFunction([ir.FunctionNode function]) {
     Map<Local, TypeMask> parameterMap = <Local, TypeMask>{};
     if (function != null) {
       void handleParameter(ir.VariableDeclaration node) {
-        Local local = _localsMap.getLocal(node);
+        Local local = localsMap.getLocal(node);
         parameterMap[local] =
             _typeInferenceMap.getInferredTypeOfParameter(local);
       }
 
       function.positionalParameters.forEach(handleParameter);
       function.namedParameters.toList()
         ..sort(namedOrdering)
         ..forEach(handleParameter);
     }
 
@@ skipping 293 matching lines @@
       // Find a type for the element. Use the element type of the indexer of the
       // array, as this is stronger than the iterator's `get current` type, for
       // example, `get current` includes null.
       // TODO(sra): The element type of a container type mask might be better.
       TypeMask type = _typeInferenceMap.inferredIndexType(forInStatement);
 
       HInstruction index = localsHandler.readLocal(indexVariable);
       HInstruction value = new HIndex(array, index, null, type);
       add(value);
 
-      Local loopVariableLocal = _localsMap.getLocal(forInStatement.variable);
+      Local loopVariableLocal = localsMap.getLocal(forInStatement.variable);
       localsHandler.updateLocal(loopVariableLocal, value);
       // Hint to name loop value after name of loop variable.
       if (loopVariableLocal is! SyntheticLocal) {
         value.sourceElement ??= loopVariableLocal;
       }
 
       forInStatement.body.accept(this);
     }
 
     void buildUpdate() {
@@ skipping 40 matching lines @@
       TypeMask mask = _typeInferenceMap.typeOfIteratorMoveNext(forInStatement);
       _pushDynamicInvocation(forInStatement, mask, <HInstruction>[iterator],
           selector: Selectors.moveNext);
       return popBoolified();
     }
 
     void buildBody() {
       TypeMask mask = _typeInferenceMap.typeOfIteratorCurrent(forInStatement);
       _pushDynamicInvocation(forInStatement, mask, [iterator],
           selector: Selectors.current);
-      Local loopVariableLocal = _localsMap.getLocal(forInStatement.variable);
+      Local loopVariableLocal = localsMap.getLocal(forInStatement.variable);
       HInstruction value = pop();
       localsHandler.updateLocal(loopVariableLocal, value);
       // Hint to name loop value after name of loop variable.
       if (loopVariableLocal is! SyntheticLocal) {
         value.sourceElement ??= loopVariableLocal;
       }
       forInStatement.body.accept(this);
     }
 
     loopHandler.handleLoop(
@@ skipping 21 matching lines @@
       HInstruction future = pop();
       push(new HAwait(future, closedWorld.commonMasks.dynamicType));
       return popBoolified();
     }
 
     void buildBody() {
       TypeMask mask = _typeInferenceMap.typeOfIteratorCurrent(forInStatement);
       _pushDynamicInvocation(forInStatement, mask, [streamIterator],
           selector: Selectors.current);
       localsHandler.updateLocal(
-          _localsMap.getLocal(forInStatement.variable), pop());
+          localsMap.getLocal(forInStatement.variable), pop());
       forInStatement.body.accept(this);
     }
 
     void buildUpdate() {}
 
     // Creates a synthetic try/finally block in case anything async goes amiss.
     TryCatchFinallyBuilder tryBuilder = new TryCatchFinallyBuilder(this);
     // Build fake try body:
     loopHandler.handleLoop(forInStatement, buildInitializer, buildCondition,
         buildUpdate, buildBody);
@@ skipping 43 matching lines @@
     loopHandler.handleLoop(whileStatement, () {}, buildCondition, () {}, () {
       whileStatement.body.accept(this);
     });
   }
 
   @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));
+    ClosureScope scopeData = localsMap.getClosureScopeForLoop(
+        localsHandler.closureData, doStatement);
+    localsHandler.startLoop(scopeData);
     JumpHandler jumpHandler = loopHandler.beginLoopHeader(doStatement);
     HLoopInformation loopInfo = current.loopInformation;
     HBasicBlock loopEntryBlock = current;
     HBasicBlock bodyEntryBlock = current;
-    JumpTarget target = _localsMap.getJumpTarget(doStatement);
+    JumpTarget target = localsMap.getJumpTarget(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();
     }
-    localsHandler.enterLoopBody(astAdapter.getNode(doStatement));
+    localsHandler.enterLoopBody(scopeData);
     doStatement.body.accept(this);
 
     // If there are no continues we could avoid the creation of the condition
     // block. This could also lead to a block having multiple entries and exits.
     HBasicBlock bodyExitBlock;
     bool isAbortingBody = false;
     if (current != null) {
       bodyExitBlock = close(new HGoto());
     } else {
       isAbortingBody = true;
@@ skipping 79 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 = _localsMap.getJumpTarget(doStatement);
+        JumpTarget target = localsMap.getJumpTarget(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 104 matching lines @@
   }
 
   /// Creates a [JumpHandler] for a statement. The node must be a jump
   /// target. If there are no breaks or continues targeting the statement,
   /// a special "null handler" is returned.
   ///
   /// [isLoopJump] is true when the jump handler is for a loop. This is used
   /// to distinguish the synthesized loop created for a switch statement with
   /// continue statements from simple switch statements.
   JumpHandler createJumpHandler(ir.TreeNode node, {bool isLoopJump: false}) {
-    JumpTarget target = _localsMap.getJumpTarget(node);
+    JumpTarget target = localsMap.getJumpTarget(node);
     assert(target is KernelJumpTarget);
     if (target == null) {
       // No breaks or continues to this node.
       return new NullJumpHandler(reporter);
     }
     if (isLoopJump && node is ir.SwitchStatement) {
-      return new KernelSwitchCaseJumpHandler(this, target, node, _localsMap);
+      return new KernelSwitchCaseJumpHandler(this, target, node, localsMap);
     }
 
     return new JumpHandler(this, target);
   }
 
   @override
   void visitBreakStatement(ir.BreakStatement breakStatement) {
     assert(!isAborted());
     handleInTryStatement();
-    JumpTarget target = _localsMap.getJumpTarget(breakStatement.target);
+    JumpTarget target = localsMap.getJumpTarget(breakStatement.target);
     assert(target != null);
     JumpHandler handler = jumpTargets[target];
     assert(handler != null);
     if (handler.labels.isNotEmpty) {
       handler.generateBreak(handler.labels.first);
     } else {
       handler.generateBreak();
     }
   }
 
@@ skipping 52 matching lines @@
         constants[caseExpression] = constant;
       }
     }
     return constants;
   }
 
   @override
   void visitContinueSwitchStatement(
       ir.ContinueSwitchStatement switchStatement) {
     handleInTryStatement();
-    JumpTarget target = _localsMap.getJumpTarget(switchStatement.target);
+    JumpTarget target = localsMap.getJumpTarget(switchStatement.target);
     assert(target != null);
     JumpHandler handler = jumpTargets[target];
     assert(handler != null);
     assert(target.labels.isNotEmpty);
     handler.generateContinue(target.labels.first);
   }
 
   @override
   void visitSwitchStatement(ir.SwitchStatement switchStatement) {
     // The switch case indices must match those computed in
@@ skipping 99 matching lines @@
     //       case 1: s_1; break l;
     //       case 2: s_2; target = i; continue l;
     //       ...
     //       case n: s_n; target = j; continue l;
     //     }
     //   }
     //
     // This is because JS does not have this same "continue label" semantics so
     // we encode it in the form of a state machine.
 
-    JumpTarget switchTarget = _localsMap.getJumpTarget(switchStatement);
+    JumpTarget switchTarget = localsMap.getJumpTarget(switchStatement);
     localsHandler.updateLocal(switchTarget, graph.addConstantNull(closedWorld));
 
     var switchCases = switchStatement.cases;
     if (!hasDefault) {
       // Use null as the marker for a synthetic default clause.
       // The synthetic default is added because otherwise there would be no
       // good place to give a default value to the local.
       switchCases = new List<ir.SwitchCase>.from(switchCases);
       switchCases.add(null);
     }
@@ skipping 451 matching lines @@
 
   @override
   void visitVariableGet(ir.VariableGet variableGet) {
     ir.VariableDeclaration variable = variableGet.variable;
     HInstruction letBinding = letBindings[variable];
     if (letBinding != null) {
       stack.add(letBinding);
       return;
     }
 
-    Local local = _localsMap.getLocal(variableGet.variable);
+    Local local = localsMap.getLocal(variableGet.variable);
     stack.add(localsHandler.readLocal(local));
   }
 
   @override
   void visitPropertySet(ir.PropertySet propertySet) {
     propertySet.receiver.accept(this);
     HInstruction receiver = pop();
     propertySet.value.accept(this);
     HInstruction value = pop();
 
@@ skipping 27 matching lines @@
 
   @override
   void visitVariableSet(ir.VariableSet variableSet) {
     variableSet.value.accept(this);
     HInstruction value = pop();
     _visitLocalSetter(variableSet.variable, value);
   }
 
   @override
   void visitVariableDeclaration(ir.VariableDeclaration declaration) {
-    Local local = _localsMap.getLocal(declaration);
+    Local local = localsMap.getLocal(declaration);
     if (declaration.initializer == null) {
       HInstruction initialValue = graph.addConstantNull(closedWorld);
       localsHandler.updateLocal(local, initialValue);
     } else {
       declaration.initializer.accept(this);
       HInstruction initialValue = pop();
 
       _visitLocalSetter(declaration, initialValue);
 
       // Ignore value
       pop();
     }
   }
 
   void _visitLocalSetter(ir.VariableDeclaration variable, HInstruction value) {
-    Local local = _localsMap.getLocal(variable);
+    Local local = localsMap.getLocal(variable);
 
     // Give the value a name if it doesn't have one already.
     if (value.sourceElement == null) {
       value.sourceElement = local;
     }
 
     stack.add(value);
     localsHandler.updateLocal(
         local,
         typeBuilder.potentiallyCheckOrTrustType(
@@ skipping 1204 matching lines @@
       // `guard` is often `dynamic`, which generates `true`.
       kernelBuilder.pushIsTest(
           catchBlock.exception, catchBlock.guard, unwrappedException);
     }
 
     void visitThen() {
       ir.Catch catchBlock = tryCatch.catches[catchesIndex];
       catchesIndex++;
       if (catchBlock.exception != null) {
         LocalVariableElement exceptionVariable =
-            kernelBuilder._localsMap.getLocal(catchBlock.exception);
+            kernelBuilder.localsMap.getLocal(catchBlock.exception);
         kernelBuilder.localsHandler
             .updateLocal(exceptionVariable, unwrappedException);
       }
       if (catchBlock.stackTrace != null) {
         kernelBuilder._pushStaticInvocation(
             kernelBuilder._commonElements.traceFromException,
             [exception],
             kernelBuilder._typeInferenceMap.getReturnTypeOf(
                 kernelBuilder._commonElements.traceFromException));
         HInstruction traceInstruction = kernelBuilder.pop();
         LocalVariableElement traceVariable =
-            kernelBuilder._localsMap.getLocal(catchBlock.stackTrace);
+            kernelBuilder.localsMap.getLocal(catchBlock.stackTrace);
         kernelBuilder.localsHandler
             .updateLocal(traceVariable, traceInstruction);
       }
       catchBlock.body.accept(kernelBuilder);
     }
 
     void visitElse() {
       if (catchesIndex >= tryCatch.catches.length) {
         kernelBuilder.closeAndGotoExit(new HThrow(
             exception, exception.sourceInformation,
@@ skipping 39 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }