Support for NamedExpression(s) as constructor initializer arguments.

pkg/analyzer/lib/src/summary/format.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.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script "pkg/analyzer/tool/generate_files".
 
 library analyzer.src.summary.format;
 
 import 'flat_buffers.dart' as fb;
@@ skipping 3265 matching lines @@
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedConstBuilder extends Object with _UnlinkedConstMixin implements idl.UnlinkedConst {
   bool _finished = false;
 
   List<idl.UnlinkedExprAssignOperator> _assignmentOperators;
   List<double> _doubles;
   List<int> _ints;
   bool _isValidConst;
+  String _name;
   List<idl.UnlinkedConstOperation> _operations;
   List<EntityRefBuilder> _references;
   List<String> _strings;
 
   @override
   List<idl.UnlinkedExprAssignOperator> get assignmentOperators => _assignmentOperators ??= <idl.UnlinkedExprAssignOperator>[];
 
   /**
    * Sequence of operators used by assignment operations.
    */
@@ skipping 33 matching lines @@
   /**
    * Indicates whether the expression is a valid potentially constant
    * expression.
    */
   void set isValidConst(bool _value) {
     assert(!_finished);
     _isValidConst = _value;
   }
 
   @override
+  String get name => _name ??= '';
+
+  /**
+   * If the expression is a [NamedExpression], the name of the expression.
+   */
+  void set name(String _value) {
+    assert(!_finished);
+    _name = _value;
+  }
+
+  @override
   List<idl.UnlinkedConstOperation> get operations => _operations ??= <idl.UnlinkedConstOperation>[];
 
   /**
    * Sequence of operations to execute (starting with an empty stack) to form
    * the constant value.
    */
   void set operations(List<idl.UnlinkedConstOperation> _value) {
     assert(!_finished);
     _operations = _value;
   }
@@ skipping 17 matching lines @@
 
   /**
    * Sequence of strings consumed by the operations `pushString` and
    * `invokeConstructor`.
    */
   void set strings(List<String> _value) {
     assert(!_finished);
     _strings = _value;
   }
 
-  UnlinkedConstBuilder({List<idl.UnlinkedExprAssignOperator> assignmentOperators, List<double> doubles, List<int> ints, bool isValidConst, List<idl.UnlinkedConstOperation> operations, List<EntityRefBuilder> references, List<String> strings})
+  UnlinkedConstBuilder({List<idl.UnlinkedExprAssignOperator> assignmentOperators, List<double> doubles, List<int> ints, bool isValidConst, String name, List<idl.UnlinkedConstOperation> operations, List<EntityRefBuilder> references, List<String> strings})
     : _assignmentOperators = assignmentOperators,
       _doubles = doubles,
       _ints = ints,
       _isValidConst = isValidConst,
+      _name = name,
       _operations = operations,
       _references = references,
       _strings = strings;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _references?.forEach((b) => b.flushInformative());
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_assignmentOperators;
     fb.Offset offset_doubles;
     fb.Offset offset_ints;
+    fb.Offset offset_name;
     fb.Offset offset_operations;
     fb.Offset offset_references;
     fb.Offset offset_strings;
     if (!(_assignmentOperators == null || _assignmentOperators.isEmpty)) {
       offset_assignmentOperators = fbBuilder.writeListUint8(_assignmentOperators.map((b) => b.index).toList());
     }
     if (!(_doubles == null || _doubles.isEmpty)) {
       offset_doubles = fbBuilder.writeListFloat64(_doubles);
     }
     if (!(_ints == null || _ints.isEmpty)) {
       offset_ints = fbBuilder.writeListUint32(_ints);
     }
+    if (_name != null) {
+      offset_name = fbBuilder.writeString(_name);
+    }
     if (!(_operations == null || _operations.isEmpty)) {
       offset_operations = fbBuilder.writeListUint8(_operations.map((b) => b.index).toList());
     }
     if (!(_references == null || _references.isEmpty)) {
       offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_strings == null || _strings.isEmpty)) {
       offset_strings = fbBuilder.writeList(_strings.map((b) => fbBuilder.writeString(b)).toList());
     }
     fbBuilder.startTable();
     if (offset_assignmentOperators != null) {
       fbBuilder.addOffset(6, offset_assignmentOperators);
     }
     if (offset_doubles != null) {
       fbBuilder.addOffset(4, offset_doubles);
     }
     if (offset_ints != null) {
       fbBuilder.addOffset(1, offset_ints);
     }
     if (_isValidConst == true) {
       fbBuilder.addBool(5, true);
     }
+    if (offset_name != null) {
+      fbBuilder.addOffset(7, offset_name);
+    }
     if (offset_operations != null) {
       fbBuilder.addOffset(0, offset_operations);
     }
     if (offset_references != null) {
       fbBuilder.addOffset(2, offset_references);
     }
     if (offset_strings != null) {
       fbBuilder.addOffset(3, offset_strings);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedConstReader extends fb.TableReader<_UnlinkedConstImpl> {
   const _UnlinkedConstReader();
 
   @override
   _UnlinkedConstImpl createObject(fb.BufferPointer bp) => new _UnlinkedConstImpl(bp);
 }
 
 class _UnlinkedConstImpl extends Object with _UnlinkedConstMixin implements idl.UnlinkedConst {
   final fb.BufferPointer _bp;
 
   _UnlinkedConstImpl(this._bp);
 
   List<idl.UnlinkedExprAssignOperator> _assignmentOperators;
   List<double> _doubles;
   List<int> _ints;
   bool _isValidConst;
+  String _name;
   List<idl.UnlinkedConstOperation> _operations;
   List<idl.EntityRef> _references;
   List<String> _strings;
 
   @override
   List<idl.UnlinkedExprAssignOperator> get assignmentOperators {
     _assignmentOperators ??= const fb.ListReader<idl.UnlinkedExprAssignOperator>(const _UnlinkedExprAssignOperatorReader()).vTableGet(_bp, 6, const <idl.UnlinkedExprAssignOperator>[]);
     return _assignmentOperators;
   }
 
   @override
   List<double> get doubles {
     _doubles ??= const fb.Float64ListReader().vTableGet(_bp, 4, const <double>[]);
     return _doubles;
   }
 
   @override
   List<int> get ints {
     _ints ??= const fb.Uint32ListReader().vTableGet(_bp, 1, const <int>[]);
     return _ints;
   }
 
   @override
   bool get isValidConst {
     _isValidConst ??= const fb.BoolReader().vTableGet(_bp, 5, false);
     return _isValidConst;
   }
 
   @override
+  String get name {
+    _name ??= const fb.StringReader().vTableGet(_bp, 7, '');
+    return _name;
+  }
+
+  @override
   List<idl.UnlinkedConstOperation> get operations {
     _operations ??= const fb.ListReader<idl.UnlinkedConstOperation>(const _UnlinkedConstOperationReader()).vTableGet(_bp, 0, const <idl.UnlinkedConstOperation>[]);
     return _operations;
   }
 
   @override
   List<idl.EntityRef> get references {
     _references ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 2, const <idl.EntityRef>[]);
     return _references;
   }
 
   @override
   List<String> get strings {
     _strings ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 3, const <String>[]);
     return _strings;
   }
 }
 
 abstract class _UnlinkedConstMixin implements idl.UnlinkedConst {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (assignmentOperators.isNotEmpty) _result["assignmentOperators"] = assignmentOperators.map((_value) => _value.toString().split('.')[1]).toList();
     if (doubles.isNotEmpty) _result["doubles"] = doubles.map((_value) => _value.isFinite ? _value : _value.toString()).toList();
     if (ints.isNotEmpty) _result["ints"] = ints;
     if (isValidConst != false) _result["isValidConst"] = isValidConst;
+    if (name != '') _result["name"] = name;
     if (operations.isNotEmpty) _result["operations"] = operations.map((_value) => _value.toString().split('.')[1]).toList();
     if (references.isNotEmpty) _result["references"] = references.map((_value) => _value.toJson()).toList();
     if (strings.isNotEmpty) _result["strings"] = strings;
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "assignmentOperators": assignmentOperators,
     "doubles": doubles,
     "ints": ints,
     "isValidConst": isValidConst,
+    "name": name,
     "operations": operations,
     "references": references,
     "strings": strings,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedConstructorInitializerBuilder extends Object with _UnlinkedConstructorInitializerMixin implements idl.UnlinkedConstructorInitializer {
@@ skipping 4871 matching lines @@
     "propagatedTypeSlot": propagatedTypeSlot,
     "type": type,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }