Entity-ify some portions of LocalsHandler and Closure.

pkg/compiler/lib/src/closure.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.
 
 library closureToClassMapper;
 
 import 'common/names.dart' show Identifiers;
 import 'common/resolution.dart' show ParsingContext, Resolution;
 import 'common/tasks.dart' show CompilerTask;
 import 'common.dart';
@@ skipping 115 matching lines @@
             failedAt(element, "No ClosureClassMap computed for ${element}."));
         return _closureMappingCache[element];
       });
     });
   }
 }
 
 /// Common interface for [BoxFieldElement] and [ClosureFieldElement] as
 /// non-elements.
 // TODO(johnniwinther): Remove `implements Element`.
 abstract class CapturedVariable implements Element {}

[Siggi Cherem (dart-lang), 2017/06/06 03:07:36]

I wonder if we should simply delete this type now.

Another option: rewrite as CapturedVariable implements FieldEntity

[Emily Fortuna, 2017/06/06 17:46:19]

oh good point! removed!

 
 // TODO(ahe): These classes continuously cause problems.  We need to
 // find a more general solution.
 class ClosureFieldElement extends ElementX
     implements FieldElement, CapturedVariable, PrivatelyNamedJSEntity {
   /// The [BoxLocal] or [LocalElement] being accessed through the field.
   final Local local;
 
   ClosureFieldElement(String name, this.local, ClosureClassElement enclosing)
       : super(name, ElementKind.FIELD, enclosing);
@@ skipping 268 matching lines @@
 
 // The box-element for a scope, and the captured variables that need to be
 // stored in the box.
 class ClosureScope {
   final BoxLocal boxElement;
   final Map<Local, BoxFieldElement> capturedVariables;
 
   // If the scope is attached to a [For] contains the variables that are
   // declared in the initializer of the [For] and that need to be boxed.
   // Otherwise contains the empty List.
-  List<VariableElement> boxedLoopVariables = const <VariableElement>[];
+  List<Local> boxedLoopVariables = const <Local>[];
 
   ClosureScope(this.boxElement, this.capturedVariables);
 
   bool hasBoxedLoopVariables() => !boxedLoopVariables.isEmpty;
 
   bool isCapturedVariable(VariableElement variable) {
     return capturedVariables.containsKey(variable);
   }
 
   void forEachCapturedVariable(
@@ skipping 39 matching lines @@
   ///
   /// The callElement will be null for methods that are not local closures.
   final MethodElement callElement;
 
   /// The [thisElement] makes handling 'this' easier by treating it like any
   /// other argument. It is only set for instance-members.
   final ThisLocal thisLocal;
 
   /// Maps free locals, arguments, function elements, and box locals to
   /// their locations.
-  final Map<Local, CapturedVariable> freeVariableMap =
-      new Map<Local, CapturedVariable>();
+  final Map<Local, FieldEntity> freeVariableMap = new Map<Local, FieldEntity>();
 
   /// Maps [Loop] and [FunctionExpression] nodes to their [ClosureScope] which
   /// contains their box and the captured variables that are stored in the box.
   /// This map will be empty if the method/closure of this [ClosureData] does
   /// not contain any nested closure.
   final Map<Node, ClosureScope> capturingScopes = new Map<Node, ClosureScope>();
 
   /// Variables that are used in a try must be treated as boxed because the
   /// control flow can be non-linear.
   ///
   /// Also parameters to a `sync*` generator must be boxed, because of the way
   /// we rewrite sync* functions. See also comments in [useLocal].
   // TODO(johnniwinther): Add variables to this only if the variable is mutated.
   final Set<Local> variablesUsedInTryOrGenerator = new Set<Local>();
 
   ClosureClassMap(this.closureElement, this.closureClassElement,
       this.callElement, this.thisLocal);
 
   void addFreeVariable(Local element) {
     assert(freeVariableMap[element] == null);
     freeVariableMap[element] = null;
   }
 
   Iterable<Local> get freeVariables => freeVariableMap.keys;
 
   bool isFreeVariable(Local element) {
     return freeVariableMap.containsKey(element);
   }
 
-  void forEachFreeVariable(f(Local variable, CapturedVariable field)) {
+  void forEachFreeVariable(f(Local variable, FieldEntity field)) {
     freeVariableMap.forEach(f);
   }
 
   Local getLocalVariableForClosureField(ClosureFieldElement field) {
     return field.local;
   }
 
   bool get isClosure => closureElement != null;
 
   bool capturingScopesBox(Local variable) {
     return capturingScopes.values.any((scope) {
       return scope.boxedLoopVariables.contains(variable);
     });
   }
 
   bool isVariableBoxed(Local variable) {
-    CapturedVariable copy = freeVariableMap[variable];
+    FieldEntity copy = freeVariableMap[variable];
     if (copy is BoxFieldElement) {
       return true;
     }
     return capturingScopesBox(variable);
   }
 
-  void forEachCapturedVariable(void f(Local variable, CapturedVariable field)) {
+  void forEachCapturedVariable(void f(Local variable, FieldEntity field)) {
     freeVariableMap.forEach((variable, copy) {
       if (variable is BoxLocal) return;
       f(variable, copy);
     });
     capturingScopes.values.forEach((ClosureScope scope) {
       scope.forEachCapturedVariable(f);
     });
   }
 
   void forEachBoxedVariable(
@@ skipping 687 matching lines @@
 ///
 /// Move the below classes to a JS model eventually.
 ///
 abstract class JSEntity implements Entity {
   Entity get declaredEntity;
 }
 
 abstract class PrivatelyNamedJSEntity implements JSEntity {
   Entity get rootOfScope;
 }