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

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 298 matching lines @@
     for (ir.Constructor body in constructorChain.reversed) {
       if (_isEmptyStatement(body.function.body)) continue;
 
       List<HInstruction> bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
 
       // Pass uncaptured arguments first, captured arguments in a box, then type
       // 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.
       functionSignature.orderedForEachParameter((ParameterElement parameter) {
         // 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 (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.
       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
               .getTypeVariableAsLocal(_elementMap.getDartType(typeParameter)
                   as ResolutionTypeVariableType));
           bodyCallInputs.add(argument);
@@ skipping 232 matching lines @@
       // what was given as parameter. This will be used in case
       // there is a parameter check expression in the initializer.
       parameters[parameter] = argument;
       localsHandler.updateLocal(parameter, argument);
     });
 
     // Set the locals handler state as if we were inlining the constructor.
     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);
     localsHandler.closureData = newClosureData;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       localsHandler.enterScope(resolvedAst.node,
           forGenerativeConstructorBody: astElement.isGenerativeConstructorBody);
     }
     inlinedFrom(constructor, () {
       _buildInitializers(constructor, constructorChain, fieldValues);
@@ skipping 113 matching lines @@
   // TODO(sra): Re-implement type builder using Kernel types and the
   // `target` for context.
   @override
   Element get sourceElement => _sourceElementForTarget(_targetStack.last);
 
   List<ir.Node> _targetStack = <ir.Node>[];
 
   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) {
       return callMethodOfClosureClass();
     }
     if (target is ir.FunctionDeclaration) {
       return callMethodOfClosureClass();
     }
     Element element = astAdapter.getElement(target);
     return element;
@@ skipping 2036 matching lines @@
       push(new HInvokeDynamicSetter(selector, mask, null, inputs, type));
     } else {
       push(new HInvokeDynamicMethod(
           selector, mask, inputs, type, isIntercepted));
     }
   }
 
   @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
   visitFunctionDeclaration(ir.FunctionDeclaration declaration) {
     assert(isReachable);
     declaration.function.accept(this);
     LocalFunctionElement localFunction =
         astAdapter.getElement(declaration.function);
     localsHandler.updateLocal(localFunction, pop());
   }
@@ skipping 611 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }