Remove 'name' from argumentNames and replace with 'argumentsNames' in UnlinkedConstructorInitialize…

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 3264 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, String name, List<idl.UnlinkedConstOperation> operations, List<EntityRefBuilder> references, List<String> strings})
+  UnlinkedConstBuilder({List<idl.UnlinkedExprAssignOperator> assignmentOperators, List<double> doubles, List<int> ints, bool isValidConst, 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 {
   bool _finished = false;
 
   List<UnlinkedConstBuilder> _arguments;
+  List<String> _argumentNames;
   UnlinkedConstBuilder _expression;
   idl.UnlinkedConstructorInitializerKind _kind;
   String _name;
 
   @override
   List<UnlinkedConstBuilder> get arguments => _arguments ??= <UnlinkedConstBuilder>[];
 
   /**
    * If [kind] is `thisInvocation` or `superInvocation`, the arguments of the
    * invocation.  Otherwise empty.
    */
   void set arguments(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
     _arguments = _value;
   }
 
   @override
+  List<String> get argumentNames => _argumentNames ??= <String>[];
+
+  /**
+   * If there are `m` [arguments] and `n` [argumentNames], then each argument
+   * from [arguments] with index `i` such that `n + i - m >= 0`, should be used
+   * with the name at `n + i - m`.
+   */
+  void set argumentNames(List<String> _value) {
+    assert(!_finished);
+    _argumentNames = _value;
+  }
+
+  @override
   UnlinkedConstBuilder get expression => _expression;
 
   /**
    * If [kind] is `field`, the expression of the field initializer.
    * Otherwise `null`.
    */
   void set expression(UnlinkedConstBuilder _value) {
     assert(!_finished);
     _expression = _value;
   }
@@ skipping 16 matching lines @@
    * If [kind] is `field`, the name of the field declared in the class.  If
    * [kind] is `thisInvocation`, the name of the constructor, declared in this
    * class, to redirect to.  If [kind] is `superInvocation`, the name of the
    * constructor, declared in the superclass, to invoke.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
-  UnlinkedConstructorInitializerBuilder({List<UnlinkedConstBuilder> arguments, UnlinkedConstBuilder expression, idl.UnlinkedConstructorInitializerKind kind, String name})
+  UnlinkedConstructorInitializerBuilder({List<UnlinkedConstBuilder> arguments, List<String> argumentNames, UnlinkedConstBuilder expression, idl.UnlinkedConstructorInitializerKind kind, String name})
     : _arguments = arguments,
+      _argumentNames = argumentNames,
       _expression = expression,
       _kind = kind,
       _name = name;
 
   /**
    * Flush [informative] data recursively.
    */
   void flushInformative() {
     _arguments?.forEach((b) => b.flushInformative());
     _expression?.flushInformative();
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_arguments;
+    fb.Offset offset_argumentNames;
     fb.Offset offset_expression;
     fb.Offset offset_name;
     if (!(_arguments == null || _arguments.isEmpty)) {
       offset_arguments = fbBuilder.writeList(_arguments.map((b) => b.finish(fbBuilder)).toList());
     }
+    if (!(_argumentNames == null || _argumentNames.isEmpty)) {
+      offset_argumentNames = fbBuilder.writeList(_argumentNames.map((b) => fbBuilder.writeString(b)).toList());
+    }
     if (_expression != null) {
       offset_expression = _expression.finish(fbBuilder);
     }
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     fbBuilder.startTable();
     if (offset_arguments != null) {
       fbBuilder.addOffset(3, offset_arguments);
     }
+    if (offset_argumentNames != null) {
+      fbBuilder.addOffset(4, offset_argumentNames);
+    }
     if (offset_expression != null) {
       fbBuilder.addOffset(1, offset_expression);
     }
     if (_kind != null && _kind != idl.UnlinkedConstructorInitializerKind.field) {
       fbBuilder.addUint8(2, _kind.index);
     }
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedConstructorInitializerReader extends fb.TableReader<_UnlinkedConstructorInitializerImpl> {
   const _UnlinkedConstructorInitializerReader();
 
   @override
   _UnlinkedConstructorInitializerImpl createObject(fb.BufferPointer bp) => new _UnlinkedConstructorInitializerImpl(bp);
 }
 
 class _UnlinkedConstructorInitializerImpl extends Object with _UnlinkedConstructorInitializerMixin implements idl.UnlinkedConstructorInitializer {
   final fb.BufferPointer _bp;
 
   _UnlinkedConstructorInitializerImpl(this._bp);
 
   List<idl.UnlinkedConst> _arguments;
+  List<String> _argumentNames;
   idl.UnlinkedConst _expression;
   idl.UnlinkedConstructorInitializerKind _kind;
   String _name;
 
   @override
   List<idl.UnlinkedConst> get arguments {
     _arguments ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
     return _arguments;
   }
 
   @override
+  List<String> get argumentNames {
+    _argumentNames ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 4, const <String>[]);
+    return _argumentNames;
+  }
+
+  @override
   idl.UnlinkedConst get expression {
     _expression ??= const _UnlinkedConstReader().vTableGet(_bp, 1, null);
     return _expression;
   }
 
   @override
   idl.UnlinkedConstructorInitializerKind get kind {
     _kind ??= const _UnlinkedConstructorInitializerKindReader().vTableGet(_bp, 2, idl.UnlinkedConstructorInitializerKind.field);
     return _kind;
   }
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 }
 
 abstract class _UnlinkedConstructorInitializerMixin implements idl.UnlinkedConstructorInitializer {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (arguments.isNotEmpty) _result["arguments"] = arguments.map((_value) => _value.toJson()).toList();
+    if (argumentNames.isNotEmpty) _result["argumentNames"] = argumentNames;
     if (expression != null) _result["expression"] = expression.toJson();
     if (kind != idl.UnlinkedConstructorInitializerKind.field) _result["kind"] = kind.toString().split('.')[1];
     if (name != '') _result["name"] = name;
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "arguments": arguments,
+    "argumentNames": argumentNames,
     "expression": expression,
     "kind": kind,
     "name": name,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedDocumentationCommentBuilder extends Object with _UnlinkedDocumentationCommentMixin implements idl.UnlinkedDocumentationComment {
@@ skipping 4703 matching lines @@
     "propagatedTypeSlot": propagatedTypeSlot,
     "type": type,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }