Add ClosureRepresentationInfo, the new public face of ClosureClassMap

pkg/compiler/lib/src/ssa/locals_handler.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 '../closure.dart';
 import '../common.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
 import '../io/source_information.dart';
@@ skipping 14 matching lines @@
   /// The values of locals that can be directly accessed (without redirections
   /// to boxes or closure-fields).
   ///
   /// [directLocals] is iterated, so it is "insertion ordered" to make the
   /// iteration order a function only of insertions and not a function of
   /// e.g. Element hash codes.  I'd prefer to use a SortedMap but some elements
   /// don't have source locations for [Elements.compareByPosition].
   Map<Local, HInstruction> directLocals = new Map<Local, HInstruction>();
   Map<Local, FieldEntity> redirectionMapping = new Map<Local, FieldEntity>();
   final GraphBuilder builder;
-  ClosureClassMap closureData;
+  ClosureRepresentationInfo closureData;
   Map<TypeVariableType, TypeVariableLocal> typeVariableLocals =
       new Map<TypeVariableType, TypeVariableLocal>();
   final Entity executableContext;
   final MemberEntity memberContext;
 
   /// The class that defines the current type environment or null if no type
   /// variables are in scope.
   final ClassEntity contextClass;
 
   /// The type of the current instance, if concrete.
@@ skipping 143 matching lines @@
       HInstruction oldValue = readLocal(boxedVariable);
       updateLocal(boxElement, newBox);
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
   /// Documentation wanted -- johnniwinther
   ///
   /// Invariant: [function] must be an implementation element.
-  void startFunction(MemberEntity element, ClosureClassMap closureData,
-      ClosureScope scopeData, Map<Local, TypeMask> parameters,
+  void startFunction(
+      MemberEntity element,
+      ClosureRepresentationInfo closureData,
+      ClosureAnalysisInfo scopeData,
+      Map<Local, TypeMask> parameters,
       {bool isGenerativeConstructorBody}) {
     assert(!(element is MemberElement && !element.isImplementation),
         failedAt(element));
     this.closureData = closureData;
 
     parameters.forEach((Local local, TypeMask typeMask) {
       if (isGenerativeConstructorBody) {
-        if (scopeData != null && scopeData.isCaptured(local)) {
+        if (scopeData.isCaptured(local)) {
           // The parameter will be a field in the box passed as the
           // last parameter. So no need to have it.
           return;
         }
       }
       HInstruction parameter = builder.addParameter(local, typeMask);
       builder.parameters[local] = parameter;
       directLocals[local] = parameter;
     });
 
-    if (scopeData != null) {
-      // TODO(efortuna): Remove the above if wrapper (always execute this step)
-      // when the switch away from ClosureClassMap is complete (prior behavior
-      // in enterScope it was acceptable to pass in a null scopeData, but no
-      // longer).
-      enterScope(scopeData,
-          forGenerativeConstructorBody: isGenerativeConstructorBody);
-    }
+    enterScope(scopeData,
+        forGenerativeConstructorBody: isGenerativeConstructorBody);
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.forEachFreeVariable((Local from, FieldEntity to) {
       redirectElement(from, to);
     });
     if (closureData.isClosure) {
       // Inside closure redirect references to itself to [:this:].
       HThis thisInstruction =
           new HThis(closureData.thisLocal, commonMasks.nonNullType);
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
-      updateLocal(closureData.closureElement, thisInstruction);
+      updateLocal(closureData.closureEntity, thisInstruction);
     } else if (element.isInstanceMember) {
       // Once closures have been mapped to classes their instance members might
       // not have any thisElement if the closure was created inside a static
       // context.
       HThis thisInstruction = new HThis(closureData.thisLocal, getTypeOfThis());
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
       directLocals[closureData.thisLocal] = thisInstruction;
     }
 
@@ skipping 37 matching lines @@
         builder.lastAddedParameter = value;
       }
     }
   }
 
   /// Returns true if the local can be accessed directly. Boxed variables or
   /// captured variables that are stored in the closure-field return [:false:].
   bool isAccessedDirectly(Local local) {
     assert(local != null);
     return !redirectionMapping.containsKey(local) &&
-        !closureData.variablesUsedInTryOrGenerator.contains(local);
+        !closureData.variableIsUsedInTryOrSync(local);
   }
 
   bool isStoredInClosureField(Local local) {
     assert(local != null);
     if (isAccessedDirectly(local)) return false;
     FieldEntity redirectTarget = redirectionMapping[local];
     if (redirectTarget == null) return false;
     return redirectTarget is ClosureFieldElement;
   }
 
   bool isBoxed(Local local) {
     if (isAccessedDirectly(local)) return false;
     if (isStoredInClosureField(local)) return false;
     return redirectionMapping.containsKey(local);
   }
 
   bool isUsedInTryOrGenerator(Local local) {
-    return closureData.variablesUsedInTryOrGenerator.contains(local);
+    return closureData.variableIsUsedInTryOrSync(local);
   }
 
   /// Returns an [HInstruction] for the given element. If the element is
   /// boxed or stored in a closure then the method generates code to retrieve
   /// the value.
   HInstruction readLocal(Local local, {SourceInformation sourceInformation}) {
     if (isAccessedDirectly(local)) {
       if (directLocals[local] == null) {
         if (local is TypeVariableLocal) {
           throw new SpannableAssertionFailure(
               CURRENT_ELEMENT_SPANNABLE,
               "Runtime type information not available for $local "
               "in $executableContext.");
         } else {
           throw new SpannableAssertionFailure(
               local,
               "Cannot find value $local in ${directLocals.keys} for "
               "$executableContext.");
         }
       }
       HInstruction value = directLocals[local];
       if (sourceInformation != null) {
         value = new HRef(value, sourceInformation);
         builder.add(value);
       }
       return value;
     } else if (isStoredInClosureField(local)) {
       ClosureFieldElement redirect = redirectionMapping[local];
-      HInstruction receiver = readLocal(closureData.closureElement);
+      HInstruction receiver = readLocal(closureData.closureEntity);
       TypeMask type = local is BoxLocal
           ? commonMasks.nonNullType
           : getTypeOfCapturedVariable(redirect);
       HInstruction fieldGet = new HFieldGet(redirect, receiver, type);
       builder.add(fieldGet);
       return fieldGet..sourceInformation = sourceInformation;
     } else if (isBoxed(local)) {
       BoxFieldElement redirect = redirectionMapping[local];
       // In the function that declares the captured variable the box is
       // accessed as direct local. Inside the nested closure the box is
@@ skipping 320 matching lines @@
   final MemberEntity memberContext;
 
   // Avoid slow Object.hashCode.
   final int hashCode = _nextHashCode = (_nextHashCode + 1).toUnsigned(30);
   static int _nextHashCode = 0;
 
   SyntheticLocal(this.name, this.executableContext, this.memberContext);
 
   toString() => 'SyntheticLocal($name)';
 }