Use closure conversion in new dart2js backend.

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 "elements/elements.dart";
 import "dart2jslib.dart";
 import "dart_types.dart";
 import "js_backend/js_backend.dart" show JavaScriptBackend;
@@ skipping 86 matching lines @@
 }
 
 /// Common interface for [BoxFieldElement] and [ClosureFieldElement] as
 /// non-elements.
 abstract class CapturedVariable {}
 
 // TODO(ahe): These classes continuously cause problems.  We need to
 // find a more general solution.
 class ClosureFieldElement extends ElementX
     implements VariableElement, CapturedVariable {
-  /// The source variable this element refers to.
+  /// The [BoxLocal] or [LocalElement] being accessed through the field.
   final Local local;
 
   ClosureFieldElement(String name,
                       this.local,
                       ClosureClassElement enclosing)
       : super(name, ElementKind.FIELD, enclosing);
 
   /// Use [closureClass] instead.
   @deprecated
   get enclosingElement => super.enclosingElement;
@@ skipping 176 matching lines @@
   ResolvedAst get resolvedAst {
     return new ResolvedAst(this, node, treeElements);
   }
 
   Element get analyzableElement => closureClass.methodElement.analyzableElement;
 }
 
 // The box-element for a scope, and the captured variables that need to be
 // stored in the box.
 class ClosureScope {
-  BoxLocal boxElement;
-  Map<VariableElement, BoxFieldElement> _capturedVariableMapping;
+  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>[];
 
-  ClosureScope(this.boxElement, this._capturedVariableMapping);
+  ClosureScope(this.boxElement, this.capturedVariables);
 
   bool hasBoxedLoopVariables() => !boxedLoopVariables.isEmpty;
 
   bool isCapturedVariable(VariableElement variable) {
-    return _capturedVariableMapping.containsKey(variable);
+    return capturedVariables.containsKey(variable);
   }
 
   void forEachCapturedVariable(f(LocalVariableElement variable,
                                  BoxFieldElement boxField)) {
-    _capturedVariableMapping.forEach(f);
+    capturedVariables.forEach(f);
   }
 }
 
 class ClosureClassMap {
   // The closure's element before any translation. Will be null for methods.
   final LocalFunctionElement closureElement;
   // The closureClassElement will be null for methods that are not local
   // closures.
   final ClosureClassElement closureClassElement;
   // The callElement will be null for methods that are not local closures.
   final FunctionElement 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 and function elements to their captured
-  // copies.
-  final Map<Local, CapturedVariable> _freeVariableMapping =
+  // Maps free locals, arguments, function elements, and box locals to
+  // their locations.
+  final Map<Local, CapturedVariable> freeVariableMap =
       new Map<Local, CapturedVariable>();
 
-  // Maps closure-fields to their captured elements. This is somehow the inverse
-  // mapping of [freeVariableMapping], but whereas [freeVariableMapping] does
-  // not deal with boxes, here we map instance-fields (which might represent
-  // boxes) to their boxElement.
-  final Map<ClosureFieldElement, Local> _closureFieldMapping =
-      new Map<ClosureFieldElement, Local>();
-
-  // Maps scopes ([Loop] and [FunctionExpression] nodes) to their
+  // 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>();
 
   final Set<Local> usedVariablesInTry = new Set<Local>();
 
   ClosureClassMap(this.closureElement,
                   this.closureClassElement,
                   this.callElement,
                   this.thisLocal);
 
   void addFreeVariable(Local element) {
-    assert(_freeVariableMapping[element] == null);
-    _freeVariableMapping[element] = null;
+    assert(freeVariableMap[element] == null);
+    freeVariableMap[element] = null;
   }
 
-  Iterable<Local> get freeVariables => _freeVariableMapping.keys;
+  Iterable<Local> get freeVariables => freeVariableMap.keys;
 
   bool isFreeVariable(Local element) {
-    return _freeVariableMapping.containsKey(element);
+    return freeVariableMap.containsKey(element);
   }
 
-  CapturedVariable getFreeVariableElement(Local element) {
-    return _freeVariableMapping[element];
-  }
-
-  /// Sets the free [variable] to be captured by the [boxField].
-  void setFreeVariableBoxField(Local variable,
-                               BoxFieldElement boxField) {
-    _freeVariableMapping[variable] = boxField;
-  }
-
-  /// Sets the free [variable] to be captured by the [closureField].
-  void setFreeVariableClosureField(Local variable,
-                                   ClosureFieldElement closureField) {
-    _freeVariableMapping[variable] = closureField;
-  }
-
-
   void forEachFreeVariable(f(Local variable,
                              CapturedVariable field)) {
-    _freeVariableMapping.forEach(f);
+    freeVariableMap.forEach(f);
   }
 
   Local getLocalVariableForClosureField(ClosureFieldElement field) {
-    return _closureFieldMapping[field];
-  }
-
-  void setLocalVariableForClosureField(ClosureFieldElement field,
-      Local variable) {
-    _closureFieldMapping[field] = variable;
+    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 = _freeVariableMapping[variable];
+    CapturedVariable copy = freeVariableMap[variable];
     if (copy is BoxFieldElement) {
       return true;
     }
     return capturingScopesBox(variable);
   }
 
   void forEachCapturedVariable(void f(Local variable,
                                       CapturedVariable field)) {
-    _freeVariableMapping.forEach((variable, copy) {
+    freeVariableMap.forEach((variable, copy) {
       if (variable is BoxLocal) return;
       f(variable, copy);
     });
     capturingScopes.values.forEach((ClosureScope scope) {
       scope.forEachCapturedVariable(f);
     });
   }
 
   void forEachBoxedVariable(void f(LocalVariableElement local,
                                    BoxFieldElement field)) {
-    _freeVariableMapping.forEach((variable, copy) {
+    freeVariableMap.forEach((variable, copy) {
       if (!isVariableBoxed(variable)) return;
       f(variable, copy);
     });
     capturingScopes.values.forEach((ClosureScope scope) {
       scope.forEachCapturedVariable(f);
     });
   }
 
   void removeMyselfFrom(Universe universe) {
-    _freeVariableMapping.values.forEach((e) {
+    freeVariableMap.values.forEach((e) {
       universe.closurizedMembers.remove(e);
       universe.fieldSetters.remove(e);
       universe.fieldGetters.remove(e);
     });
   }
 }
 
 class ClosureTranslator extends Visitor {
   final Compiler compiler;
   final TreeElements elements;
@@ skipping 81 matching lines @@
       // The captured variables that need to be stored in a field of the closure
       // class.
       Set<Local> fieldCaptures = new Set<Local>();
       Set<BoxLocal> boxes = new Set<BoxLocal>();
       ClosureClassMap data = closureMappingCache[closure];
       // We get a copy of the keys and iterate over it, to avoid modifications
       // to the map while iterating over it.
       Iterable<Local> freeVariables = data.freeVariables.toList();
       freeVariables.forEach((Local fromElement) {
         assert(data.isFreeVariable(fromElement));
-        assert(data.getFreeVariableElement(fromElement) == null);
+        assert(data.freeVariableMap[fromElement] == null);
         assert(isCapturedVariable(fromElement));
         BoxFieldElement boxFieldElement =
             getCapturedVariableBoxField(fromElement);
         if (boxFieldElement == null) {
           assert(fromElement is! BoxLocal);
           // The variable has not been boxed.
           fieldCaptures.add(fromElement);
         } else {
           // A boxed element.
-          data.setFreeVariableBoxField(fromElement, boxFieldElement);
+          data.freeVariableMap[fromElement] = boxFieldElement;
           boxes.add(boxFieldElement.box);
         }
       });
       ClosureClassElement closureClass = data.closureClassElement;
       assert(closureClass != null ||
              (fieldCaptures.isEmpty && boxes.isEmpty));
 
       void addClosureField(Local local, String name) {
         ClosureFieldElement closureField =
             new ClosureFieldElement(name, local, closureClass);
         closureClass.addField(closureField, compiler);
-        data.setLocalVariableForClosureField(closureField, local);
-        data.setFreeVariableClosureField(local, closureField);
+        data.freeVariableMap[local] = closureField;
       }
 
       // Add the box elements first so we get the same ordering.
       // TODO(sra): What is the canonical order of multiple boxes?
       for (BoxLocal capturedElement in boxes) {
         addClosureField(capturedElement, capturedElement.name);
       }
 
       /// Comparator for locals. Position boxes before elements.
       int compareLocals(a, b) {
@@ skipping 441 matching lines @@
 
   String get name => typeVariable.name;
 
   int get hashCode => typeVariable.hashCode;
 
   bool operator ==(other) {
     if (other is! TypeVariableLocal) return false;
     return typeVariable == other.typeVariable;
   }
 }