Rename ClosureClassMaps to ClosureDataLookup

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 40 matching lines @@
   final MemberEntity targetElement;
 
   /// The root node of [targetElement]. This is used as the key into the
   /// [startFunction] of the locals handler.
   // TODO(johnniwinther,efortuna): Avoid the need for AST nodes in the locals
   // handler.
   final Node functionNode;
   final ClosedWorld closedWorld;
   final CodegenWorldBuilder _worldBuilder;
   final CodegenRegistry registry;
-  final ClosureClassMaps closureToClassMapper;
+  final ClosureDataLookup closureDataLookup;
 
   /// Helper accessor for all kernel function-like targets (Procedure,
   /// FunctionExpression, FunctionDeclaration) of the inner FunctionNode itself.
   /// If the current target is not a function-like target, _targetFunction will
   /// be null.
   ir.FunctionNode _targetFunction;
 
   /// A stack of [ResolutionDartType]s that have been seen during inlining of
   /// factory constructors.  These types are preserved in [HInvokeStatic]s and
   /// [HCreate]s inside the inline code and registered during code generation
@@ skipping 30 matching lines @@
       this.targetElement,
       ClassEntity contextClass,
       this.target,
       this.compiler,
       this._elementMap,
       this._typeInferenceMap,
       this.localsMap,
       this.closedWorld,
       this._worldBuilder,
       this.registry,
-      this.closureToClassMapper,
+      this.closureDataLookup,
       // 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();
@@ skipping 209 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.
-      ClosureAnalysisInfo scopeData = closureToClassMapper
+      ClosureAnalysisInfo scopeData = closureDataLookup
           .getClosureAnalysisInfo(constructorElement.resolvedAst.node);
       if (scopeData.requiresContextBox()) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.context));
       }
 
       // Pass type arguments.
       ir.Class currentClass = body.enclosingClass;
       if (backend.rtiNeed.classNeedsRti(_elementMap.getClass(currentClass))) {
         for (ir.DartType typeParameter in currentClass.thisType.typeArguments) {
           HInstruction argument = localsHandler.readLocal(localsHandler
@@ skipping 237 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 astElement = _elementMap.getConstructor(constructor);
     ClosureRepresentationInfo oldClosureData = localsHandler.closureData;
     ClosureRepresentationInfo newClosureData =
-        closureToClassMapper.getClosureRepresentationInfo(astElement);
+        closureDataLookup.getClosureRepresentationInfo(astElement);
     if (astElement is ConstructorElement) {
       // TODO(johnniwinther): Support constructor (body) entities.
       ResolvedAst resolvedAst = astElement.resolvedAst;
       localsHandler.closureData = newClosureData;
       if (resolvedAst.kind == ResolvedAstKind.PARSED) {
         localsHandler.enterScope(
-            closureToClassMapper.getClosureAnalysisInfo(resolvedAst.node),
+            closureDataLookup.getClosureAnalysisInfo(resolvedAst.node),
             forGenerativeConstructorBody:
                 astElement.isGenerativeConstructorBody);
       }
     }
     inlinedFrom(astElement, () {
       _buildInitializers(constructor, constructorChain, fieldValues);
     });
     localsHandler.closureData = oldClosureData;
   }
 
@@ skipping 70 matching lines @@
       function.namedParameters.toList()
         ..sort(namedOrdering)
         ..forEach(handleParameter);
     }
 
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     localsHandler.startFunction(
         targetElement,
-        closureToClassMapper.getClosureRepresentationInfo(targetElement),
-        closureToClassMapper.getClosureAnalysisInfo(functionNode),
+        closureDataLookup.getClosureRepresentationInfo(targetElement),
+        closureDataLookup.getClosureAnalysisInfo(functionNode),
         parameterMap,
         isGenerativeConstructorBody: _targetIsConstructorBody);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
   }
 
   void closeFunction() {
     if (!isAborted()) closeAndGotoExit(new HGoto());
     graph.finalize();
@@ skipping 183 matching lines @@
       }
     }
 
     void buildBody() {
       forStatement.body.accept(this);
     }
 
     loopHandler.handleLoop(
         forStatement,
         localsMap.getClosureRepresentationInfoForLoop(
-            closureToClassMapper, forStatement),
+            closureDataLookup, forStatement),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   @override
   void visitForInStatement(ir.ForInStatement forInStatement) {
     if (forInStatement.isAsync) {
       _buildAsyncForIn(forInStatement);
@@ skipping 108 matching lines @@
       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.getClosureRepresentationInfoForLoop(
-            closureToClassMapper, forInStatement),
+            closureDataLookup, forInStatement),
         buildInitializer,
         buildCondition,
         buildUpdate,
         buildBody);
   }
 
   _buildForInIterator(ir.ForInStatement forInStatement) {
     // Generate a structure equivalent to:
     //   Iterator<E> $iter = <iterable>.iterator;
     //   while ($iter.moveNext()) {
@@ skipping 30 matching lines @@
       // 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.getClosureRepresentationInfoForLoop(
-            closureToClassMapper, forInStatement),
+            closureDataLookup, forInStatement),
         buildInitializer,
         buildCondition,
         () {},
         buildBody);
   }
 
   void _buildAsyncForIn(ir.ForInStatement forInStatement) {
     // The async-for is implemented with a StreamIterator.
     HInstruction streamIterator;
 
@@ skipping 26 matching lines @@
     }
 
     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.getClosureRepresentationInfoForLoop(
-            closureToClassMapper, forInStatement),
+            closureDataLookup, 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 @@
   void visitWhileStatement(ir.WhileStatement whileStatement) {
     assert(isReachable);
     HInstruction buildCondition() {
       whileStatement.condition.accept(this);
       return popBoolified();
     }
 
     loopHandler.handleLoop(
         whileStatement,
         localsMap.getClosureRepresentationInfoForLoop(
-            closureToClassMapper, whileStatement),
+            closureDataLookup, 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);
     LoopClosureRepresentationInfo loopClosureInfo = localsMap
-        .getClosureRepresentationInfoForLoop(closureToClassMapper, doStatement);
+        .getClosureRepresentationInfoForLoop(closureDataLookup, doStatement);
     localsHandler.startLoop(loopClosureInfo);
     JumpHandler jumpHandler = loopHandler.beginLoopHeader(doStatement);
     HLoopInformation loopInfo = current.loopInformation;
     HBasicBlock loopEntryBlock = current;
     HBasicBlock bodyEntryBlock = current;
     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
@@ skipping 500 matching lines @@
           switchStatement.cases,
           getConstants,
           (_) => false, // No case is default.
           buildSwitchCase);
     }
 
     void buildLoop() {
       loopHandler.handleLoop(
           switchStatement,
           localsMap.getClosureRepresentationInfoForLoop(
-              closureToClassMapper, switchStatement),
+              closureDataLookup, switchStatement),
           () {},
           buildCondition,
           () {},
           buildSwitch);
     }
 
     if (hasDefault) {
       buildLoop();
     } else {
       // If the switch statement has no default case, surround the loop with
@@ skipping 1100 matching lines @@
     } else {
       push(new HInvokeDynamicMethod(
           selector, mask, inputs, type, isIntercepted));
     }
   }
 
   @override
   visitFunctionNode(ir.FunctionNode node) {
     Local methodElement = _elementMap.getLocalFunction(node);
     ClosureRepresentationInfo closureInfo =
-        closureToClassMapper.getClosureRepresentationInfo(methodElement);
+        closureDataLookup.getClosureRepresentationInfo(methodElement);
     ClassEntity closureClassEntity = closureInfo.closureClassEntity;
 
     List<HInstruction> capturedVariables = <HInstruction>[];
     closureInfo.createdFieldEntities.forEach((Local capturedLocal) {
       assert(capturedLocal != null);
       capturedVariables.add(localsHandler.readLocal(capturedLocal));
     });
 
     TypeMask type = new TypeMask.nonNullExact(closureClassEntity, closedWorld);
     // TODO(efortuna): Add source information here.
@@ skipping 623 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }