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 576 matching lines @@
       localsHandler.updateLocal(parameter, argument);
     }
 
     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);
-    ClosureClassMap oldClosureData = localsHandler.closureData;
-    ClosureClassMap newClosureData =
-        closureToClassMapper.getMemberMap(astElement);
+    ClosureRepresentationInfo oldClosureData = localsHandler.closureData;
+    ClosureRepresentationInfo newClosureData =
+        closureToClassMapper.getClosureRepresentationInfo(astElement);
     if (astElement is ConstructorElement) {
       // TODO(johnniwinther): Support constructor (body) entities.
       ResolvedAst resolvedAst = astElement.resolvedAst;
       localsHandler.closureData = newClosureData;
       if (resolvedAst.kind == ResolvedAstKind.PARSED) {
         // TODO(efortuna): Take out the test below for null once we are no
         // longer dealing with the ClosureClassMap interface directly.
         if (newClosureData.capturingScopes[resolvedAst.node] != null) {
           localsHandler.enterScope(
               newClosureData.capturingScopes[resolvedAst.node],
@@ skipping 2218 matching lines @@
       push(new HInvokeDynamicSetter(selector, mask, null, inputs, type));
     } else {
       push(new HInvokeDynamicMethod(
           selector, mask, inputs, type, isIntercepted));
     }
   }
 
   @override
   visitFunctionNode(ir.FunctionNode node) {
     Local methodElement = _elementMap.getLocalFunction(node);
-    ClosureClassMap nestedClosureData =
-        closureToClassMapper.getLocalFunctionMap(methodElement);
-    assert(nestedClosureData != null);
-    assert(nestedClosureData.closureClassElement != null);
-    ClosureClassElement closureClassElement =
-        nestedClosureData.closureClassElement;
-    MethodElement callElement = nestedClosureData.callElement;
+    // TODO(efortuna): Rewrite this so we're not reaching into the
+    // closureToClassMapper. We're instead asking it to do something on our
+    // behalf.
+    ClosureRepresentationInfo closureInfo =
+        closureToClassMapper.getClosureRepresentationInfo(methodElement);
+    ClassEntity closureClassEntity = closureInfo.closureClassEntity;
 
     List<HInstruction> capturedVariables = <HInstruction>[];
-    closureClassElement.closureFields.forEach((ClosureFieldElement field) {
-      Local capturedLocal =
-          nestedClosureData.getLocalVariableForClosureField(field);
+    closureInfo.createdFieldEntities.forEach((Local capturedLocal) {
       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: closureInfo.callEntity, localFunction: methodElement));
   }
 
   @override
   visitFunctionDeclaration(ir.FunctionDeclaration declaration) {
     assert(isReachable);
     declaration.function.accept(this);
     Local localFunction = _elementMap.getLocalFunction(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;
   }
 }