fix(encode): handle non-addressable values with pointer receivers (#3)

Add ensureAddr helper that creates an addressable copy when v.CanAddr()
is false, instead of returning an error. Applied to encodeCustomValuePtr,
marshalValuePtr, marshalBinaryValueAddr, marshalTextValueAddr, and
makeExtEncoderAddr. The common case (struct fields) remains zero-cost
since they are already addressable.

Closes #3

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)