Compute closure model purely from IR nodes

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 = <MemberEntity, Map<ir.TreeNode, ScopeInfo>>{};
+    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;
       }
-      closuresToGenerate[entity] =
-          _buildClosureModel(entity, closedWorldRefiner);
+      closureModels[entity] = _buildClosureModel(entity);
     });
+    return closureModels;
+  }
 
-    closuresToGenerate.forEach(
-        (MemberEntity member, Map<ir.TreeNode, ScopeInfo> closuresToGenerate) {
+  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.
-  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>{};
+  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;
-    assert(!_scopeMap.containsKey(entity),
-        failedAt(entity, "CaptureScope already computed for $node."));
-    CapturedScopeBuilder translator = new CapturedScopeBuilder(
-        entity,
-        _capturedScopesMap,
-        _scopeMap,
-        closuresToGenerate,
-        _globalLocalsMap.getLocalsMap(entity));
+    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 closuresToGenerate;
+    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,
-      ScopeInfo info,
+      KernelScopeInfo info,
       ClosedWorldRefiner closedWorldRefiner) {
     String name = _computeClosureName(node);
     KernelToLocalsMap localsMap = _globalLocalsMap.getLocalsMap(member);
     KernelClosureClass closureClass = new KernelClosureClass.fromScopeInfo(
         name, member.library, info, node.location, localsMap);
 
     Entity entity;
     if (node is ir.Member) {
       entity = member;
     } else {
@@ skipping 88 matching lines @@
 
   @override
   // TODO(efortuna): Eventually closureRepresentationMap[node] should always be
   // non-null, and we should just test that with an assert.
   ClosureRepresentationInfo getClosureRepresentationInfo(Entity entity) {
     return _closureRepresentationMap[entity] ??
         const ClosureRepresentationInfo();
   }
 }
 
-class KernelScopeInfo extends ScopeInfo {
+class KernelScopeInfo {
+  final Set<ir.VariableDeclaration> localsUsedInTryOrSync;
+  final bool hasThisLocal;
+  final Set<ir.VariableDeclaration> boxedVariables;
+
+  /// The set of variables that were defined in another scope, but are used in
+  /// this scope.
+  Set<ir.VariableDeclaration> freeVariables = new Set<ir.VariableDeclaration>();
+
+  KernelScopeInfo(this.hasThisLocal)
+      : localsUsedInTryOrSync = new Set<ir.VariableDeclaration>(),
+        boxedVariables = new Set<ir.VariableDeclaration>();
+
+  KernelScopeInfo.from(this.hasThisLocal, KernelScopeInfo info)
+      : localsUsedInTryOrSync = info.localsUsedInTryOrSync,
+        boxedVariables = info.boxedVariables;
+
+  KernelScopeInfo.withBoxedVariables(this.boxedVariables,
+      this.localsUsedInTryOrSync, this.freeVariables, this.hasThisLocal);
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.write('this=$hasThisLocal,');
+    sb.write('localsUsedInTryOrSync={${localsUsedInTryOrSync.join(', ')}}');
+    return sb.toString();
+  }
+}
+
+class JsScopeInfo extends ScopeInfo {
   final Set<Local> localsUsedInTryOrSync;
   final Local thisLocal;
   final Set<Local> boxedVariables;
 
   /// The set of variables that were defined in another scope, but are used in
   /// this scope.
-  Set<ir.VariableDeclaration> freeVariables = new Set<ir.VariableDeclaration>();
+  final Set<Local> freeVariables;
 
-  KernelScopeInfo(this.thisLocal)
-      : localsUsedInTryOrSync = new Set<Local>(),
-        boxedVariables = new Set<Local>();
+  JsScopeInfo(this.thisLocal, this.localsUsedInTryOrSync, this.boxedVariables,
+      this.freeVariables);
 
-  KernelScopeInfo.from(this.thisLocal, KernelScopeInfo info)
-      : localsUsedInTryOrSync = info.localsUsedInTryOrSync,
-        boxedVariables = info.boxedVariables;
-
-  KernelScopeInfo.withBoxedVariables(this.boxedVariables,
-      this.localsUsedInTryOrSync, this.freeVariables, this.thisLocal);
+  JsScopeInfo.from(KernelScopeInfo info, KernelToLocalsMap localsMap)
+      : this.thisLocal =
+            info.hasThisLocal ? new ThisLocal(localsMap.currentMember) : null,
+        this.localsUsedInTryOrSync =
+            info.localsUsedInTryOrSync.map(localsMap.getLocalVariable).toSet(),
+        this.boxedVariables =
+            info.boxedVariables.map(localsMap.getLocalVariable).toSet(),
+        this.freeVariables =
+            info.freeVariables.map(localsMap.getLocalVariable).toSet();
 
   void forEachBoxedVariable(f(Local local, FieldEntity field)) {
     boxedVariables.forEach((Local l) {
       // TODO(efortuna): add FieldEntities as created.
       f(l, null);
     });
   }
 
   bool localIsUsedInTryOrSync(Local variable) =>
       localsUsedInTryOrSync.contains(variable);
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('this=$thisLocal,');
     sb.write('localsUsedInTryOrSync={${localsUsedInTryOrSync.join(', ')}}');
     return sb.toString();
   }
 
   bool isBoxed(Local variable) => boxedVariables.contains(variable);
 }
 
-class KernelCapturedScope extends KernelScopeInfo implements CapturedScope {
-  final Local context;
+class KernelCapturedScope extends KernelScopeInfo {
+  final ir.TreeNode context;
 
   KernelCapturedScope(
-      Set<Local> boxedVariables,
+      Set<ir.VariableDeclaration> boxedVariables,
       this.context,
-      Set<Local> localsUsedInTryOrSync,
+      Set<ir.VariableDeclaration> localsUsedInTryOrSync,
       Set<ir.VariableDeclaration> freeVariables,
-      Local thisLocal)
+      bool hasThisLocal)
       : super.withBoxedVariables(
-            boxedVariables, localsUsedInTryOrSync, freeVariables, thisLocal);
+            boxedVariables, localsUsedInTryOrSync, freeVariables, hasThisLocal);
 
   bool get requiresContextBox => boxedVariables.isNotEmpty;
 }
 
-class KernelCapturedLoopScope extends KernelCapturedScope
-    implements CapturedLoopScope {
+class JsCapturedScope extends JsScopeInfo implements CapturedScope {
+  final Local context;
+
+  JsCapturedScope.from(
+      KernelCapturedScope capturedScope, KernelToLocalsMap localsMap)
+      : this.context = localsMap.getLocalVariable(capturedScope.context),
+        super.from(capturedScope, localsMap);
+
+  bool get requiresContextBox => boxedVariables.isNotEmpty;
+}
+
+class KernelCapturedLoopScope extends KernelCapturedScope {
+  final List<ir.VariableDeclaration> boxedLoopVariables;
+
+  KernelCapturedLoopScope(
+      Set<ir.VariableDeclaration> boxedVariables,
+      this.boxedLoopVariables,
+      ir.TreeNode context,
+      Set<ir.VariableDeclaration> localsUsedInTryOrSync,
+      Set<ir.VariableDeclaration> freeVariables,
+      bool hasThisLocal)
+      : super(boxedVariables, context, localsUsedInTryOrSync, freeVariables,
+            hasThisLocal);
+
+  bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
+}
+
+class JsCapturedLoopScope extends JsCapturedScope implements CapturedLoopScope {
   final List<Local> boxedLoopVariables;
 
-  KernelCapturedLoopScope(
-      Set<Local> boxedVariables,
-      this.boxedLoopVariables,
-      Local context,
-      Set<Local> localsUsedInTryOrSync,
-      Set<ir.VariableDeclaration> freeVariables,
-      Local thisLocal)
-      : super(boxedVariables, context, localsUsedInTryOrSync, freeVariables,
-            thisLocal);
+  JsCapturedLoopScope.from(
+      KernelCapturedLoopScope capturedScope, KernelToLocalsMap localsMap)
+      : this.boxedLoopVariables = capturedScope.boxedLoopVariables
+            .map(localsMap.getLocalVariable)
+            .toList(),
+        super.from(capturedScope, localsMap);
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
 }
 
 // TODO(johnniwinther): Add unittest for the computed [ClosureClass].
-class KernelClosureClass extends KernelScopeInfo
+class KernelClosureClass extends JsScopeInfo
     implements ClosureRepresentationInfo, JClass {
   final ir.Location location;
 
   final String name;
   final JLibrary library;
 
   /// Index into the classData, classList and classEnvironment lists where this
   /// entity is stored in [JsToFrontendMapImpl].
   int classIndex;
 
   final Map<Local, JField> localToFieldMap = new Map<Local, JField>();
 
   KernelClosureClass.fromScopeInfo(this.name, this.library,
       KernelScopeInfo info, this.location, KernelToLocalsMap localsMap)
-      : super.from(info.thisLocal, info) {
+      : super.from(info, localsMap) {
     // 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 = localsMap.getLocalVariable(variable);
-      if (info.isBoxed(capturedLocal)) {
+      if (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.
       }
       i++;
@@ skipping 64 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)';
 }
+
+/// Collection of closure data collected for a single member.
+class ClosureModel {
+  /// Collection [ScopeInfo] data for the member, if any.
+  // TODO(johnniwinther): [scopeInfo] seem to be missing only for fields
+  // without initializers; we shouldn't even create a [ClosureModel] in these
+  // cases.
+  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>{};
+}