Record static constant public fields.

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 'base.dart' as base;
 import 'flat_buffers.dart' as fb;
 
 /**
  * Enum used to indicate the kind of entity referred to by a
  * [LinkedReference].
  */
 enum ReferenceKind {
   /**
    * The entity is a class or enum.
    */
   classOrEnum,
 
   /**
    * The entity is a constructor.
    */
   constructor,
 
   /**
+   * The entity is a static const field.
+   */
+  constField,
+
+  /**
    * The entity is a static method.
    */
   staticMethod,
 
   /**
    * The entity is a typedef.
    */
   typedef,
 
   /**
@@ skipping 4338 matching lines @@
     "uriEnd": uriEnd,
   };
 }
 
 class UnlinkedPublicNameBuilder extends Object with _UnlinkedPublicNameMixin implements UnlinkedPublicName {
   bool _finished = false;
 
   String _name;
   ReferenceKind _kind;
   int _numTypeParameters;
-  List<UnlinkedPublicNameBuilder> _executables;
+  List<UnlinkedPublicNameBuilder> _constMembers;
 
   @override
   String get name => _name ??= '';
 
   /**
    * The name itself.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
@@ skipping 17 matching lines @@
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   void set numTypeParameters(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _numTypeParameters = _value;
   }
 
   @override
-  List<UnlinkedPublicNameBuilder> get executables => _executables ??= <UnlinkedPublicNameBuilder>[];
+  List<UnlinkedPublicNameBuilder> get constMembers => _constMembers ??= <UnlinkedPublicNameBuilder>[];
 
   /**
-   * If this [UnlinkedPublicName] is a class, the list of static methods
-   * and constructors.  Otherwise empty.
+   * If this [UnlinkedPublicName] is a class, the list of members which can be
+   * referenced from constants - static constant fields, static methods, and
+   * constructors.  Otherwise empty.
    */
-  void set executables(List<UnlinkedPublicNameBuilder> _value) {
+  void set constMembers(List<UnlinkedPublicNameBuilder> _value) {
     assert(!_finished);
-    _executables = _value;
+    _constMembers = _value;
   }
 
-  UnlinkedPublicNameBuilder({String name, ReferenceKind kind, int numTypeParameters, List<UnlinkedPublicNameBuilder> executables})
+  UnlinkedPublicNameBuilder({String name, ReferenceKind kind, int numTypeParameters, List<UnlinkedPublicNameBuilder> constMembers})
     : _name = name,
       _kind = kind,
       _numTypeParameters = numTypeParameters,
-      _executables = executables;
+      _constMembers = constMembers;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
-    fb.Offset offset_executables;
+    fb.Offset offset_constMembers;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
-    if (!(_executables == null || _executables.isEmpty)) {
-      offset_executables = fbBuilder.writeList(_executables.map((b) => b.finish(fbBuilder)).toList());
+    if (!(_constMembers == null || _constMembers.isEmpty)) {
+      offset_constMembers = fbBuilder.writeList(_constMembers.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_name != null) {
       fbBuilder.addOffset(0, offset_name);
     }
     if (_kind != null && _kind != ReferenceKind.classOrEnum) {
       fbBuilder.addUint32(1, _kind.index);
     }
     if (_numTypeParameters != null && _numTypeParameters != 0) {
       fbBuilder.addUint32(2, _numTypeParameters);
     }
-    if (offset_executables != null) {
-      fbBuilder.addOffset(3, offset_executables);
+    if (offset_constMembers != null) {
+      fbBuilder.addOffset(3, offset_constMembers);
     }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Unlinked summary information about a specific name contributed by a
  * compilation unit to a library's public namespace.
  *
  * TODO(paulberry): add a count of generic parameters, so that resynthesis
@@ skipping 15 matching lines @@
    */
   ReferenceKind get kind;
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   int get numTypeParameters;
 
   /**
-   * If this [UnlinkedPublicName] is a class, the list of static methods
-   * and constructors.  Otherwise empty.
+   * If this [UnlinkedPublicName] is a class, the list of members which can be
+   * referenced from constants - static constant fields, static methods, and
+   * constructors.  Otherwise empty.
    */
-  List<UnlinkedPublicName> get executables;
+  List<UnlinkedPublicName> get constMembers;
 }
 
 class _UnlinkedPublicNameReader extends fb.TableReader<_UnlinkedPublicNameImpl> {
   const _UnlinkedPublicNameReader();
 
   @override
   _UnlinkedPublicNameImpl createObject(fb.BufferPointer bp) => new _UnlinkedPublicNameImpl(bp);
 }
 
 class _UnlinkedPublicNameImpl extends Object with _UnlinkedPublicNameMixin implements UnlinkedPublicName {
   final fb.BufferPointer _bp;
 
   _UnlinkedPublicNameImpl(this._bp);
 
   String _name;
   ReferenceKind _kind;
   int _numTypeParameters;
-  List<UnlinkedPublicName> _executables;
+  List<UnlinkedPublicName> _constMembers;
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
   ReferenceKind get kind {
     _kind ??= const _ReferenceKindReader().vTableGet(_bp, 1, ReferenceKind.classOrEnum);
     return _kind;
   }
 
   @override
   int get numTypeParameters {
     _numTypeParameters ??= const fb.Uint32Reader().vTableGet(_bp, 2, 0);
     return _numTypeParameters;
   }
 
   @override
-  List<UnlinkedPublicName> get executables {
-    _executables ??= const fb.ListReader<UnlinkedPublicName>(const _UnlinkedPublicNameReader()).vTableGet(_bp, 3, const <UnlinkedPublicName>[]);
-    return _executables;
+  List<UnlinkedPublicName> get constMembers {
+    _constMembers ??= const fb.ListReader<UnlinkedPublicName>(const _UnlinkedPublicNameReader()).vTableGet(_bp, 3, const <UnlinkedPublicName>[]);
+    return _constMembers;
   }
 }
 
 abstract class _UnlinkedPublicNameMixin implements UnlinkedPublicName {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "kind": kind,
     "numTypeParameters": numTypeParameters,
-    "executables": executables,
+    "constMembers": constMembers,
   };
 }
 
 class UnlinkedPublicNamespaceBuilder extends Object with _UnlinkedPublicNamespaceMixin implements UnlinkedPublicNamespace {
   bool _finished = false;
 
   List<UnlinkedPublicNameBuilder> _names;
   List<UnlinkedExportPublicBuilder> _exports;
   List<String> _parts;
 
@@ skipping 1529 matching lines @@
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "propagatedTypeSlot": propagatedTypeSlot,
     "inferredTypeSlot": inferredTypeSlot,
   };
 }