Skip to content

Commit 6db7a29

Browse files
goccygoccy
authored
Merge pull request #120 from goccy/feature/fix-interface
Fix decoding of interface{} type
2 parents 3244416 + a57bc23 commit 6db7a29

11 files changed

+139
-52
lines changed

‎codec.go‎

Lines changed: 7 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -12,13 +12,12 @@ const (
1212
)
1313

1414
var (
15-
cachedOpcodeSets []*opcodeSet
16-
cachedOpcodeMap unsafe.Pointer // map[uintptr]*opcodeSet
17-
existsCachedOpcodeSets bool
18-
cachedDecoder []decoder
19-
cachedDecoderMap unsafe.Pointer // map[uintptr]decoder
20-
existsCachedDecoder bool
21-
baseTypeAddr uintptr
15+
cachedOpcodeSets []*opcodeSet
16+
cachedOpcodeMap unsafe.Pointer // map[uintptr]*opcodeSet
17+
cachedDecoder []decoder
18+
cachedDecoderMap unsafe.Pointer // map[uintptr]decoder
19+
baseTypeAddr uintptr
20+
maxTypeAddr uintptr
2221
)
2322

2423
//go:linkname typelinks reflect.typelinks
@@ -68,10 +67,9 @@ func setupCodec() error {
6867
return fmt.Errorf("too big address range %d", addrRange)
6968
}
7069
cachedOpcodeSets = make([]*opcodeSet, addrRange)
71-
existsCachedOpcodeSets = true
7270
cachedDecoder = make([]decoder, addrRange)
73-
existsCachedDecoder = true
7471
baseTypeAddr = min
72+
maxTypeAddr = max
7573
return nil
7674
}
7775

‎decode_compile.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -245,7 +245,7 @@ func (d *Decoder) compileMap(typ *rtype, structName, fieldName string) (decoder,
245245
}
246246

247247
func (d *Decoder) compileInterface(typ *rtype, structName, fieldName string) (decoder, error) {
248-
return newInterfaceDecoder(typ, structName, fieldName), nil
248+
return newInterfaceDecoder(d, typ, structName, fieldName), nil
249249
}
250250

251251
func (d *Decoder) removeConflictFields(fieldMap map[string]*structFieldSet, conflictedMap map[string]struct{}, dec *structDecoder, baseOffset uintptr) {

‎decode_compile_norace.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
package json
44

55
func (d *Decoder) compileToGetDecoder(typeptr uintptr, typ *rtype) (decoder, error) {
6-
if !existsCachedDecoder {
6+
if typeptr > maxTypeAddr {
77
return d.compileToGetDecoderSlowPath(typeptr, typ)
88
}
99

‎decode_compile_race.go‎

Lines changed: 4 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2,12 +2,14 @@
22

33
package json
44

5-
import "sync"
5+
import (
6+
"sync"
7+
)
68

79
var decMu sync.RWMutex
810

911
func (d *Decoder) compileToGetDecoder(typeptr uintptr, typ *rtype) (decoder, error) {
10-
if !existsCachedDecoder {
12+
if typeptr > maxTypeAddr {
1113
return d.compileToGetDecoderSlowPath(typeptr, typ)
1214
}
1315

‎decode_interface.go‎

Lines changed: 89 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -10,13 +10,15 @@ type interfaceDecoder struct {
1010
typ *rtype
1111
structName string
1212
fieldName string
13+
dec *Decoder
1314
}
1415

15-
func newInterfaceDecoder(typ *rtype, structName, fieldName string) *interfaceDecoder {
16+
func newInterfaceDecoder(dec *Decoder, typ *rtype, structName, fieldName string) *interfaceDecoder {
1617
return &interfaceDecoder{
1718
typ: typ,
1819
structName: structName,
1920
fieldName: fieldName,
21+
dec: dec,
2022
}
2123
}
2224

@@ -40,7 +42,7 @@ var (
4042
)
4143
)
4244

43-
func decodeWithUnmarshaler(s *stream, unmarshaler Unmarshaler) error {
45+
func decodeStreamUnmarshaler(s *stream, unmarshaler Unmarshaler) error {
4446
start := s.cursor
4547
if err := s.skipValue(); err != nil {
4648
return err
@@ -55,7 +57,7 @@ func decodeWithUnmarshaler(s *stream, unmarshaler Unmarshaler) error {
5557
return nil
5658
}
5759

58-
func decodeWithTextUnmarshaler(s *stream, unmarshaler encoding.TextUnmarshaler) error {
60+
func decodeStreamTextUnmarshaler(s *stream, unmarshaler encoding.TextUnmarshaler) error {
5961
start := s.cursor
6062
if err := s.skipValue(); err != nil {
6163
return err
@@ -70,34 +72,19 @@ func decodeWithTextUnmarshaler(s *stream, unmarshaler encoding.TextUnmarshaler)
7072
return nil
7173
}
7274

73-
func (d *interfaceDecoder) decodeStream(s *stream, p unsafe.Pointer) error {
75+
func (d *interfaceDecoder) decodeStreamEmptyInterface(s *stream, p unsafe.Pointer) error {
7476
s.skipWhiteSpace()
7577
for {
7678
switch s.char() {
7779
case '{':
78-
runtimeInterfaceValue := *(*interface{})(unsafe.Pointer(&interfaceHeader{
79-
typ: d.typ,
80-
ptr: p,
81-
}))
82-
rv := reflect.ValueOf(runtimeInterfaceValue)
83-
if rv.NumMethod() > 0 && rv.CanInterface() {
84-
if u, ok := rv.Interface().(Unmarshaler); ok {
85-
return decodeWithUnmarshaler(s, u)
86-
}
87-
if u, ok := rv.Interface().(encoding.TextUnmarshaler); ok {
88-
return decodeWithTextUnmarshaler(s, u)
89-
}
90-
return nil
91-
}
92-
// empty interface
9380
var v map[string]interface{}
9481
ptr := unsafe.Pointer(&v)
9582
if err := newMapDecoder(
9683
interfaceMapType,
9784
stringType,
9885
newStringDecoder(d.structName, d.fieldName),
9986
interfaceMapType.Elem(),
100-
newInterfaceDecoder(d.typ, d.structName, d.fieldName),
87+
newInterfaceDecoder(d.dec, d.typ, d.structName, d.fieldName),
10188
d.structName,
10289
d.fieldName,
10390
).decodeStream(s, ptr); err != nil {
@@ -109,7 +96,7 @@ func (d *interfaceDecoder) decodeStream(s *stream, p unsafe.Pointer) error {
10996
var v []interface{}
11097
ptr := unsafe.Pointer(&v)
11198
if err := newSliceDecoder(
112-
newInterfaceDecoder(d.typ, d.structName, d.fieldName),
99+
newInterfaceDecoder(d.dec, d.typ, d.structName, d.fieldName),
113100
d.typ,
114101
d.typ.Size(),
115102
d.structName,
@@ -171,7 +158,86 @@ func (d *interfaceDecoder) decodeStream(s *stream, p unsafe.Pointer) error {
171158
return errNotAtBeginningOfValue(s.totalOffset())
172159
}
173160

161+
func (d *interfaceDecoder) decodeStream(s *stream, p unsafe.Pointer) error {
162+
runtimeInterfaceValue := *(*interface{})(unsafe.Pointer(&interfaceHeader{
163+
typ: d.typ,
164+
ptr: p,
165+
}))
166+
rv := reflect.ValueOf(runtimeInterfaceValue)
167+
if rv.NumMethod() > 0 && rv.CanInterface() {
168+
if u, ok := rv.Interface().(Unmarshaler); ok {
169+
return decodeStreamUnmarshaler(s, u)
170+
}
171+
if u, ok := rv.Interface().(encoding.TextUnmarshaler); ok {
172+
return decodeStreamTextUnmarshaler(s, u)
173+
}
174+
return nil
175+
}
176+
iface := rv.Interface()
177+
ifaceHeader := (*interfaceHeader)(unsafe.Pointer(&iface))
178+
typ := ifaceHeader.typ
179+
if d.typ == typ || typ == nil {
180+
// concrete type is empty interface
181+
return d.decodeStreamEmptyInterface(s, p)
182+
}
183+
if typ.Kind() == reflect.Ptr && typ.Elem() == d.typ || typ.Kind() != reflect.Ptr {
184+
return d.decodeStreamEmptyInterface(s, p)
185+
}
186+
if s.char() == 'n' {
187+
if err := nullBytes(s); err != nil {
188+
return err
189+
}
190+
*(*interface{})(p) = nil
191+
return nil
192+
}
193+
decoder, err := d.dec.compileToGetDecoder(uintptr(unsafe.Pointer(typ)), typ)
194+
if err != nil {
195+
return err
196+
}
197+
return decoder.decodeStream(s, ifaceHeader.ptr)
198+
}
199+
174200
func (d *interfaceDecoder) decode(buf []byte, cursor int64, p unsafe.Pointer) (int64, error) {
201+
runtimeInterfaceValue := *(*interface{})(unsafe.Pointer(&interfaceHeader{
202+
typ: d.typ,
203+
ptr: p,
204+
}))
205+
rv := reflect.ValueOf(runtimeInterfaceValue)
206+
iface := rv.Interface()
207+
ifaceHeader := (*interfaceHeader)(unsafe.Pointer(&iface))
208+
typ := ifaceHeader.typ
209+
if d.typ == typ || typ == nil {
210+
// concrete type is empty interface
211+
return d.decodeEmptyInterface(buf, cursor, p)
212+
}
213+
if typ.Kind() == reflect.Ptr && typ.Elem() == d.typ || typ.Kind() != reflect.Ptr {
214+
return d.decodeEmptyInterface(buf, cursor, p)
215+
}
216+
if buf[cursor] == 'n' {
217+
if cursor+3 >= int64(len(buf)) {
218+
return 0, errUnexpectedEndOfJSON("null", cursor)
219+
}
220+
if buf[cursor+1] != 'u' {
221+
return 0, errInvalidCharacter(buf[cursor+1], "null", cursor)
222+
}
223+
if buf[cursor+2] != 'l' {
224+
return 0, errInvalidCharacter(buf[cursor+2], "null", cursor)
225+
}
226+
if buf[cursor+3] != 'l' {
227+
return 0, errInvalidCharacter(buf[cursor+3], "null", cursor)
228+
}
229+
cursor += 4
230+
**(**interface{})(unsafe.Pointer(&p)) = nil
231+
return cursor, nil
232+
}
233+
decoder, err := d.dec.compileToGetDecoder(uintptr(unsafe.Pointer(typ)), typ)
234+
if err != nil {
235+
return 0, err
236+
}
237+
return decoder.decode(buf, cursor, ifaceHeader.ptr)
238+
}
239+
240+
func (d *interfaceDecoder) decodeEmptyInterface(buf []byte, cursor int64, p unsafe.Pointer) (int64, error) {
175241
cursor = skipWhiteSpace(buf, cursor)
176242
switch buf[cursor] {
177243
case '{':
@@ -182,7 +248,7 @@ func (d *interfaceDecoder) decode(buf []byte, cursor int64, p unsafe.Pointer) (i
182248
stringType,
183249
newStringDecoder(d.structName, d.fieldName),
184250
interfaceMapType.Elem(),
185-
newInterfaceDecoder(d.typ, d.structName, d.fieldName),
251+
newInterfaceDecoder(d.dec, d.typ, d.structName, d.fieldName),
186252
d.structName, d.fieldName,
187253
)
188254
cursor, err := dec.decode(buf, cursor, ptr)
@@ -195,7 +261,7 @@ func (d *interfaceDecoder) decode(buf []byte, cursor int64, p unsafe.Pointer) (i
195261
var v []interface{}
196262
ptr := unsafe.Pointer(&v)
197263
dec := newSliceDecoder(
198-
newInterfaceDecoder(d.typ, d.structName, d.fieldName),
264+
newInterfaceDecoder(d.dec, d.typ, d.structName, d.fieldName),
199265
d.typ,
200266
d.typ.Size(),
201267
d.structName, d.fieldName,

‎decode_ptr.go‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,9 @@ func (d *ptrDecoder) decode(buf []byte, cursor int64, p unsafe.Pointer) (int64,
6868
if buf[cursor+3] != 'l' {
6969
return 0, errInvalidCharacter(buf[cursor+3], "null", cursor)
7070
}
71-
*(*unsafe.Pointer)(p) = nil
71+
if p != nil {
72+
*(*unsafe.Pointer)(p) = nil
73+
}
7274
cursor += 4
7375
return cursor, nil
7476
}

‎decode_slice.go‎

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
package json
22

33
import (
4+
"reflect"
45
"sync"
56
"unsafe"
67
)
@@ -62,6 +63,16 @@ func copySlice(elemType *rtype, dst, src sliceHeader) int
6263
//go:linkname newArray reflect.unsafe_NewArray
6364
func newArray(*rtype, int) unsafe.Pointer
6465

66+
func (d *sliceDecoder) errNumber(offset int64) *UnmarshalTypeError {
67+
return &UnmarshalTypeError{
68+
Value: "number",
69+
Type: reflect.SliceOf(rtype2type(d.elemType)),
70+
Struct: d.structName,
71+
Field: d.fieldName,
72+
Offset: offset,
73+
}
74+
}
75+
6576
func (d *sliceDecoder) decodeStream(s *stream, p unsafe.Pointer) error {
6677
for {
6778
switch s.char() {
@@ -140,11 +151,15 @@ func (d *sliceDecoder) decodeStream(s *stream, p unsafe.Pointer) error {
140151
}
141152
s.cursor++
142153
}
154+
case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
155+
return d.errNumber(s.totalOffset())
143156
case nul:
144157
if s.read() {
145158
continue
146159
}
147160
goto ERROR
161+
default:
162+
goto ERROR
148163
}
149164
}
150165
ERROR:
@@ -233,7 +248,12 @@ func (d *sliceDecoder) decode(buf []byte, cursor int64, p unsafe.Pointer) (int64
233248
}
234249
cursor++
235250
}
251+
case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
252+
return 0, d.errNumber(cursor)
253+
default:
254+
goto ERROR
236255
}
237256
}
257+
ERROR:
238258
return 0, errUnexpectedEndOfJSON("slice", cursor)
239259
}

‎decode_string.go‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -35,7 +35,7 @@ func (d *stringDecoder) decodeStream(s *stream, p unsafe.Pointer) error {
3535
if err != nil {
3636
return err
3737
}
38-
*(*string)(p) = *(*string)(unsafe.Pointer(&bytes))
38+
**(**string)(unsafe.Pointer(&p)) = *(*string)(unsafe.Pointer(&bytes))
3939
s.reset()
4040
return nil
4141
}

‎decode_test.go‎

Lines changed: 5 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -2091,32 +2091,29 @@ var interfaceSetTests = []struct {
20912091
{"foo", `2`, 2.0},
20922092
{"foo", `true`, true},
20932093
{"foo", `null`, nil},
2094-
20952094
{nil, `null`, nil},
20962095
{new(int), `null`, nil},
20972096
{(*int)(nil), `null`, nil},
2098-
{new(*int), `null`, new(*int)},
2097+
//{new(*int), `null`, new(*int)},
20992098
{(**int)(nil), `null`, nil},
21002099
{intp(1), `null`, nil},
2101-
{intpp(nil), `null`, intpp(nil)},
2102-
{intpp(intp(1)), `null`, intpp(nil)},
2100+
//{intpp(nil), `null`, intpp(nil)},
2101+
//{intpp(intp(1)), `null`, intpp(nil)},
21032102
}
21042103

2105-
/*
21062104
func TestInterfaceSet(t *testing.T) {
2107-
for _, tt := range interfaceSetTests {
2105+
for idx, tt := range interfaceSetTests {
21082106
b := struct{ X interface{} }{tt.pre}
21092107
blob := `{"X":` + tt.json + `}`
21102108
if err := json.Unmarshal([]byte(blob), &b); err != nil {
21112109
t.Errorf("Unmarshal %#q: %v", blob, err)
21122110
continue
21132111
}
21142112
if !reflect.DeepEqual(b.X, tt.post) {
2115-
t.Errorf("Unmarshal %#q into %#v: X=%#v, want %#v", blob, tt.pre, b.X, tt.post)
2113+
t.Errorf("%d: Unmarshal %#q into %#v: X=%#v, want %#v", idx, blob, tt.pre, b.X, tt.post)
21162114
}
21172115
}
21182116
}
2119-
*/
21202117

21212118
/*
21222119
// JSON null values should be ignored for primitives and string values instead of resulting in an error.

‎encode_compile_norace.go‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,10 +5,11 @@ package json
55
import "unsafe"
66

77
func encodeCompileToGetCodeSet(typeptr uintptr) (*opcodeSet, error) {
8-
if !existsCachedOpcodeSets {
8+
if typeptr > maxTypeAddr {
99
return encodeCompileToGetCodeSetSlowPath(typeptr)
1010
}
11-
if codeSet := cachedOpcodeSets[typeptr-baseTypeAddr]; codeSet != nil {
11+
index := typeptr - baseTypeAddr
12+
if codeSet := cachedOpcodeSets[index]; codeSet != nil {
1213
return codeSet, nil
1314
}
1415

@@ -29,6 +30,6 @@ func encodeCompileToGetCodeSet(typeptr uintptr) (*opcodeSet, error) {
2930
code: code,
3031
codeLength: codeLength,
3132
}
32-
cachedOpcodeSets[int(typeptr-baseTypeAddr)] = codeSet
33+
cachedOpcodeSets[index] = codeSet
3334
return codeSet, nil
3435
}

0 commit comments

Comments
 (0)