Rename ClosureClassMaps to ClosureDataLookup

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 850 matching lines @@
    * stores it in the [returnLocal] field.
    */
   void setupStateForInlining(
       MethodElement function, List<HInstruction> compiledArguments,
       {ResolutionInterfaceType instanceType}) {
     ResolvedAst resolvedAst = function.resolvedAst;
     assert(resolvedAst != null);
     localsHandler = new LocalsHandler(this, function, function.memberContext,
         function.contextClass, instanceType, nativeData, interceptorData);
     localsHandler.closureData =
-        closureToClassMapper.getClosureRepresentationInfo(function);
+        closureDataLookup.getClosureRepresentationInfo(function);
     returnLocal =
         new SyntheticLocal("result", function, function.memberContext);
     localsHandler.updateLocal(returnLocal, graph.addConstantNull(closedWorld));
 
     inTryStatement = false; // TODO(lry): why? Document.
 
     int argumentIndex = 0;
     if (function.isInstanceMember) {
       localsHandler.updateLocal(localsHandler.closureData.thisLocal,
           compiledArguments[argumentIndex++]);
@@ skipping 147 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);
       ClosureRepresentationInfo oldClosureData = localsHandler.closureData;
       ClosureRepresentationInfo newClosureData =
-          closureToClassMapper.getClosureRepresentationInfo(callee);
+          closureDataLookup.getClosureRepresentationInfo(callee);
       localsHandler.closureData = newClosureData;
       if (resolvedAst.kind == ResolvedAstKind.PARSED) {
         localsHandler.enterScope(
-            closureToClassMapper.getClosureAnalysisInfo(resolvedAst.node),
+            closureDataLookup.getClosureAnalysisInfo(resolvedAst.node),
             forGenerativeConstructorBody: callee.isGenerativeConstructorBody);
       }
       buildInitializers(callee, constructorResolvedAsts, fieldValues);
       localsHandler.closureData = oldClosureData;
       resolvedAst = oldResolvedAst;
       elementInferenceResults = oldElementInferenceResults;
     });
   }
 
   void buildInitializers(
@@ skipping 334 matching lines @@
         // 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.
       ClosureAnalysisInfo scopeData =
-          closureToClassMapper.getClosureAnalysisInfo(node);
+          closureDataLookup.getClosureAnalysisInfo(node);
       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
@@ skipping 38 matching lines @@
     Map<Local, TypeMask> parameters = <Local, TypeMask>{};
     if (element is MethodElement) {
       element.functionSignature
           .orderedForEachParameter((ParameterElement parameter) {
         parameters[parameter] = TypeMaskFactory.inferredTypeForParameter(
             parameter, globalInferenceResults);
       });
     }
 
     ClosureRepresentationInfo closureData =
-        closureToClassMapper.getClosureRepresentationInfo(element);
+        closureDataLookup.getClosureRepresentationInfo(element);
     localsHandler.startFunction(element, closureData,
-        closureToClassMapper.getClosureAnalysisInfo(node), parameters,
+        closureDataLookup.getClosureAnalysisInfo(node), 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;
     if ((element.isConstructor || element.isGenerativeConstructorBody) &&
         rtiNeed.classNeedsRti(cls)) {
       cls.typeVariables.forEach((ResolutionTypeVariableType typeVariable) {
         HParameterValue param =
             addParameter(typeVariable.element, commonMasks.nonNullType);
         localsHandler.directLocals[
             localsHandler.getTypeVariableAsLocal(typeVariable)] = param;
       });
     }
 
     if (element is MethodElement) {
       MethodElement functionElement = element;
       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) {
         if (element.isGenerativeConstructorBody) {
-          if (closureToClassMapper
+          if (closureDataLookup
               .getClosureAnalysisInfo(node)
               .isCaptured(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 ||
@@ skipping 224 matching lines @@
         pop();
       }
     }
 
     void buildBody() {
       visit(node.body);
     }
 
     loopHandler.handleLoop(
         node,
-        closureToClassMapper.getClosureRepresentationInfoForLoop(node),
+        closureDataLookup.getClosureRepresentationInfoForLoop(node),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   visitWhile(ast.While node) {
     assert(isReachable);
     HInstruction buildCondition() {
       visit(node.condition);
       return popBoolified();
     }
 
     loopHandler.handleLoop(
         node,
-        closureToClassMapper.getClosureRepresentationInfoForLoop(node),
+        closureDataLookup.getClosureRepresentationInfoForLoop(node),
         () {},
         buildCondition,
         () {}, () {
       visit(node.body);
     });
   }
 
   visitDoWhile(ast.DoWhile node) {
     assert(isReachable);
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
     var loopClosureInfo =
-        closureToClassMapper.getClosureRepresentationInfoForLoop(node);
+        closureDataLookup.getClosureRepresentationInfoForLoop(node);
     localsHandler.startLoop(loopClosureInfo);
     loopDepth++;
     JumpHandler jumpHandler = loopHandler.beginLoopHeader(node);
     HLoopInformation loopInfo = current.loopInformation;
     HBasicBlock loopEntryBlock = current;
     HBasicBlock bodyEntryBlock = current;
     JumpTarget target = elements.getTargetDefinition(node);
     bool hasContinues = target != null && target.isContinueTarget;
     if (hasContinues) {
       // Add extra block to hang labels on.
@@ skipping 118 matching lines @@
         });
       }
     }
     jumpHandler.close();
     loopDepth--;
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     LocalFunctionElement methodElement = elements[node];
     ClosureRepresentationInfo closureInfo =
-        closureToClassMapper.getClosureRepresentationInfo(methodElement);
+        closureDataLookup.getClosureRepresentationInfo(methodElement);
     ClassEntity closureClassEntity = closureInfo.closureClassEntity;
 
     List<HInstruction> capturedVariables = <HInstruction>[];
     closureInfo.createdFieldEntities.forEach((Local field) {
       assert(field != null);
       capturedVariables.add(localsHandler.readLocal(field));
     });
 
     TypeMask type = new TypeMask.nonNullExact(closureClassEntity, closedWorld);
     push(new HCreate(closureClassEntity, capturedVariables, type,
@@ skipping 3543 matching lines @@
       pop(); // Pop the value pushed by the setter call.
 
       visit(node.body);
     }
 
     void buildUpdate() {}
 
     buildProtectedByFinally(() {
       loopHandler.handleLoop(
           node,
-          closureToClassMapper.getClosureRepresentationInfoForLoop(node),
+          closureDataLookup.getClosureRepresentationInfoForLoop(node),
           buildInitializer,
           buildCondition,
           buildUpdate,
           buildBody);
     }, () {
       pushInvokeDynamic(node, Selectors.cancel, null, [streamIterator]);
       push(new HAwait(pop(),
           new TypeMask.subclass(commonElements.objectClass, closedWorld)));
       pop();
     });
@@ skipping 51 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,
-        closureToClassMapper.getClosureRepresentationInfoForLoop(node),
+        closureDataLookup.getClosureRepresentationInfoForLoop(node),
         buildInitializer,
         buildCondition,
         () {},
         buildBody);
   }
 
   buildAssignLoopVariable(ast.ForIn node, HInstruction value) {
     ast.Node identifier = node.declaredIdentifier;
     Element variable = elements.getForInVariable(node);
     Selector selector = elements.getSelector(identifier);
@@ skipping 103 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,
-        closureToClassMapper.getClosureRepresentationInfoForLoop(node),
+        closureDataLookup.getClosureRepresentationInfoForLoop(node),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   visitLabel(ast.Label node) {
     reporter.internalError(node, 'SsaFromAstMixin.visitLabel.');
   }
 
@@ skipping 332 matching lines @@
           buildExpression,
           node.cases,
           getConstants,
           (_) => false, // No case is default.
           buildSwitchCase);
     }
 
     void buildLoop() {
       loopHandler.handleLoop(
           node,
-          closureToClassMapper.getClosureRepresentationInfoForLoop(node),
+          closureDataLookup.getClosureRepresentationInfoForLoop(node),
           () {},
           buildCondition,
           () {},
           buildSwitch);
     }
 
     if (hasDefault) {
       buildLoop();
     } else {
       // If the switch statement has no default case, surround the loop with
@@ skipping 842 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }