Add boxed fields in closure classes.

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/entities.dart';
@@ skipping 136 matching lines @@
 
   // TODO(efortuna): Eventually capturedScopesMap[node] should always
   // be non-null, and we should just test that with an assert.
   @override
   CapturedScope getCapturedScope(MemberEntity entity) {
     MemberDefinition definition = _elementMap.getMemberDefinition(entity);
     switch (definition.kind) {
       case MemberKind.regular:
       case MemberKind.constructor:
       case MemberKind.constructorBody:
+      case MemberKind.closureCall:
         return _capturedScopesMap[definition.node] ?? const CapturedScope();
       default:
         throw failedAt(entity, "Unexpected member definition $definition");
     }
   }
 
   @override
   // TODO(efortuna): Eventually capturedScopesMap[node] should always
   // be non-null, and we should just test that with an assert.
   CapturedLoopScope getCapturedLoopScope(ir.Node loopNode) =>
       _capturedScopesMap[loopNode] ?? const CapturedLoopScope();
 
   @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 {
   final Set<ir.VariableDeclaration> localsUsedInTryOrSync;
   final bool hasThisLocal;
   final Set<ir.VariableDeclaration> boxedVariables;
+  // If boxedVariables is empty, this will be null, because no variables will
+  // need to be boxed.
+  final NodeBox capturedVariablesAccessor;
 
   /// 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>();
+        boxedVariables = new Set<ir.VariableDeclaration>(),
+        capturedVariablesAccessor = null;
 
   KernelScopeInfo.from(this.hasThisLocal, KernelScopeInfo info)
       : localsUsedInTryOrSync = info.localsUsedInTryOrSync,
-        boxedVariables = info.boxedVariables;
+        boxedVariables = info.boxedVariables,
+        capturedVariablesAccessor = null;
 
-  KernelScopeInfo.withBoxedVariables(this.boxedVariables,
-      this.localsUsedInTryOrSync, this.freeVariables, this.hasThisLocal);
+  KernelScopeInfo.withBoxedVariables(
+      this.boxedVariables,
+      this.capturedVariablesAccessor,
+      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 {
@@ skipping 36 matching lines @@
   }
 
   bool isBoxed(Local variable) => boxedVariables.contains(variable);
 }
 
 class KernelCapturedScope extends KernelScopeInfo {
   final ir.TreeNode context;
 
   KernelCapturedScope(
       Set<ir.VariableDeclaration> boxedVariables,
+      NodeBox capturedVariablesAccessor,
       this.context,
       Set<ir.VariableDeclaration> localsUsedInTryOrSync,
       Set<ir.VariableDeclaration> freeVariables,
       bool hasThisLocal)
-      : super.withBoxedVariables(
-            boxedVariables, localsUsedInTryOrSync, freeVariables, hasThisLocal);
+      : super.withBoxedVariables(boxedVariables, capturedVariablesAccessor,
+            localsUsedInTryOrSync, freeVariables, hasThisLocal);
 
   bool get requiresContextBox => boxedVariables.isNotEmpty;
 }
 
 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,
+      NodeBox capturedVariablesAccessor,
       this.boxedLoopVariables,
       ir.TreeNode context,
       Set<ir.VariableDeclaration> localsUsedInTryOrSync,
       Set<ir.VariableDeclaration> freeVariables,
       bool hasThisLocal)
-      : super(boxedVariables, context, localsUsedInTryOrSync, freeVariables,
-            hasThisLocal);
+      : super(boxedVariables, capturedVariablesAccessor, context,
+            localsUsedInTryOrSync, freeVariables, hasThisLocal);
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
 }
 
 class JsCapturedLoopScope extends JsCapturedScope implements CapturedLoopScope {
   final List<Local> boxedLoopVariables;
 
   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 JsScopeInfo
     implements ClosureRepresentationInfo, JClass {
   final ir.Location location;
 
   final String name;
   final JLibrary library;
   JFunction callMethod;
+  final Local closureEntity;
 
   /// Index into the classData, classList and classEnvironment lists where this
   /// entity is stored in [JsToFrontendMapImpl].
   final int classIndex;
 
   final Map<Local, JField> localToFieldMap = new Map<Local, JField>();
 
-  KernelClosureClass.fromScopeInfo(this.name, this.classIndex, this.library,
-      KernelScopeInfo info, this.location, KernelToLocalsMap localsMap)
-      : super.from(info, localsMap);
-
-  // TODO(efortuna): Implement.
-  Local get closureEntity => null;
+  KernelClosureClass.fromScopeInfo(
+      ir.FunctionNode closureSourceNode,
+      this.name,
+      this.classIndex,
+      this.library,
+      KernelScopeInfo info,
+      this.location,
+      KernelToLocalsMap localsMap)
+      : super.from(info, localsMap),
+        closureEntity = localsMap.getLocalFunction(closureSourceNode.parent);
 
   ClassEntity get closureClassEntity => this;
 
   List<Local> get createdFieldEntities => localToFieldMap.keys.toList();
 
   // TODO(efortuna): Implement.
   FieldEntity get thisFieldEntity => null;
 
   void forEachCapturedVariable(f(Local from, JField to)) {
     localToFieldMap.forEach(f);
   }
 
-  // TODO(efortuna): Implement.
   @override
-  void forEachBoxedVariable(f(Local local, JField field)) {}
+  void forEachBoxedVariable(f(Local local, JField field)) {
+    for (Local l in localToFieldMap.keys) {
+      if (localToFieldMap[l] is JBoxedField) f(l, localToFieldMap[l]);
+    }
+  }
 
-  // TODO(efortuna): Implement.
-  void forEachFreeVariable(f(Local variable, JField field)) {}
+  void forEachFreeVariable(f(Local variable, JField field)) {
+    for (Local l in localToFieldMap.keys) {
+      var jField = localToFieldMap[l];
+      if (jField is! JBoxedField && jField is! BoxLocal) f(l, jField);
+    }
+  }
 
-  // TODO(efortuna): Implement.
-  bool isVariableBoxed(Local variable) => false;
+  bool isVariableBoxed(Local variable) =>
+      localToFieldMap.keys.contains(variable);
 
   bool get isClosure => true;
 
   bool get isAbstract => false;
 
   String toString() => '${jsElementPrefix}class($name)';
 }
 
+/// A local variable to disambiguate between a variable that has been captured
+/// from one scope to another. This is the ir.Node version that corresponds to
+/// [BoxLocal].
+class NodeBox {
+  final String name;
+  final ir.TreeNode executableContext;
+  final ir.Member memberContext;
+  NodeBox(this.name, this.executableContext, this.memberContext);
+}
+
 class JClosureField extends JField {
   JClosureField(String name, int memberIndex,
       KernelClosureClass containingClass, bool isConst, bool isAssignable)
       : super(memberIndex, containingClass.library, containingClass,
             new Name(name, containingClass.library),
             isAssignable: isAssignable, isConst: isConst);
 }
 
+/// A ClosureField that has been "boxed" to prevent name shadowing with the
+/// original variable and ensure that this variable is updated/read with the
+/// most recent value.
+/// This corresponds to BoxFieldElement; we reuse BoxLocal from the original
+/// algorithm to correspond to the actual name of the variable.
+class JBoxedField extends JField {
+  final BoxLocal box;
+  JBoxedField(String name, int memberIndex, this.box,
+      KernelClosureClass containingClass, bool isConst, bool isAssignable)
+      : super(memberIndex, containingClass.library, containingClass,
+            new Name(name, containingClass.library),
+            isAssignable: isAssignable, isConst: isConst);
+}
+
 class ClosureClassDefinition implements ClassDefinition {
   final ClassEntity cls;
   final ir.Location location;
 
   ClosureClassDefinition(this.cls, this.location);
 
   ClassKind get kind => ClassKind.closure;
 
   ir.Node get node =>
       throw new UnsupportedError('ClosureClassDefinition.node for $cls');
@@ skipping 23 matching lines @@
   KernelScopeInfo scopeInfo;
 
   /// Collected [CapturedScope] data for nodes.
   Map<ir.Node, KernelCapturedScope> capturedScopesMap =
       <ir.Node, KernelCapturedScope>{};
 
   /// Collected [ScopeInfo] data for nodes.
   Map<ir.FunctionNode, KernelScopeInfo> closuresToGenerate =
       <ir.FunctionNode, KernelScopeInfo>{};
 }