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

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 1349 matching lines @@
       List bodyCallInputs = <HInstruction>[];
       if (isNativeUpgradeFactory) {
         if (interceptor == null) {
           ConstantValue constant = new InterceptorConstantValue(classElement);
           interceptor = graph.addConstant(constant, closedWorld);
         }
         bodyCallInputs.add(interceptor);
       }
       bodyCallInputs.add(newObject);
       ast.Node node = constructorResolvedAst.node;
-      ClosureClassMap parameterClosureData =
-          closureToClassMapper.getMemberMap(constructor);
 
       FunctionSignature functionSignature = body.functionSignature;
       // 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 (ie mutated in closures), we
       // pass the box to the constructor.
       // The box must be passed before any type variable.
-      ClosureScope scopeData = parameterClosureData.capturingScopes[node];
-      if (scopeData != null) {
-        bodyCallInputs.add(localsHandler.readLocal(scopeData.boxElement));
+      CapturedVariableInfo scopeData =
+          closureToClassMapper.getCapturedVariableInfo(node);
+      if (scopeData.hasCapturedVariables()) {
+        bodyCallInputs.add(localsHandler
+            .readLocal(closureToClassMapper.getExecutableContext(node)));
       }
 
       // 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
             .forEach((ResolutionTypeVariableType argument) {
           // TODO(johnniwinther): Substitute [argument] with
@@ skipping 54 matching lines @@
     }
 
     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.
-      ClosureScope scopeData = localsHandler.closureData.capturingScopes[node];
       signature.orderedForEachParameter((ParameterElement parameterElement) {
         if (element.isGenerativeConstructorBody) {
-          if (scopeData != null &&
-              scopeData.isCapturedVariable(parameterElement)) {
+          if (closureToClassMapper
+              .getCapturedVariableInfo(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 ||
             !(element as ConstructorElement).isRedirectingFactory) {
           // Redirection factories must not check their argument types.
@@ skipping 376 matching lines @@
           block.remove(breakInstruction);
         });
       }
     }
     jumpHandler.close();
     loopDepth--;
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
     LocalFunctionElement methodElement = elements[node];
-    ClosureClassMap nestedClosureData =
-        closureToClassMapper.getLocalFunctionMap(methodElement);
-    assert(nestedClosureData != null);
-    assert(nestedClosureData.closureClassElement != null);
-    ClosureClassElement closureClassElement =
-        nestedClosureData.closureClassElement;
-    MethodElement callElement = nestedClosureData.callElement;
+    ClassEntity closureClassElement =
+        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);
     push(new HCreate(closureClassElement, capturedVariables, type,
-        callMethod: callElement, localFunction: methodElement)
+        callMethod: closureToClassMapper.getCallEntity(methodElement),
+        localFunction: methodElement)
       ..sourceInformation = sourceInformationBuilder.buildCreate(node));
   }
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     assert(isReachable);
     visit(node.function);
     LocalFunctionElement localFunction =
         elements.getFunctionDefinition(node.function);
     localsHandler.updateLocal(localFunction, pop());
   }
@@ skipping 4919 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }