Convert closures in all initializers, and share the context between them.

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,
         Catch,
         Class,
         ClosureCreation,
         Constructor,
         DartType,
         DynamicType,
         EmptyStatement,
         Expression,
         ExpressionStatement,
         Field,
-        FieldInitializer,
         ForInStatement,
         ForStatement,
         FunctionDeclaration,
         FunctionExpression,
         FunctionNode,
         FunctionType,
-        Initializer,
         InterfaceType,
         InvalidExpression,
         InvocationExpression,
-        Let,
         Library,
         LocalInitializer,
         Member,
         MethodInvocation,
         Name,
         NamedExpression,
         NamedType,
         NullLiteral,
         Procedure,
         ProcedureKind,
@@ skipping 20 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,
-        FieldInitializerRewriter,
-        LocalInitializerRewriter;
+import 'rewriter.dart' show AstRewriter, BlockRewriter, InitializerListRewriter;
 
 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 || initializer is LocalInitializer) {
-        // Create a rewriter and a context for the initializer expression.
-        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` (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' "
-              ",a 'FieldInitializer', or a 'LocalInitializer'.";
-        }
-      }
+    if (node.initializers.length > 0) {
+      var initRewriter = new InitializerListRewriter(node);
+      rewriter = initRewriter;
+      context = new NoContext(this);
+
+      // 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);
+
+      transformList(node.initializers, this, node);
+      node.initializers.insertAll(0, initRewriter.prefix);
+      context = rewriter = null;
     }
-    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) {
         context.extend(self, new ThisExpression());
       }
       node.function.accept(this);
       resetContext();
@@ skipping 254 matching lines @@
       // initializer, just use this variable name to put it into the context.
       context.extend(node, new VariableGet(node));
     } else {
       context.extend(node, node.initializer ?? new NullLiteral());
     }
 
     if (node.parent == currentFunction) {
       return node;
     } else {
       assert(node.parent is Block);
-      // When returning null, the parent block will remove this node from its
-      // list of statements.
+      // When returning null, the parent block will remove
+      // this node from its list of statements.
       return null;
     }
   }
 
   TreeNode visitVariableGet(VariableGet node) {
     return capturedVariables.contains(node.variable)
         ? context.lookup(node.variable)
         : node;
   }
 
@@ skipping 357 matching lines @@
         newClassMembers.add(tearOffMethod);
 
         resetContext();
       });
     } finally {
       currentMember = oldCurrentMember;
       currentMemberFunction = oldCurrentMemberFunction;
     }
   }
 }