From dc44e85a86518c4e78581a21d44d418954dc6f86 Mon Sep 17 00:00:00 2001
From: Tao Wen <taowen@gmail.com>
Date: Mon, 26 Jun 2017 22:37:24 +0800
Subject: [PATCH] #73 fix interface{} optimization for one ptr field struct and
 array

---
 feature_reflect_array.go   | 12 +++++---
 feature_reflect_map.go     |  1 -
 feature_reflect_object.go  | 14 +++++++++
 jsoniter_interface_test.go | 62 ++++++++++++++++++++++++++++++++++++++
 jsoniter_object_test.go    | 23 --------------
 5 files changed, 84 insertions(+), 28 deletions(-)

diff --git a/feature_reflect_array.go b/feature_reflect_array.go
index 727b654..29959b1 100644
--- a/feature_reflect_array.go
+++ b/feature_reflect_array.go
@@ -33,10 +33,6 @@ type arrayEncoder struct {
 }
 
 func (encoder *arrayEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
-	if ptr == nil {
-		stream.WriteNil()
-		return
-	}
 	stream.WriteArrayStart()
 	elemPtr := uintptr(ptr)
 	encoder.elemEncoder.Encode(unsafe.Pointer(elemPtr), stream)
@@ -52,6 +48,14 @@ func (encoder *arrayEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
 }
 
 func (encoder *arrayEncoder) EncodeInterface(val interface{}, stream *Stream) {
+	// special optimization for interface{}
+	e := (*emptyInterface)(unsafe.Pointer(&val))
+	if e.word == nil {
+		stream.WriteArrayStart()
+		stream.WriteNil()
+		stream.WriteArrayEnd()
+		return
+	}
 	WriteToStream(val, stream, encoder)
 }
 
diff --git a/feature_reflect_map.go b/feature_reflect_map.go
index f8c2428..576c13d 100644
--- a/feature_reflect_map.go
+++ b/feature_reflect_map.go
@@ -85,7 +85,6 @@ func (encoder *mapEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
 	mapInterface.word = ptr
 	realInterface := (*interface{})(unsafe.Pointer(&mapInterface))
 	realVal := reflect.ValueOf(*realInterface)
-
 	stream.WriteObjectStart()
 	for i, key := range realVal.MapKeys() {
 		if i != 0 {
diff --git a/feature_reflect_object.go b/feature_reflect_object.go
index ea31b33..41cc061 100644
--- a/feature_reflect_object.go
+++ b/feature_reflect_object.go
@@ -1039,6 +1039,20 @@ func (encoder *structEncoder) EncodeInterface(val interface{}, stream *Stream) {
 					},
 				},
 			}
+			e := (*emptyInterface)(unsafe.Pointer(&val))
+			if e.word == nil {
+				stream.WriteObjectStart()
+				stream.WriteObjectField(firstFieldName)
+				stream.WriteNil()
+				stream.WriteObjectEnd()
+				return
+			}
+			if reflect.TypeOf(val).Kind() == reflect.Ptr {
+				encoderToUse.Encode(unsafe.Pointer(&e.word), stream)
+			} else {
+				encoderToUse.Encode(e.word, stream)
+			}
+			return
 		}
 	}
 	WriteToStream(val, stream, encoderToUse)
diff --git a/jsoniter_interface_test.go b/jsoniter_interface_test.go
index 266e7c2..ae5385c 100644
--- a/jsoniter_interface_test.go
+++ b/jsoniter_interface_test.go
@@ -162,3 +162,65 @@ func Test_read_large_number_as_interface(t *testing.T) {
 	should.Nil(err)
 	should.Equal(`123456789123456789123456789`, output)
 }
+
+func Test_nested_one_field_struct(t *testing.T) {
+	should := require.New(t)
+	type YetYetAnotherObject struct {
+		Field string
+	}
+	type YetAnotherObject struct {
+		Field *YetYetAnotherObject
+	}
+	type AnotherObject struct {
+		Field *YetAnotherObject
+	}
+	type TestObject struct {
+		Me *AnotherObject
+	}
+	obj := TestObject{&AnotherObject{&YetAnotherObject{&YetYetAnotherObject{"abc"}}}}
+	str, err := MarshalToString(obj)
+	should.Nil(err)
+	should.Equal(`{"Me":{"Field":{"Field":{"Field":"abc"}}}}`, str)
+	str, err = MarshalToString(&obj)
+	should.Nil(err)
+	should.Equal(`{"Me":{"Field":{"Field":{"Field":"abc"}}}}`, str)
+}
+
+func Test_struct_with_one_nil(t *testing.T) {
+	type TestObject struct {
+		F *float64
+	}
+	var obj TestObject
+	should := require.New(t)
+	output, err := MarshalToString(obj)
+	should.Nil(err)
+	should.Equal(`{"F":null}`, output)
+}
+
+func Test_array_with_one_nil(t *testing.T) {
+	obj := [1]*float64{nil}
+	should := require.New(t)
+	output, err := MarshalToString(obj)
+	should.Nil(err)
+	should.Equal(`[null]`, output)
+}
+
+func Test_embedded_array_with_one_nil(t *testing.T) {
+	type TestObject struct {
+		Field1 int
+		Field2 [1]*float64
+	}
+	var obj TestObject
+	should := require.New(t)
+	output, err := MarshalToString(obj)
+	should.Nil(err)
+	should.Contains(output, `"Field2":[null]`)
+}
+
+func Test_array_with_nothing(t *testing.T) {
+	var obj [2]*float64
+	should := require.New(t)
+	output, err := MarshalToString(obj)
+	should.Nil(err)
+	should.Equal(`[null,null]`, output)
+}
diff --git a/jsoniter_object_test.go b/jsoniter_object_test.go
index 4ff9473..9e2c10a 100644
--- a/jsoniter_object_test.go
+++ b/jsoniter_object_test.go
@@ -280,29 +280,6 @@ func Test_recursive_struct(t *testing.T) {
 	should.Nil(err)
 }
 
-func Test_one_field_struct(t *testing.T) {
-	should := require.New(t)
-	type YetYetAnotherObject struct {
-		Field string
-	}
-	type YetAnotherObject struct {
-		Field *YetYetAnotherObject
-	}
-	type AnotherObject struct {
-		Field *YetAnotherObject
-	}
-	type TestObject struct {
-		Me *AnotherObject
-	}
-	obj := TestObject{&AnotherObject{&YetAnotherObject{&YetYetAnotherObject{"abc"}}}}
-	str, err := MarshalToString(obj)
-	should.Nil(err)
-	should.Equal(`{"Me":{"Field":{"Field":{"Field":"abc"}}}}`, str)
-	str, err = MarshalToString(&obj)
-	should.Nil(err)
-	should.Equal(`{"Me":{"Field":{"Field":{"Field":"abc"}}}}`, str)
-}
-
 func Test_encode_anonymous_struct(t *testing.T) {
 	should := require.New(t)
 	type TestObject struct {