Support for Int64 and fix for the root reference.

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:typed_data';
 
@@ skipping 20 matching lines @@
   @override
   String toString() => _offset.toString();
 
   BufferPointer _advance(int delta) {
     return new BufferPointer._(_buffer, _offset + delta);
   }
 
   int _getInt32([int delta = 0]) =>
       _buffer.getInt32(_offset + delta, Endianness.LITTLE_ENDIAN);
 
+  int _getInt64([int delta = 0]) =>
+      _buffer.getInt64(_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);
 
   /**
    * If the [byteList] is already a [Uint8List] return it.
@@ skipping 51 matching lines @@
     }
     if (value != def) {
       int size = 4;
       _prepare(size, 1);
       _trackField(field);
       _setInt32AtTail(_buf, _tail, value);
     }
   }
 
   /**
+   * Add the [field] with the given 64-bit signed integer [value].  The field is
+   * not added if the [value] is equal to [def].
+   */
+  void addInt64(int field, int value, [int def]) {
+    if (_currentVTableBuilder == null) {
+      throw new StateError('Start a table before adding values.');
+    }
+    if (value != def) {
+      int size = 8;
+      _prepare(size, 1);
+      _trackField(field);
+      _setInt64AtTail(_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 (_currentVTableBuilder == null) {
       throw new StateError('Start a table before adding values.');
     }
     if (value != def) {
       int size = 1;
       _prepare(size, 1);
@@ skipping 40 matching lines @@
     return new Offset(tableTail);
   }
 
   /**
    * Finish off the creation of the buffer.  The given [offset] is used as the
    * root object offset, and usually references directly or indirectly every
    * written object.
    */
   Uint8List finish(Offset offset) {
     _prepare(4, 1);
-    _setUint32AtTail(_buf, _tail, _tail - offset._tail);
     int alignedTail = _tail + ((-_tail) % _maxAlign);
+    _setUint32AtTail(_buf, alignedTail, alignedTail - offset._tail);

[Paul Berry, 2016/01/08 18:11:18]

This won't work either.  Consider the case where _tail == 64, buf.lengthInBytes
== 68, and _maxAlign == 8 on entry to this function.  After the call to
_prepare, _tail will be 68.  Then we will set alignedTail to 72, and the call to
_setUint32AtTail will underflow the buffer.

Perhaps this would work:

_prepare(max(4, _maxAlign), 1);
_setUint32AtTail(...);

[scheglov, 2016/01/08 18:39:07]

Done.

     return _buf.buffer.asUint8List(_buf.lengthInBytes - alignedTail);
   }
 
   /**
    * This is a low-level method, it should not be invoked by clients.
    */
   Uint8List lowFinish() {
     int alignedTail = _tail + ((-_tail) % _maxAlign);
     return _buf.buffer.asUint8List(_buf.lengthInBytes - alignedTail);
   }
@@ skipping 11 matching lines @@
    * This is a low-level method, it should not be invoked by clients.
    */
   void lowWriteUint32(int value) {
     _prepare(4, 1);
     _setUint32AtTail(_buf, _tail, value);
   }
 
   /**
    * This is a low-level method, it should not be invoked by clients.
    */
+  void lowWriteUint64(int value) {
+    _prepare(8, 1);
+    _setUint64AtTail(_buf, _tail, value);
+  }
+
+  /**
+   * This is a low-level method, it should not be invoked by clients.
+   */
   void lowWriteUint8(int value) {
     _prepare(1, 1);
     _buf.setUint8(_buf.lengthInBytes - _tail, value);
   }
 
   /**
    * Reset the builder and make it ready for filling a new buffer.
    */
   void reset() {
     _buf = new ByteData(initialSize);
@@ skipping 95 matching lines @@
    * Record the offset of the given [field].
    */
   void _trackField(int field) {
     _currentVTableBuilder.addField(field, _tail);
   }
 
   static void _setInt32AtTail(ByteData _buf, int tail, int x) {
     _buf.setInt32(_buf.lengthInBytes - tail, x, Endianness.LITTLE_ENDIAN);
   }
 
+  static void _setInt64AtTail(ByteData _buf, int tail, int x) {
+    _buf.setInt64(_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 _setUint64AtTail(ByteData _buf, int tail, int x) {
+    _buf.setUint64(_buf.lengthInBytes - tail, x, Endianness.LITTLE_ENDIAN);
+  }
 }
 
 /**
  * The reader of 32-bit signed integers.
  */
 class Int32Reader extends Reader<int> {
   const Int32Reader() : super();
 
   @override
-  int get size => 2;
+  int get size => 4;
 
   @override
   int read(BufferPointer bp) => bp._getInt32();
 }
 
 /**
+ * The reader of 64-bit signed integers.
+ */
+class Int64Reader extends Reader<int> {
+  const Int64Reader() : super();
+
+  @override
+  int get size => 8;
+
+  @override
+  int read(BufferPointer bp) => bp._getInt64();
+}
+
+/**
  * The reader of 8-bit signed integers.
  */
 class Int8Reader extends Reader<int> {
   const Int8Reader() : super();
 
   @override
   int get size => 1;
 
   @override
   int read(BufferPointer bp) => bp._getInt8();
@@ skipping 151 matching lines @@
     buf.setUint16(bufOffset, tableSize, Endianness.LITTLE_ENDIAN);
     bufOffset += 2;
     // Field offsets.
     for (int fieldTail in fieldTails) {
       int fieldOffset = fieldTail == null ? 0 : tableTail - fieldTail;
       buf.setUint16(bufOffset, fieldOffset, Endianness.LITTLE_ENDIAN);
       bufOffset += 2;
     }
   }
 }