Compute closure model during resolution

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';
 import '../elements/entities.dart';
 import '../elements/entity_utils.dart' as utils;
 import '../elements/names.dart' show Name;
 import '../kernel/element_map.dart';
 import '../world.dart';
 import 'elements.dart';
 import 'closure_visitors.dart';
 import 'locals.dart';
 
+class KernelClosureAnalysis {
+  /// Inspect members and mark if those members capture any state that needs to
+  /// be marked as free variables.
+  static ClosureModel computeClosureModel(MemberEntity entity, ir.Member node) {
+    if (entity.isAbstract) return null;
+    if (entity.isField && !entity.isInstanceMember) {
+      ir.Field field = node;
+      // Skip top-level/static fields without an initializer.
+      if (field.initializer == null) return null;
+    }
+
+    ClosureModel model = new ClosureModel();
+    CapturedScopeBuilder translator = new CapturedScopeBuilder(model,
+        hasThisLocal: entity.isInstanceMember || entity.isConstructor);
+    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 model;
+  }
+}
+
 /// Closure conversion code using our new Entity model. Closure conversion is
 /// necessary because the semantics of closures are slightly different in Dart
 /// than JavaScript. Closure conversion is separated out into two phases:
 /// generation of a new (temporary) representation to store where variables need
 /// to be hoisted/captured up at another level to re-write the closure, and then
 /// the code generation phase where we generate elements and/or instructions to
 /// represent this new code path.
 ///
 /// For a general explanation of how closure conversion works at a high level,
 /// check out:
 /// http://siek.blogspot.com/2012/07/essence-of-closure-conversion.html or
 /// http://matt.might.net/articles/closure-conversion/.
 // TODO(efortuna): Change inheritance hierarchy so that the
 // ClosureConversionTask doesn't inherit from ClosureTask because it's just a
 // glorified timer.
 class KernelClosureConversionTask extends ClosureConversionTask<ir.Node> {
   final KernelToElementMapForBuilding _elementMap;
   final GlobalLocalsMap _globalLocalsMap;
+  final Map<MemberEntity, ClosureModel> _closureModels;
 
   /// Map of the scoping information that corresponds to a particular entity.
   Map<Entity, ScopeInfo> _scopeMap = <Entity, ScopeInfo>{};
   Map<ir.Node, CapturedScope> _capturedScopesMap = <ir.Node, CapturedScope>{};
 
   Map<Entity, ClosureRepresentationInfo> _closureRepresentationMap =
       <Entity, ClosureRepresentationInfo>{};
 
-  /// Should only be used at the very beginning to ensure we are looking at the
-  /// right kind of elements.
-  // TODO(efortuna): Remove this map once we have one kernel backend strategy.
-  final JsToFrontendMap _kToJElementMap;
-
   KernelClosureConversionTask(Measurer measurer, this._elementMap,
-      this._kToJElementMap, this._globalLocalsMap)
+      this._globalLocalsMap, this._closureModels)
       : super(measurer);
 
   /// 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) {
-    Map<MemberEntity, ClosureModel> closureModels =
-        _computeClosureModels(processedEntities);
-    _createClosureEntities(closureModels, closedWorldRefiner);
-  }
-
-  // TODO(johnniwinther,efortuna): Compute this during resolution. See
-  // documentation on [convertClosures].
-  Map<MemberEntity, ClosureModel> _computeClosureModels(
-      Iterable<MemberEntity> processedEntities) {
-    Map<MemberEntity, ClosureModel> closureModels =
-        <MemberEntity, ClosureModel>{};
-
-    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;
-      }
-      closureModels[entity] = _buildClosureModel(entity);
-    });
-    return closureModels;
+    _createClosureEntities(_closureModels, closedWorldRefiner);
   }
 
   void _createClosureEntities(Map<MemberEntity, ClosureModel> closureModels,
       ClosedWorldRefiner closedWorldRefiner) {
     closureModels.forEach((MemberEntity member, ClosureModel model) {
       KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(member);
       if (model.scopeInfo != null) {
         _scopeMap[member] = new JsScopeInfo.from(model.scopeInfo, localsMap);
       }
 
       model.capturedScopesMap
           .forEach((ir.Node node, KernelCapturedScope scope) {
         if (scope is KernelCapturedLoopScope) {
           _capturedScopesMap[node] =
               new JsCapturedLoopScope.from(scope, localsMap);
         } else {
           _capturedScopesMap[node] = new JsCapturedScope.from(scope, localsMap);
         }
       });
 
       Map<ir.TreeNode, KernelScopeInfo> closuresToGenerate =
           model.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.
-  ClosureModel _buildClosureModel(MemberEntity entity) {
-    ClosureModel model = new ClosureModel();
-    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;
-    CapturedScopeBuilder translator = new CapturedScopeBuilder(model,
-        hasThisLocal: entity.isInstanceMember || entity.isConstructor);
-    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 model;
-  }
-
   /// 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,
       KernelScopeInfo info,
@@ skipping 350 matching lines @@
   KernelScopeInfo scopeInfo;
 
   /// Collected [CapturedScope] data for nodes.
   Map<ir.Node, KernelCapturedScope> capturedScopesMap =
       <ir.Node, KernelCapturedScope>{};
 
   /// Collected [ScopeInfo] data for nodes.
   Map<ir.TreeNode, KernelScopeInfo> closuresToGenerate =
       <ir.TreeNode, KernelScopeInfo>{};
 }