rewrite how eface and iface are handled

Author: taowen

api_tests/config_test.go

@@ -35,4 +35,14 @@ func Test_customize_tag_key(t *testing.T) {
 	str, err := json.MarshalToString(TestObject{"hello"})
 	should.Nil(err)
 	should.Equal(`{"field":"hello"}`, str)
+}
+
+func Test_read_large_number_as_interface(t *testing.T) {
+	should := require.New(t)
+	var val interface{}
+	err := jsoniter.Config{UseNumber: true}.Froze().UnmarshalFromString(`123456789123456789123456789`, &val)
+	should.Nil(err)
+	output, err := jsoniter.MarshalToString(val)
+	should.Nil(err)
+	should.Equal(`123456789123456789123456789`, output)
 }

config.go

@@ -2,7 +2,6 @@ package jsoniter
 
 import (
 	"encoding/json"
-	"errors"
 	"io"
 	"reflect"
 	"unsafe"
@@ -267,11 +266,6 @@ func (cfg *frozenConfig) Unmarshal(data []byte, v interface{}) error {
 	data = data[:lastNotSpacePos(data)]
 	iter := cfg.BorrowIterator(data)
 	defer cfg.ReturnIterator(iter)
-	typ := reflect.TypeOf(v)
-	if typ.Kind() != reflect.Ptr {
-		// return non-pointer error
-		return errors.New("the second param must be ptr type")
-	}
 	iter.ReadVal(v)
 	if iter.head == iter.tail {
 		iter.loadMore()

misc_tests/jsoniter_float_test.go

@@ -49,13 +49,13 @@ func Test_read_float64_cursor(t *testing.T) {
 func Test_read_float_scientific(t *testing.T) {
 	should := require.New(t)
 	var obj interface{}
-	should.Nil(jsoniter.UnmarshalFromString(`1e1`, &obj))
+	should.NoError(jsoniter.UnmarshalFromString(`1e1`, &obj))
 	should.Equal(float64(10), obj)
-	should.Nil(json.Unmarshal([]byte(`1e1`), &obj))
+	should.NoError(json.Unmarshal([]byte(`1e1`), &obj))
 	should.Equal(float64(10), obj)
-	should.Nil(jsoniter.UnmarshalFromString(`1.0e1`, &obj))
+	should.NoError(jsoniter.UnmarshalFromString(`1.0e1`, &obj))
 	should.Equal(float64(10), obj)
-	should.Nil(json.Unmarshal([]byte(`1.0e1`), &obj))
+	should.NoError(json.Unmarshal([]byte(`1.0e1`), &obj))
 	should.Equal(float64(10), obj)
 }
 

misc_tests/jsoniter_interface_test.go

@@ -2,36 +2,15 @@ package misc_tests
 
 import (
 	"encoding/json"
-	"fmt"
 	"testing"
 	"github.com/stretchr/testify/require"
 	"github.com/json-iterator/go"
+	"io"
 )
 
-type MyInterface interface {
-	Hello() string
-}
-
-type MyString string
-
-func (ms MyString) Hello() string {
-	return string(ms)
-}
-
-func Test_decode_object_contain_non_empty_interface(t *testing.T) {
-	type TestObject struct {
-		Field MyInterface
-	}
-	should := require.New(t)
-	obj := TestObject{}
-	obj.Field = MyString("abc")
-	should.Nil(jsoniter.UnmarshalFromString(`{"Field": "hello"}`, &obj))
-	should.Equal(MyString("hello"), obj.Field)
-}
-
 func Test_nil_non_empty_interface(t *testing.T) {
 	type TestObject struct {
-		Field []MyInterface
+		Field []io.Closer
 	}
 	should := require.New(t)
 	obj := TestObject{}
@@ -40,31 +19,6 @@ func Test_nil_non_empty_interface(t *testing.T) {
 	should.NotNil(jsoniter.Unmarshal(b, &obj))
 }
 
-func Test_read_large_number_as_interface(t *testing.T) {
-	should := require.New(t)
-	var val interface{}
-	err := jsoniter.Config{UseNumber: true}.Froze().UnmarshalFromString(`123456789123456789123456789`, &val)
-	should.Nil(err)
-	output, err := jsoniter.MarshalToString(val)
-	should.Nil(err)
-	should.Equal(`123456789123456789123456789`, output)
-}
-
-func Test_unmarshal_ptr_to_interface(t *testing.T) {
-	type TestData struct {
-		Name string `json:"name"`
-	}
-	should := require.New(t)
-	var obj interface{} = &TestData{}
-	err := json.Unmarshal([]byte(`{"name":"value"}`), &obj)
-	should.Nil(err)
-	should.Equal("&{value}", fmt.Sprintf("%v", obj))
-	obj = interface{}(&TestData{})
-	err = jsoniter.Unmarshal([]byte(`{"name":"value"}`), &obj)
-	should.Nil(err)
-	should.Equal("&{value}", fmt.Sprintf("%v", obj))
-}
-
 func Test_nil_out_null_interface(t *testing.T) {
 	type TestData struct {
 		Field interface{} `json:"field"`
@@ -86,7 +40,7 @@ func Test_nil_out_null_interface(t *testing.T) {
 
 	err = jsoniter.Unmarshal(data2, &obj)
 	should.NoError(err)
-	should.Equal(nil, obj.Field)
+	should.Nil(obj.Field)
 
 	// Checking stdlib behavior matches.
 	obj2 := TestData{
@@ -118,12 +72,12 @@ func Test_overwrite_interface_ptr_value_with_nil(t *testing.T) {
 	}
 
 	err := json.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
-	should.Equal(nil, err)
+	should.NoError(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.NoError(err)
 	should.Equal(&payload, wrapper.Payload)
 	should.Equal((*Payload)(nil), payload)
 
@@ -138,7 +92,7 @@ func Test_overwrite_interface_ptr_value_with_nil(t *testing.T) {
 	should.Equal(42, (*(wrapper.Payload.(**Payload))).Value)
 
 	err = jsoniter.Unmarshal([]byte(`{"payload": null}`), &wrapper)
-	should.Equal(nil, err)
+	should.NoError(err)
 	should.Equal(&payload, wrapper.Payload)
 	should.Equal((*Payload)(nil), payload)
 }
@@ -159,11 +113,11 @@ func Test_overwrite_interface_value_with_nil(t *testing.T) {
 	}
 
 	err := json.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
-	should.Equal(nil, err)
+	should.NoError(err)
 	should.Equal(42, (*(wrapper.Payload.(*Payload))).Value)
 
 	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
-	should.Equal(nil, err)
+	should.NoError(err)
 	should.Equal(nil, wrapper.Payload)
 	should.Equal(42, payload.Value)
 
@@ -198,12 +152,12 @@ func Test_unmarshal_into_nil(t *testing.T) {
 	}
 
 	err := json.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
-	should.Nil(err)
+	should.NoError(err)
 	should.NotNil(wrapper.Payload)
 	should.Nil(payload)
 
 	err = json.Unmarshal([]byte(`{"payload": null}`), &wrapper)
-	should.Nil(err)
+	should.NoError(err)
 	should.Nil(wrapper.Payload)
 	should.Nil(payload)
 
@@ -213,12 +167,12 @@ func Test_unmarshal_into_nil(t *testing.T) {
 	}
 
 	err = jsoniter.Unmarshal([]byte(`{"payload": {"val": 42}}`), &wrapper)
-	should.Nil(err)
+	should.NoError(err)
 	should.NotNil(wrapper.Payload)
 	should.Nil(payload)
 
 	err = jsoniter.Unmarshal([]byte(`{"payload": null}`), &wrapper)
-	should.Nil(err)
+	should.NoError(err)
 	should.Nil(wrapper.Payload)
 	should.Nil(payload)
 }

reflect.go

@@ -36,14 +36,17 @@ type checkIsEmpty interface {
 // ReadVal copy the underlying JSON into go interface, same as json.Unmarshal
 func (iter *Iterator) ReadVal(obj interface{}) {
 	typ := reflect.TypeOf(obj)
-	cacheKey := typ.Elem()
-	decoder := decoderOfType(iter.cfg, "", cacheKey)
-	e := (*emptyInterface)(unsafe.Pointer(&obj))
-	if e.word == nil {
+	if typ.Kind() != reflect.Ptr {
+		iter.ReportError("ReadVal", "can only unmarshal into pointer")
+		return
+	}
+	decoder := iter.cfg.DecoderOf(typ)
+	ptr := reflect2.PtrOf(obj)
+	if ptr == nil {
 		iter.ReportError("ReadVal", "can not read into nil pointer")
 		return
 	}
-	decoder.Decode(e.word, iter)
+	decoder.Decode(ptr, iter)
 }
 
 // WriteVal copy the go interface into underlying JSON, same as json.Marshal
@@ -63,7 +66,7 @@ func (cfg *frozenConfig) DecoderOf(typ reflect.Type) ValDecoder {
 	if decoder != nil {
 		return decoder
 	}
-	decoder = decoderOfType(cfg, "", typ)
+	decoder = decoderOfType(cfg, "", typ.Elem())
 	cfg.addDecoderToCache(cacheKey, decoder)
 	return decoder
 }
@@ -106,10 +109,11 @@ func createDecoderOfType(cfg *frozenConfig, prefix string, typ reflect.Type) Val
 	}
 	switch typ.Kind() {
 	case reflect.Interface:
-		if typ.NumMethod() == 0 {
-			return &emptyInterfaceCodec{}
+		if typ.NumMethod() > 0 {
+			ifaceType := reflect2.Type2(typ).(*reflect2.UnsafeIFaceType)
+			return &ifaceDecoder{valType: ifaceType}
 		}
-		return &nonEmptyInterfaceCodec{}
+		return &efaceDecoder{}
 	case reflect.Struct:
 		return decoderOfStruct(cfg, prefix, typ)
 	case reflect.Array:
@@ -239,27 +243,3 @@ func (encoder *lazyErrorEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
 func (encoder *lazyErrorEncoder) IsEmpty(ptr unsafe.Pointer) bool {
 	return false
 }
-
-func extractInterface(val interface{}) emptyInterface {
-	return *((*emptyInterface)(unsafe.Pointer(&val)))
-}
-
-// emptyInterface is the header for an interface{} value.
-type emptyInterface struct {
-	typ  unsafe.Pointer
-	word unsafe.Pointer
-}
-
-// emptyInterface is the header for an interface with method (not interface{})
-type nonEmptyInterface struct {
-	// see ../runtime/iface.go:/Itab
-	itab *struct {
-		ityp   unsafe.Pointer // static interface type
-		typ    unsafe.Pointer // dynamic concrete type
-		link   unsafe.Pointer
-		bad    int32
-		unused int32
-		fun    [100000]unsafe.Pointer // method table
-	}
-	word unsafe.Pointer
-}

reflect_dynamic.go

@@ -0,0 +1,70 @@
+package jsoniter
+
+import (
+	"github.com/v2pro/plz/reflect2"
+	"unsafe"
+	"reflect"
+)
+
+type dynamicEncoder struct {
+	valType reflect2.Type
+}
+
+func (encoder *dynamicEncoder) Encode(ptr unsafe.Pointer, stream *Stream) {
+	obj := encoder.valType.UnsafeIndirect(ptr)
+	stream.WriteVal(obj)
+}
+
+func (encoder *dynamicEncoder) IsEmpty(ptr unsafe.Pointer) bool {
+	return encoder.valType.UnsafeIndirect(ptr) == nil
+}
+
+type efaceDecoder struct {
+}
+
+func (decoder *efaceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+	pObj := (*interface{})(ptr)
+	obj := *pObj
+	if obj == nil {
+		*pObj = iter.Read()
+		return
+	}
+	typ := reflect2.TypeOf(obj)
+	if typ.Kind() != reflect.Ptr {
+		*pObj = iter.Read()
+		return
+	}
+	ptrType := typ.(*reflect2.UnsafePtrType)
+	ptrElemType := ptrType.Elem()
+	if iter.WhatIsNext() == NilValue {
+		if ptrElemType.Kind() != reflect.Ptr {
+			iter.skipFourBytes('n', 'u', 'l', 'l')
+			*pObj = nil
+			return
+		}
+	}
+	if reflect2.IsNil(obj) {
+		obj := ptrElemType.New()
+		iter.ReadVal(obj)
+		*pObj = obj
+		return
+	}
+	iter.ReadVal(obj)
+}
+
+type ifaceDecoder struct {
+	valType *reflect2.UnsafeIFaceType
+}
+
+func (decoder *ifaceDecoder) Decode(ptr unsafe.Pointer, iter *Iterator) {
+	if iter.ReadNil() {
+		decoder.valType.UnsafeSet(ptr, decoder.valType.UnsafeNew())
+		return
+	}
+	obj := decoder.valType.UnsafeIndirect(ptr)
+	if reflect2.IsNil(obj) {
+		iter.ReportError("decode non empty interface", "can not unmarshal into nil")
+		return
+	}
+	iter.ReadVal(obj)
+}

reflect_extension.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"unicode"
 	"unsafe"
+	"github.com/v2pro/plz/reflect2"
 )
 
 var typeDecoders = map[string]ValDecoder{}
@@ -240,7 +241,7 @@ func _getTypeDecoderFromExtension(cfg *frozenConfig, typ reflect.Type) ValDecode
 	if typ.Kind() == reflect.Ptr {
 		decoder := typeDecoders[typ.Elem().String()]
 		if decoder != nil {
-			return &OptionalDecoder{typ.Elem(), decoder}
+			return &OptionalDecoder{reflect2.Type2(typ.Elem()), decoder}
 		}
 	}
 	return nil
@@ -317,7 +318,7 @@ func describeStruct(cfg *frozenConfig, prefix string, typ reflect.Type) *StructD
 					omitempty := binding.Encoder.(*structFieldEncoder).omitempty
 					binding.Encoder = &dereferenceEncoder{binding.Encoder}
 					binding.Encoder = &structFieldEncoder{&field, binding.Encoder, omitempty}
-					binding.Decoder = &dereferenceDecoder{field.Type.Elem(), binding.Decoder}
+					binding.Decoder = &dereferenceDecoder{reflect2.Type2(field.Type.Elem()), binding.Decoder}
 					binding.Decoder = &structFieldDecoder{&field, binding.Decoder}
 					embeddedBindings = append(embeddedBindings, binding)
 				}