bencode: Improve support for embedded structs

diff --git a/bencode/decode.go b/bencode/decode.go
index e891f5be0dc8b868d136d3003721a45729e365e8..43bb9ce69493cae2a90ee6eadcb944ca2b4f8328 100644 (file)
--- a/bencode/decode.go
+++ b/bencode/decode.go
@@ -253,14 +253,19 @@ func parseStructFields(struct_ reflect.Type, each func(key string, df dictField)
                i := _i
                f := struct_.Field(i)
                if f.Anonymous {
-                       parseStructFields(f.Type.Elem(), func(key string, df dictField) {
+                       t := f.Type
+                       if t.Kind() == reflect.Ptr {
+                               t = t.Elem()
+                       }
+                       parseStructFields(t, func(key string, df dictField) {
                                innerGet := df.Get
                                df.Get = func(value reflect.Value) func(reflect.Value) {
                                        anonPtr := value.Field(i)
-                                       if anonPtr.IsNil() {
+                                       if anonPtr.Kind() == reflect.Ptr && anonPtr.IsNil() {
                                                anonPtr.Set(reflect.New(f.Type.Elem()))
+                                               anonPtr = anonPtr.Elem()
                                        }
-                                       return innerGet(anonPtr.Elem())
+                                       return innerGet(anonPtr)
                                }
                                each(key, df)
                        })

diff --git a/bencode/encode.go b/bencode/encode.go
index f25cfef82bdf4ed70df4728f5f3bf119a9a1c462..05153a8c273beb5d62a5bc035b31b02fc71a11f3 100644 (file)
--- a/bencode/encode.go
+++ b/bencode/encode.go
@@ -231,16 +231,24 @@ func makeEncodeFields(t reflect.Type) (fs []encodeField) {
                        continue
                }
                if f.Anonymous {
-                       anonEFs := makeEncodeFields(f.Type.Elem())
+                       t := f.Type
+                       if t.Kind() == reflect.Ptr {
+                               t = t.Elem()
+                       }
+                       anonEFs := makeEncodeFields(t)
                        for aefi := range anonEFs {
                                anonEF := anonEFs[aefi]
                                bottomField := anonEF
                                bottomField.i = func(v reflect.Value) reflect.Value {
                                        v = v.Field(i)
-                                       if v.IsNil() {
-                                               return reflect.Value{}
+                                       if v.Kind() == reflect.Ptr {
+                                               if v.IsNil() {
+                                                       // This will skip serializing this value.
+                                                       return reflect.Value{}
+                                               }
+                                               v = v.Elem()
                                        }
-                                       return anonEF.i(v.Elem())
+                                       return anonEF.i(v)
                                }
                                fs = append(fs, bottomField)
                        }