Create new interface instead of ClosureClassMap for variable usage information that is not Element-…

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

Index: pkg/compiler/lib/src/ssa/builder_kernel.dart
diff --git a/pkg/compiler/lib/src/ssa/builder_kernel.dart b/pkg/compiler/lib/src/ssa/builder_kernel.dart
index b7d05ebf4b966ef5ff937bd28c50aba96799b212..f504a7cc27ec3dd1e50fc94bc1bcc4074a9a0347 100644
--- a/pkg/compiler/lib/src/ssa/builder_kernel.dart
+++ b/pkg/compiler/lib/src/ssa/builder_kernel.dart
@@ -316,8 +316,6 @@ class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
       // arguments.
 
       ConstructorElement constructorElement = astAdapter.getElement(body);
-      ClosureClassMap parameterClosureData =
-          closureToClassMapper.getMemberMap(constructorElement);
 
       var functionSignature = astAdapter.getFunctionSignature(body.function);
       // Provide the parameters to the generative constructor body.
@@ -331,10 +329,11 @@ class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
 
       // If there are locals that escape (i.e. mutated in closures), we pass the
       // box to the constructor.
-      ClosureScope scopeData = parameterClosureData
-          .capturingScopes[constructorElement.resolvedAst.node];
-      if (scopeData != null) {
-        bodyCallInputs.add(localsHandler.readLocal(scopeData.boxElement));
+      CapturedVariableInfo scopeData = closureToClassMapper
+          .getCapturedVariableInfo(constructorElement.resolvedAst.node);

[Johnni Winther, 2017/05/31 12:39:51]

The uses of `constructorElement.resolvedAst.node` needs to go away. We can avoid
it by using a per member ClosureClassMap<T>.

[Siggi Cherem (dart-lang), 2017/05/31 20:44:39]

Another idea:
I noticed that we have 2 kinds of calls to getCapturedVariableInfo:
 - when the key node is a loop
 - when the key node is a function

What if we have 2 APIs one for each:

  CapturedVariableInfo capturedVariableInfoForFunction(
      FunctionEntity entity);

  CapturedVariableInfo capturedVariableInfoForLoop(T node);

Then here, the parameter will be constructorElement and we can drop
.resolvedAst.node

+      if (scopeData.hasCapturedVariables()) {
+        bodyCallInputs.add(localsHandler.readLocal(closureToClassMapper
+            .getExecutableContext(constructorElement.resolvedAst.node)));
       }
 
       // Pass type arguments.
@@ -587,6 +586,7 @@ class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
     astAdapter.pushResolvedAst(constructor);
     ConstructorElement astElement = astAdapter.getElement(constructor);
     ResolvedAst resolvedAst = astElement.resolvedAst;
+    // TODO(efortuna): Remove reference to ClosureClassMap.
     ClosureClassMap oldClosureData = localsHandler.closureData;
     ClosureClassMap newClosureData =
         closureToClassMapper.getMemberMap(astElement);
@@ -720,11 +720,9 @@ class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
   Element _sourceElementForTarget(ir.Node target) {
     // For closure-converted (i.e. local functions) the source element is the
     // 'call' method of the class that represents the closure.
-    Element callMethodOfClosureClass() {
+    FunctionEntity callMethodOfClosureClass() {
       LocalFunctionElement element = astAdapter.getElement(target);
-      ClosureClassMap classMap =
-          closureToClassMapper.getLocalFunctionMap(element);
-      return classMap.callElement;
+      return closureToClassMapper.getCallEntity(element);
     }
 
     if (target is ir.FunctionExpression) {
@@ -2781,26 +2779,23 @@ class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
   @override
   visitFunctionNode(ir.FunctionNode node) {
     LocalFunctionElement methodElement = astAdapter.getElement(node);
-    ClosureClassMap nestedClosureData =
-        closureToClassMapper.getLocalFunctionMap(methodElement);
-    assert(nestedClosureData != null);
-    assert(nestedClosureData.closureClassElement != null);
-    ClosureClassElement closureClassElement =
-        nestedClosureData.closureClassElement;
-    MethodElement callElement = nestedClosureData.callElement;
+    ClassEntity closureClassEntity =
+        closureToClassMapper.getClosureClassEntity(methodElement);
 
     List<HInstruction> capturedVariables = <HInstruction>[];
-    closureClassElement.closureFields.forEach((ClosureFieldElement field) {
+    closureToClassMapper.forEachClosureClassFieldEntity(methodElement,
+        (ClosureFieldElement field) {
       Local capturedLocal =
-          nestedClosureData.getLocalVariableForClosureField(field);
+          closureToClassMapper.getLocalVarForClosureField(methodElement, field);
       assert(capturedLocal != null);
       capturedVariables.add(localsHandler.readLocal(capturedLocal));
     });
 
-    TypeMask type = new TypeMask.nonNullExact(closureClassElement, closedWorld);
+    TypeMask type = new TypeMask.nonNullExact(closureClassEntity, closedWorld);
     // TODO(efortuna): Add source information here.
-    push(new HCreate(closureClassElement, capturedVariables, type,
-        callMethod: callElement, localFunction: methodElement));
+    push(new HCreate(closureClassEntity, capturedVariables, type,
+        callMethod: closureToClassMapper.getCallEntity(methodElement),
+        localFunction: methodElement));
   }
 
   @override