Test the CapturedScope for local functions

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 '../constants/expressions.dart';
@@ skipping 248 matching lines @@
     var closure = _localClosureRepresentationMap[node];
     assert(
         closure != null,
         "Corresponding closure class not found for $node. "
         "Closures found for ${_localClosureRepresentationMap.keys}");
     return closure;
   }
 }
 
 class KernelScopeInfo {
+  // TODO(johnniwinther): Remove this. It seems to be unneeded.
   final ir.TreeNode node;

[Emily Fortuna, 2017/08/22 23:47:36]

why not just delete it then?

[Johnni Winther, 2017/08/23 07:47:18]

It's good for debugging and it seemed that I might need it to correct the
free-variables issue solve in a later CL.

   final Set<ir.VariableDeclaration> localsUsedInTryOrSync;
   final bool hasThisLocal;
 
   /// 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.node, this.hasThisLocal)
       : localsUsedInTryOrSync = new Set<ir.VariableDeclaration>();
 
   KernelScopeInfo.from(this.node, this.hasThisLocal, KernelScopeInfo info)
       : localsUsedInTryOrSync = info.localsUsedInTryOrSync;
 
   KernelScopeInfo.withBoxedVariables(this.node, this.localsUsedInTryOrSync,
       this.freeVariables, this.hasThisLocal);
 
+  bool _printOn(StringBuffer sb, bool needsComma) {
+    if (node != null) {
+      if (needsComma) {
+        sb.write(',');
+      }
+      sb.write('node=$node');
+      needsComma = true;
+    }
+    if (hasThisLocal) {
+      if (needsComma) {
+        sb.write(',');
+      }
+      sb.write('hasThisLocal');
+      needsComma = true;
+    }
+    if (localsUsedInTryOrSync.isNotEmpty) {
+      if (needsComma) {
+        sb.write(',');
+      }
+      sb.write('localsUsedInTryOrSync={${localsUsedInTryOrSync.join(', ')}}');
+      needsComma = true;
+    }
+    /*if (freeVariables.isNotEmpty) {

[Emily Fortuna, 2017/08/22 23:47:37]

delete or uncomment?

+      if (needsComma) {
+        sb.write(',');
+      }
+      sb.write('freeVariables=${freeVariables}');
+      needsComma = true;
+    }*/
+    return needsComma;
+  }
+
   String toString() {
     StringBuffer sb = new StringBuffer();
-    sb.write('this=$hasThisLocal,');
-    sb.write('localsUsedInTryOrSync={${localsUsedInTryOrSync.join(', ')}}');
+    sb.write('KernelScopeInfo(');
+    _printOn(sb, false);
+    sb.write(')');
     return sb.toString();
   }
 }
 
 class JsScopeInfo extends ScopeInfo {
   final Set<Local> localsUsedInTryOrSync;
   final Local thisLocal;
 
-  /// The set of variables that were defined in another scope, but are used in
-  /// this scope.
-  final Set<Local> freeVariables;
-
   JsScopeInfo.from(KernelScopeInfo info, KernelToLocalsMap localsMap)
       : this.thisLocal =
             info.hasThisLocal ? new ThisLocal(localsMap.currentMember) : null,
         this.localsUsedInTryOrSync =
-            info.localsUsedInTryOrSync.map(localsMap.getLocalVariable).toSet(),
-        this.freeVariables =
-            info.freeVariables.map(localsMap.getLocalVariable).toSet();
+            info.localsUsedInTryOrSync.map(localsMap.getLocalVariable).toSet();
 
   bool localIsUsedInTryOrSync(Local variable) =>
       localsUsedInTryOrSync.contains(variable);
 
+  bool _printOn(StringBuffer sb, bool needsComma) {
+    if (thisLocal != null) {
+      if (needsComma) {
+        sb.write(',');
+      }
+      sb.write('this=$thisLocal');
+      needsComma = true;
+    }
+    if (localsUsedInTryOrSync.isNotEmpty) {
+      if (needsComma) {
+        sb.write(',');
+      }
+      sb.write('localsUsedInTryOrSync={${localsUsedInTryOrSync.join(', ')}}');
+      needsComma = true;
+    }
+    return needsComma;
+  }
+
   String toString() {
     StringBuffer sb = new StringBuffer();
-    sb.write('this=$thisLocal,');
-    sb.write('localsUsedInTryOrSync={${localsUsedInTryOrSync.join(', ')}}');
+    sb.write('JsScopeInfo(');
+    _printOn(sb, false);
+    sb.write(')');
     return sb.toString();
   }
 }
 
 class KernelCapturedScope extends KernelScopeInfo {
   final NodeBox box;
   final Set<ir.VariableDeclaration> boxedVariables;
 
   KernelCapturedScope(
       ir.TreeNode node,
       this.box,
       this.boxedVariables,
       Set<ir.VariableDeclaration> localsUsedInTryOrSync,
       Set<ir.VariableDeclaration> freeVariables,
       bool hasThisLocal)
       : super.withBoxedVariables(
             node, localsUsedInTryOrSync, freeVariables, hasThisLocal);
 
   bool get requiresContextBox => boxedVariables.isNotEmpty;
+
+  bool _printOn(StringBuffer sb, bool needsComma) {
+    needsComma = super._printOn(sb, needsComma);
+    if (box != null) {
+      if (needsComma) {
+        sb.write(',');
+      }
+      sb.write('box=${box}');
+      needsComma = true;
+    }
+    if (boxedVariables.isNotEmpty) {
+      if (needsComma) {
+        sb.write(',');
+      }
+      sb.write('boxedVariables={${boxedVariables.join(',')}}');
+      needsComma = true;
+    }
+    return needsComma;
+  }
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.write('KernelCapturedScope(');
+    _printOn(sb, false);
+    sb.write(')');
+    return sb.toString();
+  }
 }
 
 class JsCapturedScope extends JsScopeInfo implements CapturedScope {
-  final Local context;
+  final Local box;
   final Map<Local, FieldEntity> boxedVariables;
 
   JsCapturedScope.from(KernelCapturedScope capturedScope,
-      KernelToLocalsMap localsMap, this.context, this.boxedVariables)
+      KernelToLocalsMap localsMap, this.box, this.boxedVariables)
       : super.from(capturedScope, localsMap);
 
-  bool get requiresContextBox => boxedVariables.isNotEmpty;
+  bool get hasBox => box != null;
 
   void forEachBoxedVariable(f(Local local, FieldEntity field)) {
     boxedVariables.forEach(f);
   }
 
   bool isBoxed(Local variable) => boxedVariables.containsKey(variable);
+
+  bool _printOn(StringBuffer sb, bool needsComma) {
+    needsComma = super._printOn(sb, needsComma);
+    if (box != null) {
+      if (needsComma) {
+        sb.write(',');
+      }
+      sb.write('box=${box}');
+      needsComma = true;
+    }
+    if (boxedVariables.isNotEmpty) {
+      if (needsComma) {
+        sb.write(',');
+      }
+      sb.write('boxedVariables=${boxedVariables}');
+      needsComma = true;
+    }
+    return needsComma;
+  }
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.write('JsCapturedScope(');
+    _printOn(sb, false);
+    sb.write(')');
+    return sb.toString();
+  }
 }
 
 class KernelCapturedLoopScope extends KernelCapturedScope {
   final List<ir.VariableDeclaration> boxedLoopVariables;
 
   KernelCapturedLoopScope(
       ir.TreeNode node,
       NodeBox box,
       Set<ir.VariableDeclaration> boxedVariables,
       this.boxedLoopVariables,
       Set<ir.VariableDeclaration> localsUsedInTryOrSync,
       Set<ir.VariableDeclaration> freeVariables,
       bool hasThisLocal)
       : super(node, box, boxedVariables, localsUsedInTryOrSync, freeVariables,
             hasThisLocal);
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
+
+  bool _printOn(StringBuffer sb, bool needsComma) {
+    needsComma = super._printOn(sb, needsComma);
+    if (boxedLoopVariables.isNotEmpty) {
+      if (needsComma) {
+        sb.write(',');
+      }
+      sb.write('boxedLoopVariables={${boxedLoopVariables.join(',')}}');
+      needsComma = true;
+    }
+    return needsComma;
+  }
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.write('KernelCapturedLoopScope(');
+    _printOn(sb, false);
+    sb.write(')');
+    return sb.toString();
+  }
 }
 
 class JsCapturedLoopScope extends JsCapturedScope implements CapturedLoopScope {
   final List<Local> boxedLoopVariables;
 
   JsCapturedLoopScope.from(
       KernelCapturedLoopScope capturedScope,
       KernelToLocalsMap localsMap,
       Local box,
       Map<Local, FieldEntity> boxedVariables)
       : this.boxedLoopVariables = capturedScope.boxedLoopVariables
             .map(localsMap.getLocalVariable)
             .toList(),
         super.from(capturedScope, localsMap, box, boxedVariables);
 
   bool get hasBoxedLoopVariables => boxedLoopVariables.isNotEmpty;
+
+  bool _printOn(StringBuffer sb, bool needsComma) {
+    needsComma = super._printOn(sb, needsComma);
+    if (boxedLoopVariables.isNotEmpty) {
+      if (needsComma) {
+        sb.write(',');
+      }
+      sb.write('boxedLoopVariables={${boxedLoopVariables.join(',')}}');
+      needsComma = true;
+    }
+    return needsComma;
+  }
+
+  String toString() {
+    StringBuffer sb = new StringBuffer();
+    sb.write('JsCapturedLoopScope(');
+    _printOn(sb, false);
+    sb.write(')');
+    return sb.toString();
+  }
 }
 
 // TODO(johnniwinther): Add unittest for the computed [ClosureClass].
 class KernelClosureClass extends JsScopeInfo
     implements ClosureRepresentationInfo {
   JFunction callMethod;
   final Local closureEntity;
   final Local thisLocal;
   final JClass closureClassEntity;
   final Map<Local, FieldEntity> boxedVariables;
@@ skipping 19 matching lines @@
             : localsMap.getLocalFunction(closureSourceNode.parent),
         thisLocal =
             info.hasThisLocal ? new ThisLocal(localsMap.currentMember) : null,
         super.from(info, localsMap);
 
   List<Local> get createdFieldEntities => localToFieldMap.keys.toList();
 
   FieldEntity get thisFieldEntity => localToFieldMap[thisLocal];
 
   void forEachBoxedVariable(f(Local from, FieldEntity to)) {
-    boxedVariables.forEach(f);
+    throw new UnsupportedError('KernelClosureClass.forEachBoxedVariable');
   }
 
   void forEachCapturedVariable(f(Local from, FieldEntity to)) {
-    for (Local local in localToFieldMap.keys) {
-      FieldEntity field = localToFieldMap[local];
-      if (local is! BoxLocal) f(local, field);
-    }
-    boxedVariables.forEach(f);
+    throw new UnsupportedError('KernelClosureClass.forEachCapturedVariable');
   }
 
   void forEachFreeVariable(f(Local variable, FieldEntity field)) {
     localToFieldMap.forEach(f);
     boxedVariables.forEach(f);
   }
 
-  bool isVariableBoxed(Local variable) => boxedVariables.containsKey(variable);
+  bool isVariableBoxed(Local variable) {
+    throw new UnsupportedError('KernelClosureClass.isVariableBoxed');
+  }
 
   bool get isClosure => true;
 }
 
 /// 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;
 
   NodeBox(this.name);
+
+  String toString() => 'NodeBox(name=$name)';
 }
 
 class JClosureClass extends JClass {
   JClosureClass(JLibrary library, int classIndex, String name)
       : super(library, classIndex, name, isAbstract: false);
 
   @override
   bool get isClosure => true;
 
   String toString() => '${jsElementPrefix}closure_class($name)';
@@ skipping 141 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>{};
 }