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

pkg/kernel/testcases/closures_initializers/initializers.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.
 
 // The purpose of this test is to detect that closures in [LocalInitializer]s
 // and [FieldInitializer]s are properly converted. This test assumes that
 // [ArgumentExtractionForRedirecting] transformer was run before closure
 // conversion. It should introduce one [LocalInitializer] for each argument
 // passed to the redirecting constructor. If such argument contains a closure,
 // it would appear in a [LocalInitializer]. The [FieldInitializer] example
 // requires no such elaboration.
 
 class X {}
 
 // Closure in field initializer.
 //
 class A {
   X foo;
   A(X i) : foo = ((() => i)());
 }
 
+// Closure in super initializer.
+//
+class S extends A {
+  S(X i) : super((() => i)());
+}
+
+// Closure in redirecting constructor.
+//
+class S2 {
+  X foo;
+  S2(this.foo);
+
+  S2.wat(X i) : this((() => i)());

[Dmitry Stefantsov, 2017/07/13 07:19:53]

How this test case is different from the one for the constructor of [B] below?

[sjindel, 2017/07/13 11:34:05]

It wasn't -- I fixed this in patch set 2 by changing the argument extraction
method to extract arguments from field initializers instead, based on whether
the field name ended in "_li".

+}
+
 // Closure in local initializer.
 //
 class B {
   X foo;
   B.named(X foo) {}
   B(X foo) : this.named((() => foo)());
 }
 
 main() {
   A a = new A(new X());
   a.foo; // To prevent dartanalyzer from marking [a] as unused.
   B b = new B(new X());
   b.foo;
+  S s = new S(new X());
+  s.foo;
+  S2 s2 = new S2(new X());
+  s2.foo;
 }