Summarize constructor initializers.

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 18 matching lines @@
   @override
   int get size => 4;
 
   @override
   idl.UnlinkedConstOperation read(fb.BufferPointer bp) {
     int index = const fb.Uint32Reader().read(bp);
     return idl.UnlinkedConstOperation.values[index];
   }
 }
 
+class _UnlinkedConstructorInitializerKindReader extends fb.Reader<idl.UnlinkedConstructorInitializerKind> {
+  const _UnlinkedConstructorInitializerKindReader() : super();
+
+  @override
+  int get size => 4;
+
+  @override
+  idl.UnlinkedConstructorInitializerKind read(fb.BufferPointer bp) {
+    int index = const fb.Uint32Reader().read(bp);
+    return idl.UnlinkedConstructorInitializerKind.values[index];
+  }
+}
+
 class _UnlinkedExecutableKindReader extends fb.Reader<idl.UnlinkedExecutableKind> {
   const _UnlinkedExecutableKindReader() : super();
 
   @override
   int get size => 4;
 
   @override
   idl.UnlinkedExecutableKind read(fb.BufferPointer bp) {
     int index = const fb.Uint32Reader().read(bp);
     return idl.UnlinkedExecutableKind.values[index];
@@ skipping 1774 matching lines @@
   @override
   Map<String, Object> toMap() => {
     "operations": operations,
     "ints": ints,
     "doubles": doubles,
     "strings": strings,
     "references": references,
   };
 }
 
+class UnlinkedConstructorInitializerBuilder extends Object with _UnlinkedConstructorInitializerMixin implements idl.UnlinkedConstructorInitializer {
+  bool _finished = false;
+
+  idl.UnlinkedConstructorInitializerKind _kind;
+  String _name;
+  UnlinkedConstBuilder _expression;
+  List<UnlinkedConstBuilder> _arguments;
+
+  @override
+  idl.UnlinkedConstructorInitializerKind get kind => _kind ??= idl.UnlinkedConstructorInitializerKind.field;
+
+  /**
+   * The kind of the constructor initializer (field, redirect, super).
+   */
+  void set kind(idl.UnlinkedConstructorInitializerKind _value) {
+    assert(!_finished);
+    _kind = _value;
+  }
+
+  @override
+  String get name => _name ??= '';
+
+  /**
+   * Depending on the [kind] is the name of the field declared in the class,
+   * or the name of the constructor to redirect to (may be `null`), or the name
+   * of the invoked super constructor (may be `null`).
+   */
+  void set name(String _value) {
+    assert(!_finished);
+    _name = _value;
+  }
+
+  @override
+  UnlinkedConstBuilder get expression => _expression;
+
+  /**
+   * If [UnlinkedConstructorInitializerKind.field], the expression of the
+   * field initializer.  Otherwise `null`.
+   */
+  void set expression(UnlinkedConstBuilder _value) {
+    assert(!_finished);
+    _expression = _value;
+  }
+
+  @override
+  List<UnlinkedConstBuilder> get arguments => _arguments ??= <UnlinkedConstBuilder>[];
+
+  /**
+   * If [UnlinkedConstructorInitializerKind.thisInvocation] or
+   * [UnlinkedConstructorInitializerKind.superInvocation], the arguments of
+   * the invocation.  Otherwise empty.
+   */
+  void set arguments(List<UnlinkedConstBuilder> _value) {
+    assert(!_finished);
+    _arguments = _value;
+  }
+
+  UnlinkedConstructorInitializerBuilder({idl.UnlinkedConstructorInitializerKind kind, String name, UnlinkedConstBuilder expression, List<UnlinkedConstBuilder> arguments})
+    : _kind = kind,
+      _name = name,
+      _expression = expression,
+      _arguments = arguments;
+
+  fb.Offset finish(fb.Builder fbBuilder) {
+    assert(!_finished);
+    _finished = true;
+    fb.Offset offset_name;
+    fb.Offset offset_expression;
+    fb.Offset offset_arguments;
+    if (_name != null) {
+      offset_name = fbBuilder.writeString(_name);
+    }
+    if (_expression != null) {
+      offset_expression = _expression.finish(fbBuilder);
+    }
+    if (!(_arguments == null || _arguments.isEmpty)) {
+      offset_arguments = fbBuilder.writeList(_arguments.map((b) => b.finish(fbBuilder)).toList());
+    }
+    fbBuilder.startTable();
+    if (_kind != null && _kind != idl.UnlinkedConstructorInitializerKind.field) {
+      fbBuilder.addUint32(0, _kind.index);
+    }
+    if (offset_name != null) {
+      fbBuilder.addOffset(1, offset_name);
+    }
+    if (offset_expression != null) {
+      fbBuilder.addOffset(2, offset_expression);
+    }
+    if (offset_arguments != null) {
+      fbBuilder.addOffset(3, offset_arguments);
+    }
+    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);
+
+  idl.UnlinkedConstructorInitializerKind _kind;
+  String _name;
+  idl.UnlinkedConst _expression;
+  List<idl.UnlinkedConst> _arguments;
+
+  @override
+  idl.UnlinkedConstructorInitializerKind get kind {
+    _kind ??= const _UnlinkedConstructorInitializerKindReader().vTableGet(_bp, 0, idl.UnlinkedConstructorInitializerKind.field);
+    return _kind;
+  }
+
+  @override
+  String get name {
+    _name ??= const fb.StringReader().vTableGet(_bp, 1, '');
+    return _name;
+  }
+
+  @override
+  idl.UnlinkedConst get expression {
+    _expression ??= const _UnlinkedConstReader().vTableGet(_bp, 2, null);
+    return _expression;
+  }
+
+  @override
+  List<idl.UnlinkedConst> get arguments {
+    _arguments ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 3, const <idl.UnlinkedConst>[]);
+    return _arguments;
+  }
+}
+
+abstract class _UnlinkedConstructorInitializerMixin implements idl.UnlinkedConstructorInitializer {
+  @override
+  Map<String, Object> toMap() => {
+    "kind": kind,
+    "name": name,
+    "expression": expression,
+    "arguments": arguments,
+  };
+}
+
 class UnlinkedDocumentationCommentBuilder extends Object with _UnlinkedDocumentationCommentMixin implements idl.UnlinkedDocumentationComment {
   bool _finished = false;
 
   String _text;
   int _offset;
   int _length;
 
   @override
   String get text => _text ??= '';
 
@@ skipping 401 matching lines @@
   List<UnlinkedTypeParamBuilder> _typeParameters;
   EntityRefBuilder _returnType;
   List<UnlinkedParamBuilder> _parameters;
   idl.UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _isExternal;
   int _inferredReturnTypeSlot;
+  List<UnlinkedConstructorInitializerBuilder> _constantInitializers;
 
   @override
   String get name => _name ??= '';
 
   /**
    * Name of the executable.  For setters, this includes the trailing "=".  For
    * named constructors, this excludes the class name and excludes the ".".
    * For unnamed constructors, this is the empty string.
    */
   void set name(String _value) {
@@ skipping 145 matching lines @@
   void set isExternal(bool _value) {
     assert(!_finished);
     _isExternal = _value;
   }
 
   @override
   int get inferredReturnTypeSlot => _inferredReturnTypeSlot ??= 0;
 
   /**
    * If this executable's return type is inferable, nonzero slot id
-   * identifying which entry in [LinkedLibrary.types] contains the inferred
-   * return type.  If there is no matching entry in [LinkedLibrary.types], then
+   * identifying which entry in [LinkedUnit.types] contains the inferred
+   * return type.  If there is no matching entry in [LinkedUnit.types], then
    * no return type was inferred for this variable, so its static type is
    * `dynamic`.
    */
   void set inferredReturnTypeSlot(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _inferredReturnTypeSlot = _value;
   }
 
-  UnlinkedExecutableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedConstBuilder> annotations, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder returnType, List<UnlinkedParamBuilder> parameters, idl.UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool isExternal, int inferredReturnTypeSlot})
+  @override
+  List<UnlinkedConstructorInitializerBuilder> get constantInitializers => _constantInitializers ??= <UnlinkedConstructorInitializerBuilder>[];
+
+  /**
+   * If a constant [UnlinkedExecutableKind.constructor], the constructor
+   * initializers.  Otherwise empty.
+   */
+  void set constantInitializers(List<UnlinkedConstructorInitializerBuilder> _value) {
+    assert(!_finished);
+    _constantInitializers = _value;
+  }
+
+  UnlinkedExecutableBuilder({String name, int nameOffset, UnlinkedDocumentationCommentBuilder documentationComment, List<UnlinkedConstBuilder> annotations, List<UnlinkedTypeParamBuilder> typeParameters, EntityRefBuilder returnType, List<UnlinkedParamBuilder> parameters, idl.UnlinkedExecutableKind kind, bool isAbstract, bool isStatic, bool isConst, bool isFactory, bool isExternal, int inferredReturnTypeSlot, List<UnlinkedConstructorInitializerBuilder> constantInitializers})
     : _name = name,
       _nameOffset = nameOffset,
       _documentationComment = documentationComment,
       _annotations = annotations,
       _typeParameters = typeParameters,
       _returnType = returnType,
       _parameters = parameters,
       _kind = kind,
       _isAbstract = isAbstract,
       _isStatic = isStatic,
       _isConst = isConst,
       _isFactory = isFactory,
       _isExternal = isExternal,
-      _inferredReturnTypeSlot = inferredReturnTypeSlot;
+      _inferredReturnTypeSlot = inferredReturnTypeSlot,
+      _constantInitializers = constantInitializers;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
     fb.Offset offset_documentationComment;
     fb.Offset offset_annotations;
     fb.Offset offset_typeParameters;
     fb.Offset offset_returnType;
     fb.Offset offset_parameters;
+    fb.Offset offset_constantInitializers;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
     if (_documentationComment != null) {
       offset_documentationComment = _documentationComment.finish(fbBuilder);
     }
     if (!(_annotations == null || _annotations.isEmpty)) {
       offset_annotations = fbBuilder.writeList(_annotations.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_typeParameters == null || _typeParameters.isEmpty)) {
       offset_typeParameters = fbBuilder.writeList(_typeParameters.map((b) => b.finish(fbBuilder)).toList());
     }
     if (_returnType != null) {
       offset_returnType = _returnType.finish(fbBuilder);
     }
     if (!(_parameters == null || _parameters.isEmpty)) {
       offset_parameters = fbBuilder.writeList(_parameters.map((b) => b.finish(fbBuilder)).toList());
     }
+    if (!(_constantInitializers == null || _constantInitializers.isEmpty)) {
+      offset_constantInitializers = fbBuilder.writeList(_constantInitializers.map((b) => b.finish(fbBuilder)).toList());
+    }
     fbBuilder.startTable();
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_nameOffset != null && _nameOffset != 0) {
       fbBuilder.addUint32(1, _nameOffset);
     }
     if (offset_documentationComment != null) {
       fbBuilder.addOffset(2, offset_documentationComment);
     }
@@ skipping 23 matching lines @@
     }
     if (_isFactory == true) {
       fbBuilder.addBool(11, true);
     }
     if (_isExternal == true) {
       fbBuilder.addBool(12, true);
     }
     if (_inferredReturnTypeSlot != null && _inferredReturnTypeSlot != 0) {
       fbBuilder.addUint32(13, _inferredReturnTypeSlot);
     }
+    if (offset_constantInitializers != null) {
+      fbBuilder.addOffset(14, offset_constantInitializers);
+    }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedExecutableReader extends fb.TableReader<_UnlinkedExecutableImpl> {
   const _UnlinkedExecutableReader();
 
   @override
   _UnlinkedExecutableImpl createObject(fb.BufferPointer bp) => new _UnlinkedExecutableImpl(bp);
 }
@@ skipping 10 matching lines @@
   List<idl.UnlinkedTypeParam> _typeParameters;
   idl.EntityRef _returnType;
   List<idl.UnlinkedParam> _parameters;
   idl.UnlinkedExecutableKind _kind;
   bool _isAbstract;
   bool _isStatic;
   bool _isConst;
   bool _isFactory;
   bool _isExternal;
   int _inferredReturnTypeSlot;
+  List<idl.UnlinkedConstructorInitializer> _constantInitializers;
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   int get nameOffset {
     _nameOffset ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
@@ skipping 64 matching lines @@
   bool get isExternal {
     _isExternal ??= const fb.BoolReader().vTableGet(_bp, 12, false);
     return _isExternal;
   }
 
   @override
   int get inferredReturnTypeSlot {
     _inferredReturnTypeSlot ??= const fb.Uint32Reader().vTableGet(_bp, 13, 0);
     return _inferredReturnTypeSlot;
   }
+
+  @override
+  List<idl.UnlinkedConstructorInitializer> get constantInitializers {
+    _constantInitializers ??= const fb.ListReader<idl.UnlinkedConstructorInitializer>(const _UnlinkedConstructorInitializerReader()).vTableGet(_bp, 14, const <idl.UnlinkedConstructorInitializer>[]);
+    return _constantInitializers;
+  }
 }
 
 abstract class _UnlinkedExecutableMixin implements idl.UnlinkedExecutable {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "nameOffset": nameOffset,
     "documentationComment": documentationComment,
     "annotations": annotations,
     "typeParameters": typeParameters,
     "returnType": returnType,
     "parameters": parameters,
     "kind": kind,
     "isAbstract": isAbstract,
     "isStatic": isStatic,
     "isConst": isConst,
     "isFactory": isFactory,
     "isExternal": isExternal,
     "inferredReturnTypeSlot": inferredReturnTypeSlot,
+    "constantInitializers": constantInitializers,
   };
 }
 
 class UnlinkedExportNonPublicBuilder extends Object with _UnlinkedExportNonPublicMixin implements idl.UnlinkedExportNonPublic {
   bool _finished = false;
 
   int _offset;
   int _uriOffset;
   int _uriEnd;
   List<UnlinkedConstBuilder> _annotations;
@@ skipping 2472 matching lines @@
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "propagatedTypeSlot": propagatedTypeSlot,
     "inferredTypeSlot": inferredTypeSlot,
   };
 }