Renamed some scoping classes to make their usage clearer.

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 327 matching lines @@
       }
 
       // Provide the parameters to the generative constructor body.
       body.function.positionalParameters.forEach(handleParameter);
       body.function.namedParameters.toList()
         ..sort(namedOrdering)
         ..forEach(handleParameter);
 
       // If there are locals that escape (i.e. mutated in closures), we pass the
       // box to the constructor.
-      ClosureScope scopeData =
-          closureDataLookup.getClosureScope(constructorElement);
+      CapturedScope scopeData =
+          closureDataLookup.getCapturedScope(constructorElement);
       if (scopeData.requiresContextBox) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.context));
       }
 
       // Pass type arguments.
       ir.Class currentClass = body.enclosingClass;
       if (closedWorld.rtiNeed
           .classNeedsRti(_elementMap.getClass(currentClass))) {
         for (ir.DartType typeParameter in currentClass.thisType.typeArguments) {
           HInstruction argument = localsHandler.readLocal(localsHandler
@@ skipping 241 matching lines @@
     constructor.function.positionalParameters.forEach(handleParameter);
     constructor.function.namedParameters.toList()
       ..sort(namedOrdering)
       ..forEach(handleParameter);
 
     // Set the locals handler state as if we were inlining the constructor.
     ConstructorEntity element = _elementMap.getConstructor(constructor);
     ScopeInfo oldScopeInfo = localsHandler.scopeInfo;
     ScopeInfo newScopeInfo = closureDataLookup.getScopeInfo(element);
     localsHandler.scopeInfo = newScopeInfo;
-    localsHandler.enterScope(closureDataLookup.getClosureScope(element));
+    localsHandler.enterScope(closureDataLookup.getCapturedScope(element));
     inlinedFrom(element, () {
       _buildInitializers(constructor, constructorChain, fieldValues);
     });
     localsHandler.scopeInfo = oldScopeInfo;
   }
 
   /// Builds generative constructor body.
   void buildConstructorBody(ir.Constructor constructor) {
     openFunction(constructor.function);
     _addClassTypeVariablesIfNeeded(constructor);
@@ skipping 67 matching lines @@
         ..sort(namedOrdering)
         ..forEach(handleParameter);
     }
 
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     localsHandler.startFunction(
         targetElement,
         closureDataLookup.getScopeInfo(targetElement),
-        closureDataLookup.getClosureScope(targetElement),
+        closureDataLookup.getCapturedScope(targetElement),
         parameterMap,
         isGenerativeConstructorBody: targetElement is ConstructorBodyEntity);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
   }
 
   void closeFunction() {
     if (!isAborted()) closeAndGotoExit(new HGoto());
     graph.finalize();
@@ skipping 176 matching lines @@
       }
     }
 
     void buildBody() {
       forStatement.body.accept(this);
     }
 
     JumpTarget jumpTarget = localsMap.getJumpTargetForFor(forStatement);
     loopHandler.handleLoop(
         forStatement,
-        localsMap.getLoopClosureScope(closureDataLookup, forStatement),
+        localsMap.getCapturedLoopScope(closureDataLookup, forStatement),
         jumpTarget,
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   @override
   void visitForInStatement(ir.ForInStatement forInStatement) {
     if (forInStatement.isAsync) {
@@ skipping 108 matching lines @@
       HInstruction index = localsHandler.readLocal(indexVariable);
       HInstruction one = graph.addConstantInt(1, closedWorld);
       HInstruction addInstruction =
           new HAdd(index, one, null, commonMasks.positiveIntType);
       add(addInstruction);
       localsHandler.updateLocal(indexVariable, addInstruction);
     }
 
     loopHandler.handleLoop(
         forInStatement,
-        localsMap.getLoopClosureScope(closureDataLookup, forInStatement),
+        localsMap.getCapturedLoopScope(closureDataLookup, forInStatement),
         localsMap.getJumpTargetForForIn(forInStatement),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   _buildForInIterator(ir.ForInStatement forInStatement) {
     // Generate a structure equivalent to:
     //   Iterator<E> $iter = <iterable>.iterator;
@@ skipping 30 matching lines @@
       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(
         forInStatement,
-        localsMap.getLoopClosureScope(closureDataLookup, forInStatement),
+        localsMap.getCapturedLoopScope(closureDataLookup, forInStatement),
         localsMap.getJumpTargetForForIn(forInStatement),
         buildInitializer,
         buildCondition,
         () {},
         buildBody);
   }
 
   void _buildAsyncForIn(ir.ForInStatement forInStatement) {
     // The async-for is implemented with a StreamIterator.
     HInstruction streamIterator;
@@ skipping 26 matching lines @@
       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,
-        localsMap.getLoopClosureScope(closureDataLookup, forInStatement),
+        localsMap.getCapturedLoopScope(closureDataLookup, forInStatement),
         localsMap.getJumpTargetForForIn(forInStatement),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
 
     void finalizerFunction() {
       _pushDynamicInvocation(forInStatement, null, [streamIterator],
           selector: Selectors.cancel);
       add(new HAwait(pop(), closedWorld.commonMasks.dynamicType));
@@ skipping 30 matching lines @@
   @override
   void visitWhileStatement(ir.WhileStatement whileStatement) {
     assert(isReachable);
     HInstruction buildCondition() {
       whileStatement.condition.accept(this);
       return popBoolified();
     }
 
     loopHandler.handleLoop(
         whileStatement,
-        localsMap.getLoopClosureScope(closureDataLookup, whileStatement),
+        localsMap.getCapturedLoopScope(closureDataLookup, whileStatement),
         localsMap.getJumpTargetForWhile(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);
-    LoopClosureScope loopClosureInfo =
-        localsMap.getLoopClosureScope(closureDataLookup, doStatement);
+    CapturedLoopScope loopClosureInfo =
+        localsMap.getCapturedLoopScope(closureDataLookup, doStatement);
     localsHandler.startLoop(loopClosureInfo);
     JumpTarget target = localsMap.getJumpTargetForDo(doStatement);
     JumpHandler jumpHandler = loopHandler.beginLoopHeader(doStatement, target);
     HLoopInformation loopInfo = current.loopInformation;
     HBasicBlock loopEntryBlock = current;
     HBasicBlock bodyEntryBlock = current;
     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
@@ skipping 517 matching lines @@
           buildExpression,
           switchStatement.cases,
           getConstants,
           (_) => false, // No case is default.
           buildSwitchCase);
     }
 
     void buildLoop() {
       loopHandler.handleLoop(
           switchStatement,
-          localsMap.getLoopClosureScope(closureDataLookup, switchStatement),
+          localsMap.getCapturedLoopScope(closureDataLookup, switchStatement),
           switchTarget,
           () {},
           buildCondition,
           () {},
           buildSwitch);
     }
 
     if (hasDefault) {
       buildLoop();
     } else {
@@ skipping 1778 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }