Improve stdlib compatibility

olegshaldybin · olegshaldybin · commit 68ce834f4cf5 · 2017-09-16T15:17:47.000-07:00
1. Null values for primitive types no longer clear the original value in
the destination object.

2. Dereference multiple levels of pointers in the destination interface{}
type before unmarshaling into it. This is needed to match stdlib
behavior when working with nested interface{} fields. If the destination
object is a pointer to interface{} then the incoming nil value should
nil out the destination object but keep the reference to that nil value
on its parent object. However if the destination object is an
interface{} value it should set the reference to nil but keep the
original object intact.

3. Correctly handle typed nil decode destinations.
diff --git a/feature_reflect_native.go b/feature_reflect_native.go
@@ -32,11 +32,9 @@ type intCodec struct {
 }
 
 func (codec *intCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*int)(ptr)) = 0
-		return
+	if !iter.ReadNil() {
+		*((*int)(ptr)) = iter.ReadInt()
 	}
-	*((*int)(ptr)) = iter.ReadInt()
 }
 
 func (codec *intCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -55,11 +53,9 @@ type uintptrCodec struct {
 }
 
 func (codec *uintptrCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*uintptr)(ptr)) = 0
-		return
+	if !iter.ReadNil() {
+		*((*uintptr)(ptr)) = uintptr(iter.ReadUint64())
 	}
-	*((*uintptr)(ptr)) = uintptr(iter.ReadUint64())
 }
 
 func (codec *uintptrCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -78,11 +74,9 @@ type int8Codec struct {
 }
 
 func (codec *int8Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*uint8)(ptr)) = 0
-		return
+	if !iter.ReadNil() {
+		*((*int8)(ptr)) = iter.ReadInt8()
 	}
-	*((*int8)(ptr)) = iter.ReadInt8()
 }
 
 func (codec *int8Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -101,11 +95,9 @@ type int16Codec struct {
 }
 
 func (codec *int16Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*int16)(ptr)) = 0
-		return
+	if !iter.ReadNil() {
+		*((*int16)(ptr)) = iter.ReadInt16()
 	}
-	*((*int16)(ptr)) = iter.ReadInt16()
 }
 
 func (codec *int16Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -124,11 +116,9 @@ type int32Codec struct {
 }
 
 func (codec *int32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*int32)(ptr)) = 0
-		return
+	if !iter.ReadNil() {
+		*((*int32)(ptr)) = iter.ReadInt32()
 	}
-	*((*int32)(ptr)) = iter.ReadInt32()
 }
 
 func (codec *int32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -147,11 +137,9 @@ type int64Codec struct {
 }
 
 func (codec *int64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*int64)(ptr)) = 0
-		return
+	if !iter.ReadNil() {
+		*((*int64)(ptr)) = iter.ReadInt64()
 	}
-	*((*int64)(ptr)) = iter.ReadInt64()
 }
 
 func (codec *int64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -170,11 +158,10 @@ type uintCodec struct {
 }
 
 func (codec *uintCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*uint)(ptr)) = 0
+	if !iter.ReadNil() {
+		*((*uint)(ptr)) = iter.ReadUint()
 		return
 	}
-	*((*uint)(ptr)) = iter.ReadUint()
 }
 
 func (codec *uintCodec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -193,11 +180,9 @@ type uint8Codec struct {
 }
 
 func (codec *uint8Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*uint8)(ptr)) = 0
-		return
+	if !iter.ReadNil() {
+		*((*uint8)(ptr)) = iter.ReadUint8()
 	}
-	*((*uint8)(ptr)) = iter.ReadUint8()
 }
 
 func (codec *uint8Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -216,11 +201,9 @@ type uint16Codec struct {
 }
 
 func (codec *uint16Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*uint16)(ptr)) = 0
-		return
+	if !iter.ReadNil() {
+		*((*uint16)(ptr)) = iter.ReadUint16()
 	}
-	*((*uint16)(ptr)) = iter.ReadUint16()
 }
 
 func (codec *uint16Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -239,11 +222,9 @@ type uint32Codec struct {
 }
 
 func (codec *uint32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*uint32)(ptr)) = 0
-		return
+	if !iter.ReadNil() {
+		*((*uint32)(ptr)) = iter.ReadUint32()
 	}
-	*((*uint32)(ptr)) = iter.ReadUint32()
 }
 
 func (codec *uint32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -262,11 +243,9 @@ type uint64Codec struct {
 }
 
 func (codec *uint64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*uint64)(ptr)) = 0
-		return
+	if !iter.ReadNil() {
+		*((*uint64)(ptr)) = iter.ReadUint64()
 	}
-	*((*uint64)(ptr)) = iter.ReadUint64()
 }
 
 func (codec *uint64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -285,11 +264,9 @@ type float32Codec struct {
 }
 
 func (codec *float32Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*float32)(ptr)) = 0
-		return
+	if !iter.ReadNil() {
+		*((*float32)(ptr)) = iter.ReadFloat32()
 	}
-	*((*float32)(ptr)) = iter.ReadFloat32()
 }
 
 func (codec *float32Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -308,11 +285,9 @@ type float64Codec struct {
 }
 
 func (codec *float64Codec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*float64)(ptr)) = 0
-		return
+	if !iter.ReadNil() {
+		*((*float64)(ptr)) = iter.ReadFloat64()
 	}
-	*((*float64)(ptr)) = iter.ReadFloat64()
 }
 
 func (codec *float64Codec) Encode(ptr unsafe.Pointer, stream *Stream) {
@@ -352,13 +327,39 @@ type emptyInterfaceCodec struct {
 }
 
 func (codec *emptyInterfaceCodec) Decode(ptr unsafe.Pointer, iter *Iterator) {
-	if iter.ReadNil() {
-		*((*interface{})(ptr)) = nil
+	existing := *((*interface{})(ptr))
+
+	// Checking for both typed and untyped nil pointers.
+	if existing != nil &&
+		reflect.TypeOf(existing).Kind() == reflect.Ptr &&
+		!reflect.ValueOf(existing).IsNil() {
+
+		var ptrToExisting interface{}
+		for {
+			elem := reflect.ValueOf(existing).Elem()
+			if elem.Kind() != reflect.Ptr || elem.IsNil() {
+				break
+			}
+			ptrToExisting = existing
+			existing = elem.Interface()
+		}
+
+		if iter.ReadNil() {
+			if ptrToExisting != nil {
+				nilPtr := reflect.Zero(reflect.TypeOf(ptrToExisting).Elem())
+				reflect.ValueOf(ptrToExisting).Elem().Set(nilPtr)
+			} else {
+				*((*interface{})(ptr)) = nil
+			}
+		} else {
+			iter.ReadVal(existing)
+		}
+
 		return
 	}
-	existing := *((*interface{})(ptr))
-	if existing != nil && reflect.TypeOf(existing).Kind() == reflect.Ptr {
-		iter.ReadVal(existing)
+
+	if iter.ReadNil() {
+		*((*interface{})(ptr)) = nil
 	} else {
 		*((*interface{})(ptr)) = iter.Read()
 	}
diff --git a/jsoniter_interface_test.go b/jsoniter_interface_test.go
@@ -370,3 +370,124 @@ func Test_omitempty_nil_interface(t *testing.T) {
 	should.Equal(nil, err)
 	should.Equal(string(js), str)
 }
+
+func Test_overwrite_interface_ptr_value_with_nil(t *testing.T) {
+	type Wrapper struct {
+		Payload interface{} `json:"payload,omitempty"`
+	}
+	type Payload struct {
+		Value int `json:"val,omitempty"`
+	}
+
+	should := require.New(t)
+
+	payload := &Payload{}
+	wrapper := &Wrapper{
+		Payload: &payload,
+	}
+
+	err := json.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.Equal(nil, err)
+	should.Equal(&payload, wrapper.Payload)
+	should.Equal(42, (*(wrapper.Payload.(**Payload))).Value)
+
+	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.Equal(nil, err)
+	should.Equal(&payload, wrapper.Payload)
+	should.Equal((*Payload)(nil), payload)
+
+	payload = &Payload{}
+	wrapper = &Wrapper{
+		Payload: &payload,
+	}
+
+	err = Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.Equal(nil, err)
+	should.Equal(&payload, wrapper.Payload)
+	should.Equal(42, (*(wrapper.Payload.(**Payload))).Value)
+
+	err = Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.Equal(nil, err)
+	should.Equal(&payload, wrapper.Payload)
+	should.Equal((*Payload)(nil), payload)
+}
+
+func Test_overwrite_interface_value_with_nil(t *testing.T) {
+	type Wrapper struct {
+		Payload interface{} `json:"payload,omitempty"`
+	}
+	type Payload struct {
+		Value int `json:"val,omitempty"`
+	}
+
+	should := require.New(t)
+
+	payload := &Payload{}
+	wrapper := &Wrapper{
+		Payload: payload,
+	}
+
+	err := json.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.Equal(nil, err)
+	should.Equal(42, (*(wrapper.Payload.(*Payload))).Value)
+
+	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.Equal(nil, err)
+	should.Equal(nil, wrapper.Payload)
+	should.Equal(42, payload.Value)
+
+	payload = &Payload{}
+	wrapper = &Wrapper{
+		Payload: payload,
+	}
+
+	err = Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.Equal(nil, err)
+	should.Equal(42, (*(wrapper.Payload.(*Payload))).Value)
+
+	err = Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.Equal(nil, err)
+	should.Equal(nil, wrapper.Payload)
+	should.Equal(42, payload.Value)
+}
+
+func Test_unmarshal_into_nil(t *testing.T) {
+	type Payload struct {
+		Value int `json:"val,omitempty"`
+	}
+	type Wrapper struct {
+		Payload interface{} `json:"payload,omitempty"`
+	}
+
+	should := require.New(t)
+
+	var payload *Payload
+	wrapper := &Wrapper{
+		Payload: payload,
+	}
+
+	err := json.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.Nil(err)
+	should.NotNil(wrapper.Payload)
+	should.Nil(payload)
+
+	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.Nil(err)
+	should.Nil(wrapper.Payload)
+	should.Nil(payload)
+
+	payload = nil
+	wrapper = &Wrapper{
+		Payload: payload,
+	}
+
+	err = Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
+	should.Nil(err)
+	should.NotNil(wrapper.Payload)
+	should.Nil(payload)
+
+	err = Unmarshal([]byte(`{"payload": null}`), &wrapper)
+	should.Nil(err)
+	should.Nil(wrapper.Payload)
+	should.Nil(payload)
+}
diff --git a/jsoniter_null_test.go b/jsoniter_null_test.go
@@ -3,9 +3,10 @@ package jsoniter
 import (
 	"bytes"
 	"encoding/json"
-	"github.com/stretchr/testify/require"
 	"io"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func Test_read_null(t *testing.T) {
@@ -135,3 +136,33 @@ func Test_encode_nil_array(t *testing.T) {
 	should.Nil(err)
 	should.Equal("null", string(output))
 }
+
+func Test_decode_nil_num(t *testing.T) {
+	type TestData struct {
+		Field int `json:"field"`
+	}
+	should := require.New(t)
+
+	data1 := []byte(`{"field": 42}`)
+	data2 := []byte(`{"field": null}`)
+
+	// Checking stdlib behavior as well
+	obj2 := TestData{}
+	err := json.Unmarshal(data1, &obj2)
+	should.Equal(nil, err)
+	should.Equal(42, obj2.Field)
+
+	err = json.Unmarshal(data2, &obj2)
+	should.Equal(nil, err)
+	should.Equal(42, obj2.Field)
+
+	obj := TestData{}
+
+	err = Unmarshal(data1, &obj)
+	should.Equal(nil, err)
+	should.Equal(42, obj.Field)
+
+	err = Unmarshal(data2, &obj)
+	should.Equal(nil, err)
+	should.Equal(42, obj.Field)
+}

Original file line number	Diff line number	Diff line change
`@@ -32,11 +32,9 @@ type intCodec struct {`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`func (codec intCodec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`35`		`- if iter.ReadNil() {`
`36`		`- ((int)(ptr)) = 0`
`37`		`- return`
	`35`	`+ if !iter.ReadNil() {`
	`36`	`+ ((int)(ptr)) = iter.ReadInt()`
`38`	`37`	`}`
`39`		`- ((int)(ptr)) = iter.ReadInt()`
`40`	`38`	`}`
`41`	`39`
`42`	`40`	`func (codec intCodec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -55,11 +53,9 @@ type uintptrCodec struct {`
`55`	`53`	`}`
`56`	`54`
`57`	`55`	`func (codec uintptrCodec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`58`		`- if iter.ReadNil() {`
`59`		`- ((uintptr)(ptr)) = 0`
`60`		`- return`
	`56`	`+ if !iter.ReadNil() {`
	`57`	`+ ((uintptr)(ptr)) = uintptr(iter.ReadUint64())`
`61`	`58`	`}`
`62`		`- ((uintptr)(ptr)) = uintptr(iter.ReadUint64())`
`63`	`59`	`}`
`64`	`60`
`65`	`61`	`func (codec uintptrCodec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -78,11 +74,9 @@ type int8Codec struct {`
`78`	`74`	`}`
`79`	`75`
`80`	`76`	`func (codec int8Codec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`81`		`- if iter.ReadNil() {`
`82`		`- ((uint8)(ptr)) = 0`
`83`		`- return`
	`77`	`+ if !iter.ReadNil() {`
	`78`	`+ ((int8)(ptr)) = iter.ReadInt8()`
`84`	`79`	`}`
`85`		`- ((int8)(ptr)) = iter.ReadInt8()`
`86`	`80`	`}`
`87`	`81`
`88`	`82`	`func (codec int8Codec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -101,11 +95,9 @@ type int16Codec struct {`
`101`	`95`	`}`
`102`	`96`
`103`	`97`	`func (codec int16Codec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`104`		`- if iter.ReadNil() {`
`105`		`- ((int16)(ptr)) = 0`
`106`		`- return`
	`98`	`+ if !iter.ReadNil() {`
	`99`	`+ ((int16)(ptr)) = iter.ReadInt16()`
`107`	`100`	`}`
`108`		`- ((int16)(ptr)) = iter.ReadInt16()`
`109`	`101`	`}`
`110`	`102`
`111`	`103`	`func (codec int16Codec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -124,11 +116,9 @@ type int32Codec struct {`
`124`	`116`	`}`
`125`	`117`
`126`	`118`	`func (codec int32Codec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`127`		`- if iter.ReadNil() {`
`128`		`- ((int32)(ptr)) = 0`
`129`		`- return`
	`119`	`+ if !iter.ReadNil() {`
	`120`	`+ ((int32)(ptr)) = iter.ReadInt32()`
`130`	`121`	`}`
`131`		`- ((int32)(ptr)) = iter.ReadInt32()`
`132`	`122`	`}`
`133`	`123`
`134`	`124`	`func (codec int32Codec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -147,11 +137,9 @@ type int64Codec struct {`
`147`	`137`	`}`
`148`	`138`
`149`	`139`	`func (codec int64Codec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`150`		`- if iter.ReadNil() {`
`151`		`- ((int64)(ptr)) = 0`
`152`		`- return`
	`140`	`+ if !iter.ReadNil() {`
	`141`	`+ ((int64)(ptr)) = iter.ReadInt64()`
`153`	`142`	`}`
`154`		`- ((int64)(ptr)) = iter.ReadInt64()`
`155`	`143`	`}`
`156`	`144`
`157`	`145`	`func (codec int64Codec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -170,11 +158,10 @@ type uintCodec struct {`
`170`	`158`	`}`
`171`	`159`
`172`	`160`	`func (codec uintCodec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`173`		`- if iter.ReadNil() {`
`174`		`- ((uint)(ptr)) = 0`
	`161`	`+ if !iter.ReadNil() {`
	`162`	`+ ((uint)(ptr)) = iter.ReadUint()`
`175`	`163`	`return`
`176`	`164`	`}`
`177`		`- ((uint)(ptr)) = iter.ReadUint()`
`178`	`165`	`}`
`179`	`166`
`180`	`167`	`func (codec uintCodec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -193,11 +180,9 @@ type uint8Codec struct {`
`193`	`180`	`}`
`194`	`181`
`195`	`182`	`func (codec uint8Codec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`196`		`- if iter.ReadNil() {`
`197`		`- ((uint8)(ptr)) = 0`
`198`		`- return`
	`183`	`+ if !iter.ReadNil() {`
	`184`	`+ ((uint8)(ptr)) = iter.ReadUint8()`
`199`	`185`	`}`
`200`		`- ((uint8)(ptr)) = iter.ReadUint8()`
`201`	`186`	`}`
`202`	`187`
`203`	`188`	`func (codec uint8Codec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -216,11 +201,9 @@ type uint16Codec struct {`
`216`	`201`	`}`
`217`	`202`
`218`	`203`	`func (codec uint16Codec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`219`		`- if iter.ReadNil() {`
`220`		`- ((uint16)(ptr)) = 0`
`221`		`- return`
	`204`	`+ if !iter.ReadNil() {`
	`205`	`+ ((uint16)(ptr)) = iter.ReadUint16()`
`222`	`206`	`}`
`223`		`- ((uint16)(ptr)) = iter.ReadUint16()`
`224`	`207`	`}`
`225`	`208`
`226`	`209`	`func (codec uint16Codec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -239,11 +222,9 @@ type uint32Codec struct {`
`239`	`222`	`}`
`240`	`223`
`241`	`224`	`func (codec uint32Codec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`242`		`- if iter.ReadNil() {`
`243`		`- ((uint32)(ptr)) = 0`
`244`		`- return`
	`225`	`+ if !iter.ReadNil() {`
	`226`	`+ ((uint32)(ptr)) = iter.ReadUint32()`
`245`	`227`	`}`
`246`		`- ((uint32)(ptr)) = iter.ReadUint32()`
`247`	`228`	`}`
`248`	`229`
`249`	`230`	`func (codec uint32Codec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -262,11 +243,9 @@ type uint64Codec struct {`
`262`	`243`	`}`
`263`	`244`
`264`	`245`	`func (codec uint64Codec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`265`		`- if iter.ReadNil() {`
`266`		`- ((uint64)(ptr)) = 0`
`267`		`- return`
	`246`	`+ if !iter.ReadNil() {`
	`247`	`+ ((uint64)(ptr)) = iter.ReadUint64()`
`268`	`248`	`}`
`269`		`- ((uint64)(ptr)) = iter.ReadUint64()`
`270`	`249`	`}`
`271`	`250`
`272`	`251`	`func (codec uint64Codec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -285,11 +264,9 @@ type float32Codec struct {`
`285`	`264`	`}`
`286`	`265`
`287`	`266`	`func (codec float32Codec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`288`		`- if iter.ReadNil() {`
`289`		`- ((float32)(ptr)) = 0`
`290`		`- return`
	`267`	`+ if !iter.ReadNil() {`
	`268`	`+ ((float32)(ptr)) = iter.ReadFloat32()`
`291`	`269`	`}`
`292`		`- ((float32)(ptr)) = iter.ReadFloat32()`
`293`	`270`	`}`
`294`	`271`
`295`	`272`	`func (codec float32Codec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -308,11 +285,9 @@ type float64Codec struct {`
`308`	`285`	`}`
`309`	`286`
`310`	`287`	`func (codec float64Codec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`311`		`- if iter.ReadNil() {`
`312`		`- ((float64)(ptr)) = 0`
`313`		`- return`
	`288`	`+ if !iter.ReadNil() {`
	`289`	`+ ((float64)(ptr)) = iter.ReadFloat64()`
`314`	`290`	`}`
`315`		`- ((float64)(ptr)) = iter.ReadFloat64()`
`316`	`291`	`}`
`317`	`292`
`318`	`293`	`func (codec float64Codec) Encode(ptr unsafe.Pointer, stream Stream) {`
`@@ -352,13 +327,39 @@ type emptyInterfaceCodec struct {`
`352`	`327`	`}`
`353`	`328`
`354`	`329`	`func (codec emptyInterfaceCodec) Decode(ptr unsafe.Pointer, iter Iterator) {`
`355`		`- if iter.ReadNil() {`
`356`		`- ((interface{})(ptr)) = nil`
	`330`	`+ existing := ((interface{})(ptr))`
	`331`	`+`
	`332`	`+ // Checking for both typed and untyped nil pointers.`
	`333`	`+ if existing != nil &&`
	`334`	`+ reflect.TypeOf(existing).Kind() == reflect.Ptr &&`
	`335`	`+ !reflect.ValueOf(existing).IsNil() {`
	`336`	`+`
	`337`	`+ var ptrToExisting interface{}`
	`338`	`+ for {`
	`339`	`+ elem := reflect.ValueOf(existing).Elem()`
	`340`	`+ if elem.Kind() != reflect.Ptr \|\| elem.IsNil() {`
	`341`	`+ break`
	`342`	`+ }`
	`343`	`+ ptrToExisting = existing`
	`344`	`+ existing = elem.Interface()`
	`345`	`+ }`
	`346`	`+`
	`347`	`+ if iter.ReadNil() {`
	`348`	`+ if ptrToExisting != nil {`
	`349`	`+ nilPtr := reflect.Zero(reflect.TypeOf(ptrToExisting).Elem())`
	`350`	`+ reflect.ValueOf(ptrToExisting).Elem().Set(nilPtr)`
	`351`	`+ } else {`
	`352`	`+ ((interface{})(ptr)) = nil`
	`353`	`+ }`
	`354`	`+ } else {`
	`355`	`+ iter.ReadVal(existing)`
	`356`	`+ }`
	`357`	`+`
`357`	`358`	`return`
`358`	`359`	`}`
`359`		`- existing := ((interface{})(ptr))`
`360`		`- if existing != nil && reflect.TypeOf(existing).Kind() == reflect.Ptr {`
`361`		`- iter.ReadVal(existing)`
	`360`	`+`
	`361`	`+ if iter.ReadNil() {`
	`362`	`+ ((interface{})(ptr)) = nil`
`362`	`363`	`} else {`
`363`	`364`	`((interface{})(ptr)) = iter.Read()`
`364`	`365`	`}`