From e112aa753effc252ecc65a4c32ff2189d707f935 Mon Sep 17 00:00:00 2001 From: Masaaki Goshima Date: Tue, 11 Aug 2020 19:05:20 +0900 Subject: [PATCH] Support DisallowUnknownFields --- decode.go | 8 ++++++-- decode_array.go | 4 ++++ decode_bool.go | 2 ++ decode_float.go | 2 ++ decode_int.go | 2 ++ decode_interface.go | 13 +++++++++++-- decode_map.go | 5 +++++ decode_number.go | 2 ++ decode_ptr.go | 4 ++++ decode_slice.go | 4 ++++ decode_string.go | 2 ++ decode_struct.go | 17 +++++++++++++++-- decode_test.go | 15 +++++++++++++++ decode_uint.go | 2 ++ decode_unmarshal_json.go | 2 ++ decode_unmarshal_text.go | 2 ++ 16 files changed, 80 insertions(+), 6 deletions(-) diff --git a/decode.go b/decode.go index 668ffe0..e4efc48 100644 --- a/decode.go +++ b/decode.go @@ -18,10 +18,12 @@ func (d Delim) String() string { type decoder interface { decode([]byte, int64, uintptr) (int64, error) decodeStream(*stream, uintptr) error + setDisallowUnknownFields(bool) } type Decoder struct { - s *stream + s *stream + disallowUnknownFields bool } type decoderMap struct { @@ -97,6 +99,7 @@ func (d *Decoder) decode(src []byte, header *interfaceHeader) error { cachedDecoder.set(typeptr, compiledDec) dec = compiledDec } + dec.setDisallowUnknownFields(d.disallowUnknownFields) if _, err := dec.decode(src, 0, ptr); err != nil { return err } @@ -161,6 +164,7 @@ func (d *Decoder) Decode(v interface{}) error { cachedDecoder.set(typeptr, compiledDec) dec = compiledDec } + dec.setDisallowUnknownFields(d.disallowUnknownFields) if err := d.prepareForDecode(); err != nil { return err } @@ -248,7 +252,7 @@ func (d *Decoder) Token() (Token, error) { // is a struct and the input contains object keys which do not match any // non-ignored, exported fields in the destination. func (d *Decoder) DisallowUnknownFields() { - + d.disallowUnknownFields = true } func (d *Decoder) InputOffset() int64 { diff --git a/decode_array.go b/decode_array.go index 5a0eac7..419a406 100644 --- a/decode_array.go +++ b/decode_array.go @@ -16,6 +16,10 @@ func newArrayDecoder(dec decoder, elemType *rtype, alen int) *arrayDecoder { } } +func (d *arrayDecoder) setDisallowUnknownFields(disallowUnknownFields bool) { + d.valueDecoder.setDisallowUnknownFields(disallowUnknownFields) +} + func (d *arrayDecoder) decodeStream(s *stream, p uintptr) error { for { switch s.char() { diff --git a/decode_bool.go b/decode_bool.go index de1edc5..644b763 100644 --- a/decode_bool.go +++ b/decode_bool.go @@ -58,6 +58,8 @@ func falseBytes(s *stream) error { return nil } +func (d *boolDecoder) setDisallowUnknownFields(_ bool) {} + func (d *boolDecoder) decodeStream(s *stream, p uintptr) error { s.skipWhiteSpace() for { diff --git a/decode_float.go b/decode_float.go index 3393a6c..4043964 100644 --- a/decode_float.go +++ b/decode_float.go @@ -46,6 +46,8 @@ func floatBytes(s *stream) []byte { return s.buf[start:s.cursor] } +func (d *floatDecoder) setDisallowUnknownFields(_ bool) {} + func (d *floatDecoder) decodeStreamByte(s *stream) ([]byte, error) { for { switch s.char() { diff --git a/decode_int.go b/decode_int.go index 3db1f45..b4a4ed6 100644 --- a/decode_int.go +++ b/decode_int.go @@ -49,6 +49,8 @@ var ( } ) +func (d *intDecoder) setDisallowUnknownFields(_ bool) {} + func (d *intDecoder) decodeStreamByte(s *stream) ([]byte, error) { for { switch s.char() { diff --git a/decode_interface.go b/decode_interface.go index 7c3066e..17f4c25 100644 --- a/decode_interface.go +++ b/decode_interface.go @@ -6,8 +6,9 @@ import ( ) type interfaceDecoder struct { - typ *rtype - dummy unsafe.Pointer // for escape value + typ *rtype + dummy unsafe.Pointer // for escape value + disallowUnknownFields bool } func newInterfaceDecoder(typ *rtype) *interfaceDecoder { @@ -16,6 +17,10 @@ func newInterfaceDecoder(typ *rtype) *interfaceDecoder { } } +func (d *interfaceDecoder) setDisallowUnknownFields(disallowUnknownFields bool) { + d.disallowUnknownFields = disallowUnknownFields +} + func (d *interfaceDecoder) numDecoder(s *stream) decoder { if s.useNumber { return newNumberDecoder(func(p uintptr, v Number) { @@ -46,6 +51,7 @@ func (d *interfaceDecoder) decodeStream(s *stream, p uintptr) error { newInterfaceDecoder(d.typ), newInterfaceDecoder(d.typ), ) + dec.setDisallowUnknownFields(d.disallowUnknownFields) if err := dec.decodeStream(s, uintptr(ptr)); err != nil { return err } @@ -60,6 +66,7 @@ func (d *interfaceDecoder) decodeStream(s *stream, p uintptr) error { d.typ, d.typ.Size(), ) + dec.setDisallowUnknownFields(d.disallowUnknownFields) if err := dec.decodeStream(s, uintptr(ptr)); err != nil { return err } @@ -128,6 +135,7 @@ func (d *interfaceDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, e newInterfaceDecoder(d.typ), newInterfaceDecoder(d.typ), ) + dec.setDisallowUnknownFields(d.disallowUnknownFields) cursor, err := dec.decode(buf, cursor, uintptr(ptr)) if err != nil { return 0, err @@ -143,6 +151,7 @@ func (d *interfaceDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, e d.typ, d.typ.Size(), ) + dec.setDisallowUnknownFields(d.disallowUnknownFields) cursor, err := dec.decode(buf, cursor, uintptr(ptr)) if err != nil { return 0, err diff --git a/decode_map.go b/decode_map.go index a14cc6a..876eb11 100644 --- a/decode_map.go +++ b/decode_map.go @@ -26,6 +26,11 @@ func makemap(*rtype, int) unsafe.Pointer //go:noescape func mapassign(t *rtype, m unsafe.Pointer, key, val unsafe.Pointer) +func (d *mapDecoder) setDisallowUnknownFields(disallowUnknownFields bool) { + d.keyDecoder.setDisallowUnknownFields(disallowUnknownFields) + d.valueDecoder.setDisallowUnknownFields(disallowUnknownFields) +} + func (d *mapDecoder) setKey(buf []byte, cursor int64, key interface{}) (int64, error) { header := (*interfaceHeader)(unsafe.Pointer(&key)) return d.keyDecoder.decode(buf, cursor, uintptr(header.ptr)) diff --git a/decode_number.go b/decode_number.go index 0f1c856..12ccea3 100644 --- a/decode_number.go +++ b/decode_number.go @@ -16,6 +16,8 @@ func newNumberDecoder(op func(uintptr, Number)) *numberDecoder { } } +func (d *numberDecoder) setDisallowUnknownFields(_ bool) {} + func (d *numberDecoder) decodeStream(s *stream, p uintptr) error { bytes, err := d.floatDecoder.decodeStreamByte(s) if err != nil { diff --git a/decode_ptr.go b/decode_ptr.go index 4ce625d..7bbebab 100644 --- a/decode_ptr.go +++ b/decode_ptr.go @@ -16,6 +16,10 @@ func newPtrDecoder(dec decoder, typ *rtype) *ptrDecoder { //go:linkname unsafe_New reflect.unsafe_New func unsafe_New(*rtype) uintptr +func (d *ptrDecoder) setDisallowUnknownFields(disallowUnknownFields bool) { + d.dec.setDisallowUnknownFields(disallowUnknownFields) +} + func (d *ptrDecoder) decodeStream(s *stream, p uintptr) error { newptr := unsafe_New(d.typ) if err := d.dec.decodeStream(s, newptr); err != nil { diff --git a/decode_slice.go b/decode_slice.go index 974a6df..dbe3576 100644 --- a/decode_slice.go +++ b/decode_slice.go @@ -56,6 +56,10 @@ func copySlice(elemType *rtype, dst, src reflect.SliceHeader) int //go:linkname newArray reflect.unsafe_NewArray func newArray(*rtype, int) unsafe.Pointer +func (d *sliceDecoder) setDisallowUnknownFields(disallowUnknownFields bool) { + d.valueDecoder.setDisallowUnknownFields(disallowUnknownFields) +} + func (d *sliceDecoder) decodeStream(s *stream, p uintptr) error { for { switch s.char() { diff --git a/decode_string.go b/decode_string.go index 2512271..198ae1a 100644 --- a/decode_string.go +++ b/decode_string.go @@ -11,6 +11,8 @@ func newStringDecoder() *stringDecoder { return &stringDecoder{} } +func (d *stringDecoder) setDisallowUnknownFields(_ bool) {} + func (d *stringDecoder) decodeStream(s *stream, p uintptr) error { bytes, err := d.decodeStreamByte(s) if err != nil { diff --git a/decode_struct.go b/decode_struct.go index decbc52..dbd7827 100644 --- a/decode_struct.go +++ b/decode_struct.go @@ -1,6 +1,7 @@ package json import ( + "fmt" "unsafe" ) @@ -10,8 +11,9 @@ type structFieldSet struct { } type structDecoder struct { - fieldMap map[string]*structFieldSet - keyDecoder *stringDecoder + fieldMap map[string]*structFieldSet + keyDecoder *stringDecoder + disallowUnknownFields bool } func newStructDecoder(fieldMap map[string]*structFieldSet) *structDecoder { @@ -21,6 +23,13 @@ func newStructDecoder(fieldMap map[string]*structFieldSet) *structDecoder { } } +func (d *structDecoder) setDisallowUnknownFields(disallowUnknownFields bool) { + d.disallowUnknownFields = disallowUnknownFields + for _, field := range d.fieldMap { + field.dec.setDisallowUnknownFields(disallowUnknownFields) + } +} + func (d *structDecoder) decodeStream(s *stream, p uintptr) error { s.skipWhiteSpace() if s.char() == nul { @@ -56,6 +65,8 @@ func (d *structDecoder) decodeStream(s *stream, p uintptr) error { if err := field.dec.decodeStream(s, p+field.offset); err != nil { return err } + } else if d.disallowUnknownFields { + return fmt.Errorf("json: unknown field %q", k) } else { if err := s.skipValue(); err != nil { return err @@ -110,6 +121,8 @@ func (d *structDecoder) decode(buf []byte, cursor int64, p uintptr) (int64, erro return 0, err } cursor = c + } else if d.disallowUnknownFields { + return 0, fmt.Errorf("json: unknown field %q", k) } else { c, err := skipValue(buf, cursor) if err != nil { diff --git a/decode_test.go b/decode_test.go index 3ded818..c86565e 100644 --- a/decode_test.go +++ b/decode_test.go @@ -225,6 +225,21 @@ func Test_Decoder_UseNumber(t *testing.T) { assertEq(t, "json.Number", "json.Number", fmt.Sprintf("%T", v["a"])) } +func Test_Decoder_DisallowUnknownFields(t *testing.T) { + dec := json.NewDecoder(strings.NewReader(`{"x": 1}`)) + dec.DisallowUnknownFields() + var v struct { + x int + } + err := dec.Decode(&v) + if err == nil { + t.Fatal("expected unknown field error") + } + if err.Error() != `json: unknown field "x"` { + t.Fatal("expected unknown field error") + } +} + type unmarshalJSON struct { v int } diff --git a/decode_uint.go b/decode_uint.go index 5ab2277..a38dc80 100644 --- a/decode_uint.go +++ b/decode_uint.go @@ -24,6 +24,8 @@ func (d *uintDecoder) parseUint(b []byte) uint64 { return sum } +func (d *uintDecoder) setDisallowUnknownFields(_ bool) {} + func (d *uintDecoder) decodeStreamByte(s *stream) ([]byte, error) { for { switch s.char() { diff --git a/decode_unmarshal_json.go b/decode_unmarshal_json.go index f84f850..ba5a3ed 100644 --- a/decode_unmarshal_json.go +++ b/decode_unmarshal_json.go @@ -12,6 +12,8 @@ func newUnmarshalJSONDecoder(typ *rtype) *unmarshalJSONDecoder { return &unmarshalJSONDecoder{typ: typ} } +func (d *unmarshalJSONDecoder) setDisallowUnknownFields(_ bool) {} + func (d *unmarshalJSONDecoder) decodeStream(s *stream, p uintptr) error { s.skipWhiteSpace() start := s.cursor diff --git a/decode_unmarshal_text.go b/decode_unmarshal_text.go index 73ea335..d93e18c 100644 --- a/decode_unmarshal_text.go +++ b/decode_unmarshal_text.go @@ -13,6 +13,8 @@ func newUnmarshalTextDecoder(typ *rtype) *unmarshalTextDecoder { return &unmarshalTextDecoder{typ: typ} } +func (d *unmarshalTextDecoder) setDisallowUnknownFields(_ bool) {} + func (d *unmarshalTextDecoder) decodeStream(s *stream, p uintptr) error { s.skipWhiteSpace() start := s.cursor