Downplay the distinction between linked and prelinked 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 'base.dart' as base;
 import 'flat_buffers.dart' as fb;
 
 /**
  * Enum used to indicate the kind of entity referred to by a
- * [PrelinkedReference].
+ * [LinkedReference].
  */
-enum PrelinkedReferenceKind {
+enum ReferenceKind {
   classOrEnum,
   typedef,
   topLevelFunction,
   topLevelPropertyAccessor,
   prefix,
   unresolved,
 }
 
 /**
  * Enum used to indicate the kind of an executable.
  */
 enum UnlinkedExecutableKind {
   functionOrMethod,
   getter,
   setter,
   constructor,
 }
 
 /**
  * Enum used to indicate the kind of a parameter.
  */
 enum UnlinkedParamKind {
   required,
   positional,
   named,
 }
 
-class PrelinkedDependencyBuilder extends Object with _PrelinkedDependencyMixin implements PrelinkedDependency {
+class LinkedDependencyBuilder extends Object with _LinkedDependencyMixin implements LinkedDependency {
   bool _finished = false;
 
   String _uri;
   List<String> _parts;
 
   @override
   String get uri => _uri ?? '';
 
   /**
    * The relative URI of the dependent library.  This URI is relative to the
@@ skipping 12 matching lines @@
 
   /**
    * URI for the compilation units listed in the library's `part` declarations.
    * These URIs are relative to the importing library.
    */
   void set parts(List<String> _value) {
     assert(!_finished);
     _parts = _value;
   }
 
-  PrelinkedDependencyBuilder({String uri, List<String> parts})
+  LinkedDependencyBuilder({String uri, List<String> parts})
     : _uri = uri,
       _parts = parts;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_uri;
     fb.Offset offset_parts;
     if (_uri != null) {
       offset_uri = fbBuilder.writeString(_uri);
     }
     if (!(_parts == null || _parts.isEmpty)) {
       offset_parts = fbBuilder.writeList(_parts.map((b) => fbBuilder.writeString(b)).toList());
     }
     fbBuilder.startTable();
     if (offset_uri != null) {
       fbBuilder.addOffset(0, offset_uri);
     }
     if (offset_parts != null) {
       fbBuilder.addOffset(1, offset_parts);
     }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Information about a dependency that exists between one library and another
  * due to an "import" declaration.
  */
-abstract class PrelinkedDependency extends base.SummaryClass {
+abstract class LinkedDependency extends base.SummaryClass {
 
   /**
    * The relative URI of the dependent library.  This URI is relative to the
    * importing library, even if there are intervening `export` declarations.
    * So, for example, if `a.dart` imports `b/c.dart` and `b/c.dart` exports
    * `d/e.dart`, the URI listed for `a.dart`'s dependency on `e.dart` will be
    * `b/d/e.dart`.
    */
   String get uri;
 
   /**
    * URI for the compilation units listed in the library's `part` declarations.
    * These URIs are relative to the importing library.
    */
   List<String> get parts;
 }
 
-class _PrelinkedDependencyReader extends fb.TableReader<_PrelinkedDependencyImpl> {
-  const _PrelinkedDependencyReader();
+class _LinkedDependencyReader extends fb.TableReader<_LinkedDependencyImpl> {
+  const _LinkedDependencyReader();
 
   @override
-  _PrelinkedDependencyImpl createObject(fb.BufferPointer bp) => new _PrelinkedDependencyImpl(bp);
+  _LinkedDependencyImpl createObject(fb.BufferPointer bp) => new _LinkedDependencyImpl(bp);
 }
 
-class _PrelinkedDependencyImpl extends Object with _PrelinkedDependencyMixin implements PrelinkedDependency {
+class _LinkedDependencyImpl extends Object with _LinkedDependencyMixin implements LinkedDependency {
   final fb.BufferPointer _bp;
 
-  _PrelinkedDependencyImpl(this._bp);
+  _LinkedDependencyImpl(this._bp);
 
   String _uri;
   List<String> _parts;
 
   @override
   String get uri {
     _uri ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _uri;
   }
 
   @override
   List<String> get parts {
     _parts ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 1, const <String>[]);
     return _parts;
   }
 }
 
-abstract class _PrelinkedDependencyMixin implements PrelinkedDependency {
+abstract class _LinkedDependencyMixin implements LinkedDependency {
   @override
   Map<String, Object> toMap() => {
     "uri": uri,
     "parts": parts,
   };
 }
 
-class PrelinkedExportNameBuilder extends Object with _PrelinkedExportNameMixin implements PrelinkedExportName {
+class LinkedExportNameBuilder extends Object with _LinkedExportNameMixin implements LinkedExportName {
   bool _finished = false;
 
   String _name;
   int _dependency;
   int _unit;
-  PrelinkedReferenceKind _kind;
+  ReferenceKind _kind;
 
   @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
+   * Index into [LinkedLibrary.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 exported library contains the
-   * definition of the entity.  As with indices into [PrelinkedLibrary.units],
+   * definition of the entity.  As with indices into [LinkedLibrary.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;
+  ReferenceKind get kind => _kind ?? ReferenceKind.classOrEnum;
 
   /**
    * The kind of the entity being referred to.
    */
-  void set kind(PrelinkedReferenceKind _value) {
+  void set kind(ReferenceKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
-  PrelinkedExportNameBuilder({String name, int dependency, int unit, PrelinkedReferenceKind kind})
+  LinkedExportNameBuilder({String name, int dependency, int unit, ReferenceKind kind})
     : _name = name,
       _dependency = dependency,
       _unit = unit,
       _kind = kind;
 
   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) {
+    if (_kind != null && _kind != ReferenceKind.classOrEnum) {
       fbBuilder.addInt32(3, _kind.index);
     }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * 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 {
+abstract class LinkedExportName 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
+   * Index into [LinkedLibrary.dependencies] for the library in which the
    * entity is defined.
    */
   int get dependency;
 
   /**
    * Integer index indicating which unit in the exported library contains the
-   * definition of the entity.  As with indices into [PrelinkedLibrary.units],
+   * definition of the entity.  As with indices into [LinkedLibrary.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;
+  ReferenceKind get kind;
 }
 
-class _PrelinkedExportNameReader extends fb.TableReader<_PrelinkedExportNameImpl> {
-  const _PrelinkedExportNameReader();
+class _LinkedExportNameReader extends fb.TableReader<_LinkedExportNameImpl> {
+  const _LinkedExportNameReader();
 
   @override
-  _PrelinkedExportNameImpl createObject(fb.BufferPointer bp) => new _PrelinkedExportNameImpl(bp);
+  _LinkedExportNameImpl createObject(fb.BufferPointer bp) => new _LinkedExportNameImpl(bp);
 }
 
-class _PrelinkedExportNameImpl extends Object with _PrelinkedExportNameMixin implements PrelinkedExportName {
+class _LinkedExportNameImpl extends Object with _LinkedExportNameMixin implements LinkedExportName {
   final fb.BufferPointer _bp;
 
-  _PrelinkedExportNameImpl(this._bp);
+  _LinkedExportNameImpl(this._bp);
 
   String _name;
   int _dependency;
   int _unit;
-  PrelinkedReferenceKind _kind;
+  ReferenceKind _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)];
+  ReferenceKind get kind {
+    _kind ??= ReferenceKind.values[const fb.Int32Reader().vTableGet(_bp, 3, 0)];
     return _kind;
   }
 }
 
-abstract class _PrelinkedExportNameMixin implements PrelinkedExportName {
+abstract class _LinkedExportNameMixin implements LinkedExportName {
   @override
   Map<String, Object> toMap() => {
     "name": name,
     "dependency": dependency,
     "unit": unit,
     "kind": kind,
   };
 }
 
-class PrelinkedLibraryBuilder extends Object with _PrelinkedLibraryMixin implements PrelinkedLibrary {
+class LinkedLibraryBuilder extends Object with _LinkedLibraryMixin implements LinkedLibrary {
   bool _finished = false;
 
-  List<PrelinkedUnitBuilder> _units;
-  List<PrelinkedDependencyBuilder> _dependencies;
+  List<LinkedUnitBuilder> _units;
+  List<LinkedDependencyBuilder> _dependencies;
   List<int> _importDependencies;
-  List<PrelinkedExportNameBuilder> _exportNames;
+  List<LinkedExportNameBuilder> _exportNames;
 
   @override
-  List<PrelinkedUnit> get units => _units ?? const <PrelinkedUnit>[];
+  List<LinkedUnit> get units => _units ?? const <LinkedUnit>[];
 
   /**
-   * The pre-linked summary of all the compilation units constituting the
+   * The 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`
    * declarations in the defining compilation unit.
    */
-  void set units(List<PrelinkedUnitBuilder> _value) {
+  void set units(List<LinkedUnitBuilder> _value) {
     assert(!_finished);
     _units = _value;
   }
 
   @override
-  List<PrelinkedDependency> get dependencies => _dependencies ?? const <PrelinkedDependency>[];
+  List<LinkedDependency> get dependencies => _dependencies ?? const <LinkedDependency>[];
 
   /**
    * The libraries that this library depends on (either via an explicit import
    * statement or via the implicit dependencies on `dart:core` and
    * `dart:async`).  The first element of this array is a pseudo-dependency
    * representing the library itself (it is also used for "dynamic").
    *
    * TODO(paulberry): consider removing this entirely and just using
    * [UnlinkedLibrary.imports].
    */
-  void set dependencies(List<PrelinkedDependencyBuilder> _value) {
+  void set dependencies(List<LinkedDependencyBuilder> _value) {
     assert(!_finished);
     _dependencies = _value;
   }
 
   @override
   List<int> get importDependencies => _importDependencies ?? const <int>[];
 
   /**
    * 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.
    */
   void set importDependencies(List<int> _value) {
     assert(!_finished);
     _importDependencies = _value;
   }
 
   @override
-  List<PrelinkedExportName> get exportNames => _exportNames ?? const <PrelinkedExportName>[];
+  List<LinkedExportName> get exportNames => _exportNames ?? const <LinkedExportName>[];
 
   /**
    * 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) {
+  void set exportNames(List<LinkedExportNameBuilder> _value) {
     assert(!_finished);
     _exportNames = _value;
   }
 
-  PrelinkedLibraryBuilder({List<PrelinkedUnitBuilder> units, List<PrelinkedDependencyBuilder> dependencies, List<int> importDependencies, List<PrelinkedExportNameBuilder> exportNames})
+  LinkedLibraryBuilder({List<LinkedUnitBuilder> units, List<LinkedDependencyBuilder> dependencies, List<int> importDependencies, List<LinkedExportNameBuilder> exportNames})
     : _units = units,
       _dependencies = dependencies,
       _importDependencies = importDependencies,
       _exportNames = exportNames;
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder));
   }
 
@@ skipping 27 matching lines @@
       fbBuilder.addOffset(2, offset_importDependencies);
     }
     if (offset_exportNames != null) {
       fbBuilder.addOffset(3, offset_exportNames);
     }
     return fbBuilder.endTable();
   }
 }
 
 /**
- * Pre-linked summary of a library.
+ * Linked summary of a library.
  */
-abstract class PrelinkedLibrary extends base.SummaryClass {
-  factory PrelinkedLibrary.fromBuffer(List<int> buffer) {
+abstract class LinkedLibrary extends base.SummaryClass {
+  factory LinkedLibrary.fromBuffer(List<int> buffer) {
     fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
-    return const _PrelinkedLibraryReader().read(rootRef);
+    return const _LinkedLibraryReader().read(rootRef);
   }
 
   /**
-   * The pre-linked summary of all the compilation units constituting the
+   * The 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`
    * declarations in the defining compilation unit.
    */
-  List<PrelinkedUnit> get units;
+  List<LinkedUnit> get units;
 
   /**
    * The libraries that this library depends on (either via an explicit import
    * statement or via the implicit dependencies on `dart:core` and
    * `dart:async`).  The first element of this array is a pseudo-dependency
    * representing the library itself (it is also used for "dynamic").
    *
    * TODO(paulberry): consider removing this entirely and just using
    * [UnlinkedLibrary.imports].
    */
-  List<PrelinkedDependency> get dependencies;
+  List<LinkedDependency> 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;
+  List<LinkedExportName> get exportNames;
 }
 
-class _PrelinkedLibraryReader extends fb.TableReader<_PrelinkedLibraryImpl> {
-  const _PrelinkedLibraryReader();
+class _LinkedLibraryReader extends fb.TableReader<_LinkedLibraryImpl> {
+  const _LinkedLibraryReader();
 
   @override
-  _PrelinkedLibraryImpl createObject(fb.BufferPointer bp) => new _PrelinkedLibraryImpl(bp);
+  _LinkedLibraryImpl createObject(fb.BufferPointer bp) => new _LinkedLibraryImpl(bp);
 }
 
-class _PrelinkedLibraryImpl extends Object with _PrelinkedLibraryMixin implements PrelinkedLibrary {
+class _LinkedLibraryImpl extends Object with _LinkedLibraryMixin implements LinkedLibrary {
   final fb.BufferPointer _bp;
 
-  _PrelinkedLibraryImpl(this._bp);
+  _LinkedLibraryImpl(this._bp);
 
-  List<PrelinkedUnit> _units;
-  List<PrelinkedDependency> _dependencies;
+  List<LinkedUnit> _units;
+  List<LinkedDependency> _dependencies;
   List<int> _importDependencies;
-  List<PrelinkedExportName> _exportNames;
+  List<LinkedExportName> _exportNames;
 
   @override
-  List<PrelinkedUnit> get units {
-    _units ??= const fb.ListReader<PrelinkedUnit>(const _PrelinkedUnitReader()).vTableGet(_bp, 0, const <PrelinkedUnit>[]);
+  List<LinkedUnit> get units {
+    _units ??= const fb.ListReader<LinkedUnit>(const _LinkedUnitReader()).vTableGet(_bp, 0, const <LinkedUnit>[]);
     return _units;
   }
 
   @override
-  List<PrelinkedDependency> get dependencies {
-    _dependencies ??= const fb.ListReader<PrelinkedDependency>(const _PrelinkedDependencyReader()).vTableGet(_bp, 1, const <PrelinkedDependency>[]);
+  List<LinkedDependency> get dependencies {
+    _dependencies ??= const fb.ListReader<LinkedDependency>(const _LinkedDependencyReader()).vTableGet(_bp, 1, const <LinkedDependency>[]);
     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>[]);
+  List<LinkedExportName> get exportNames {
+    _exportNames ??= const fb.ListReader<LinkedExportName>(const _LinkedExportNameReader()).vTableGet(_bp, 3, const <LinkedExportName>[]);
     return _exportNames;
   }
 }
 
-abstract class _PrelinkedLibraryMixin implements PrelinkedLibrary {
+abstract class _LinkedLibraryMixin implements LinkedLibrary {
   @override
   Map<String, Object> toMap() => {
     "units": units,
     "dependencies": dependencies,
     "importDependencies": importDependencies,
     "exportNames": exportNames,
   };
 }
 
-class PrelinkedReferenceBuilder extends Object with _PrelinkedReferenceMixin implements PrelinkedReference {
+class LinkedReferenceBuilder extends Object with _LinkedReferenceMixin implements LinkedReference {
   bool _finished = false;
 
   int _dependency;
-  PrelinkedReferenceKind _kind;
+  ReferenceKind _kind;
   int _unit;
   int _numTypeParameters;
 
   @override
   int get dependency => _dependency ?? 0;
 
   /**
-   * Index into [PrelinkedLibrary.dependencies] indicating which imported library
+   * Index into [LinkedLibrary.dependencies] indicating which imported library
    * declares the entity being referred to.
    */
   void set dependency(int _value) {
     assert(!_finished);
     _dependency = _value;
   }
 
   @override
-  PrelinkedReferenceKind get kind => _kind ?? PrelinkedReferenceKind.classOrEnum;
+  ReferenceKind get kind => _kind ?? ReferenceKind.classOrEnum;
 
   /**
    * The kind of the entity being referred to.  For the pseudo-type `dynamic`,
-   * the kind is [PrelinkedReferenceKind.classOrEnum].
+   * the kind is [ReferenceKind.classOrEnum].
    */
-  void set kind(PrelinkedReferenceKind _value) {
+  void set kind(ReferenceKind _value) {
     assert(!_finished);
     _kind = _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],
+   * definition of the entity.  As with indices into [LinkedLibrary.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
   int get numTypeParameters => _numTypeParameters ?? 0;
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   void set numTypeParameters(int _value) {
     assert(!_finished);
     _numTypeParameters = _value;
   }
 
-  PrelinkedReferenceBuilder({int dependency, PrelinkedReferenceKind kind, int unit, int numTypeParameters})
+  LinkedReferenceBuilder({int dependency, ReferenceKind kind, int unit, int numTypeParameters})
     : _dependency = dependency,
       _kind = kind,
       _unit = unit,
       _numTypeParameters = numTypeParameters;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fbBuilder.startTable();
     if (_dependency != null && _dependency != 0) {
       fbBuilder.addInt32(0, _dependency);
     }
-    if (_kind != null && _kind != PrelinkedReferenceKind.classOrEnum) {
+    if (_kind != null && _kind != ReferenceKind.classOrEnum) {
       fbBuilder.addInt32(1, _kind.index);
     }
     if (_unit != null && _unit != 0) {
       fbBuilder.addInt32(2, _unit);
     }
     if (_numTypeParameters != null && _numTypeParameters != 0) {
       fbBuilder.addInt32(3, _numTypeParameters);
     }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Information about the resolution of an [UnlinkedReference].
  */
-abstract class PrelinkedReference extends base.SummaryClass {
+abstract class LinkedReference extends base.SummaryClass {
 
   /**
-   * Index into [PrelinkedLibrary.dependencies] indicating which imported library
+   * Index into [LinkedLibrary.dependencies] indicating which imported library
    * declares the entity being referred to.
    */
   int get dependency;
 
   /**
    * The kind of the entity being referred to.  For the pseudo-type `dynamic`,
-   * the kind is [PrelinkedReferenceKind.classOrEnum].
+   * the kind is [ReferenceKind.classOrEnum].
    */
-  PrelinkedReferenceKind get kind;
+  ReferenceKind get kind;
 
   /**
    * Integer index indicating which unit in the imported library contains the
-   * definition of the entity.  As with indices into [PrelinkedLibrary.units],
+   * definition of the entity.  As with indices into [LinkedLibrary.units],
    * zero represents the defining compilation unit, and nonzero values
    * represent parts in the order of the corresponding `part` declarations.
    */
   int get unit;
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   int get numTypeParameters;
 }
 
-class _PrelinkedReferenceReader extends fb.TableReader<_PrelinkedReferenceImpl> {
-  const _PrelinkedReferenceReader();
+class _LinkedReferenceReader extends fb.TableReader<_LinkedReferenceImpl> {
+  const _LinkedReferenceReader();
 
   @override
-  _PrelinkedReferenceImpl createObject(fb.BufferPointer bp) => new _PrelinkedReferenceImpl(bp);
+  _LinkedReferenceImpl createObject(fb.BufferPointer bp) => new _LinkedReferenceImpl(bp);
 }
 
-class _PrelinkedReferenceImpl extends Object with _PrelinkedReferenceMixin implements PrelinkedReference {
+class _LinkedReferenceImpl extends Object with _LinkedReferenceMixin implements LinkedReference {
   final fb.BufferPointer _bp;
 
-  _PrelinkedReferenceImpl(this._bp);
+  _LinkedReferenceImpl(this._bp);
 
   int _dependency;
-  PrelinkedReferenceKind _kind;
+  ReferenceKind _kind;
   int _unit;
   int _numTypeParameters;
 
   @override
   int get dependency {
     _dependency ??= const fb.Int32Reader().vTableGet(_bp, 0, 0);
     return _dependency;
   }
 
   @override
-  PrelinkedReferenceKind get kind {
-    _kind ??= PrelinkedReferenceKind.values[const fb.Int32Reader().vTableGet(_bp, 1, 0)];
+  ReferenceKind get kind {
+    _kind ??= ReferenceKind.values[const fb.Int32Reader().vTableGet(_bp, 1, 0)];
     return _kind;
   }
 
   @override
   int get unit {
     _unit ??= const fb.Int32Reader().vTableGet(_bp, 2, 0);
     return _unit;
   }
 
   @override
   int get numTypeParameters {
     _numTypeParameters ??= const fb.Int32Reader().vTableGet(_bp, 3, 0);
     return _numTypeParameters;
   }
 }
 
-abstract class _PrelinkedReferenceMixin implements PrelinkedReference {
+abstract class _LinkedReferenceMixin implements LinkedReference {
   @override
   Map<String, Object> toMap() => {
     "dependency": dependency,
     "kind": kind,
     "unit": unit,
     "numTypeParameters": numTypeParameters,
   };
 }
 
-class PrelinkedUnitBuilder extends Object with _PrelinkedUnitMixin implements PrelinkedUnit {
+class LinkedUnitBuilder extends Object with _LinkedUnitMixin implements LinkedUnit {
   bool _finished = false;
 
-  List<PrelinkedReferenceBuilder> _references;
+  List<LinkedReferenceBuilder> _references;
 
   @override
-  List<PrelinkedReference> get references => _references ?? const <PrelinkedReference>[];
+  List<LinkedReference> get references => _references ?? const <LinkedReference>[];
 
   /**
    * For each reference in [UnlinkedUnit.references], information about how
    * that reference is resolved.
    */
-  void set references(List<PrelinkedReferenceBuilder> _value) {
+  void set references(List<LinkedReferenceBuilder> _value) {
     assert(!_finished);
     _references = _value;
   }
 
-  PrelinkedUnitBuilder({List<PrelinkedReferenceBuilder> references})
+  LinkedUnitBuilder({List<LinkedReferenceBuilder> references})
     : _references = references;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_references;
     if (!(_references == null || _references.isEmpty)) {
       offset_references = fbBuilder.writeList(_references.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
     if (offset_references != null) {
       fbBuilder.addOffset(0, offset_references);
     }
     return fbBuilder.endTable();
   }
 }
 
 /**
- * Pre-linked summary of a compilation unit.
+ * Linked summary of a compilation unit.
  */
-abstract class PrelinkedUnit extends base.SummaryClass {
+abstract class LinkedUnit extends base.SummaryClass {
 
   /**
    * For each reference in [UnlinkedUnit.references], information about how
    * that reference is resolved.
    */
-  List<PrelinkedReference> get references;
+  List<LinkedReference> get references;
 }
 
-class _PrelinkedUnitReader extends fb.TableReader<_PrelinkedUnitImpl> {
-  const _PrelinkedUnitReader();
+class _LinkedUnitReader extends fb.TableReader<_LinkedUnitImpl> {
+  const _LinkedUnitReader();
 
   @override
-  _PrelinkedUnitImpl createObject(fb.BufferPointer bp) => new _PrelinkedUnitImpl(bp);
+  _LinkedUnitImpl createObject(fb.BufferPointer bp) => new _LinkedUnitImpl(bp);
 }
 
-class _PrelinkedUnitImpl extends Object with _PrelinkedUnitMixin implements PrelinkedUnit {
+class _LinkedUnitImpl extends Object with _LinkedUnitMixin implements LinkedUnit {
   final fb.BufferPointer _bp;
 
-  _PrelinkedUnitImpl(this._bp);
+  _LinkedUnitImpl(this._bp);
 
-  List<PrelinkedReference> _references;
+  List<LinkedReference> _references;
 
   @override
-  List<PrelinkedReference> get references {
-    _references ??= const fb.ListReader<PrelinkedReference>(const _PrelinkedReferenceReader()).vTableGet(_bp, 0, const <PrelinkedReference>[]);
+  List<LinkedReference> get references {
+    _references ??= const fb.ListReader<LinkedReference>(const _LinkedReferenceReader()).vTableGet(_bp, 0, const <LinkedReference>[]);
     return _references;
   }
 }
 
-abstract class _PrelinkedUnitMixin implements PrelinkedUnit {
+abstract class _LinkedUnitMixin implements LinkedUnit {
   @override
   Map<String, Object> toMap() => {
     "references": references,
   };
 }
 
 class SdkBundleBuilder extends Object with _SdkBundleMixin implements SdkBundle {
   bool _finished = false;
 
-  List<String> _prelinkedLibraryUris;
-  List<PrelinkedLibraryBuilder> _prelinkedLibraries;
+  List<String> _linkedLibraryUris;
+  List<LinkedLibraryBuilder> _linkedLibraries;
   List<String> _unlinkedUnitUris;
   List<UnlinkedUnitBuilder> _unlinkedUnits;
 
   @override
-  List<String> get prelinkedLibraryUris => _prelinkedLibraryUris ?? const <String>[];
+  List<String> get linkedLibraryUris => _linkedLibraryUris ?? const <String>[];
 
   /**
-   * The list of URIs of items in [prelinkedLibraries], e.g. `dart:core`.
+   * The list of URIs of items in [linkedLibraries], e.g. `dart:core`.
    */
-  void set prelinkedLibraryUris(List<String> _value) {
+  void set linkedLibraryUris(List<String> _value) {
     assert(!_finished);
-    _prelinkedLibraryUris = _value;
+    _linkedLibraryUris = _value;
   }
 
   @override
-  List<PrelinkedLibrary> get prelinkedLibraries => _prelinkedLibraries ?? const <PrelinkedLibrary>[];
+  List<LinkedLibrary> get linkedLibraries => _linkedLibraries ?? const <LinkedLibrary>[];
 
   /**
-   * Pre-linked libraries.
+   * Linked libraries.
    */
-  void set prelinkedLibraries(List<PrelinkedLibraryBuilder> _value) {
+  void set linkedLibraries(List<LinkedLibraryBuilder> _value) {
     assert(!_finished);
-    _prelinkedLibraries = _value;
+    _linkedLibraries = _value;
   }
 
   @override
   List<String> get unlinkedUnitUris => _unlinkedUnitUris ?? const <String>[];
 
   /**
    * The list of URIs of items in [unlinkedUnits], e.g. `dart:core/bool.dart`.
    */
   void set unlinkedUnitUris(List<String> _value) {
     assert(!_finished);
     _unlinkedUnitUris = _value;
   }
 
   @override
   List<UnlinkedUnit> get unlinkedUnits => _unlinkedUnits ?? const <UnlinkedUnit>[];
 
   /**
    * Unlinked information for the compilation units constituting the SDK.
    */
   void set unlinkedUnits(List<UnlinkedUnitBuilder> _value) {
     assert(!_finished);
     _unlinkedUnits = _value;
   }
 
-  SdkBundleBuilder({List<String> prelinkedLibraryUris, List<PrelinkedLibraryBuilder> prelinkedLibraries, List<String> unlinkedUnitUris, List<UnlinkedUnitBuilder> unlinkedUnits})
-    : _prelinkedLibraryUris = prelinkedLibraryUris,
-      _prelinkedLibraries = prelinkedLibraries,
+  SdkBundleBuilder({List<String> linkedLibraryUris, List<LinkedLibraryBuilder> linkedLibraries, List<String> unlinkedUnitUris, List<UnlinkedUnitBuilder> unlinkedUnits})
+    : _linkedLibraryUris = linkedLibraryUris,
+      _linkedLibraries = linkedLibraries,
       _unlinkedUnitUris = unlinkedUnitUris,
       _unlinkedUnits = unlinkedUnits;
 
   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_prelinkedLibraryUris;
-    fb.Offset offset_prelinkedLibraries;
+    fb.Offset offset_linkedLibraryUris;
+    fb.Offset offset_linkedLibraries;
     fb.Offset offset_unlinkedUnitUris;
     fb.Offset offset_unlinkedUnits;
-    if (!(_prelinkedLibraryUris == null || _prelinkedLibraryUris.isEmpty)) {
-      offset_prelinkedLibraryUris = fbBuilder.writeList(_prelinkedLibraryUris.map((b) => fbBuilder.writeString(b)).toList());
+    if (!(_linkedLibraryUris == null || _linkedLibraryUris.isEmpty)) {
+      offset_linkedLibraryUris = fbBuilder.writeList(_linkedLibraryUris.map((b) => fbBuilder.writeString(b)).toList());
     }
-    if (!(_prelinkedLibraries == null || _prelinkedLibraries.isEmpty)) {
-      offset_prelinkedLibraries = fbBuilder.writeList(_prelinkedLibraries.map((b) => b.finish(fbBuilder)).toList());
+    if (!(_linkedLibraries == null || _linkedLibraries.isEmpty)) {
+      offset_linkedLibraries = fbBuilder.writeList(_linkedLibraries.map((b) => b.finish(fbBuilder)).toList());
     }
     if (!(_unlinkedUnitUris == null || _unlinkedUnitUris.isEmpty)) {
       offset_unlinkedUnitUris = fbBuilder.writeList(_unlinkedUnitUris.map((b) => fbBuilder.writeString(b)).toList());
     }
     if (!(_unlinkedUnits == null || _unlinkedUnits.isEmpty)) {
       offset_unlinkedUnits = fbBuilder.writeList(_unlinkedUnits.map((b) => b.finish(fbBuilder)).toList());
     }
     fbBuilder.startTable();
-    if (offset_prelinkedLibraryUris != null) {
-      fbBuilder.addOffset(0, offset_prelinkedLibraryUris);
+    if (offset_linkedLibraryUris != null) {
+      fbBuilder.addOffset(0, offset_linkedLibraryUris);
     }
-    if (offset_prelinkedLibraries != null) {
-      fbBuilder.addOffset(1, offset_prelinkedLibraries);
+    if (offset_linkedLibraries != null) {
+      fbBuilder.addOffset(1, offset_linkedLibraries);
     }
     if (offset_unlinkedUnitUris != null) {
       fbBuilder.addOffset(2, offset_unlinkedUnitUris);
     }
     if (offset_unlinkedUnits != null) {
       fbBuilder.addOffset(3, offset_unlinkedUnits);
     }
     return fbBuilder.endTable();
   }
 }
 
 /**
  * Information about SDK.
  */
 abstract class SdkBundle extends base.SummaryClass {
   factory SdkBundle.fromBuffer(List<int> buffer) {
     fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
     return const _SdkBundleReader().read(rootRef);
   }
 
   /**
-   * The list of URIs of items in [prelinkedLibraries], e.g. `dart:core`.
+   * The list of URIs of items in [linkedLibraries], e.g. `dart:core`.
    */
-  List<String> get prelinkedLibraryUris;
+  List<String> get linkedLibraryUris;
 
   /**
-   * Pre-linked libraries.
+   * Linked libraries.
    */
-  List<PrelinkedLibrary> get prelinkedLibraries;
+  List<LinkedLibrary> get linkedLibraries;
 
   /**
    * The list of URIs of items in [unlinkedUnits], e.g. `dart:core/bool.dart`.
    */
   List<String> get unlinkedUnitUris;
 
   /**
    * Unlinked information for the compilation units constituting the SDK.
    */
   List<UnlinkedUnit> get unlinkedUnits;
 }
 
 class _SdkBundleReader extends fb.TableReader<_SdkBundleImpl> {
   const _SdkBundleReader();
 
   @override
   _SdkBundleImpl createObject(fb.BufferPointer bp) => new _SdkBundleImpl(bp);
 }
 
 class _SdkBundleImpl extends Object with _SdkBundleMixin implements SdkBundle {
   final fb.BufferPointer _bp;
 
   _SdkBundleImpl(this._bp);
 
-  List<String> _prelinkedLibraryUris;
-  List<PrelinkedLibrary> _prelinkedLibraries;
+  List<String> _linkedLibraryUris;
+  List<LinkedLibrary> _linkedLibraries;
   List<String> _unlinkedUnitUris;
   List<UnlinkedUnit> _unlinkedUnits;
 
   @override
-  List<String> get prelinkedLibraryUris {
-    _prelinkedLibraryUris ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 0, const <String>[]);
-    return _prelinkedLibraryUris;
+  List<String> get linkedLibraryUris {
+    _linkedLibraryUris ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 0, const <String>[]);
+    return _linkedLibraryUris;
   }
 
   @override
-  List<PrelinkedLibrary> get prelinkedLibraries {
-    _prelinkedLibraries ??= const fb.ListReader<PrelinkedLibrary>(const _PrelinkedLibraryReader()).vTableGet(_bp, 1, const <PrelinkedLibrary>[]);
-    return _prelinkedLibraries;
+  List<LinkedLibrary> get linkedLibraries {
+    _linkedLibraries ??= const fb.ListReader<LinkedLibrary>(const _LinkedLibraryReader()).vTableGet(_bp, 1, const <LinkedLibrary>[]);
+    return _linkedLibraries;
   }
 
   @override
   List<String> get unlinkedUnitUris {
     _unlinkedUnitUris ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 2, const <String>[]);
     return _unlinkedUnitUris;
   }
 
   @override
   List<UnlinkedUnit> get unlinkedUnits {
     _unlinkedUnits ??= const fb.ListReader<UnlinkedUnit>(const _UnlinkedUnitReader()).vTableGet(_bp, 3, const <UnlinkedUnit>[]);
     return _unlinkedUnits;
   }
 }
 
 abstract class _SdkBundleMixin implements SdkBundle {
   @override
   Map<String, Object> toMap() => {
-    "prelinkedLibraryUris": prelinkedLibraryUris,
-    "prelinkedLibraries": prelinkedLibraries,
+    "linkedLibraryUris": linkedLibraryUris,
+    "linkedLibraries": linkedLibraries,
     "unlinkedUnitUris": unlinkedUnitUris,
     "unlinkedUnits": unlinkedUnits,
   };
 }
 
 class UnlinkedClassBuilder extends Object with _UnlinkedClassMixin implements UnlinkedClass {
   bool _finished = false;
 
   String _name;
   int _nameOffset;
@@ skipping 2403 matching lines @@
   Map<String, Object> toMap() => {
     "uriOffset": uriOffset,
     "uriEnd": uriEnd,
   };
 }
 
 class UnlinkedPublicNameBuilder extends Object with _UnlinkedPublicNameMixin implements UnlinkedPublicName {
   bool _finished = false;
 
   String _name;
-  PrelinkedReferenceKind _kind;
+  ReferenceKind _kind;
   int _numTypeParameters;
 
   @override
   String get name => _name ?? '';
 
   /**
    * The name itself.
    */
   void set name(String _value) {
     assert(!_finished);
     _name = _value;
   }
 
   @override
-  PrelinkedReferenceKind get kind => _kind ?? PrelinkedReferenceKind.classOrEnum;
+  ReferenceKind get kind => _kind ?? ReferenceKind.classOrEnum;
 
   /**
    * The kind of object referred to by the name.
    */
-  void set kind(PrelinkedReferenceKind _value) {
+  void set kind(ReferenceKind _value) {
     assert(!_finished);
     _kind = _value;
   }
 
   @override
   int get numTypeParameters => _numTypeParameters ?? 0;
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   void set numTypeParameters(int _value) {
     assert(!_finished);
     _numTypeParameters = _value;
   }
 
-  UnlinkedPublicNameBuilder({String name, PrelinkedReferenceKind kind, int numTypeParameters})
+  UnlinkedPublicNameBuilder({String name, ReferenceKind kind, int numTypeParameters})
     : _name = name,
       _kind = kind,
       _numTypeParameters = numTypeParameters;
 
   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 (_kind != null && _kind != PrelinkedReferenceKind.classOrEnum) {
+    if (_kind != null && _kind != ReferenceKind.classOrEnum) {
       fbBuilder.addInt32(1, _kind.index);
     }
     if (_numTypeParameters != null && _numTypeParameters != 0) {
       fbBuilder.addInt32(2, _numTypeParameters);
     }
     return fbBuilder.endTable();
   }
 }
 
 /**
@@ skipping 13 matching lines @@
 abstract class UnlinkedPublicName extends base.SummaryClass {
 
   /**
    * The name itself.
    */
   String get name;
 
   /**
    * The kind of object referred to by the name.
    */
-  PrelinkedReferenceKind get kind;
+  ReferenceKind get kind;
 
   /**
    * If the entity being referred to is generic, the number of type parameters
    * it accepts.  Otherwise zero.
    */
   int get numTypeParameters;
 }
 
 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;
-  PrelinkedReferenceKind _kind;
+  ReferenceKind _kind;
   int _numTypeParameters;
 
   @override
   String get name {
     _name ??= const fb.StringReader().vTableGet(_bp, 0, '');
     return _name;
   }
 
   @override
-  PrelinkedReferenceKind get kind {
-    _kind ??= PrelinkedReferenceKind.values[const fb.Int32Reader().vTableGet(_bp, 1, 0)];
+  ReferenceKind get kind {
+    _kind ??= ReferenceKind.values[const fb.Int32Reader().vTableGet(_bp, 1, 0)];
     return _kind;
   }
 
   @override
   int get numTypeParameters {
     _numTypeParameters ??= const fb.Int32Reader().vTableGet(_bp, 2, 0);
     return _numTypeParameters;
   }
 }
 
@@ skipping 1634 matching lines @@
     "nameOffset": nameOffset,
     "documentationComment": documentationComment,
     "type": type,
     "isStatic": isStatic,
     "isFinal": isFinal,
     "isConst": isConst,
     "hasImplicitType": hasImplicitType,
   };
 }