Store enums in summary file as bytes.

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 45 matching lines @@
       _buffer.getInt32(_offset + delta, Endianness.LITTLE_ENDIAN);
 
   int _getInt8([int delta = 0]) => _buffer.getInt8(_offset + delta);
 
   int _getUint16([int delta = 0]) =>
       _buffer.getUint16(_offset + delta, Endianness.LITTLE_ENDIAN);
 
   int _getUint32([int delta = 0]) =>
       _buffer.getUint32(_offset + delta, Endianness.LITTLE_ENDIAN);
 
+  int _getUint8([int delta = 0]) => _buffer.getUint8(_offset + delta);
+
   /**
    * If the [byteList] is already a [Uint8List] return it.
    * Otherwise return a [Uint8List] copy of the [byteList].
    */
   static Uint8List _asUint8List(List<int> byteList) {
     if (byteList is Uint8List) {
       return byteList;
     } else {
       return new Uint8List.fromList(byteList);
     }
@@ skipping 43 matching lines @@
   Builder({this.initialSize: 1024}) {
     reset();
   }
 
   /**
    * Add the [field] with the given boolean [value].  The field is not added if
    * the [value] is equal to [def].  Booleans are stored as 8-bit fields with
    * `0` for `false` and `1` for `true`.
    */
   void addBool(int field, bool value, [bool def]) {
-    if (_currentVTable == null) {
-      throw new StateError('Start a table before adding values.');
-    }
+    _ensureCurrentVTable();
     if (value != null && value != def) {
       int size = 1;
       _prepare(size, 1);
       _trackField(field);
       _buf.setInt8(_buf.lengthInBytes - _tail, value ? 1 : 0);
     }
   }
 
   /**
    * Add the [field] with the given 32-bit signed integer [value].  The field is
    * not added if the [value] is equal to [def].
    */
   void addInt32(int field, int value, [int def]) {
-    if (_currentVTable == null) {
-      throw new StateError('Start a table before adding values.');
-    }
+    _ensureCurrentVTable();
     if (value != null && value != def) {
       int size = 4;
       _prepare(size, 1);
       _trackField(field);
       _setInt32AtTail(_buf, _tail, value);
     }
   }
 
   /**
    * Add the [field] with the given 8-bit signed integer [value].  The field is
    * not added if the [value] is equal to [def].
    */
   void addInt8(int field, int value, [int def]) {
-    if (_currentVTable == null) {
-      throw new StateError('Start a table before adding values.');
-    }
+    _ensureCurrentVTable();
     if (value != null && value != def) {
       int size = 1;
       _prepare(size, 1);
       _trackField(field);
       _buf.setInt8(_buf.lengthInBytes - _tail, value);
     }
   }
 
   /**
    * Add the [field] referencing an object with the given [offset].
    */
   void addOffset(int field, Offset offset) {
-    if (_currentVTable == null) {
-      throw new StateError('Start a table before adding values.');
-    }
+    _ensureCurrentVTable();
     if (offset != null) {
       _prepare(4, 1);
       _trackField(field);
       _setUint32AtTail(_buf, _tail, _tail - offset._tail);
     }
   }
 
   /**
    * Add the [field] with the given 32-bit unsigned integer [value].  The field
    * is not added if the [value] is equal to [def].
    */
   void addUint32(int field, int value, [int def]) {
-    if (_currentVTable == null) {
-      throw new StateError('Start a table before adding values.');
-    }
+    _ensureCurrentVTable();
     if (value != null && value != def) {
       int size = 4;
       _prepare(size, 1);
       _trackField(field);
       _setUint32AtTail(_buf, _tail, value);
     }
   }
 
   /**
+   * Add the [field] with the given 8-bit unsigned integer [value].  The field
+   * is not added if the [value] is equal to [def].
+   */
+  void addUint8(int field, int value, [int def]) {
+    _ensureCurrentVTable();
+    if (value != null && value != def) {
+      int size = 1;
+      _prepare(size, 1);
+      _trackField(field);
+      _setUint8AtTail(_buf, _tail, value);
+    }
+  }
+
+  /**
    * End the current table and return its offset.
    */
   Offset endTable() {
     if (_currentVTable == null) {
       throw new StateError('Start a table before ending it.');
     }
     // Prepare for writing the VTable.
     _prepare(4, 1);
     int tableTail = _tail;
     // Prepare the size of the current table.
@@ skipping 87 matching lines @@
       throw new StateError('Inline tables are not supported.');
     }
     _currentVTable = new _VTable();
     _currentTableEndTail = _tail;
   }
 
   /**
    * Write the given list of [values].
    */
   Offset writeList(List<Offset> values) {
-    if (_currentVTable != null) {
-      throw new StateError(
-          'Cannot write a non-scalar value while writing a table.');
-    }
+    _ensureNoVTable();
     _prepare(4, 1 + values.length);
     Offset result = new Offset(_tail);
     int tail = _tail;
     _setUint32AtTail(_buf, tail, values.length);
     tail -= 4;
     for (Offset value in values) {
       _setUint32AtTail(_buf, tail, tail - value._tail);
       tail -= 4;
     }
     return result;
   }
 
   /**
    * Write the given list of 64-bit float [values].
    */
   Offset writeListFloat64(List<double> values) {
-    if (_currentVTable != null) {
-      throw new StateError(
-          'Cannot write a non-scalar value while writing a table.');
-    }
+    _ensureNoVTable();
     _prepare(8, 1 + values.length);
     Offset result = new Offset(_tail);
     int tail = _tail;
     _setUint32AtTail(_buf, tail, values.length);
     tail -= 8;
     for (double value in values) {
       _setFloat64AtTail(_buf, tail, value);
       tail -= 8;
     }
     return result;
   }
 
   /**
    * Write the given list of signed 32-bit integer [values].
    */
   Offset writeListInt32(List<int> values) {
-    if (_currentVTable != null) {
-      throw new StateError(
-          'Cannot write a non-scalar value while writing a table.');
-    }
+    _ensureNoVTable();
     _prepare(4, 1 + values.length);
     Offset result = new Offset(_tail);
     int tail = _tail;
     _setUint32AtTail(_buf, tail, values.length);
     tail -= 4;
     for (int value in values) {
       _setInt32AtTail(_buf, tail, value);
       tail -= 4;
     }
     return result;
   }
 
   /**
    * Write the given list of unsigned 32-bit integer [values].
    */
   Offset writeListUint32(List<int> values) {
-    if (_currentVTable != null) {
-      throw new StateError(
-          'Cannot write a non-scalar value while writing a table.');
-    }
+    _ensureNoVTable();
     _prepare(4, 1 + values.length);
     Offset result = new Offset(_tail);
     int tail = _tail;
     _setUint32AtTail(_buf, tail, values.length);
     tail -= 4;
     for (int value in values) {
       _setUint32AtTail(_buf, tail, value);
       tail -= 4;
     }
     return result;
   }
 
   /**
+   * Write the given list of unsigned 8-bit integer [values].
+   */
+  Offset writeListUint8(List<int> values) {
+    _ensureNoVTable();
+    _prepare(4, 1, additionalBytes: values.length);
+    Offset result = new Offset(_tail);
+    int tail = _tail;
+    _setUint32AtTail(_buf, tail, values.length);
+    tail -= 4;
+    for (int value in values) {
+      _setUint8AtTail(_buf, tail, value);
+      tail -= 1;
+    }
+    return result;
+  }
+
+  /**
    * Write the given string [value] and return its [Offset], or `null` if
    * the [value] is equal to [def].
    */
   Offset<String> writeString(String value, [String def]) {
-    if (_currentVTable != null) {
-      throw new StateError(
-          'Cannot write a non-scalar value while writing a table.');
-    }
+    _ensureNoVTable();
     if (value != def) {
       return _strings.putIfAbsent(value, () {
         // TODO(scheglov) optimize for ASCII strings
         List<int> bytes = UTF8.encode(value);
         int length = bytes.length;
         _prepare(4, 1, additionalBytes: length);
         Offset<String> result = new Offset(_tail);
         _setUint32AtTail(_buf, _tail, length);
         int offset = _buf.lengthInBytes - _tail + 4;
         for (int i = 0; i < length; i++) {
           _buf.setUint8(offset++, bytes[i]);
         }
         return result;
       });
     }
     return null;
   }
 
   /**
+   * Throw an exception if there is not currently a vtable.
+   */
+  void _ensureCurrentVTable() {
+    if (_currentVTable == null) {
+      throw new StateError('Start a table before adding values.');
+    }
+  }
+
+  /**
+   * Throw an exception if there is currently a vtable.
+   */
+  void _ensureNoVTable() {
+    if (_currentVTable != null) {
+      throw new StateError(
+          'Cannot write a non-scalar value while writing a table.');
+    }
+  }
+
+  /**
    * Prepare for writing the given [count] of scalars of the given [size].
    * Additionally allocate the specified [additionalBytes]. Update the current
    * tail pointer to point at the allocated space.
    */
   void _prepare(int size, int count, {int additionalBytes: 0}) {
     // Update the alignment.
     if (_maxAlign < size) {
       _maxAlign = size;
     }
     // Prepare amount of required space.
@@ skipping 30 matching lines @@
     _buf.setFloat64(_buf.lengthInBytes - tail, x, Endianness.LITTLE_ENDIAN);
   }
 
   static void _setInt32AtTail(ByteData _buf, int tail, int x) {
     _buf.setInt32(_buf.lengthInBytes - tail, x, Endianness.LITTLE_ENDIAN);
   }
 
   static void _setUint32AtTail(ByteData _buf, int tail, int x) {
     _buf.setUint32(_buf.lengthInBytes - tail, x, Endianness.LITTLE_ENDIAN);
   }
+
+  static void _setUint8AtTail(ByteData _buf, int tail, int x) {
+    _buf.setUint8(_buf.lengthInBytes - tail, x);
+  }
 }
 
 /**
  * The reader of lists of 64-bit float values.
  *
  * The returned unmodifiable lists lazily read values on access.
  */
 class Float64ListReader extends Reader<List<double>> {
   const Float64ListReader();
 
@@ skipping 153 matching lines @@
   const Uint32Reader() : super();
 
   @override
   int get size => 4;
 
   @override
   int read(BufferPointer bp) => bp._getUint32();
 }
 
 /**
+ * The reader of unsigned 8-bit integers.
+ */
+class Uint8Reader extends Reader<int> {
+  const Uint8Reader() : super();
+
+  @override
+  int get size => 1;
+
+  @override
+  int read(BufferPointer bp) => bp._getUint8();
+}
+
+/**
  * The list backed by 64-bit values - Uint64 length and Float64.
  */
 class _FbFloat64List extends _FbList<double> {
   List<double> _items;
 
   _FbFloat64List(BufferPointer bp) : super(bp);
 
   @override
   double operator [](int i) {
     _items ??= new List<double>(length);
@@ skipping 141 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;
     }
   }
 }