Merge pull request #42 from Basekick-Labs/fix/non-addressable-pointer-encode

Fix/non addressable pointer encode

Author: xe-nvdk

encode_value.go

@@ -132,11 +132,21 @@ func ptrEncoderFunc(typ reflect.Type) encoderFunc {
 	}
 }
 
-func encodeCustomValuePtr(e *Encoder, v reflect.Value) error {
-	if !v.CanAddr() {
-		return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
+// ensureAddr returns v.Addr() if v is addressable, otherwise it allocates
+// a new value, copies v into it, and returns the pointer. This allows
+// types with pointer receivers to encode even when the source is not
+// addressable (e.g. map values, bare literals).
+func ensureAddr(v reflect.Value) reflect.Value {
+	if v.CanAddr() {
+		return v.Addr()
 	}
-	encoder := v.Addr().Interface().(CustomEncoder)
+	ptr := reflect.New(v.Type())
+	ptr.Elem().Set(v)
+	return ptr
+}
+
+func encodeCustomValuePtr(e *Encoder, v reflect.Value) error {
+	encoder := ensureAddr(v).Interface().(CustomEncoder)
 	return encoder.EncodeMsgpack(e)
 }
 
@@ -150,10 +160,7 @@ func encodeCustomValue(e *Encoder, v reflect.Value) error {
 }
 
 func marshalValuePtr(e *Encoder, v reflect.Value) error {
-	if !v.CanAddr() {
-		return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
-	}
-	return marshalValue(e, v.Addr())
+	return marshalValue(e, ensureAddr(v))
 }
 
 func marshalValue(e *Encoder, v reflect.Value) error {
@@ -210,10 +217,7 @@ func nilableType(t reflect.Type) bool {
 //------------------------------------------------------------------------------
 
 func marshalBinaryValueAddr(e *Encoder, v reflect.Value) error {
-	if !v.CanAddr() {
-		return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
-	}
-	return marshalBinaryValue(e, v.Addr())
+	return marshalBinaryValue(e, ensureAddr(v))
 }
 
 func marshalBinaryValue(e *Encoder, v reflect.Value) error {
@@ -233,10 +237,7 @@ func marshalBinaryValue(e *Encoder, v reflect.Value) error {
 //------------------------------------------------------------------------------
 
 func marshalTextValueAddr(e *Encoder, v reflect.Value) error {
-	if !v.CanAddr() {
-		return fmt.Errorf("msgpack: Encode(non-addressable %T)", v.Interface())
-	}
-	return marshalTextValue(e, v.Addr())
+	return marshalTextValue(e, ensureAddr(v))
 }
 
 func marshalTextValue(e *Encoder, v reflect.Value) error {

ext.go

@@ -95,10 +95,7 @@ func makeExtEncoder(
 
 func makeExtEncoderAddr(extEncoder encoderFunc) encoderFunc {
 	return func(e *Encoder, v reflect.Value) error {
-		if !v.CanAddr() {
-			return fmt.Errorf("msgpack: EncodeExt(nonaddressable %T)", v.Interface())
-		}
-		return extEncoder(e, v.Addr())
+		return extEncoder(e, ensureAddr(v))
 	}
 }
 

types_test.go

@@ -289,6 +289,33 @@ var encoderTests = []encoderTest{
 	{&Intern{A: "foo", B: "foo", C: "foo"}, "83a141a3666f6fa142d48000a143d48000"},
 }
 
+// Issue #3: types with pointer receivers should encode even when non-addressable.
+type PtrRecvMarshaler uint16
+
+func (p *PtrRecvMarshaler) MarshalMsgpack() ([]byte, error) {
+	return msgpack.Marshal(uint16(*p))
+}
+
+func (p *PtrRecvMarshaler) UnmarshalMsgpack(b []byte) error {
+	var n uint16
+	if err := msgpack.Unmarshal(b, &n); err != nil {
+		return err
+	}
+	*p = PtrRecvMarshaler(n)
+	return nil
+}
+
+func TestEncodeNonAddressablePtrReceiver(t *testing.T) {
+	// Encoding a non-pointer value whose pointer type implements Marshaler.
+	v := PtrRecvMarshaler(42)
+	b, err := msgpack.Marshal(v)
+	require.NoError(t, err)
+
+	var out PtrRecvMarshaler
+	require.NoError(t, msgpack.Unmarshal(b, &out))
+	require.Equal(t, v, out)
+}
+
 func TestEncoder(t *testing.T) {
 	var buf bytes.Buffer
 	enc := msgpack.NewEncoder(&buf)