Add tests for handling closures in LocalInitializers

pkg/kernel/lib/transformations/closure/converter.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.converter;
 
 import '../../ast.dart'
     show
         Arguments,
         Block,
@@ skipping 52 matching lines @@
 import '../../core_types.dart' show CoreTypes;
 
 import '../../type_algebra.dart' show substitute;
 
 import 'clone_without_body.dart' show CloneWithoutBody;
 
 import 'context.dart' show Context, NoContext;
 
 import 'info.dart' show ClosureInfo;
 
-import 'rewriter.dart' show AstRewriter, BlockRewriter, InitializerRewriter;
+import 'rewriter.dart'
+    show
+        AstRewriter,
+        BlockRewriter,
+        InitializerRewriter,
+        FieldInitializerRewriter,
+        LocalInitializerRewriter;
 
 class ClosureConverter extends Transformer {
   final CoreTypes coreTypes;
   final Set<VariableDeclaration> capturedVariables;
   final Map<FunctionNode, Set<TypeParameter>> capturedTypeVariables;
   final Map<FunctionNode, VariableDeclaration> thisAccess;
   final Map<FunctionNode, String> localNames;
 
   /// Records place-holders for cloning contexts. See [visitForStatement].
   final Set<InvalidExpression> contextClonePlaceHolders =
@@ skipping 104 matching lines @@
     newClassMembers.forEach(node.addMember);
     newClassMembers.clear();
     currentClass = null;
     return node;
   }
 
   void extendContextWith(VariableDeclaration parameter) {
     context.extend(parameter, new VariableGet(parameter));
   }
 
+  static InitializerRewriter getRewriterForInitializer(
+      Initializer initializer) {
+    if (initializer is FieldInitializer) {
+      return new FieldInitializerRewriter(initializer.value);
+    }
+    if (initializer is LocalInitializer) {
+      return new LocalInitializerRewriter(initializer.variable.initializer);
+    }
+    throw "Trying to extract an initializer expression from "
+        "${initializer.runtimeType}, but only FieldInitializer and "
+        "LocalInitializer are supported.";
+  }
+
+  static Expression getInitializerExpression(Initializer initializer) {
+    if (initializer is FieldInitializer) {
+      return initializer.value;
+    }
+    if (initializer is LocalInitializer) {
+      return initializer.variable.initializer;
+    }
+    throw "Trying to get initializing expressino from "
+        "${initializer.runtimeType}, but only Field Initializer and "
+        "LocalInitializer are supported.";
+  }
+
   TreeNode visitConstructor(Constructor node) {
     assert(isEmptyContext);
     currentMember = node;
     // Transform initializers.
     for (Initializer initializer in node.initializers) {
-      if (initializer is FieldInitializer) {
+      if (initializer is FieldInitializer || initializer is LocalInitializer) {
         // Create a rewriter and a context for the initializer expression.
-        rewriter = new InitializerRewriter(initializer.value);
+        InitializerRewriter initializerRewriter =
+            getRewriterForInitializer(initializer);
+        rewriter = initializerRewriter;
         context = new NoContext(this);
         // Save the expression to visit it in the extended context, since the
-        // rewriter will modify `initializer.value`.
-        Expression initializerExpression = initializer.value;
+        // rewriter will modify `initializer.value` (for [FieldInitializer]) or
+        // `initializer.variable.initializer` (for [LocalInitializer]).
+        Expression initializerExpression =
+            getInitializerExpression(initializer);
         // Extend the context with all captured parameters of the constructor.
         // TODO(karlklose): add a fine-grained analysis of captured parameters.
         node.function.positionalParameters
             .where(capturedVariables.contains)
             .forEach(extendContextWith);
         node.function.namedParameters
             .where(capturedVariables.contains)
             .forEach(extendContextWith);
         // Transform the initializer expression.
         var parent = initializerExpression.parent;
         initializerExpression = initializerExpression.accept(this);
         initializerExpression.parent = parent;
         if (parent is Let) {
           parent.body = initializerExpression;
         } else if (parent is FieldInitializer) {
           parent.value = initializerExpression;
+        } else if (parent is LocalInitializer) {
+          parent.variable.initializer = initializerExpression;
         } else {
           throw "Found unexpected node '${node.runtimeType}, expected a 'Let' "
-              "or a 'FieldInitializer'.";
+              ",a 'FieldInitializer', or a 'LocalInitializer'.";
         }
       }
     }
     rewriter = null;
     // Transform constructor body.
     FunctionNode function = node.function;
     if (function.body != null && function.body is! EmptyStatement) {
       setupContextForFunctionBody(function);
       VariableDeclaration self = thisAccess[currentMemberFunction];
       if (self != null) {
@@ skipping 637 matching lines @@
         newClassMembers.add(tearOffMethod);
 
         resetContext();
       });
     } finally {
       currentMember = oldCurrentMember;
       currentMemberFunction = oldCurrentMemberFunction;
     }
   }
 }