Add ScopeInfo class for variable information that doesn't actually involve closures.

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;
-  ClosureRepresentationInfo closureData;
+  ScopeInfo scopeInfo;
   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 60 matching lines @@
   /// copy the [directLocals], since the other fields can be shared
   /// throughout the AST visit.
   LocalsHandler.from(LocalsHandler other)
       : directLocals = new Map<Local, HInstruction>.from(other.directLocals),
         redirectionMapping = other.redirectionMapping,
         executableContext = other.executableContext,
         memberContext = other.memberContext,
         contextClass = other.contextClass,
         instanceType = other.instanceType,
         builder = other.builder,
-        closureData = other.closureData,
+        scopeInfo = other.scopeInfo,
         _nativeData = other._nativeData,
         _interceptorData = other._interceptorData,
         activationVariables = other.activationVariables,
         cachedTypeOfThis = other.cachedTypeOfThis,
         cachedTypesOfCapturedVariables = other.cachedTypesOfCapturedVariables;
 
   /// Redirects accesses from element [from] to element [to]. The [to] element
   /// must be a boxed variable or a variable that is stored in a closure-field.
   void redirectElement(Local from, FieldEntity to) {
     assert(redirectionMapping[from] == null);
@@ skipping 63 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,
-      ClosureRepresentationInfo closureData,
-      ClosureAnalysisInfo scopeData,
-      Map<Local, TypeMask> parameters,
+  void startFunction(MemberEntity element, ScopeInfo scopeInfo,
+      ClosureAnalysisInfo scopeData, Map<Local, TypeMask> parameters,
       {bool isGenerativeConstructorBody}) {
     assert(!(element is MemberElement && !element.isImplementation),
         failedAt(element));
-    this.closureData = closureData;
+    this.scopeInfo = scopeInfo;
 
     parameters.forEach((Local local, TypeMask typeMask) {
       if (isGenerativeConstructorBody) {
         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;
     });
 
     enterScope(scopeData,
         forGenerativeConstructorBody: isGenerativeConstructorBody);
 
-    if (closureData.isClosure) {
+    // When we remove the element model, we can just use the first check
+    // (because the underlying elements won't all be *both* ScopeInfos and
+    // ClosureRepresentationInfos).
+    if (scopeInfo is ClosureRepresentationInfo && scopeInfo.isClosure) {
+      ClosureRepresentationInfo closureData = scopeInfo;
       // 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);
       });
       // 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.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());
+      HThis thisInstruction = new HThis(scopeInfo.thisLocal, getTypeOfThis());
       builder.graph.thisInstruction = thisInstruction;
       builder.graph.entry.addAtEntry(thisInstruction);
-      directLocals[closureData.thisLocal] = thisInstruction;
+      directLocals[scopeInfo.thisLocal] = thisInstruction;
     }
 
     // If this method is an intercepted method, add the extra
     // parameter to it, that is the actual receiver for intercepted
     // classes, or the same as [:this:] for non-intercepted classes.
     ClassEntity cls = element.enclosingClass;
 
     // When the class extends a native class, the instance is pre-constructed
     // and passed to the generative constructor factory function as a parameter.
     // Instead of allocating and initializing the object, the constructor
     // 'upgrades' the native subclass object by initializing the Dart fields.
     bool isNativeUpgradeFactory = element is ConstructorEntity &&
         element.isGenerativeConstructor &&
         _nativeData.isNativeOrExtendsNative(cls);
     if (_interceptorData.isInterceptedMethod(element)) {
       bool isInterceptedClass = _interceptorData.isInterceptedClass(cls);
       String name = isInterceptedClass ? 'receiver' : '_';
       SyntheticLocal parameter = createLocal(name);
       HParameterValue value = new HParameterValue(parameter, getTypeOfThis());
       builder.graph.explicitReceiverParameter = value;
-      builder.graph.entry.addAfter(directLocals[closureData.thisLocal], value);
+      builder.graph.entry.addAfter(directLocals[scopeInfo.thisLocal], value);
       if (builder.lastAddedParameter == null) {
         // If this is the first parameter inserted, make sure it stays first.
         builder.lastAddedParameter = value;
       }
       if (isInterceptedClass) {
         // Only use the extra parameter in intercepted classes.
-        directLocals[closureData.thisLocal] = value;
+        directLocals[scopeInfo.thisLocal] = value;
       }
     } else if (isNativeUpgradeFactory) {
       SyntheticLocal parameter = createLocal('receiver');
       // Unlike `this`, receiver is nullable since direct calls to generative
       // constructor call the constructor with `null`.
       HParameterValue value =
           new HParameterValue(parameter, new TypeMask.exact(cls, closedWorld));
       builder.graph.explicitReceiverParameter = value;
       builder.graph.entry.addAtEntry(value);
       if (builder.lastAddedParameter == null) {
         // If this is the first parameter inserted, make sure it stays first.
         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.variableIsUsedInTryOrSync(local);
+        !scopeInfo.variableIsUsedInTryOrSync(local);
   }
 
   bool isStoredInClosureField(Local local) {
     assert(local != null);
     if (isAccessedDirectly(local)) return false;
+    if (scopeInfo is! ClosureRepresentationInfo) 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.variableIsUsedInTryOrSync(local);
+    return scopeInfo.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)) {
+      ClosureRepresentationInfo closureData = scopeInfo;
       ClosureFieldElement redirect = redirectionMapping[local];
       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];
@@ skipping 11 matching lines @@
       assert(_isUsedInTryOrGenerator(local));
       HLocalValue localValue = getLocal(local);
       HInstruction instruction = new HLocalGet(
           local, localValue, commonMasks.dynamicType, sourceInformation);
       builder.add(instruction);
       return instruction;
     }
   }
 
   HInstruction readThis() {
-    HInstruction res = readLocal(closureData.thisLocal);
+    HInstruction res = readLocal(scopeInfo.thisLocal);
     if (res.instructionType == null) {
       res.instructionType = getTypeOfThis();
     }
     return res;
   }
 
   HLocalValue getLocal(Local local, {SourceInformation sourceInformation}) {
     // If the element is a parameter, we already have a
     // HParameterValue for it. We cannot create another one because
     // it could then have another name than the real parameter. And
@@ skipping 103 matching lines @@
   /// from the back edge).  Populate the phis with the current values.
   void beginLoopHeader(HBasicBlock loopEntry) {
     // Create a copy because we modify the map while iterating over it.
     Map<Local, HInstruction> savedDirectLocals =
         new Map<Local, HInstruction>.from(directLocals);
 
     // Create phis for all elements in the definitions environment.
     savedDirectLocals.forEach((Local local, HInstruction instruction) {
       if (isAccessedDirectly(local)) {
         // We know 'this' cannot be modified.
-        if (local != closureData.thisLocal) {
+        if (local != scopeInfo.thisLocal) {
           HPhi phi =
               new HPhi.singleInput(local, instruction, commonMasks.dynamicType);
           loopEntry.addPhi(phi);
           directLocals[local] = phi;
         } else {
           directLocals[local] = instruction;
         }
       }
     });
   }
@@ skipping 36 matching lines @@
   /// first input, and the otherLocals instruction as the second.
   void mergeWith(LocalsHandler otherLocals, HBasicBlock joinBlock) {
     // If an element is in one map but not the other we can safely
     // ignore it. It means that a variable was declared in the
     // block. Since variable declarations are scoped the declared
     // variable cannot be alive outside the block. Note: this is only
     // true for nodes where we do joins.
     Map<Local, HInstruction> joinedLocals = new Map<Local, HInstruction>();
     otherLocals.directLocals.forEach((Local local, HInstruction instruction) {
       // We know 'this' cannot be modified.
-      if (local == closureData.thisLocal) {
+      if (local == scopeInfo.thisLocal) {
         assert(directLocals[local] == instruction);
         joinedLocals[local] = instruction;
       } else {
         HInstruction mine = directLocals[local];
         if (mine == null) return;
         if (identical(instruction, mine)) {
           joinedLocals[local] = instruction;
         } else {
           HInstruction phi = new HPhi.manyInputs(local,
               <HInstruction>[mine, instruction], commonMasks.dynamicType);
@@ skipping 10 matching lines @@
   /// returned.  Unless it is also in the list, the current localsHandler is not
   /// used for its values, only for its declared variables. This is a way to
   /// exclude local values from the result when they are no longer in scope.
   LocalsHandler mergeMultiple(
       List<LocalsHandler> localsHandlers, HBasicBlock joinBlock) {
     assert(localsHandlers.length > 0);
     if (localsHandlers.length == 1) return localsHandlers.single;
     Map<Local, HInstruction> joinedLocals = new Map<Local, HInstruction>();
     HInstruction thisValue = null;
     directLocals.forEach((Local local, HInstruction instruction) {
-      if (local != closureData.thisLocal) {
+      if (local != scopeInfo.thisLocal) {
         HPhi phi = new HPhi.noInputs(local, commonMasks.dynamicType);
         joinedLocals[local] = phi;
         joinBlock.addPhi(phi);
       } else {
         // We know that "this" never changes, if it's there.
         // Save it for later. While merging, there is no phi for "this",
         // so we don't have to special case it in the merge loop.
         thisValue = instruction;
       }
     });
     for (LocalsHandler handler in localsHandlers) {
       handler.directLocals.forEach((Local local, HInstruction instruction) {
         HPhi phi = joinedLocals[local];
         if (phi != null) {
           phi.addInput(instruction);
         }
       });
     }
     if (thisValue != null) {
       // If there was a "this" for the scope, add it to the new locals.
-      joinedLocals[closureData.thisLocal] = thisValue;
+      joinedLocals[scopeInfo.thisLocal] = thisValue;
     }
 
     // Remove locals that are not in all handlers.
     directLocals = new Map<Local, HInstruction>();
     joinedLocals.forEach((Local local, HInstruction instruction) {
-      if (local != closureData.thisLocal &&
+      if (local != scopeInfo.thisLocal &&
           instruction.inputs.length != localsHandlers.length) {
         joinBlock.removePhi(instruction);
       } else {
         directLocals[local] = instruction;
       }
     });
     return this;
   }
 
   TypeMask cachedTypeOfThis;
 
   TypeMask getTypeOfThis() {
     TypeMask result = cachedTypeOfThis;
     if (result == null) {
-      ThisLocal local = closureData.thisLocal;
+      ThisLocal local = scopeInfo.thisLocal;
       ClassEntity cls = local.enclosingClass;
       if (closedWorld.isUsedAsMixin(cls)) {
         // If the enclosing class is used as a mixin, [:this:] can be
         // of the class that mixins the enclosing class. These two
         // classes do not have a subclass relationship, so, for
         // simplicity, we mark the type as an interface type.
         result = new TypeMask.nonNullSubtype(cls, closedWorld);
       } else {
         result = new TypeMask.nonNullSubclass(cls, closedWorld);
       }
@@ skipping 32 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)';
 }