Support for boolean lists in FlatBuffer.

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

Index: pkg/analyzer/lib/src/summary/flat_buffers.dart
diff --git a/pkg/analyzer/lib/src/summary/flat_buffers.dart b/pkg/analyzer/lib/src/summary/flat_buffers.dart
index 65a786a650a19879153a7cf6175cb0b0b50af0d5..b16054be51adcf6f3e650614f88d26d655207389 100644
--- a/pkg/analyzer/lib/src/summary/flat_buffers.dart
+++ b/pkg/analyzer/lib/src/summary/flat_buffers.dart
@@ -10,6 +10,21 @@ import 'dart:math';
 import 'dart:typed_data';
 
 /**
+ * Reader of lists of boolean values.
+ *
+ * The returned unmodifiable lists lazily read values on access.
+ */
+class BoolListReader extends Reader<List<bool>> {
+  const BoolListReader();
+
+  @override
+  int get size => 4;
+
+  @override
+  List<bool> read(BufferPointer bp) => new _FbBoolList(bp.derefObject());
+}
+
+/**
  * The reader of booleans.
  */
 class BoolReader extends Reader<bool> {
@@ -335,6 +350,39 @@ class Builder {
   }
 
   /**
+   * Write the given list of boolean [values].
+   */
+  Offset writeListBool(List<bool> values) {
+    int bitLength = values.length;
+    bool hasPartial = bitLength % 32 != 0;
+    int intLength = 1 + bitLength ~/ 32 + (hasPartial ? 1 : 0);
+    // Prepare the backing Uint32 list.
+    List<int> intItems = new List<int>(intLength);
+    // Put the bit length as the 0-th item.
+    intItems[0] = bitLength;
+    // Record every bit.
+    int itemIndex = 1;
+    int item = 0;
+    int mask = 1;
+    for (int bitIndex = 0; bitIndex < bitLength; bitIndex++) {
+      if (bitIndex != 0 && (bitIndex % 32 == 0)) {
+        intItems[itemIndex++] = item;
+        item = 0;
+        mask = 1;
+      }
+      if (values[bitIndex]) {
+        item |= mask;
+      }
+      mask <<= 1;
+    }
+    if (hasPartial) {

[Paul Berry, 2016/02/29 21:12:32]

Change this to `if (values.isNotEmpty)`.  Otherwise when `values.length` is a
nonzero multiple of 32, we won't store the last int.

+      intItems[itemIndex] = item;
+    }
+    // Write as a Uint32 list.
+    return writeListUint32(intItems);
+  }
+
+  /**
    * Write the given list of 64-bit float [values].
    */
   Offset writeListFloat64(List<double> values) {
@@ -645,7 +693,7 @@ abstract class TableReader<T> extends Reader<T> {
 }
 
 /**
- * Reader of lists of 32-bit float values.
+ * Reader of lists of unsigned 32-bit integer values.
  *
  * The returned unmodifiable lists lazily read values on access.
  */
@@ -686,6 +734,33 @@ class Uint8Reader extends Reader<int> {
 }
 
 /**
+ * List of booleans backed by 32-bit unsigned integers.
+ */
+class _FbBoolList extends Object with ListMixin<bool> implements List<bool> {
+  final _FbUint32List uint32List;
+
+  _FbBoolList(BufferPointer bp) : uint32List = new _FbUint32List(bp);
+
+  @override
+  int get length => uint32List[0];
+
+  @override
+  void set length(int i) =>
+      throw new StateError('Attempt to modify immutable list');
+
+  @override
+  bool operator [](int i) {
+    int index = i ~/ 32;
+    int mask = 1 << i % 32;
+    return uint32List[1 + index] & mask != 0;
+  }
+
+  @override
+  void operator []=(int i, bool e) =>
+      throw new StateError('Attempt to modify immutable list');
+}
+
+/**
  * The list backed by 64-bit values - Uint64 length and Float64.
  */
 class _FbFloat64List extends _FbList<double> {