Update the protocol buffer library to use Int64 from the fixnum package

lib/generated_message.dart

 // Copyright (c) 2011, 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.
 
 part of protobuf;
 
 typedef GeneratedMessage CreateBuilderFunc();
 typedef Object MakeDefaultFunc();
 typedef ProtobufEnum ValueOfFunc(int value);
 
 _inRange(min, value, max) => (min <= value) && (value <= max);
 
 _isSigned32(int value) => _inRange(-2147483648, value, 2147483647);
 _isUnsigned32(int value) => _inRange(0, value, 4294967295);
-_isSigned64(ByteData value) => _isUnsigned64(value);
-_isUnsigned64(ByteData value) => value is ByteData && value.lengthInBytes == 8;
+_isSigned64(Int64 value) => _isUnsigned64(value);
+_isUnsigned64(Int64 value) => value is Int64;
 _isFloat32(double value) => value.isNaN || value.isInfinite ||
     _inRange(-3.4028234663852886E38, value, 3.4028234663852886E38);
 
 class GeneratedMessage {
   static const int _REQUIRED_BIT      = 0x1;
   static const int _REPEATED_BIT      = 0x2;
   static const int _PACKED_BIT        = 0x4;
 
   static const int _BOOL_BIT         = 0x10;
   static const int _BYTES_BIT        = 0x20;
@@ skipping 159 matching lines @@
   static const int K6 = _PACKED_INT64;
   static const int KS3 = _PACKED_SINT32;
   static const int KS6 = _PACKED_SINT64;
   static const int KU3 = _PACKED_UINT32;
   static const int KU6 = _PACKED_UINT64;
   static const int KF3 = _PACKED_FIXED32;
   static const int KF6 = _PACKED_FIXED64;
   static const int KSF3 = _PACKED_SFIXED32;
   static const int KSF6 = _PACKED_SFIXED64;
 
+  // Range of integers in JSON (53-bit integers).
+  static Int64 MAX_JSON_INT = new Int64.fromInts(0x200000, 0);
+  static Int64 MIN_JSON_INT = -MAX_JSON_INT;
+
   // Closures commonly used by initializers.
   static String _STRING_EMPTY() => '';
   static List<int> _BYTES_EMPTY() => new PbList<int>();
   static bool _BOOL_FALSE() => false;
   static int _INT_ZERO() => 0;
   static double _DOUBLE_ZERO() => 0.0;
 
   static MakeDefaultFunc _defaultForType(int type) {
     switch (type) {
     case _OPTIONAL_BOOL: case _REQUIRED_BOOL:
@@ skipping 408 matching lines @@
       case _BYTES_BIT:
         // Encode 'bytes' as a base64-encoded string.
         return CryptoUtils.bytesToBase64(fieldValue);
       case _ENUM_BIT:
         return fieldValue.value; // assume |value| < 2^52
       case _INT64_BIT:
       case _SINT64_BIT:
       case _UINT64_BIT:
       case _FIXED64_BIT:
       case _SFIXED64_BIT:
-        // TODO(antonm): fix for longs.
-        final asInt = scalarType == _UINT64_BIT ?
-            fieldValue.getUint64(0, Endianness.LITTLE_ENDIAN) :
-            fieldValue.getInt64(0, Endianness.LITTLE_ENDIAN);
-        return "$asInt";
+        // Use strings for 64-bit integers which cannot fit in doubles.
+        if (MIN_JSON_INT <= fieldValue && fieldValue <= MAX_JSON_INT) {
+          return fieldValue.toInt();
+        } else {
+          return fieldValue.toString();
+        }
       case _GROUP_BIT:
       case _MESSAGE_BIT:
         return fieldValue._toMap();
       default:
         throw 'Unknown type $fieldType';
       }
     }
 
     var result = <String, dynamic>{};
     for (int tagNumber in sorted(_fieldValues.keys)) {
@@ skipping 91 matching lines @@
         }
         expectedType = 'int or stringified int';
         break;
       case _INT64_BIT:
       case _SINT64_BIT:
       case _UINT64_BIT:
       case _FIXED64_BIT:
       case _SFIXED64_BIT:
         // Allow quoted values, although we don't emit them.
         if (value is String) {
-          value = int.parse(value);
+          return Int64.parseRadix(value, 10);
         }
         if (value is int) {
-          const lowPart = ((1 << 31) * 2); // 2^32 which works in dart2js.
-          return new ByteData(8)
-              ..setUint32(0, value % lowPart, Endianness.LITTLE_ENDIAN)
-              ..setUint32(4, value ~/ lowPart, Endianness.LITTLE_ENDIAN);
+          return new Int64.fromInt(value);
         }
         expectedType = 'int or stringified int';
         break;
       case _GROUP_BIT:
       case _MESSAGE_BIT:
         if (value is Map<String, Object>) {
           GeneratedMessage subMessage =
               _getEmptyMessage(tagNumber, extensionRegistry);
           subMessage._mergeFromJson(value, extensionRegistry);
           return subMessage;
@@ skipping 321 matching lines @@
         if (value is !int) {
           throw new ArgumentError(
               _generateMessage(tagNumber, value, 'not type int'));
         }
         if (!_isSigned32(value)) {
           throw new ArgumentError(_generateMessage(tagNumber, value,
               'out of range for int32'));
         }
         break;
       case _INT64_BIT:
-        if (value is !ByteData) {
+        if (value is !Int64) {
           throw new ArgumentError(
-              _generateMessage(tagNumber, value, 'not ByteData'));
+              _generateMessage(tagNumber, value, 'not Int64'));
         }
         if (!_isSigned64(value)) {
           throw new ArgumentError(_generateMessage(tagNumber, value,
               'out of range for int64'));
         }
         break;
       case _SINT32_BIT:
         if (value is !int) {
           throw new ArgumentError(
               _generateMessage(tagNumber, value, 'not type int'));
         }
         if (!_isSigned32(value)) {
           throw new ArgumentError(_generateMessage(tagNumber, value,
               'out of range for sint32'));
         }
         break;
       case _SINT64_BIT:
-        if (value is !ByteData) {
+        if (value is !Int64) {
           throw new ArgumentError(
-              _generateMessage(tagNumber, value, 'not ByteData'));
+              _generateMessage(tagNumber, value, 'not Int64'));
         }
         if (!_isSigned64(value)) {
           throw new ArgumentError(_generateMessage(tagNumber, value,
               'out of range for sint64'));
         }
         break;
       case _UINT32_BIT:
         if (value is !int) {
           throw new ArgumentError(
               _generateMessage(tagNumber, value, 'not type int'));
         }
         if (!_isUnsigned32(value)) {
           throw new ArgumentError(_generateMessage(tagNumber, value,
               'out of range for uint32'));
         }
         break;
       case _UINT64_BIT:
-        if (value is !ByteData) {
+        if (value is !Int64) {
           throw new ArgumentError(
-              _generateMessage(tagNumber, value, 'not ByteData'));
+              _generateMessage(tagNumber, value, 'not Int64'));
         }
         if (!_isUnsigned64(value)) {
           throw new ArgumentError(_generateMessage(tagNumber, value,
               'out of range for uint64'));
         }
         break;
       case _FIXED32_BIT:
         if (value is !int) {
           throw new ArgumentError(
               _generateMessage(tagNumber, value, 'not type int'));
         }
         if (!_isUnsigned32(value)) {
           throw new ArgumentError(_generateMessage(tagNumber, value,
               'out of range for fixed32'));
         }
         break;
       case _FIXED64_BIT:
-        if (value is !ByteData) {
+        if (value is !Int64) {
           throw new ArgumentError(
-              _generateMessage(tagNumber, value, 'not ByteData'));
+              _generateMessage(tagNumber, value, 'not Int64'));
         }
         if (!_isUnsigned64(value)) {
           throw new ArgumentError(_generateMessage(tagNumber, value,
               'out of range for fixed64'));
         }
         break;
       case _SFIXED32_BIT:
         if (value is !int) {
           throw new ArgumentError(
               _generateMessage(tagNumber, value, 'not type int'));
         }
         if (!_isSigned32(value)) {
           throw new ArgumentError(_generateMessage(tagNumber, value,
               'out of range for sfixed32'));
         }
         break;
       case _SFIXED64_BIT:
-        if (value is !ByteData) {
+        if (value is !Int64) {
           throw new ArgumentError(
-              _generateMessage(tagNumber, value, 'not ByteData'));
+              _generateMessage(tagNumber, value, 'not Int64'));
         }
         if (!_isSigned64(value)) {
           throw new ArgumentError(_generateMessage(tagNumber, value,
               'out of range for sfixed64'));
         }
         break;
       case _GROUP_BIT:
       case _MESSAGE_BIT:
         if (value is !GeneratedMessage) {
           throw new ArgumentError(
               _generateMessage(tagNumber, value, 'not a GeneratedMessage'));
         }
         break;
       default:
         throw new ArgumentError(
             _generateMessage(tagNumber, value, 'field has unknown type '
             '$fieldType'));
     }
   }
 }