Release 0.14.0 (#240)

* minimal changes to ensure proto3 compat. for unsigned ints (int,
int32, int64)
* Add changes to decode ints, too

* Fix example that contains an int

* Add changelog entry

* Delete outdated tests (covered by new table driven test)

* Add overflow checks for int & int32

* unum -> u64

* prep release: update changelog

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.14.0 (October 26, 2018)
+
+BREAKING CHANGE:
+ - Switch default encoding of unsigned ints (`int`, `int32`, `int64`) to be on par with [proto3's] variable length 
+ encoding (of `int32`, `int64`) ([#237])
+
+ [proto3's]: https://developers.google.com/protocol-buffers/docs/proto#scalar
+ [#237]: https://github.com/tendermint/go-amino/issues/237
+
 ## 0.13.0 (October 15, 2018)
 
 BREAKING CHANGE:

binary-decode.go

@@ -3,6 +3,7 @@ package amino
 import (
 	"errors"
 	"fmt"
+	"math"
 	"reflect"
 	"time"
 
@@ -12,6 +13,16 @@ import (
 //----------------------------------------
 // cdc.decodeReflectBinary
 
+var (
+	ErrOverflowInt = errors.New("encoded integer value overflows int(32)")
+)
+
+const (
+	// architecture dependent int limits:
+	maxInt = int(^uint(0) >> 1)
+	minInt = -maxInt - 1
+)
+
 // This is the main entrypoint for decoding all types from binary form. This
 // function calls decodeReflectBinary*, and generally those functions should
 // only call this one, for the prefix bytes are consumed here when present.
@@ -115,11 +126,12 @@ func (cdc *Codec) decodeReflectBinary(bz []byte, info *TypeInfo, rv reflect.Valu
 			}
 			rv.SetInt(num)
 		} else {
-			num, _n, err = DecodeVarint(bz)
+			var u64 uint64
+			u64, _n, err = DecodeUvarint(bz)
 			if slide(&bz, &n, _n) && err != nil {
 				return
 			}
-			rv.SetInt(num)
+			rv.SetInt(int64(u64))
 		}
 		return
 
@@ -132,11 +144,15 @@ func (cdc *Codec) decodeReflectBinary(bz []byte, info *TypeInfo, rv reflect.Valu
 			}
 			rv.SetInt(int64(num))
 		} else {
-			var num int64
-			num, _n, err = DecodeVarint(bz)
+			var num uint64
+			num, _n, err = DecodeUvarint(bz)
 			if slide(&bz, &n, _n) && err != nil {
 				return
 			}
+			if int64(num) > math.MaxInt32 || int64(num) < math.MinInt32 {
+				err = ErrOverflowInt
+				return
+			}
 			rv.SetInt(int64(num))
 		}
 		return
@@ -160,12 +176,16 @@ func (cdc *Codec) decodeReflectBinary(bz []byte, info *TypeInfo, rv reflect.Valu
 		return
 
 	case reflect.Int:
-		var num int64
-		num, _n, err = DecodeVarint(bz)
+		var num uint64
+		num, _n, err = DecodeUvarint(bz)
 		if slide(&bz, &n, _n) && err != nil {
 			return
 		}
-		rv.SetInt(num)
+		if int64(num) > int64(maxInt) || int64(num) < int64(minInt) {
+			err = ErrOverflowInt
+			return
+		}
+		rv.SetInt(int64(num))
 		return
 
 	//----------------------------------------

binary-encode.go

@@ -86,14 +86,14 @@ func (cdc *Codec) encodeReflectBinary(w io.Writer, info *TypeInfo, rv reflect.Va
 		if fopts.BinFixed64 {
 			err = EncodeInt64(w, rv.Int())
 		} else {
-			err = EncodeVarint(w, rv.Int())
+			err = EncodeUvarint(w, uint64(rv.Int()))
 		}
 
 	case reflect.Int32:
 		if fopts.BinFixed32 {
 			err = EncodeInt32(w, int32(rv.Int()))
 		} else {
-			err = EncodeVarint(w, rv.Int())
+			err = EncodeUvarint(w, uint64(rv.Int()))
 		}
 
 	case reflect.Int16:
@@ -103,7 +103,7 @@ func (cdc *Codec) encodeReflectBinary(w io.Writer, info *TypeInfo, rv reflect.Va
 		err = EncodeInt8(w, int8(rv.Int()))
 
 	case reflect.Int:
-		err = EncodeVarint(w, rv.Int())
+		err = EncodeUvarint(w, uint64(rv.Int()))
 
 	//----------------------------------------
 	// Unsigned

binary_test.go

@@ -168,7 +168,7 @@ func TestStructSlice(t *testing.T) {
 
 	bz, err := cdc.MarshalBinaryBare(f)
 	assert.NoError(t, err)
-	assert.Equal(t, "0A0608C80110CA010A0608CC0110CE01", fmt.Sprintf("%X", bz))
+	assert.Equal(t, "0A04086410650A0408661067", fmt.Sprintf("%X", bz))
 	t.Log(bz)
 	var f2 Foos
 	cdc.UnmarshalBinaryBare(bz, &f2)

encoder.go

@@ -76,6 +76,9 @@ func EncodeUint64(w io.Writer, u uint64) (err error) {
 	return
 }
 
+// EncodeUvarint is used to encode golang's int, int32, int64 by default. unless specified differently by the
+// `binary:"fixed32"`, `binary:"fixed64"`, or `binary:"zigzag32"` `binary:"zigzag64"` tags.
+// It matches protobufs varint encoding.
 func EncodeUvarint(w io.Writer, u uint64) (err error) {
 	var buf [10]byte
 	n := binary.PutUvarint(buf[:], u)

example_test.go

@@ -65,7 +65,7 @@ func Example() {
 	fmt.Printf("Decoded successfully: %v\n", *bm == *bm2)
 
 	// Output:
-	// Encoded: 0C740613650A0341424310C801 (err: <nil>)
+	// Encoded: 0B740613650A034142431064 (err: <nil>)
 	// Decoded: &{ABC 100} (err: <nil>)
 	// Decoded successfully: true
 }

tests/proto3/proto/compat.proto

@@ -42,6 +42,8 @@ message TestInt32 {
     int32 Int32 = 1;
 }
 
-message TestInt64 {
-    int64 Int64 = 1;
+
+message TestInts {
+    int32 Int32 = 1;
+    int64 Int64 = 2;
 }