Include the export namespace in the prelinked summary.

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
  * [PrelinkedReference].
  */
 enum PrelinkedReferenceKind {
   classOrEnum,
   typedef,
-  other,
+  topLevelFunction,
+  topLevelPropertyAccessor,
   prefix,
   unresolved,
 }
 
 /**
  * Enum used to indicate the kind of an executable.
  */
 enum UnlinkedExecutableKind {
   functionOrMethod,
   getter,
@@ skipping 125 matching lines @@
 }
 
 abstract class _PrelinkedDependencyMixin implements PrelinkedDependency {
   @override
   Map<String, Object> toMap() => {
     "uri": uri,
     "parts": parts,
   };
 }
 
+class PrelinkedExportNameBuilder extends Object with _PrelinkedExportNameMixin implements PrelinkedExportName {
+  bool _finished = false;
+
+  String _name;
+  int _dependency;
+  int _unit;
+  PrelinkedReferenceKind _kind;
+
+  PrelinkedExportNameBuilder();
+
+  @override
+  String get name => _name ?? '';
+
+  /**
+   * Name of the exported entity.  TODO(paulberry): do we include the trailing
+   * '=' for a setter?
+   */
+  void set name(String _value) {
+    assert(!_finished);
+    _name = _value;
+  }
+
+  @override
+  int get dependency => _dependency ?? 0;
+
+  /**
+   * Index into [PrelinkedLibrary.dependencies] for the library in which the
+   * entity is defined.
+   */
+  void set dependency(int _value) {
+    assert(!_finished);
+    _dependency = _value;
+  }
+
+  @override
+  int get unit => _unit ?? 0;
+
+  /**
+   * Integer index indicating which unit in the imported library contains the
+   * definition of the entity.  As with indices into [PrelinkedLibrary.units],
+   * zero represents the defining compilation unit, and nonzero values
+   * represent parts in the order of the corresponding `part` declarations.
+   */
+  void set unit(int _value) {
+    assert(!_finished);
+    _unit = _value;
+  }
+
+  @override
+  PrelinkedReferenceKind get kind => _kind ?? PrelinkedReferenceKind.classOrEnum;
+
+  /**
+   * The kind of the entity being referred to.
+   */
+  void set kind(PrelinkedReferenceKind _value) {
+    assert(!_finished);
+    _kind = _value;
+  }
+
+  fb.Offset finish(fb.Builder fbBuilder) {
+    assert(!_finished);
+    _finished = true;
+    fb.Offset offset_name;
+    if (_name != null) {
+      offset_name = fbBuilder.writeString(_name);
+    }
+    fbBuilder.startTable();
+    if (offset_name != null) {
+      fbBuilder.addOffset(0, offset_name);
+    }
+    if (_dependency != null && _dependency != 0) {
+      fbBuilder.addInt32(1, _dependency);
+    }
+    if (_unit != null && _unit != 0) {
+      fbBuilder.addInt32(2, _unit);
+    }
+    if (_kind != null && _kind != PrelinkedReferenceKind.classOrEnum) {
+      fbBuilder.addInt32(3, _kind.index);
+    }
+    return fbBuilder.endTable();
+  }
+}
+
+PrelinkedExportNameBuilder encodePrelinkedExportName({String name, int dependency, int unit, PrelinkedReferenceKind kind}) {
+  PrelinkedExportNameBuilder builder = new PrelinkedExportNameBuilder();
+  builder.name = name;
+  builder.dependency = dependency;
+  builder.unit = unit;
+  builder.kind = kind;
+  return builder;
+}
+
+/**
+ * Information about a single name in the export namespace of the library that
+ * is not in the public namespace.
+ */
+abstract class PrelinkedExportName extends base.SummaryClass {
+
+  /**
+   * Name of the exported entity.  TODO(paulberry): do we include the trailing
+   * '=' for a setter?
+   */
+  String get name;
+
+  /**
+   * Index into [PrelinkedLibrary.dependencies] for the library in which the
+   * entity is defined.
+   */
+  int get dependency;
+
+  /**
+   * Integer index indicating which unit in the imported library contains the
+   * definition of the entity.  As with indices into [PrelinkedLibrary.units],
+   * zero represents the defining compilation unit, and nonzero values
+   * represent parts in the order of the corresponding `part` declarations.
+   */
+  int get unit;
+
+  /**
+   * The kind of the entity being referred to.
+   */
+  PrelinkedReferenceKind get kind;
+}
+
+class _PrelinkedExportNameReader extends fb.TableReader<_PrelinkedExportNameImpl> {
+  const _PrelinkedExportNameReader();
+
+  @override
+  _PrelinkedExportNameImpl createObject(fb.BufferPointer bp) => new _PrelinkedExportNameImpl(bp);
+}
+
+class _PrelinkedExportNameImpl extends Object with _PrelinkedExportNameMixin implements PrelinkedExportName {
+  final fb.BufferPointer _bp;
+
+  _PrelinkedExportNameImpl(this._bp);
+
+  String _name;
+  int _dependency;
+  int _unit;
+  PrelinkedReferenceKind _kind;
+
+  @override
+  String get name {
+    _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
+    return _name;
+  }
+
+  @override
+  int get dependency {
+    _dependency ??= const fb.Int32Reader().vTableGet(_bp, 1, 0);
+    return _dependency;
+  }
+
+  @override
+  int get unit {
+    _unit ??= const fb.Int32Reader().vTableGet(_bp, 2, 0);
+    return _unit;
+  }
+
+  @override
+  PrelinkedReferenceKind get kind {
+    _kind ??= PrelinkedReferenceKind.values[const fb.Int32Reader().vTableGet(_bp, 3, 0)];
+    return _kind;
+  }
+}
+
+abstract class _PrelinkedExportNameMixin implements PrelinkedExportName {
+  @override
+  Map<String, Object> toMap() => {
+    "name": name,
+    "dependency": dependency,
+    "unit": unit,
+    "kind": kind,
+  };
+}
+
 class PrelinkedLibraryBuilder extends Object with _PrelinkedLibraryMixin implements PrelinkedLibrary {
   bool _finished = false;
 
   List<PrelinkedUnitBuilder> _units;
   List<PrelinkedDependencyBuilder> _dependencies;
   List<int> _importDependencies;
+  List<PrelinkedExportNameBuilder> _exportNames;
 
   PrelinkedLibraryBuilder();
 
   @override
   List<PrelinkedUnit> get units => _units ?? const <PrelinkedUnit>[];
 
   /**
    * The pre-linked summary of all the compilation units constituting the
    * library.  The summary of the defining compilation unit is listed first,
    * followed by the summary of each part, in the order of the `part`
@@ skipping 29 matching lines @@
    * of the library being imported.
    *
    * TODO(paulberry): if [dependencies] is removed, this can be removed as
    * well, since there will effectively be a one-to-one mapping.
    */
   void set importDependencies(List<int> _value) {
     assert(!_finished);
     _importDependencies = _value;
   }
 
+  @override
+  List<PrelinkedExportName> get exportNames => _exportNames ?? const <PrelinkedExportName>[];
+
+  /**
+   * Information about entities in the export namespace of the library that are
+   * not in the public namespace of the library (that is, entities that are
+   * brought into the namespace via `export` directives).
+   *
+   * Sorted by name.
+   */
+  void set exportNames(List<PrelinkedExportNameBuilder> _value) {
+    assert(!_finished);
+    _exportNames = _value;
+  }
+
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder));
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_units;
     fb.Offset offset_dependencies;
     fb.Offset offset_importDependencies;
+    fb.Offset offset_exportNames;
     if (!(_units == null || _units.isEmpty)) {
       offset_units = fbBuilder.writeList(_units.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_dependencies == null || _dependencies.isEmpty)) {
       offset_dependencies = fbBuilder.writeList(_dependencies.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_importDependencies == null || _importDependencies.isEmpty)) {
       offset_importDependencies = fbBuilder.writeListInt32(_importDependencies);
     }
+    if (!(_exportNames == null || _exportNames.isEmpty)) {
+      offset_exportNames = fbBuilder.writeList(_exportNames.map((b) => b.finish(fbBuilder)).toList());
+    }
     fbBuilder.startTable();
     if (offset_units != null) {
       fbBuilder.addOffset(0, offset_units);
     }
     if (offset_dependencies != null) {
       fbBuilder.addOffset(1, offset_dependencies);
     }
     if (offset_importDependencies != null) {
       fbBuilder.addOffset(2, offset_importDependencies);
     }
+    if (offset_exportNames != null) {
+      fbBuilder.addOffset(3, offset_exportNames);
+    }
     return fbBuilder.endTable();
   }
 }
 
-PrelinkedLibraryBuilder encodePrelinkedLibrary({List<PrelinkedUnitBuilder> units, List<PrelinkedDependencyBuilder> dependencies, List<int> importDependencies}) {
+PrelinkedLibraryBuilder encodePrelinkedLibrary({List<PrelinkedUnitBuilder> units, List<PrelinkedDependencyBuilder> dependencies, List<int> importDependencies, List<PrelinkedExportNameBuilder> exportNames}) {
   PrelinkedLibraryBuilder builder = new PrelinkedLibraryBuilder();
   builder.units = units;
   builder.dependencies = dependencies;
   builder.importDependencies = importDependencies;
+  builder.exportNames = exportNames;
   return builder;
 }
 
 /**
  * Pre-linked summary of a library.
  */
 abstract class PrelinkedLibrary extends base.SummaryClass {
   factory PrelinkedLibrary.fromBuffer(List<int> buffer) {
     fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
     return const _PrelinkedLibraryReader().read(rootRef);
@@ skipping 19 matching lines @@
   List<PrelinkedDependency> get dependencies;
 
   /**
    * For each import in [UnlinkedUnit.imports], an index into [dependencies]
    * of the library being imported.
    *
    * TODO(paulberry): if [dependencies] is removed, this can be removed as
    * well, since there will effectively be a one-to-one mapping.
    */
   List<int> get importDependencies;
+
+  /**
+   * Information about entities in the export namespace of the library that are
+   * not in the public namespace of the library (that is, entities that are
+   * brought into the namespace via `export` directives).
+   *
+   * Sorted by name.
+   */
+  List<PrelinkedExportName> get exportNames;
 }
 
 class _PrelinkedLibraryReader extends fb.TableReader<_PrelinkedLibraryImpl> {
   const _PrelinkedLibraryReader();
 
   @override
   _PrelinkedLibraryImpl createObject(fb.BufferPointer bp) => new _PrelinkedLibraryImpl(bp);
 }
 
 class _PrelinkedLibraryImpl extends Object with _PrelinkedLibraryMixin implements PrelinkedLibrary {
   final fb.BufferPointer _bp;
 
   _PrelinkedLibraryImpl(this._bp);
 
   List<PrelinkedUnit> _units;
   List<PrelinkedDependency> _dependencies;
   List<int> _importDependencies;
+  List<PrelinkedExportName> _exportNames;
 
   @override
   List<PrelinkedUnit> get units {
     _units ??= const fb.ListReader<PrelinkedUnit>(const _PrelinkedUnitReader()).vTableGet(_bp, 0, const <PrelinkedUnit>[]);
     return _units;
   }
 
   @override
   List<PrelinkedDependency> get dependencies {
     _dependencies ??= const fb.ListReader<PrelinkedDependency>(const _PrelinkedDependencyReader()).vTableGet(_bp, 1, const <PrelinkedDependency>[]);
     return _dependencies;
   }
 
   @override
   List<int> get importDependencies {
     _importDependencies ??= const fb.ListReader<int>(const fb.Int32Reader()).vTableGet(_bp, 2, const <int>[]);
     return _importDependencies;
   }
+
+  @override
+  List<PrelinkedExportName> get exportNames {
+    _exportNames ??= const fb.ListReader<PrelinkedExportName>(const _PrelinkedExportNameReader()).vTableGet(_bp, 3, const <PrelinkedExportName>[]);
+    return _exportNames;
+  }
 }
 
 abstract class _PrelinkedLibraryMixin implements PrelinkedLibrary {
   @override
   Map<String, Object> toMap() => {
     "units": units,
     "dependencies": dependencies,
     "importDependencies": importDependencies,
+    "exportNames": exportNames,
   };
 }
 
 class PrelinkedReferenceBuilder extends Object with _PrelinkedReferenceMixin implements PrelinkedReference {
   bool _finished = false;
 
   int _dependency;
   PrelinkedReferenceKind _kind;
   int _unit;
   int _numTypeParameters;
@@ skipping 4710 matching lines @@
     "nameOffset": nameOffset,
     "documentationComment": documentationComment,
     "type": type,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "hasImplicitType": hasImplicitType,
   };
 }