Move .getLocalFunction from KernelToElementMap to KernelToLocalsMap

pkg/compiler/lib/src/js_model/closure.dart

 // Copyright (c) 2017, 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 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/tasks.dart';
 import '../elements/elements.dart';
@@ skipping 43 matching lines @@
 
   /// The combined steps of generating our intermediate representation of
   /// closures that need to be rewritten and generating the element model.
   /// Ultimately these two steps will be split apart with the second step
   /// happening later in compilation just before codegen. These steps are
   /// combined here currently to provide a consistent interface to the rest of
   /// the compiler until we are ready to separate these phases.
   @override
   void convertClosures(Iterable<MemberEntity> processedEntities,
       ClosedWorldRefiner closedWorldRefiner) {
-    var closuresToGenerate = <ir.TreeNode, ScopeInfo>{};
+    var closuresToGenerate = <MemberEntity, Map<ir.TreeNode, ScopeInfo>>{};
+
     processedEntities.forEach((MemberEntity kEntity) {
       MemberEntity entity = _kToJElementMap.toBackendMember(kEntity);
       if (entity.isAbstract) return;
       if (entity.isField && !entity.isInstanceMember) {
         MemberDefinition definition = _elementMap.getMemberDefinition(entity);
         assert(definition.kind == MemberKind.regular,
             failedAt(entity, "Unexpected member definition $definition"));
         ir.Field field = definition.node;
         // Skip top-level/static fields without an initializer.
         if (field.initializer == null) return;
       }
-      _buildClosureModel(entity, closuresToGenerate, closedWorldRefiner);
+      closuresToGenerate[entity] =
+          _buildClosureModel(entity, closedWorldRefiner);
     });
 
-    for (ir.TreeNode node in closuresToGenerate.keys) {
-      _produceSyntheticElements(
-          node, closuresToGenerate[node], closedWorldRefiner);
-    }
+    closuresToGenerate.forEach(
+        (MemberEntity member, Map<ir.TreeNode, ScopeInfo> closuresToGenerate) {
+      for (ir.TreeNode node in closuresToGenerate.keys) {
+        _produceSyntheticElements(
+            member, node, closuresToGenerate[node], closedWorldRefiner);
+      }
+    });
   }
 
   /// Inspect members and mark if those members capture any state that needs to
   /// be marked as free variables.
-  void _buildClosureModel(
-      MemberEntity entity,
-      Map<ir.TreeNode, ScopeInfo> closuresToGenerate,
-      ClosedWorldRefiner closedWorldRefiner) {
-    if (_scopeMap.keys.contains(entity)) return;
+  Map<ir.TreeNode, ScopeInfo> _buildClosureModel(
+      MemberEntity entity, ClosedWorldRefiner closedWorldRefiner) {
+    assert(!_scopeMap.containsKey(entity),
+        failedAt(entity, "ScopeInfo already computed for $entity."));
+    Map<ir.TreeNode, ScopeInfo> closuresToGenerate = <ir.TreeNode, ScopeInfo>{};
     MemberDefinition definition = _elementMap.getMemberDefinition(entity);
     switch (definition.kind) {
       case MemberKind.regular:
       case MemberKind.constructor:
         break;
       default:
         failedAt(entity, "Unexpected member definition $definition");
     }
     ir.Node node = definition.node;
-    if (_capturedScopesMap.keys.contains(node)) return;
+    assert(!_scopeMap.containsKey(entity),
+        failedAt(entity, "CaptureScope already computed for $node."));
     CapturedScopeBuilder translator = new CapturedScopeBuilder(
         entity,
         _capturedScopesMap,
         _scopeMap,
         closuresToGenerate,
-        _globalLocalsMap.getLocalsMap(entity),
-        _elementMap);
+        _globalLocalsMap.getLocalsMap(entity));
     if (entity.isField) {
       if (node is ir.Field && node.initializer != null) {
         translator.translateLazyInitializer(node);
       }
     } else {
       assert(node is ir.Procedure || node is ir.Constructor);
       translator.translateConstructorOrProcedure(node);
     }
+    return closuresToGenerate;
   }
 
   /// Given what variables are captured at each point, construct closure classes
   /// with fields containing the captured variables to replicate the Dart
   /// closure semantics in JS. If this closure captures any variables (meaning
   /// the closure accesses a variable that gets accessed at some point), then
   /// boxForCapturedVariables stores the local context for those variables.
   /// If no variables are captured, this parameter is null.
   void _produceSyntheticElements(
+      MemberEntity member,
       ir.TreeNode /* ir.Member | ir.FunctionNode */ node,
       ScopeInfo info,
       ClosedWorldRefiner closedWorldRefiner) {
+    String name = _computeClosureName(node);
+    KernelClosureClass closureClass = new KernelClosureClass.fromScopeInfo(
+        name, member.library, info, node.location);
+
     Entity entity;
-    ir.Library library;
     if (node is ir.Member) {
-      entity = _elementMap.getMember(node);
-      library = node.enclosingLibrary;
+      entity = member;
     } else {
       assert(node is ir.FunctionNode);
-      entity = _elementMap.getLocalFunction(node.parent);
-      // TODO(efortuna): Consider the less roundabout way of getting this value
-      // which is just storing the "enclosingLibrary" value of the original call
-      // to CapturedScopeBuilder.
-      ir.TreeNode temp = node;
-      while (temp != null && temp is! ir.Library) {
-        temp = temp.parent;
-      }
-      assert(temp is ir.Library);
-      library = temp;
+      KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(member);
+      entity = localsMap.getLocalFunction(node.parent);
+      // We want the original declaration where that function is used to point
+      // to the correct closure class.
+      _closureRepresentationMap[closureClass.callMethod] = closureClass;
     }
     assert(entity != null);
-
-    String name = _computeClosureName(node);
-    KernelClosureClass closureClass = new KernelClosureClass.fromScopeInfo(
-        name, _elementMap.getLibrary(library), info, node.location);
-    if (node is ir.FunctionNode) {
-      // We want the original declaration where that function is used to point
-      // to the correct closure class.
-      // TODO(efortuna): entity equivalent of element.declaration?
-      node = (node as ir.FunctionNode).parent;
-      _closureRepresentationMap[closureClass.callMethod] = closureClass;
-    }
-
     _closureRepresentationMap[entity] = closureClass;
 
     // Register that a new class has been created.
-    closedWorldRefiner.registerClosureClass(
-        closureClass, node is ir.Member && node.isInstanceMember);
+    closedWorldRefiner.registerClosureClass(closureClass);
   }
 
   // Returns a non-unique name for the given closure element.
   String _computeClosureName(ir.TreeNode treeNode) {
     var parts = <String>[];
     if (treeNode is ir.Field && treeNode.name.name != "") {
       parts.add(treeNode.name.name);
     } else {
       parts.add('closure');
     }
@@ skipping 173 matching lines @@
   KernelClosureClass.fromScopeInfo(
       this.name, this.library, KernelScopeInfo info, this.location)
       : super.from(info.thisLocal, info) {
     // Make a corresponding field entity in this closure class for every single
     // freeVariable in the KernelScopeInfo.freeVariable.
     int i = 0;
     for (ir.VariableDeclaration variable in info.freeVariables) {
       // NOTE: This construction order may be slightly different than the
       // old Element version. The old version did all the boxed items and then
       // all the others.
-      Local capturedLocal = info.localsMap.getLocal(variable);
+      Local capturedLocal = info.localsMap.getLocalVariable(variable);
       if (info.isBoxed(capturedLocal)) {
         // TODO(efortuna): Coming soon.
       } else {
         localToFieldMap[capturedLocal] = new ClosureField(
             _getClosureVariableName(capturedLocal.name, i),
             this,
             variable.isConst,
             variable.isFinal || variable.isConst);
         // TODO(efortuna): These probably need to get registered somewhere.
       }
@@ skipping 65 matching lines @@
   ClosureClassDefinition(this.cls, this.location);
 
   ClassKind get kind => ClassKind.closure;
 
   ir.Node get node =>
       throw new UnsupportedError('ClosureClassDefinition.node for $cls');
 
   String toString() =>
       'ClosureClassDefinition(kind:$kind,cls:$cls,location:$location)';
 }