Index defined top-level and class member names.

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;
 import 'idl.dart' as idl;
 import 'dart:convert' as convert;
 
+class _IndexNameKindReader extends fb.Reader<idl.IndexNameKind> {
+  const _IndexNameKindReader() : super();
+
+  @override
+  int get size => 1;
+
+  @override
+  idl.IndexNameKind read(fb.BufferPointer bp) {
+    int index = const fb.Uint8Reader().read(bp);
+    return idl.IndexNameKind.values[index];
+  }
+}
+
 class _IndexRelationKindReader extends fb.Reader<idl.IndexRelationKind> {
   const _IndexRelationKindReader() : super();
 
   @override
   int get size => 1;
 
   @override
   idl.IndexRelationKind read(fb.BufferPointer bp) {
     int index = const fb.Uint8Reader().read(bp);
     return idl.IndexRelationKind.values[index];
@@ skipping 1405 matching lines @@
 }
 
 class PackageIndexBuilder extends Object with _PackageIndexMixin implements idl.PackageIndex {
   bool _finished = false;
 
   List<idl.IndexSyntheticElementKind> _elementKinds;
   List<int> _elementLibraryUris;
   List<int> _elementOffsets;
   List<int> _elementUnits;
   List<int> _elementUnitUris;
+  List<String> _strings;
   List<UnitIndexBuilder> _units;
-  List<String> _uris;
 
   @override
   List<idl.IndexSyntheticElementKind> get elementKinds => _elementKinds ??= <idl.IndexSyntheticElementKind>[];
 
   /**
    * Each item of this list corresponds to a unique referenced element.  It is
    * the kind of the synthetic element.
    */
   void set elementKinds(List<idl.IndexSyntheticElementKind> _value) {
     assert(!_finished);
@@ skipping 49 matching lines @@
    * Each item of this list corresponds to a unique unit URI with an element
    * referenced in the [PackageIndex].  It is an index into [uris] list.
    */
   void set elementUnitUris(List<int> _value) {
     assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
     _elementUnitUris = _value;
   }
 
   @override
+  List<String> get strings => _strings ??= <String>[];
+
+  /**
+   * List of unique element strings used in this [PackageIndex].
+   */
+  void set strings(List<String> _value) {
+    assert(!_finished);
+    _strings = _value;
+  }
+
+  @override
   List<UnitIndexBuilder> get units => _units ??= <UnitIndexBuilder>[];
 
   /**
    * List of units indexed in this [PackageIndex].
    */
   void set units(List<UnitIndexBuilder> _value) {
     assert(!_finished);
     _units = _value;
   }
 
-  @override
-  List<String> get uris => _uris ??= <String>[];
-
-  /**
-   * List of unique URIs used in this [PackageIndex].
-   */
-  void set uris(List<String> _value) {
-    assert(!_finished);
-    _uris = _value;
-  }
-
-  PackageIndexBuilder({List<idl.IndexSyntheticElementKind> elementKinds, List<int> elementLibraryUris, List<int> elementOffsets, List<int> elementUnits, List<int> elementUnitUris, List<UnitIndexBuilder> units, List<String> uris})
+  PackageIndexBuilder({List<idl.IndexSyntheticElementKind> elementKinds, List<int> elementLibraryUris, List<int> elementOffsets, List<int> elementUnits, List<int> elementUnitUris, List<String> strings, List<UnitIndexBuilder> units})
     : _elementKinds = elementKinds,
       _elementLibraryUris = elementLibraryUris,
       _elementOffsets = elementOffsets,
       _elementUnits = elementUnits,
       _elementUnitUris = elementUnitUris,
-      _units = units,
-      _uris = uris;
+      _strings = strings,
+      _units = units;
 
   List<int> toBuffer() {
     fb.Builder fbBuilder = new fb.Builder();
     return fbBuilder.finish(finish(fbBuilder), "Indx");
   }
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
     fb.Offset offset_elementKinds;
     fb.Offset offset_elementLibraryUris;
     fb.Offset offset_elementOffsets;
     fb.Offset offset_elementUnits;
     fb.Offset offset_elementUnitUris;
+    fb.Offset offset_strings;
     fb.Offset offset_units;
-    fb.Offset offset_uris;
     if (!(_elementKinds == null || _elementKinds.isEmpty)) {
       offset_elementKinds = fbBuilder.writeListUint8(_elementKinds.map((b) => b.index).toList());
     }
     if (!(_elementLibraryUris == null || _elementLibraryUris.isEmpty)) {
       offset_elementLibraryUris = fbBuilder.writeListUint32(_elementLibraryUris);
     }
     if (!(_elementOffsets == null || _elementOffsets.isEmpty)) {
       offset_elementOffsets = fbBuilder.writeListUint32(_elementOffsets);
     }
     if (!(_elementUnits == null || _elementUnits.isEmpty)) {
       offset_elementUnits = fbBuilder.writeListUint32(_elementUnits);
     }
     if (!(_elementUnitUris == null || _elementUnitUris.isEmpty)) {
       offset_elementUnitUris = fbBuilder.writeListUint32(_elementUnitUris);
     }
+    if (!(_strings == null || _strings.isEmpty)) {
+      offset_strings = fbBuilder.writeList(_strings.map((b) => fbBuilder.writeString(b)).toList());
+    }
     if (!(_units == null || _units.isEmpty)) {
       offset_units = fbBuilder.writeList(_units.map((b) => b.finish(fbBuilder)).toList());
     }
-    if (!(_uris == null || _uris.isEmpty)) {
-      offset_uris = fbBuilder.writeList(_uris.map((b) => fbBuilder.writeString(b)).toList());
-    }
     fbBuilder.startTable();
     if (offset_elementKinds != null) {
-      fbBuilder.addOffset(6, offset_elementKinds);
+      fbBuilder.addOffset(5, offset_elementKinds);

[Brian Wilkerson, 2016/02/27 18:15:10]

It would be good to use constants for these offsets, especially given that
someone has to remember all the places to update them when they need to change.

[scheglov, 2016/02/27 23:00:44]

I'm sorry, I should have thought to provide more details.

The files 	format.dart and format.fbs are generated from idl.dart file.
So, these constants are specified there as:
  @Id(5)
  List<IndexSyntheticElementKind> get elementKinds;

It also does not worth to review these auto-generated files.

     }
     if (offset_elementLibraryUris != null) {
       fbBuilder.addOffset(2, offset_elementLibraryUris);
     }
     if (offset_elementOffsets != null) {
       fbBuilder.addOffset(1, offset_elementOffsets);
     }
     if (offset_elementUnits != null) {
       fbBuilder.addOffset(0, offset_elementUnits);
     }
     if (offset_elementUnitUris != null) {
       fbBuilder.addOffset(3, offset_elementUnitUris);
     }
+    if (offset_strings != null) {
+      fbBuilder.addOffset(6, offset_strings);
+    }
     if (offset_units != null) {
-      fbBuilder.addOffset(5, offset_units);
-    }
-    if (offset_uris != null) {
-      fbBuilder.addOffset(4, offset_uris);
+      fbBuilder.addOffset(4, offset_units);
     }
     return fbBuilder.endTable();
   }
 }
 
 idl.PackageIndex readPackageIndex(List<int> buffer) {
   fb.BufferPointer rootRef = new fb.BufferPointer.fromBytes(buffer);
   return const _PackageIndexReader().read(rootRef);
 }
 
 class _PackageIndexReader extends fb.TableReader<_PackageIndexImpl> {
   const _PackageIndexReader();
 
   @override
   _PackageIndexImpl createObject(fb.BufferPointer bp) => new _PackageIndexImpl(bp);
 }
 
 class _PackageIndexImpl extends Object with _PackageIndexMixin implements idl.PackageIndex {
   final fb.BufferPointer _bp;
 
   _PackageIndexImpl(this._bp);
 
   List<idl.IndexSyntheticElementKind> _elementKinds;
   List<int> _elementLibraryUris;
   List<int> _elementOffsets;
   List<int> _elementUnits;
   List<int> _elementUnitUris;
+  List<String> _strings;
   List<idl.UnitIndex> _units;
-  List<String> _uris;
 
   @override
   List<idl.IndexSyntheticElementKind> get elementKinds {
-    _elementKinds ??= const fb.ListReader<idl.IndexSyntheticElementKind>(const _IndexSyntheticElementKindReader()).vTableGet(_bp, 6, const <idl.IndexSyntheticElementKind>[]);
+    _elementKinds ??= const fb.ListReader<idl.IndexSyntheticElementKind>(const _IndexSyntheticElementKindReader()).vTableGet(_bp, 5, const <idl.IndexSyntheticElementKind>[]);
     return _elementKinds;
   }
 
   @override
   List<int> get elementLibraryUris {
     _elementLibraryUris ??= const fb.Uint32ListReader().vTableGet(_bp, 2, const <int>[]);
     return _elementLibraryUris;
   }
 
   @override
   List<int> get elementOffsets {
     _elementOffsets ??= const fb.Uint32ListReader().vTableGet(_bp, 1, const <int>[]);
     return _elementOffsets;
   }
 
   @override
   List<int> get elementUnits {
     _elementUnits ??= const fb.Uint32ListReader().vTableGet(_bp, 0, const <int>[]);
     return _elementUnits;
   }
 
   @override
   List<int> get elementUnitUris {
     _elementUnitUris ??= const fb.Uint32ListReader().vTableGet(_bp, 3, const <int>[]);
     return _elementUnitUris;
   }
 
   @override
+  List<String> get strings {
+    _strings ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 6, const <String>[]);
+    return _strings;
+  }
+
+  @override
   List<idl.UnitIndex> get units {
-    _units ??= const fb.ListReader<idl.UnitIndex>(const _UnitIndexReader()).vTableGet(_bp, 5, const <idl.UnitIndex>[]);
+    _units ??= const fb.ListReader<idl.UnitIndex>(const _UnitIndexReader()).vTableGet(_bp, 4, const <idl.UnitIndex>[]);
     return _units;
   }
-
-  @override
-  List<String> get uris {
-    _uris ??= const fb.ListReader<String>(const fb.StringReader()).vTableGet(_bp, 4, const <String>[]);
-    return _uris;
-  }
 }
 
 abstract class _PackageIndexMixin implements idl.PackageIndex {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
     if (elementKinds.isNotEmpty) _result["elementKinds"] = elementKinds.map((_value) => _value.toString().split('.')[1]).toList();
     if (elementLibraryUris.isNotEmpty) _result["elementLibraryUris"] = elementLibraryUris;
     if (elementOffsets.isNotEmpty) _result["elementOffsets"] = elementOffsets;
     if (elementUnits.isNotEmpty) _result["elementUnits"] = elementUnits;
     if (elementUnitUris.isNotEmpty) _result["elementUnitUris"] = elementUnitUris;
+    if (strings.isNotEmpty) _result["strings"] = strings;
     if (units.isNotEmpty) _result["units"] = units.map((_value) => _value.toJson()).toList();
-    if (uris.isNotEmpty) _result["uris"] = uris;
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
     "elementKinds": elementKinds,
     "elementLibraryUris": elementLibraryUris,
     "elementOffsets": elementOffsets,
     "elementUnits": elementUnits,
     "elementUnitUris": elementUnitUris,
+    "strings": strings,
     "units": units,
-    "uris": uris,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }
 
 class UnitIndexBuilder extends Object with _UnitIndexMixin implements idl.UnitIndex {
   bool _finished = false;
 
+  List<idl.IndexNameKind> _definedNameKinds;
+  List<int> _definedNameOffsets;
+  List<int> _definedNames;
   List<int> _elements;
   List<idl.IndexRelationKind> _kinds;
   int _libraryUri;
   List<int> _locationLengths;
   List<int> _locationOffsets;
   int _unitUri;
 
   @override
+  List<idl.IndexNameKind> get definedNameKinds => _definedNameKinds ??= <idl.IndexNameKind>[];
+
+  /**
+   * Each item of this list is the kind of an element defined in this unit.
+   */
+  void set definedNameKinds(List<idl.IndexNameKind> _value) {
+    assert(!_finished);
+    _definedNameKinds = _value;
+  }
+
+  @override
+  List<int> get definedNameOffsets => _definedNameOffsets ??= <int>[];
+
+  /**
+   * Each item of this list is the name offset of an element defined in this
+   * unit relative to the beginning of the file.
+   */
+  void set definedNameOffsets(List<int> _value) {
+    assert(!_finished);
+    assert(_value == null || _value.every((e) => e >= 0));
+    _definedNameOffsets = _value;
+  }
+
+  @override
+  List<int> get definedNames => _definedNames ??= <int>[];
+
+  /**
+   * Each item of this list corresponds to an element defined in this unit.  It
+   * is an index into [PackageIndex.strings] list.  The list is sorted in
+   * ascending order, so that the client can quickly find name definitions in
+   * this [UnitIndex].
+   */
+  void set definedNames(List<int> _value) {
+    assert(!_finished);
+    assert(_value == null || _value.every((e) => e >= 0));
+    _definedNames = _value;
+  }
+
+  @override
   List<int> get elements => _elements ??= <int>[];
 
   /**
    * Each item of this list is the index into [PackageIndex.elementUnits] and
    * [PackageIndex.elementOffsets].  The list is sorted in ascending order, so
    * that the client can quickly find element references in this [UnitIndex].
    */
   void set elements(List<int> _value) {
     assert(!_finished);
     assert(_value == null || _value.every((e) => e >= 0));
@@ skipping 55 matching lines @@
   /**
    * The unit source URI of this unit, e.g. `dart:core/int.dart` or
    * `package:foo/bar/baz.dart`, as index into [PackageIndex.uris].
    */
   void set unitUri(int _value) {
     assert(!_finished);
     assert(_value == null || _value >= 0);
     _unitUri = _value;
   }
 
-  UnitIndexBuilder({List<int> elements, List<idl.IndexRelationKind> kinds, int libraryUri, List<int> locationLengths, List<int> locationOffsets, int unitUri})
-    : _elements = elements,
+  UnitIndexBuilder({List<idl.IndexNameKind> definedNameKinds, List<int> definedNameOffsets, List<int> definedNames, List<int> elements, List<idl.IndexRelationKind> kinds, int libraryUri, List<int> locationLengths, List<int> locationOffsets, int unitUri})
+    : _definedNameKinds = definedNameKinds,
+      _definedNameOffsets = definedNameOffsets,
+      _definedNames = definedNames,
+      _elements = elements,
       _kinds = kinds,
       _libraryUri = libraryUri,
       _locationLengths = locationLengths,
       _locationOffsets = locationOffsets,
       _unitUri = unitUri;
 
   fb.Offset finish(fb.Builder fbBuilder) {
     assert(!_finished);
     _finished = true;
+    fb.Offset offset_definedNameKinds;
+    fb.Offset offset_definedNameOffsets;
+    fb.Offset offset_definedNames;
     fb.Offset offset_elements;
     fb.Offset offset_kinds;
     fb.Offset offset_locationLengths;
     fb.Offset offset_locationOffsets;
+    if (!(_definedNameKinds == null || _definedNameKinds.isEmpty)) {
+      offset_definedNameKinds = fbBuilder.writeListUint8(_definedNameKinds.map((b) => b.index).toList());
+    }
+    if (!(_definedNameOffsets == null || _definedNameOffsets.isEmpty)) {
+      offset_definedNameOffsets = fbBuilder.writeListUint32(_definedNameOffsets);
+    }
+    if (!(_definedNames == null || _definedNames.isEmpty)) {
+      offset_definedNames = fbBuilder.writeListUint32(_definedNames);
+    }
     if (!(_elements == null || _elements.isEmpty)) {
       offset_elements = fbBuilder.writeListUint32(_elements);
     }
     if (!(_kinds == null || _kinds.isEmpty)) {
       offset_kinds = fbBuilder.writeListUint8(_kinds.map((b) => b.index).toList());
     }
     if (!(_locationLengths == null || _locationLengths.isEmpty)) {
       offset_locationLengths = fbBuilder.writeListUint32(_locationLengths);
     }
     if (!(_locationOffsets == null || _locationOffsets.isEmpty)) {
       offset_locationOffsets = fbBuilder.writeListUint32(_locationOffsets);
     }
     fbBuilder.startTable();
+    if (offset_definedNameKinds != null) {
+      fbBuilder.addOffset(7, offset_definedNameKinds);
+    }
+    if (offset_definedNameOffsets != null) {
+      fbBuilder.addOffset(8, offset_definedNameOffsets);
+    }
+    if (offset_definedNames != null) {
+      fbBuilder.addOffset(6, offset_definedNames);
+    }
     if (offset_elements != null) {
       fbBuilder.addOffset(4, offset_elements);
     }
     if (offset_kinds != null) {
       fbBuilder.addOffset(5, offset_kinds);
     }
     if (_libraryUri != null && _libraryUri != 0) {
       fbBuilder.addUint32(0, _libraryUri);
     }
     if (offset_locationLengths != null) {
@@ skipping 14 matching lines @@
 
   @override
   _UnitIndexImpl createObject(fb.BufferPointer bp) => new _UnitIndexImpl(bp);
 }
 
 class _UnitIndexImpl extends Object with _UnitIndexMixin implements idl.UnitIndex {
   final fb.BufferPointer _bp;
 
   _UnitIndexImpl(this._bp);
 
+  List<idl.IndexNameKind> _definedNameKinds;
+  List<int> _definedNameOffsets;
+  List<int> _definedNames;
   List<int> _elements;
   List<idl.IndexRelationKind> _kinds;
   int _libraryUri;
   List<int> _locationLengths;
   List<int> _locationOffsets;
   int _unitUri;
 
   @override
+  List<idl.IndexNameKind> get definedNameKinds {
+    _definedNameKinds ??= const fb.ListReader<idl.IndexNameKind>(const _IndexNameKindReader()).vTableGet(_bp, 7, const <idl.IndexNameKind>[]);
+    return _definedNameKinds;
+  }
+
+  @override
+  List<int> get definedNameOffsets {
+    _definedNameOffsets ??= const fb.Uint32ListReader().vTableGet(_bp, 8, const <int>[]);
+    return _definedNameOffsets;
+  }
+
+  @override
+  List<int> get definedNames {
+    _definedNames ??= const fb.Uint32ListReader().vTableGet(_bp, 6, const <int>[]);
+    return _definedNames;
+  }
+
+  @override
   List<int> get elements {
     _elements ??= const fb.Uint32ListReader().vTableGet(_bp, 4, const <int>[]);
     return _elements;
   }
 
   @override
   List<idl.IndexRelationKind> get kinds {
     _kinds ??= const fb.ListReader<idl.IndexRelationKind>(const _IndexRelationKindReader()).vTableGet(_bp, 5, const <idl.IndexRelationKind>[]);
     return _kinds;
   }
@@ skipping 20 matching lines @@
   int get unitUri {
     _unitUri ??= const fb.Uint32Reader().vTableGet(_bp, 1, 0);
     return _unitUri;
   }
 }
 
 abstract class _UnitIndexMixin implements idl.UnitIndex {
   @override
   Map<String, Object> toJson() {
     Map<String, Object> _result = <String, Object>{};
+    if (definedNameKinds.isNotEmpty) _result["definedNameKinds"] = definedNameKinds.map((_value) => _value.toString().split('.')[1]).toList();
+    if (definedNameOffsets.isNotEmpty) _result["definedNameOffsets"] = definedNameOffsets;
+    if (definedNames.isNotEmpty) _result["definedNames"] = definedNames;
     if (elements.isNotEmpty) _result["elements"] = elements;
     if (kinds.isNotEmpty) _result["kinds"] = kinds.map((_value) => _value.toString().split('.')[1]).toList();
     if (libraryUri != 0) _result["libraryUri"] = libraryUri;
     if (locationLengths.isNotEmpty) _result["locationLengths"] = locationLengths;
     if (locationOffsets.isNotEmpty) _result["locationOffsets"] = locationOffsets;
     if (unitUri != 0) _result["unitUri"] = unitUri;
     return _result;
   }
 
   @override
   Map<String, Object> toMap() => {
+    "definedNameKinds": definedNameKinds,
+    "definedNameOffsets": definedNameOffsets,
+    "definedNames": definedNames,
     "elements": elements,
     "kinds": kinds,
     "libraryUri": libraryUri,
     "locationLengths": locationLengths,
     "locationOffsets": locationOffsets,
     "unitUri": unitUri,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
@@ skipping 5151 matching lines @@
     "propagatedTypeSlot": propagatedTypeSlot,
     "type": type,
     "visibleLength": visibleLength,
     "visibleOffset": visibleOffset,
   };
 
   @override
   String toString() => convert.JSON.encode(toJson());
 }