Minor improvements to list representation in flatbuffers.

pkg/analyzer/lib/src/summary/flat_buffers.dart

 // Copyright (c) 2016, 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.
 
 library analyzer.src.summary.flat_buffers;
 
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:math';
 import 'dart:typed_data';
@@ skipping 501 matching lines @@
 class ListReader<E> extends Reader<List<E>> {
   final Reader<E> _elementReader;
 
   const ListReader(this._elementReader);
 
   @override
   int get size => 4;
 
   @override
   List<E> read(BufferPointer bp) =>
-      new _FbInt32List<E>(_elementReader, bp.derefObject());
+      new _FbGenericList<E>(_elementReader, bp.derefObject());
 }
 
 /**
  * The offset from the end of the buffer to a serialized object of the type [T].
  */
 class Offset<T> {
   final int _tail;
 
   Offset(this._tail);
 }
@@ skipping 66 matching lines @@
   T createObject(BufferPointer bp);
 
   @override
   T read(BufferPointer bp) {
     bp = bp.derefObject();
     return createObject(bp);
   }
 }
 
 /**
+ * Reader of lists of 32-bit float values.
+ *
+ * The returned unmodifiable lists lazily read values on access.
+ */
+class Uint32ListReader extends Reader<List<int>> {
+  const Uint32ListReader();
+
+  @override
+  int get size => 4;
+
+  @override
+  List<int> read(BufferPointer bp) => new _FbUint32List(bp.derefObject());
+}
+
+/**
  * The reader of unsigned 32-bit integers.
  */
 class Uint32Reader extends Reader<int> {
   const Uint32Reader() : super();
 
   @override
   int get size => 4;
 
   @override
   int read(BufferPointer bp) => bp._getUint32();
 }
 
 /**
  * The list backed by 64-bit values - Uint64 length and Float64.
  */
 class _FbFloat64List extends _FbList<double> {
-  final BufferPointer bp;
-
-  int _length;
   List<double> _items;
 
-  _FbFloat64List(this.bp);
-
-  @override
-  int get length {
-    _length ??= bp._getUint32();
-    return _length;
-  }
+  _FbFloat64List(BufferPointer bp) : super(bp);
 
   @override
   double operator [](int i) {
     _items ??= new List<double>(length);
     double item = _items[i];
     if (item == null) {
       BufferPointer ref = bp._advance(8 + 8 * i);
       item = ref._getFloat64();
       _items[i] = item;
     }
     return item;
   }
 }
 
 /**
- * The list backed by 32-bit values - offsets or integers.
+ * List backed by a generic object which may have any size.
  */
-class _FbInt32List<E> extends _FbList<E> {
+class _FbGenericList<E> extends _FbList<E> {
   final Reader<E> elementReader;
-  final BufferPointer bp;
 
-  int _length;
   List<E> _items;
 
-  _FbInt32List(this.elementReader, this.bp);
-
-  @override
-  int get length {
-    _length ??= bp._getUint32();
-    return _length;
-  }
+  _FbGenericList(this.elementReader, BufferPointer bp) : super(bp);
 
   @override
   E operator [](int i) {
     _items ??= new List<E>(length);
     E item = _items[i];
     if (item == null) {
-      BufferPointer ref = bp._advance(4 + 4 * i);
+      BufferPointer ref = bp._advance(4 + elementReader.size * i);
       item = elementReader.read(ref);
       _items[i] = item;
     }
     return item;
   }
 }
 
 /**
  * The base class for immutable lists read from flat buffers.
  */
 abstract class _FbList<E> extends Object with ListMixin<E> implements List<E> {
+  final BufferPointer bp;
+  int _length;
+
+  _FbList(this.bp);
+
+  @override
+  int get length {
+    _length ??= bp._getUint32();
+    return _length;
+  }
+
   @override
   void set length(int i) =>
       throw new StateError('Attempt to modify immutable list');
 
   @override
   void operator []=(int i, E e) =>
       throw new StateError('Attempt to modify immutable list');
 }
 
 /**
+ * List backed by 32-bit unsigned integers.
+ */
+class _FbUint32List extends _FbList<int> {
+  List<int> _items;
+
+  _FbUint32List(BufferPointer bp) : super(bp);
+
+  @override
+  int operator [](int i) {
+    _items ??= new List<int>(length);
+    int item = _items[i];
+    if (item == null) {
+      item = bp._getUint32(4 + 4 * i);
+      _items[i] = item;
+    }
+    return item;
+  }
+}
+
+/**
  * Class that describes the structure of a table.
  */
 class _VTable {
   final List<int> fieldTails = <int>[];
   final List<int> fieldOffsets = <int>[];
 
   /**
    * The size of the table that uses this VTable.
    */
   int tableSize;
@@ skipping 53 matching lines @@
     // Table size.
     buf.setUint16(bufOffset, tableSize, Endianness.LITTLE_ENDIAN);
     bufOffset += 2;
     // Field offsets.
     for (int fieldOffset in fieldOffsets) {
       buf.setUint16(bufOffset, fieldOffset, Endianness.LITTLE_ENDIAN);
       bufOffset += 2;
     }
   }
 }