Remove unnecessary contexts in closure conversion

pkg/kernel/lib/transformations/closure/info.dart

 // Copyright (c) 2016, 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.
 
 library kernel.transformations.closure.info;
 
 import '../../ast.dart'
     show
         Class,
         Constructor,
         Field,
+        FieldInitializer,
         FunctionDeclaration,
         FunctionNode,
+        LocalInitializer,
         Member,
         Name,
         Procedure,
         ProcedureKind,
         PropertyGet,
+        RedirectingInitializer,
+        SuperInitializer,
         ThisExpression,
         TypeParameter,
         TypeParameterType,
         VariableDeclaration,
         VariableGet,
         VariableSet;
 
 import '../../visitor.dart' show RecursiveVisitor;
 
 class ClosureInfo extends RecursiveVisitor {
@@ skipping 173 matching lines @@
     if (!isOuterMostContext) {
       thisAccess.putIfAbsent(
           currentMemberFunction, () => new VariableDeclaration("#self"));
     }
   }
 
   visitPropertyGet(PropertyGet node) {
     invokedGetters.add(node.name);
     super.visitPropertyGet(node);
   }
+
+  visitFieldInitializer(FieldInitializer node) {

[karlklose, 2017/06/16 07:54:43]

Consider adding a helper and move the comment there.

The comment could also be shorter; maybe adding an example could help.

[Dmitry Stefantsov, 2017/06/16 08:30:00]

Thanks!  I agree, an example could help with understanding of this change.  Also
agree on the helper function.

One more thing that I changed is that I save/restore currentFunction for the
constructor, not individual initializers.  It's probably more clear and saves
some resources.

+    // Set [currentFunction] to [currentMemberFunction] during visiting the
+    // initializer.  Effectively it means that [currentFunction] is set to
+    // [function] field of the constructor, and constructor parameters
+    // encountered in the initializer won't be treated as captured.
+    // Same trick is used in [visitSuperInitializer],
+    // [visitRedirectingInitializer], and [visitLocalInitializer].
+    var saved = currentFunction;
+    currentFunction = currentMemberFunction;
+    super.visitFieldInitializer(node);
+    currentFunction = saved;
+  }
+
+  visitSuperInitializer(SuperInitializer node) {
+    var saved = currentFunction;
+    currentFunction = currentMemberFunction;
+    super.visitSuperInitializer(node);
+    currentFunction = saved;
+  }
+
+  visitRedirectingInitializer(RedirectingInitializer node) {
+    var saved = currentFunction;
+    currentFunction = currentMemberFunction;
+    super.visitRedirectingInitializer(node);
+    currentFunction = saved;
+  }
+
+  visitLocalInitializer(LocalInitializer node) {
+    var saved = currentFunction;
+    currentFunction = currentMemberFunction;
+    super.visitLocalInitializer(node);
+    currentFunction = saved;
+  }
 }