Create 0 size byte slices

As with other types, create a 0 size byte slice when the serialized data says so.

This is a functional change, and will require the use of `allownil` to retain the existing behaviour (ie no allocs on nil/zero length slices).

Fixes tinylib#362

Author: klauspost

_generated/def.go

@@ -278,3 +278,24 @@ type NonMsgStructTags struct {
 }
 
 type EmptyStruct struct{}
+
+type StructByteSlice struct {
+	ABytes      []byte       `msg:",allownil"`
+	AString     []string     `msg:",allownil"`
+	ABool       []bool       `msg:",allownil"`
+	AInt        []int        `msg:",allownil"`
+	AInt8       []int8       `msg:",allownil"`
+	AInt16      []int16      `msg:",allownil"`
+	AInt32      []int32      `msg:",allownil"`
+	AInt64      []int64      `msg:",allownil"`
+	AUint       []uint       `msg:",allownil"`
+	AUint8      []uint8      `msg:",allownil"`
+	AUint16     []uint16     `msg:",allownil"`
+	AUint32     []uint32     `msg:",allownil"`
+	AUint64     []uint64     `msg:",allownil"`
+	AFloat32    []float32    `msg:",allownil"`
+	AFloat64    []float64    `msg:",allownil"`
+	AComplex64  []complex64  `msg:",allownil"`
+	AComplex128 []complex128 `msg:",allownil"`
+	AStruct     []Fixed      `msg:",allownil"`
+}

_generated/gen_test.go

@@ -165,3 +165,73 @@ func TestIssue168(t *testing.T) {
 		t.Fatalf("got back %+v", test)
 	}
 }
+
+func TestIssue362(t *testing.T) {
+	in := StructByteSlice{
+		ABytes:      make([]byte, 0),
+		AString:     make([]string, 0),
+		ABool:       make([]bool, 0),
+		AInt:        make([]int, 0),
+		AInt8:       make([]int8, 0),
+		AInt16:      make([]int16, 0),
+		AInt32:      make([]int32, 0),
+		AInt64:      make([]int64, 0),
+		AUint:       make([]uint, 0),
+		AUint8:      make([]uint8, 0),
+		AUint16:     make([]uint16, 0),
+		AUint32:     make([]uint32, 0),
+		AUint64:     make([]uint64, 0),
+		AFloat32:    make([]float32, 0),
+		AFloat64:    make([]float64, 0),
+		AComplex64:  make([]complex64, 0),
+		AComplex128: make([]complex128, 0),
+		AStruct:     make([]Fixed, 0),
+	}
+
+	b, err := in.MarshalMsg(nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var dst StructByteSlice
+	_, err = dst.UnmarshalMsg(b)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(in, dst) {
+		t.Fatalf("mismatch %#v != %#v", in, dst)
+	}
+	dst2 := StructByteSlice{}
+	dec := msgp.NewReader(bytes.NewReader(b))
+	err = dst2.DecodeMsg(dec)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(in, dst2) {
+		t.Fatalf("mismatch %#v != %#v", in, dst2)
+	}
+
+	// Encode with nil
+	zero := StructByteSlice{}
+	b, err = zero.MarshalMsg(nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Decode into dst that now has values...
+	_, err = dst.UnmarshalMsg(b)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// All should be nil now.
+	if !reflect.DeepEqual(zero, dst) {
+		t.Fatalf("mismatch %#v != %#v", zero, dst)
+	}
+	dec = msgp.NewReader(bytes.NewReader(b))
+	err = dst2.DecodeMsg(dec)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(zero, dst2) {
+		t.Fatalf("mismatch %#v != %#v", zero, dst2)
+	}
+}

msgp/read.go

@@ -934,7 +934,7 @@ func (m *Reader) ReadBytes(scratch []byte) (b []byte, err error) {
 		err = badPrefix(BinType, lead)
 		return
 	}
-	if int64(cap(scratch)) < read {
+	if int64(cap(scratch)) < read || scratch == nil {
 		b = make([]byte, read)
 	} else {
 		b = scratch[0:read]

msgp/read_bytes.go

@@ -843,7 +843,7 @@ func readBytesBytes(b []byte, scratch []byte, zc bool) (v []byte, o []byte, err
 		return
 	}
 
-	if cap(scratch) >= read {
+	if cap(scratch) >= read && scratch != nil {
 		v = scratch[0:read]
 	} else {
 		v = make([]byte, read)