Renamed some scoping classes to make their usage clearer.

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 993 matching lines @@
 
       // Build the initializers in the context of the new constructor.
       ResolvedAst oldResolvedAst = resolvedAst;
       resolvedAst = callee.resolvedAst;
       final oldElementInferenceResults = elementInferenceResults;
       elementInferenceResults = globalInferenceResults.resultOfMember(callee);
       ScopeInfo oldScopeInfo = localsHandler.scopeInfo;
       ScopeInfo newScopeInfo = closureDataLookup.getScopeInfo(callee);
       localsHandler.scopeInfo = newScopeInfo;
       if (resolvedAst.kind == ResolvedAstKind.PARSED) {
-        localsHandler.enterScope(closureDataLookup.getClosureScope(callee),
+        localsHandler.enterScope(closureDataLookup.getScopeInClosure(callee),
             forGenerativeConstructorBody: callee.isGenerativeConstructorBody);
       }
       buildInitializers(callee, constructorResolvedAsts, fieldValues);
       localsHandler.scopeInfo = oldScopeInfo;
       resolvedAst = oldResolvedAst;
       elementInferenceResults = oldElementInferenceResults;
     });
   }
 
   void buildInitializers(
@@ skipping 334 matching lines @@
         // 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));
         }
       });
 
       // If there are locals that escape (ie mutated in closures), we
       // pass the box to the constructor.
       // The box must be passed before any type variable.
-      ClosureScope scopeData = closureDataLookup.getClosureScope(constructor);
+      ScopeInClosure scopeData =
+          closureDataLookup.getScopeInClosure(constructor);
       if (scopeData.requiresContextBox) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.context));
       }
 
       // Type variables arguments must come after the box (if there is one).
       ClassElement currentClass = constructor.enclosingClass;
       if (rtiNeed.classNeedsRti(currentClass)) {
         // If [currentClass] needs RTI, we add the type variables as
         // parameters of the generative constructor body.
         currentClass.typeVariables.forEach((_argument) {
@@ skipping 40 matching lines @@
       element.functionSignature.orderedForEachParameter((_parameter) {
         ParameterElement parameter = _parameter;
         parameters[parameter] = TypeMaskFactory.inferredTypeForParameter(
             parameter, globalInferenceResults);
       });
     }
 
     localsHandler.startFunction(
         element,
         closureDataLookup.getScopeInfo(element),
-        closureDataLookup.getClosureScope(element),
+        closureDataLookup.getScopeInClosure(element),
         parameters,
         isGenerativeConstructorBody: element.isGenerativeConstructorBody);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
 
     // Add the type parameters of the class as parameters of this method.  This
     // must be done before adding the normal parameters, because their types
     // may contain references to type variables.
     ClassElement cls = element.enclosingClass;
@@ skipping 13 matching lines @@
       FunctionSignature signature = functionElement.functionSignature;
 
       // Put the type checks in the first successor of the entry,
       // because that is where the type guards will also be inserted.
       // This way we ensure that a type guard will dominate the type
       // check.
       signature.orderedForEachParameter((_parameterElement) {
         ParameterElement parameterElement = _parameterElement;
         if (element.isGenerativeConstructorBody) {
           if (closureDataLookup
-              .getClosureScope(element)
+              .getScopeInClosure(element)
               .isBoxed(parameterElement)) {
             // The parameter will be a field in the box passed as the
             // last parameter. So no need to have it.
             return;
           }
         }
         HInstruction newParameter =
             localsHandler.directLocals[parameterElement];
         if (!element.isConstructor ||
             !(element as ConstructorElement).isRedirectingFactory) {
@@ skipping 223 matching lines @@
         pop();
       }
     }
 
     void buildBody() {
       visit(node.body);
     }
 
     loopHandler.handleLoop(
         node,
-        closureDataLookup.getLoopClosureScope(node),
+        closureDataLookup.getLoopScopeInClosure(node),
         elements.getTargetDefinition(node),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   visitWhile(ast.While node) {
     assert(isReachable);
     HInstruction buildCondition() {
       visit(node.condition);
       return popBoolified();
     }
 
-    loopHandler.handleLoop(node, closureDataLookup.getLoopClosureScope(node),
+    loopHandler.handleLoop(node, closureDataLookup.getLoopScopeInClosure(node),
         elements.getTargetDefinition(node), () {}, buildCondition, () {}, () {
       visit(node.body);
     });
   }
 
   visitDoWhile(ast.DoWhile node) {
     assert(isReachable);
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
-    var loopClosureInfo = closureDataLookup.getLoopClosureScope(node);
+    var loopClosureInfo = closureDataLookup.getLoopScopeInClosure(node);
     localsHandler.startLoop(loopClosureInfo);
     loopDepth++;
     JumpTarget target = elements.getTargetDefinition(node);
     JumpHandler jumpHandler = loopHandler.beginLoopHeader(node, 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.
@@ skipping 3689 matching lines @@
       pop(); // Pop the value pushed by the setter call.
 
       visit(node.body);
     }
 
     void buildUpdate() {}
 
     buildProtectedByFinally(() {
       loopHandler.handleLoop(
           node,
-          closureDataLookup.getLoopClosureScope(node),
+          closureDataLookup.getLoopScopeInClosure(node),
           elements.getTargetDefinition(node),
           buildInitializer,
           buildCondition,
           buildUpdate,
           buildBody);
     }, () {
       pushInvokeDynamic(node, Selectors.cancel, null, [streamIterator]);
       push(new HAwait(pop(),
           new TypeMask.subclass(commonElements.objectClass, closedWorld)));
       pop();
@@ skipping 52 matching lines @@
     void buildBody() {
       Selector call = Selectors.current;
       TypeMask mask = elementInferenceResults.typeOfIteratorCurrent(node);
       pushInvokeDynamic(node, call, mask, [iterator]);
       buildAssignLoopVariable(node, pop());
       visit(node.body);
     }
 
     loopHandler.handleLoop(
         node,
-        closureDataLookup.getLoopClosureScope(node),
+        closureDataLookup.getLoopScopeInClosure(node),
         elements.getTargetDefinition(node),
         buildInitializer,
         buildCondition,
         () {},
         buildBody);
   }
 
   buildAssignLoopVariable(ast.ForIn node, HInstruction value) {
     ast.Node identifier = node.declaredIdentifier;
     Element variable = elements.getForInVariable(node);
@@ skipping 104 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(
         node,
-        closureDataLookup.getLoopClosureScope(node),
+        closureDataLookup.getLoopScopeInClosure(node),
         elements.getTargetDefinition(node),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   visitLabel(ast.Label node) {
     reporter.internalError(node, 'SsaFromAstMixin.visitLabel.');
   }
@@ skipping 334 matching lines @@
           node,
           new NullJumpHandler(reporter),
           buildExpression,
           node.cases,
           getConstants,
           (_) => false, // No case is default.
           buildSwitchCase);
     }
 
     void buildLoop() {
-      loopHandler.handleLoop(node, closureDataLookup.getLoopClosureScope(node),
-          switchTarget, () {}, buildCondition, () {}, buildSwitch);
+      loopHandler.handleLoop(
+          node,
+          closureDataLookup.getLoopScopeInClosure(node),
+          switchTarget,
+          () {},
+          buildCondition,
+          () {},
+          buildSwitch);
     }
 
     if (hasDefault) {
       buildLoop();
     } else {
       // If the switch statement has no default case, surround the loop with
       // a test of the target.
       void buildCondition() {
         js.Template code = js.js.parseForeignJS('#');
         push(new HForeignCode(
@@ skipping 836 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }