Support for NamedExpression(s) as constructor initializer arguments.

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 3416 matching lines @@
     expect(initializer.kind, UnlinkedConstructorInitializerKind.thisInvocation);
     expect(initializer.name, 'named');
     expect(initializer.expression, isNull);
     expect(initializer.arguments, hasLength(2));
     _assertUnlinkedConst(initializer.arguments[0],
         operators: [UnlinkedConstOperation.pushInt], ints: [1]);
     _assertUnlinkedConst(initializer.arguments[1],
         operators: [UnlinkedConstOperation.pushString], strings: ['bbb']);
   }
 
+  test_constructor_initializers_thisInvocation_nameExpression() {
+    UnlinkedExecutable executable =
+        findExecutable('', executables: serializeClassText(r'''
+class C {
+  const C() : this.named(a: 1, b: 2);
+  const C.named({int a, int b});
+}
+''').executables);
+    expect(executable.constantInitializers, hasLength(1));
+    UnlinkedConstructorInitializer initializer =
+        executable.constantInitializers[0];
+    expect(initializer.kind, UnlinkedConstructorInitializerKind.thisInvocation);
+    expect(initializer.name, 'named');
+    expect(initializer.expression, isNull);
+    expect(initializer.arguments, hasLength(2));
+    _assertUnlinkedConst(initializer.arguments[0],
+        name: 'a', operators: [UnlinkedConstOperation.pushInt], ints: [1]);
+    _assertUnlinkedConst(initializer.arguments[1],
+        name: 'b', operators: [UnlinkedConstOperation.pushInt], ints: [2]);
+  }
+
   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 6259 matching lines @@
       (EntityRef r) => checkTypeRef(r, null, null, 'a',
           expectedKind: ReferenceKind.topLevelPropertyAccessor)
     ]);
   }
 
   /**
    * TODO(scheglov) rename "Const" to "Expr" everywhere
    */
   void _assertUnlinkedConst(UnlinkedConst constExpr,
       {bool isValidConst: true,
+      String name: '',
       List<UnlinkedConstOperation> operators: const <UnlinkedConstOperation>[],
       List<UnlinkedExprAssignOperator> assignmentOperators:
           const <UnlinkedExprAssignOperator>[],
       List<int> ints: const <int>[],
       List<double> doubles: const <double>[],
       List<String> strings: const <String>[],
       List<_EntityRefValidator> referenceValidators:
           const <_EntityRefValidator>[]}) {
     expect(constExpr, isNotNull);
     expect(constExpr.isValidConst, isValidConst);
+    expect(constExpr.name, name);
     expect(constExpr.operations, operators);
     expect(constExpr.ints, ints);
     expect(constExpr.doubles, doubles);
     expect(constExpr.strings, strings);
     expect(constExpr.assignmentOperators, assignmentOperators);
     expect(constExpr.references, hasLength(referenceValidators.length));
     for (int i = 0; i < referenceValidators.length; i++) {
       referenceValidators[i](constExpr.references[i]);
     }
   }
@@ skipping 14 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});
 }