Add support for ConstructorElementImpl.isCycleFree to summaries.

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 1121 matching lines @@
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class LinkedUnitBuilder extends Object with _LinkedUnitMixin implements idl.LinkedUnit {
   bool _finished = false;
 
   List<LinkedReferenceBuilder> _references;
   List<EntityRefBuilder> _types;
+  List<int> _constCycles;
 
   @override
   List<LinkedReferenceBuilder> get references => _references ??= <LinkedReferenceBuilder>[];
 
   /**
    * Information about the resolution of references within the compilation
    * unit.  Each element of [UnlinkedUnit.references] has a corresponding
    * element in this list (at the same index).  If this list has additional
    * elements beyond the number of elements in [UnlinkedUnit.references], those
    * additional elements are references that are only referred to implicitly
    * (e.g. elements involved in inferred or propagated types).
    */
   void set references(List<LinkedReferenceBuilder> _value) {
     assert(!_finished);
     _references = _value;
   }
 
   @override
   List<EntityRefBuilder> get types => _types ??= <EntityRefBuilder>[];
 
   /**
    * List associating slot ids found inside the unlinked summary for the
    * compilation unit with propagated and inferred types.
    */
   void set types(List<EntityRefBuilder> _value) {
     assert(!_finished);
     _types = _value;
   }
 
-  LinkedUnitBuilder({List<LinkedReferenceBuilder> references, List<EntityRefBuilder> types})
+  @override
+  List<int> get constCycles => _constCycles ??= <int>[];
+
+  /**
+   * List of slot ids (referring to [UnlinkedExecutable.constCycleSlot])
+   * corresponding to const constructors that are part of cycles.
+   */
+  void set constCycles(List<int> _value) {
+    assert(!_finished);
+    assert(_value == null || _value.every((e) => e >= 0));
+    _constCycles = _value;
+  }
+
+  LinkedUnitBuilder({List<LinkedReferenceBuilder> references, List<EntityRefBuilder> types, List<int> constCycles})
     : _references = references,
-      _types = types;
+      _types = types,
+      _constCycles = constCycles;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_references;
     fb.Offset offset_types;
+    fb.Offset offset_constCycles;
     if (!(_references == null || _references.isEmpty)) {
       offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_types == null || _types.isEmpty)) {
       offset_types = fbBuilder.writeList(_types.map((b) => b.finish(fbBuilder)).toList());
     }
+    if (!(_constCycles == null || _constCycles.isEmpty)) {
+      offset_constCycles = fbBuilder.writeListUint32(_constCycles);
+    }
     fbBuilder.startTable();
     if (offset_references != null) {
       fbBuilder.addOffset(0, offset_references);
     }
     if (offset_types != null) {
       fbBuilder.addOffset(1, offset_types);
     }
+    if (offset_constCycles != null) {
+      fbBuilder.addOffset(2, offset_constCycles);
+    }
     return fbBuilder.endTable();
   }
 }
 
 class _LinkedUnitReader extends fb.TableReader<_LinkedUnitImpl> {
   const _LinkedUnitReader();
 
   @override
   _LinkedUnitImpl createObject(fb.BufferPointer bp) => new _LinkedUnitImpl(bp);
 }
 
 class _LinkedUnitImpl extends Object with _LinkedUnitMixin implements idl.LinkedUnit {
   final fb.BufferPointer _bp;
 
   _LinkedUnitImpl(this._bp);
 
   List<idl.LinkedReference> _references;
   List<idl.EntityRef> _types;
+  List<int> _constCycles;
 
   @override
   List<idl.LinkedReference> get references {
     _references ??= const fb.ListReader<idl.LinkedReference>(const _LinkedReferenceReader()).vTableGet(_bp, 0, const <idl.LinkedReference>[]);
     return _references;
   }
 
   @override
   List<idl.EntityRef> get types {
     _types ??= const fb.ListReader<idl.EntityRef>(const _EntityRefReader()).vTableGet(_bp, 1, const <idl.EntityRef>[]);
     return _types;
   }
+
+  @override
+  List<int> get constCycles {
+    _constCycles ??= const fb.Uint32ListReader().vTableGet(_bp, 2, const <int>[]);
+    return _constCycles;
+  }
 }
 
 abstract class _LinkedUnitMixin implements idl.LinkedUnit {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (references.isNotEmpty) _result["references"] = references.map((_value) => _value.toJson()).toList();
     if (types.isNotEmpty) _result["types"] = types.map((_value) => _value.toJson()).toList();
+    if (constCycles.isNotEmpty) _result["constCycles"] = constCycles;
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "references": references,
     "types": types,
+    "constCycles": constCycles,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class PackageBundleBuilder extends Object with _PackageBundleMixin implements idl.PackageBundle {
   bool _finished = false;
 
   List<LinkedLibraryBuilder> _linkedLibraries;
@@ skipping 2333 matching lines @@
   int _nameEnd;
   int _nameOffset;
   List<UnlinkedParamBuilder> _parameters;
   int _periodOffset;
   EntityRefBuilder _redirectedConstructor;
   String _redirectedConstructorName;
   EntityRefBuilder _returnType;
   List<UnlinkedTypeParamBuilder> _typeParameters;
   int _visibleLength;
   int _visibleOffset;
+  int _constCycleSlot;
 
   @override
   List<UnlinkedConstBuilder> get annotations => _annotations ??= <UnlinkedConstBuilder>[];
 
   /**
    * Annotations for this executable.
    */
   void set annotations(List<UnlinkedConstBuilder> _value) {
     assert(!_finished);
     _annotations = _value;
@@ skipping 290 matching lines @@
 
   /**
    * If a local function, the beginning of the visible range; zero otherwise.
    */
   void set visibleOffset(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _visibleOffset = _value;
   }
 
-  UnlinkedExecutableBuilder({List<UnlinkedConstBuilder> annotations, List<UnlinkedConstructorInitializerBuilder> constantInitializers, UnlinkedDocumentationCommentBuilder documentationComment, int inferredReturnTypeSlot, bool isAbstract, bool isConst, bool isExternal, bool isFactory, bool isRedirectedConstructor, bool isStatic, idl.UnlinkedExecutableKind kind, List<UnlinkedExecutableBuilder> localFunctions, List<UnlinkedLabelBuilder> localLabels, List<UnlinkedVariableBuilder> localVariables, String name, int nameEnd, int nameOffset, List<UnlinkedParamBuilder> parameters, int periodOffset, EntityRefBuilder redirectedConstructor, String redirectedConstructorName, EntityRefBuilder returnType, List<UnlinkedTypeParamBuilder> typeParameters, int visibleLength, int visibleOffset})
+  @override
+  int get constCycleSlot => _constCycleSlot ??= 0;
+
+  /**
+   * If [kind] is [UnlinkedExecutableKind.constructor] and [isConst] is `true`,
+   * a nonzero slot id which is unique within this compilation unit.  If this id
+   * is found in [LinkedUnit.constCycles], then this constructor is part of a
+   * cycle.
+   *
+   * Otherwise, zero.
+   */
+  void set constCycleSlot(int _value) {
+    assert(!_finished);
+    assert(_value == null || _value >= 0);
+    _constCycleSlot = _value;
+  }
+
+  UnlinkedExecutableBuilder({List<UnlinkedConstBuilder> annotations, List<UnlinkedConstructorInitializerBuilder> constantInitializers, UnlinkedDocumentationCommentBuilder documentationComment, int inferredReturnTypeSlot, bool isAbstract, bool isConst, bool isExternal, bool isFactory, bool isRedirectedConstructor, bool isStatic, idl.UnlinkedExecutableKind kind, List<UnlinkedExecutableBuilder> localFunctions, List<UnlinkedLabelBuilder> localLabels, List<UnlinkedVariableBuilder> localVariables, String name, int nameEnd, int nameOffset, List<UnlinkedParamBuilder> parameters, int periodOffset, EntityRefBuilder redirectedConstructor, String redirectedConstructorName, EntityRefBuilder returnType, List<UnlinkedTypeParamBuilder> typeParameters, int visibleLength, int visibleOffset, int constCycleSlot})
     : _annotations = annotations,
       _constantInitializers = constantInitializers,
       _documentationComment = documentationComment,
       _inferredReturnTypeSlot = inferredReturnTypeSlot,
       _isAbstract = isAbstract,
       _isConst = isConst,
       _isExternal = isExternal,
       _isFactory = isFactory,
       _isRedirectedConstructor = isRedirectedConstructor,
       _isStatic = isStatic,
       _kind = kind,
       _localFunctions = localFunctions,
       _localLabels = localLabels,
       _localVariables = localVariables,
       _name = name,
       _nameEnd = nameEnd,
       _nameOffset = nameOffset,
       _parameters = parameters,
       _periodOffset = periodOffset,
       _redirectedConstructor = redirectedConstructor,
       _redirectedConstructorName = redirectedConstructorName,
       _returnType = returnType,
       _typeParameters = typeParameters,
       _visibleLength = visibleLength,
-      _visibleOffset = visibleOffset;
+      _visibleOffset = visibleOffset,
+      _constCycleSlot = constCycleSlot;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_annotations;
     fb.Offset offset_constantInitializers;
     fb.Offset offset_documentationComment;
     fb.Offset offset_localFunctions;
     fb.Offset offset_localLabels;
     fb.Offset offset_localVariables;
@@ skipping 108 matching lines @@
     }
     if (offset_typeParameters != null) {
       fbBuilder.addOffset(16, offset_typeParameters);
     }
     if (_visibleLength != null && _visibleLength != 0) {
       fbBuilder.addUint32(20, _visibleLength);
     }
     if (_visibleOffset != null && _visibleOffset != 0) {
       fbBuilder.addUint32(21, _visibleOffset);
     }
+    if (_constCycleSlot != null && _constCycleSlot != 0) {
+      fbBuilder.addUint32(25, _constCycleSlot);
+    }
     return fbBuilder.endTable();
   }
 }
 
 class _UnlinkedExecutableReader extends fb.TableReader<_UnlinkedExecutableImpl> {
   const _UnlinkedExecutableReader();
 
   @override
   _UnlinkedExecutableImpl createObject(fb.BufferPointer bp) => new _UnlinkedExecutableImpl(bp);
 }
@@ skipping 21 matching lines @@
   int _nameEnd;
   int _nameOffset;
   List<idl.UnlinkedParam> _parameters;
   int _periodOffset;
   idl.EntityRef _redirectedConstructor;
   String _redirectedConstructorName;
   idl.EntityRef _returnType;
   List<idl.UnlinkedTypeParam> _typeParameters;
   int _visibleLength;
   int _visibleOffset;
+  int _constCycleSlot;
 
   @override
   List<idl.UnlinkedConst> get annotations {
     _annotations ??= const fb.ListReader<idl.UnlinkedConst>(const _UnlinkedConstReader()).vTableGet(_bp, 6, const <idl.UnlinkedConst>[]);
     return _annotations;
   }
 
   @override
   List<idl.UnlinkedConstructorInitializer> get constantInitializers {
     _constantInitializers ??= const fb.ListReader<idl.UnlinkedConstructorInitializer>(const _UnlinkedConstructorInitializerReader()).vTableGet(_bp, 14, const <idl.UnlinkedConstructorInitializer>[]);
@@ skipping 130 matching lines @@
   int get visibleLength {
     _visibleLength ??= const fb.Uint32Reader().vTableGet(_bp, 20, 0);
     return _visibleLength;
   }
 
   @override
   int get visibleOffset {
     _visibleOffset ??= const fb.Uint32Reader().vTableGet(_bp, 21, 0);
     return _visibleOffset;
   }
+
+  @override
+  int get constCycleSlot {
+    _constCycleSlot ??= const fb.Uint32Reader().vTableGet(_bp, 25, 0);
+    return _constCycleSlot;
+  }
 }
 
 abstract class _UnlinkedExecutableMixin implements idl.UnlinkedExecutable {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (annotations.isNotEmpty) _result["annotations"] = annotations.map((_value) => _value.toJson()).toList();
     if (constantInitializers.isNotEmpty) _result["constantInitializers"] = constantInitializers.map((_value) => _value.toJson()).toList();
     if (documentationComment != null) _result["documentationComment"] = documentationComment.toJson();
     if (inferredReturnTypeSlot != 0) _result["inferredReturnTypeSlot"] = inferredReturnTypeSlot;
@@ skipping 11 matching lines @@
     if (nameEnd != 0) _result["nameEnd"] = nameEnd;
     if (nameOffset != 0) _result["nameOffset"] = nameOffset;
     if (parameters.isNotEmpty) _result["parameters"] = parameters.map((_value) => _value.toJson()).toList();
     if (periodOffset != 0) _result["periodOffset"] = periodOffset;
     if (redirectedConstructor != null) _result["redirectedConstructor"] = redirectedConstructor.toJson();
     if (redirectedConstructorName != '') _result["redirectedConstructorName"] = redirectedConstructorName;
     if (returnType != null) _result["returnType"] = returnType.toJson();
     if (typeParameters.isNotEmpty) _result["typeParameters"] = typeParameters.map((_value) => _value.toJson()).toList();
     if (visibleLength != 0) _result["visibleLength"] = visibleLength;
     if (visibleOffset != 0) _result["visibleOffset"] = visibleOffset;
+    if (constCycleSlot != 0) _result["constCycleSlot"] = constCycleSlot;
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "annotations": annotations,
     "constantInitializers": constantInitializers,
     "documentationComment": documentationComment,
     "inferredReturnTypeSlot": inferredReturnTypeSlot,
     "isAbstract": isAbstract,
@@ skipping 10 matching lines @@
     "nameEnd": nameEnd,
     "nameOffset": nameOffset,
     "parameters": parameters,
     "periodOffset": periodOffset,
     "redirectedConstructor": redirectedConstructor,
     "redirectedConstructorName": redirectedConstructorName,
     "returnType": returnType,
     "typeParameters": typeParameters,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
+    "constCycleSlot": constCycleSlot,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnlinkedExportNonPublicBuilder extends Object with _UnlinkedExportNonPublicMixin implements idl.UnlinkedExportNonPublic {
   bool _finished = false;
 
   List<UnlinkedConstBuilder> _annotations;
@@ skipping 3007 matching lines @@
     "propagatedTypeSlot": propagatedTypeSlot,
     "type": type,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }