Include explicit constructors and static methods into UnlinkedPublicName

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 method.
+   */
+  staticMethod,
+
+  /**
    * The entity is a typedef.
    */
   typedef,
 
   /**
    * The entity is a top level function.
    */
   topLevelFunction,
 
   /**
@@ skipping 4252 matching lines @@
     "uriEnd": uriEnd,
   };
 }
 
 class UnlinkedPublicNameBuilder extends Object with _UnlinkedPublicNameMixin implements UnlinkedPublicName {
   bool _finished = false;
 
   String _name;
   ReferenceKind _kind;
   int _numTypeParameters;
+  List<UnlinkedPublicNameBuilder> _executables;
 
   @override
   String get name => _name ??= '';
 
   /**
    * The name itself.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
@@ skipping 16 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;
   }
 
-  UnlinkedPublicNameBuilder({String name, ReferenceKind kind, int numTypeParameters})
+  @override
+  List<UnlinkedPublicNameBuilder> get executables => _executables ??= <UnlinkedPublicNameBuilder>[];
+
+  /**
+   * If this [UnlinkedPublicName] is a class, the list of static methods
+   * and constructors.  Otherwise empty.
+   */
+  void set executables(List<UnlinkedPublicNameBuilder> _value) {
+    assert(!_finished);
+    _executables = _value;
+  }
+
+  UnlinkedPublicNameBuilder({String name, ReferenceKind kind, int numTypeParameters, List<UnlinkedPublicNameBuilder> executables})
     : _name = name,
       _kind = kind,
-      _numTypeParameters = numTypeParameters;
+      _numTypeParameters = numTypeParameters,
+      _executables = executables;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_name;
+    fb.Offset offset_executables;
     if (_name != null) {
       offset_name = fbBuilder.writeString(_name);
     }
+    if (!(_executables == null || _executables.isEmpty)) {
+      offset_executables = fbBuilder.writeList(_executables.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);
+    }
     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
  * doesn't have to peek into the library to obtain this info.
  *
- * TODO(paulberry): for classes, add info about static members and
- * constructors, since this will be needed to prelink info about constants.
- *
  * TODO(paulberry): some of this information is redundant with information
  * elsewhere in the summary.  Consider reducing the redundancy to reduce
  * summary size.
  */
 abstract class UnlinkedPublicName extends base.SummaryClass {
 
   /**
    * The name itself.
    */
   String get name;
 
   /**
    * The kind of object referred to by the name.
    */
   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.
+   */
+  List<UnlinkedPublicName> get executables;
 }
 
 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;
 
   @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;
+  }
 }
 
 abstract class _UnlinkedPublicNameMixin implements UnlinkedPublicName {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "kind": kind,
     "numTypeParameters": numTypeParameters,
+    "executables": executables,
   };
 }
 
 class UnlinkedPublicNamespaceBuilder extends Object with _UnlinkedPublicNamespaceMixin implements UnlinkedPublicNamespace {
   bool _finished = false;
 
   List<UnlinkedPublicNameBuilder> _names;
   List<UnlinkedExportPublicBuilder> _exports;
   List<String> _parts;
 
@@ skipping 1493 matching lines @@
     "documentationComment": documentationComment,
     "type": type,
     "constExpr": constExpr,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "propagatedTypeSlot": propagatedTypeSlot,
   };
 }