Handle more corner cases of closures while doing ast-based summaries.

pkg/analyzer/test/src/summary/summary_common.dart

 // Copyright (c) 2015, 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 analyzer.test.src.summary.summary_common;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/src/dart/scanner/reader.dart';
@@ skipping 1805 matching lines @@
       0,
       1,
       0,
       3
     ], referenceValidators: [
       (EntityRef r) => checkTypeRef(r, null, null, 'foo',
           expectedKind: ReferenceKind.topLevelFunction)
     ]);
   }
 
+  test_constExpr_functionExpression_inConstructorInitializers() {
+    // Even though function expressions are not allowed in constant
+    // declarations, they might occur due to erroneous code, so make sure they
+    // function correctly.
+    UnlinkedExecutable executable = serializeClassText('''
+class C {
+  final x, y;
+  const C() : x = (() => 42), y = (() => 43);
+}
+''').executables[0];
+    expect(executable.localFunctions, hasLength(2));
+    _assertUnlinkedConst(executable.constantInitializers[0].expression,
+        isValidConst: false,
+        operators: [UnlinkedConstOperation.pushLocalFunctionReference],
+        ints: [0, 0]);
+    _assertUnlinkedConst(executable.constantInitializers[1].expression,
+        isValidConst: false,
+        operators: [UnlinkedConstOperation.pushLocalFunctionReference],
+        ints: [0, 1]);
+  }
+
   test_constExpr_invokeConstructor_generic_named() {
     UnlinkedVariable variable = serializeVariableText('''
 class C<K, V> {
   const C.named();
 }
 const v = const C<int, String>.named();
 ''');
     _assertUnlinkedConst(variable.constExpr, operators: [
       UnlinkedConstOperation.invokeConstructor,
     ], ints: [
@@ skipping 1628 matching lines @@
         executable.constantInitializers[0];
     expect(
         initializer.kind, UnlinkedConstructorInitializerKind.superInvocation);
     expect(initializer.name, 'aaa');
     expect(initializer.expression, isNull);
     expect(initializer.arguments, hasLength(1));
     _assertUnlinkedConst(initializer.arguments[0],
         operators: [UnlinkedConstOperation.pushInt], ints: [42]);
   }
 
+  test_constructor_initializers_superInvocation_namedExpression() {
+    UnlinkedExecutable executable =
+        findExecutable('', executables: serializeClassText(r'''
+class A {
+  const A(a, {int b, int c});
+}
+class C extends A {
+  const C() : super(1, b: 2, c: 3);
+}
+''').executables);
+    expect(executable.constantInitializers, hasLength(1));
+    UnlinkedConstructorInitializer initializer =
+        executable.constantInitializers[0];
+    expect(
+        initializer.kind, UnlinkedConstructorInitializerKind.superInvocation);
+    expect(initializer.name, '');
+    expect(initializer.expression, isNull);
+    expect(initializer.arguments, hasLength(3));
+    _assertUnlinkedConst(initializer.arguments[0],
+        operators: [UnlinkedConstOperation.pushInt], ints: [1]);
+    _assertUnlinkedConst(initializer.arguments[1],
+        operators: [UnlinkedConstOperation.pushInt], ints: [2]);
+    _assertUnlinkedConst(initializer.arguments[2],
+        operators: [UnlinkedConstOperation.pushInt], ints: [3]);
+    expect(initializer.argumentNames, ['b', 'c']);
+  }
+
   test_constructor_initializers_superInvocation_unnamed() {
     UnlinkedExecutable executable =
         findExecutable('ccc', executables: serializeClassText(r'''
 class A {
   const A(int p);
 }
 class C extends A {
   const C.ccc() : super(42);
 }
 ''').executables);
@@ skipping 47 matching lines @@
     expect(initializer.arguments, hasLength(3));
     _assertUnlinkedConst(initializer.arguments[0],
         operators: [UnlinkedConstOperation.pushInt], ints: [1]);
     _assertUnlinkedConst(initializer.arguments[1],
         operators: [UnlinkedConstOperation.pushInt], ints: [2]);
     _assertUnlinkedConst(initializer.arguments[2],
         operators: [UnlinkedConstOperation.pushInt], ints: [3]);
     expect(initializer.argumentNames, ['b', 'c']);
   }
 
-  test_constructor_initializers_superInvocation_namedExpression() {
-    UnlinkedExecutable executable =
-        findExecutable('', executables: serializeClassText(r'''
-class A {
-  const A(a, {int b, int c});
-}
-class C extends A {
-  const C() : super(1, b: 2, c: 3);
-}
-''').executables);
-    expect(executable.constantInitializers, hasLength(1));
-    UnlinkedConstructorInitializer initializer =
-        executable.constantInitializers[0];
-    expect(
-        initializer.kind, UnlinkedConstructorInitializerKind.superInvocation);
-    expect(initializer.name, '');
-    expect(initializer.expression, isNull);
-    expect(initializer.arguments, hasLength(3));
-    _assertUnlinkedConst(initializer.arguments[0],
-        operators: [UnlinkedConstOperation.pushInt], ints: [1]);
-    _assertUnlinkedConst(initializer.arguments[1],
-        operators: [UnlinkedConstOperation.pushInt], ints: [2]);
-    _assertUnlinkedConst(initializer.arguments[2],
-        operators: [UnlinkedConstOperation.pushInt], ints: [3]);
-    expect(initializer.argumentNames, ['b', 'c']);
-  }
-
   test_constructor_initializers_thisInvocation_unnamed() {
     UnlinkedExecutable executable =
         findExecutable('named', executables: serializeClassText(r'''
 class C {
   const C.named() : this(1, 'bbb');
   const C(int a, String b);
 }
 ''').executables);
     expect(executable.constantInitializers, hasLength(1));
     UnlinkedConstructorInitializer initializer =
@@ skipping 6520 matching lines @@
 class _PrefixExpectation {
   final ReferenceKind kind;
   final String name;
   final String absoluteUri;
   final String relativeUri;
   final int numTypeParameters;
 
   _PrefixExpectation(this.kind, this.name,
       {this.absoluteUri, this.relativeUri, this.numTypeParameters: 0});
 }