wip: Reduce test differences [ci-skip]

 - Handle UTF-16 surrogate pairs
 - Handle cycles in values
 - Handle cycles in types
 - Better errors
 - Handle case-folding of struct field names
 - Allow []byteTypeWithMethods
 - Fix struct field-order
 - Fix handling of interfaces storing pointers
 - Enforce a maximum decode depth
 - Validate struct tags

1 files changed, 231 insertions, 111 deletions

diff --git a/decode.go b/decode.go
index 8426526..e4fdd77 100644
--- a/decode.go
+++ b/decode.go
@@ -14,6 +14,8 @@ import (
 	"reflect"
 	"strconv"
 	"strings"
+	"unicode/utf16"
+	"unicode/utf8"
 )
 
 type Decodable interface {
@@ -26,6 +28,11 @@ type runeBuffer interface {
 	Reset()
 }
 
+type decodeStackItem struct {
+	par reflect.Type
+	idx any
+}
+
 type Decoder struct {
 	io runeTypeScanner
 
@@ -35,7 +42,7 @@ type Decoder struct {
 
 	// state
 	err   error
-	stack []any
+	stack []decodeStackItem
 }
 
 func NewDecoder(r io.Reader) *Decoder {
@@ -63,8 +70,18 @@ func (dec *Decoder) More() bool {
 	return e == nil && t != RuneTypeEOF
 }
 
-func (dec *Decoder) stackPush(idx any) {
-	dec.stack = append(dec.stack, idx)
+const maxNestingDepth = 10000
+
+func (dec *Decoder) stackPush(par reflect.Type, idx any) {
+	dec.stack = append(dec.stack, decodeStackItem{par, idx})
+	if len(dec.stack) > maxNestingDepth {
+		panic(decodeError{
+			Field:       dec.stackStr(),
+			FieldParent: dec.stackParent(),
+			FieldName:   dec.stackName(),
+			Err:         ErrDecodeExceededMaxDepth,
+		})
+	}
 }
 func (dec *Decoder) stackPop() {
 	dec.stack = dec.stack[:len(dec.stack)-1]
@@ -73,11 +90,30 @@ func (dec *Decoder) stackStr() string {
 	var buf strings.Builder
 	buf.WriteString("v")
 	for _, item := range dec.stack {
-		fmt.Fprintf(&buf, "[%#v]", item)
+		fmt.Fprintf(&buf, "[%#v]", item.idx)
 	}
 	return buf.String()
 }
 
+func (dec *Decoder) stackParent() string {
+	if len(dec.stack) > 0 && dec.stack[len(dec.stack)-1].par.Kind() == reflect.Struct {
+		return dec.stack[len(dec.stack)-1].par.Name()
+	}
+	return ""
+}
+
+func (dec *Decoder) stackName() string {
+	var fields []string
+	for i := len(dec.stack) - 1; i >= 0 && dec.stack[i].par.Kind() == reflect.Struct; i-- {
+		fields = append(fields, dec.stack[i].idx.(string))
+	}
+	for i := 0; i < len(fields)/2; i++ {
+		j := (len(fields) - 1) - i
+		fields[i], fields[j] = fields[j], fields[i]
+	}
+	return strings.Join(fields, ".")
+}
+
 func Decode(r io.Reader, ptr any) error {
 	return NewDecoder(r).Decode(ptr)
 }
@@ -85,7 +121,7 @@ func Decode(r io.Reader, ptr any) error {
 func (dec *Decoder) Decode(ptr any) (err error) {
 	ptrVal := reflect.ValueOf(ptr)
 	if ptrVal.Kind() != reflect.Pointer || ptrVal.IsNil() || !ptrVal.Elem().CanSet() {
-		return &json.InvalidUnmarshalError{
+		return &DecodeArgumentError{
 			// don't use ptrVal.Type() because ptrVal might be invalid if ptr==nil
 			Type: reflect.TypeOf(ptr),
 		}
@@ -99,7 +135,8 @@ func (dec *Decoder) Decode(ptr any) (err error) {
 	defer func() {
 		if r := recover(); r != nil {
 			if de, ok := r.(decodeError); ok {
-				dec.err = de.Err
+				pub := DecodeError(de)
+				dec.err = &pub
 				err = dec.err
 			} else {
 				panic(r)
@@ -112,19 +149,31 @@ func (dec *Decoder) Decode(ptr any) (err error) {
 
 // io helpers //////////////////////////////////////////////////////////////////////////////////////
 
-type decodeError struct {
-	Err error
-}
-
-func (dec *Decoder) panicType(typ reflect.Type, err error) {
-	panic(decodeError{fmt.Errorf("json: type mismatch error at input byte %v: %s: type %v: %w",
-		dec.InputOffset(), dec.stackStr(), typ, err)})
+type decodeError DecodeError
+
+func (dec *Decoder) panicType(jTyp string, gTyp reflect.Type, err error) {
+	panic(decodeError{
+		Field:       dec.stackStr(),
+		FieldParent: dec.stackParent(),
+		FieldName:   dec.stackName(),
+		Err: &DecodeTypeError{
+			GoType:   gTyp,
+			JSONType: jTyp,
+			Err:      err,
+			Offset:   dec.InputOffset(),
+		},
+	})
 }
 
 func (dec *Decoder) readRune() (rune, RuneType) {
 	c, _, t, e := dec.io.ReadRuneType()
 	if e != nil {
-		panic(decodeError{e})
+		panic(decodeError{
+			Field:       dec.stackStr(),
+			FieldParent: dec.stackParent(),
+			FieldName:   dec.stackName(),
+			Err:         e,
+		})
 	}
 	return c, t
 }
@@ -150,10 +199,10 @@ func (dec *Decoder) expectRune(ec rune, et RuneType) {
 	}
 }
 
-func (dec *Decoder) expectRuneType(ec rune, et RuneType) {
+func (dec *Decoder) expectRuneType(ec rune, et RuneType, gt reflect.Type) {
 	ac, at := dec.readRune()
 	if ac != ec || at != et {
-		dec.panicType(nil, fmt.Errorf("TODO error message"))
+		dec.panicType(at.jsonType(), gt, nil)
 	}
 }
 
@@ -164,7 +213,12 @@ type decRuneTypeScanner struct {
 func (sc *decRuneTypeScanner) ReadRuneType() (rune, int, RuneType, error) {
 	c, s, t, e := sc.dec.io.ReadRuneType()
 	if e != nil {
-		panic(decodeError{e})
+		panic(decodeError{
+			Field:       sc.dec.stackStr(),
+			FieldParent: sc.dec.stackParent(),
+			FieldName:   sc.dec.stackName(),
+			Err:         e,
+		})
 	}
 	return c, s, t, nil
 }
@@ -223,22 +277,25 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 	typ := val.Type()
 	switch {
 	case val.CanAddr() && reflect.PointerTo(typ) == rawMessagePtrType:
+		t := dec.peekRuneType()
 		var buf bytes.Buffer
 		dec.scan(&buf)
 		if err := val.Addr().Interface().(*json.RawMessage).UnmarshalJSON(buf.Bytes()); err != nil {
-			dec.panicType(typ, err)
+			dec.panicType(t.jsonType(), typ, err)
 		}
 	case val.CanAddr() && reflect.PointerTo(typ).Implements(decodableType):
+		t := dec.peekRuneType()
 		obj := val.Addr().Interface().(Decodable)
 		if err := obj.DecodeJSON(dec.limitingScanner()); err != nil {
-			dec.panicType(typ, err)
+			dec.panicType(t.jsonType(), typ, err)
 		}
 	case val.CanAddr() && reflect.PointerTo(typ).Implements(jsonUnmarshalerType):
+		t := dec.peekRuneType()
 		var buf bytes.Buffer
 		dec.scan(&buf)
 		obj := val.Addr().Interface().(json.Unmarshaler)
 		if err := obj.UnmarshalJSON(buf.Bytes()); err != nil {
-			dec.panicType(typ, err)
+			dec.panicType(t.jsonType(), typ, err)
 		}
 	case val.CanAddr() && reflect.PointerTo(typ).Implements(textUnmarshalerType):
 		if nullOK && dec.peekRuneType() == RuneTypeNullN {
@@ -246,30 +303,29 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 			return
 		}
 		var buf bytes.Buffer
-		dec.decodeString(&buf)
+		dec.decodeString(typ, &buf)
 		obj := val.Addr().Interface().(encoding.TextUnmarshaler)
 		if err := obj.UnmarshalText(buf.Bytes()); err != nil {
-			dec.panicType(typ, err)
+			dec.panicType("string", typ, err)
 		}
 	default:
-		kind := typ.Kind()
-		switch kind {
+		switch kind := typ.Kind(); kind {
 		case reflect.Bool:
 			if nullOK && dec.peekRuneType() == RuneTypeNullN {
 				dec.decodeNull()
 				return
 			}
-			val.SetBool(dec.decodeBool())
+			val.SetBool(dec.decodeBool(typ))
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 			if nullOK && dec.peekRuneType() == RuneTypeNullN {
 				dec.decodeNull()
 				return
 			}
 			var buf strings.Builder
-			dec.scanNumber(&buf)
+			dec.scanNumber(typ, &buf)
 			n, err := strconv.ParseInt(buf.String(), 10, kind2bits[kind])
 			if err != nil {
-				dec.panicType(typ, err)
+				dec.panicType("number "+buf.String(), typ, err)
 			}
 			val.SetInt(n)
 		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
@@ -278,10 +334,10 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 				return
 			}
 			var buf strings.Builder
-			dec.scanNumber(&buf)
+			dec.scanNumber(typ, &buf)
 			n, err := strconv.ParseUint(buf.String(), 10, kind2bits[kind])
 			if err != nil {
-				dec.panicType(typ, err)
+				dec.panicType("number "+buf.String(), typ, err)
 			}
 			val.SetUint(n)
 		case reflect.Float32, reflect.Float64:
@@ -290,10 +346,10 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 				return
 			}
 			var buf strings.Builder
-			dec.scanNumber(&buf)
+			dec.scanNumber(typ, &buf)
 			n, err := strconv.ParseFloat(buf.String(), kind2bits[kind])
 			if err != nil {
-				dec.panicType(typ, err)
+				dec.panicType("number "+buf.String(), typ, err)
 			}
 			val.SetFloat(n)
 		case reflect.String:
@@ -303,32 +359,44 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 			}
 			var buf strings.Builder
 			if typ == numberType {
-				dec.scanNumber(&buf)
+				dec.scanNumber(typ, &buf)
 				val.SetString(buf.String())
 			} else {
-				dec.decodeString(&buf)
+				dec.decodeString(typ, &buf)
 				val.SetString(buf.String())
 			}
 		case reflect.Interface:
 			if typ.NumMethod() > 0 {
-				dec.panicType(typ, fmt.Errorf("cannot decode in to non-empty interface"))
+				dec.panicType("", typ, fmt.Errorf("cannot decode in to non-empty interface"))
+			}
+			// If the interface stores a pointer, try to use the type information of the pointer.
+			if !val.IsNil() && val.Elem().Kind() == reflect.Pointer {
+				// Follow a chain of pointers until we find the first settable
+				// pointer (if any).
+				ptr := val.Elem()
+				for ptr.Kind() == reflect.Pointer {
+					if ptr.CanSet() {
+						break
+					}
+					if ptr.IsNil() {
+						break
+					}
+					ptr = ptr.Elem()
+				}
+				// We only neet to be able to set the pointer itself if we're
+				// decoding "null", so add a "||" clause.
+				if ptr.Kind() == reflect.Pointer && (ptr.CanSet() || dec.peekRuneType() != RuneTypeNullN) {
+					dec.decode(ptr, false)
+					break
+				}
 			}
+			// Couldn't get type information from a pointer; fall back to untyped mode.
 			switch dec.peekRuneType() {
 			case RuneTypeNullN:
-				if !val.IsNil() && val.Elem().Kind() == reflect.Pointer && val.Elem().Elem().Kind() == reflect.Pointer {
-					// XXX: I can't justify this case, other than "it's what encoding/json does, but
-					// I don't understand their rationale".
-					dec.decode(val.Elem(), false)
-				} else {
-					dec.decodeNull()
-					val.Set(reflect.Zero(typ))
-				}
+				dec.decodeNull()
+				val.Set(reflect.Zero(typ))
 			default:
-				if !val.IsNil() && val.Elem().Kind() == reflect.Pointer {
-					dec.decode(val.Elem(), false)
-				} else {
-					val.Set(reflect.ValueOf(dec.decodeAny()))
-				}
+				val.Set(reflect.ValueOf(dec.decodeAny()))
 			}
 		case reflect.Struct:
 			if nullOK && dec.peekRuneType() == RuneTypeNullN {
@@ -337,14 +405,23 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 			}
 			index := indexStruct(typ)
 			var nameBuf strings.Builder
-			dec.decodeObject(&nameBuf, func() {
+			dec.decodeObject(typ, &nameBuf, func() {
 				name := nameBuf.String()
-				dec.stackPush(name)
+				dec.stackPush(typ, name)
 				defer dec.stackPop()
 				idx, ok := index.byName[name]
 				if !ok {
+					for oname, oidx := range index.byName {
+						if strings.EqualFold(name, oname) {
+							idx = oidx
+							ok = true
+							break
+						}
+					}
+				}
+				if !ok {
 					if dec.disallowUnknownFields {
-						dec.panicType(typ, fmt.Errorf("unknown field %q", name))
+						dec.panicType("", typ, fmt.Errorf("json: unknown field %q", name))
 					}
 					dec.scan(io.Discard)
 					return
@@ -353,18 +430,20 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 				fVal := val
 				for _, idx := range field.Path {
 					if fVal.Kind() == reflect.Pointer {
-						if fVal.IsNil() {
-							if !fVal.CanSet() { // https://golang.org/issue/21357
-								dec.panicType(fVal.Type().Elem(), fmt.Errorf("cannot set embedded pointer to unexported type"))
+						if fVal.IsNil() && !fVal.CanSet() { // https://golang.org/issue/21357
+							dec.panicType("", fVal.Type().Elem(), fmt.Errorf("cannot set embedded pointer to unexported type"))
+						}
+						if dec.peekRuneType() != RuneTypeNullN {
+							if fVal.IsNil() {
+								fVal.Set(reflect.New(fVal.Type().Elem()))
 							}
-							fVal.Set(reflect.New(fVal.Type().Elem()))
+							fVal = fVal.Elem()
 						}
-						fVal = fVal.Elem()
 					}
 					fVal = fVal.Field(idx)
 				}
 				if field.Quote {
-					switch dec.peekRuneType() {
+					switch t := dec.peekRuneType(); t {
 					case RuneTypeNullN:
 						dec.decodeNull()
 						switch fVal.Kind() {
@@ -378,18 +457,25 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 					case RuneTypeStringBeg:
 						// TODO: Figure out how to do this without buffering, have correct offsets.
 						var buf bytes.Buffer
-						dec.decodeString(&buf)
-						subD := NewDecoder(&buf)
-						subD.decode(fVal, false)
+						dec.decodeString(nil, &buf)
+						if err := Decode(bytes.NewReader(buf.Bytes()), fVal.Addr().Interface()); err != nil {
+							if str := buf.String(); str != "null" {
+								dec.panicType("", fVal.Type(),
+									fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal %q into %v",
+										str, fVal.Type()))
+							}
+						}
 					default:
-						dec.panicType(typ, fmt.Errorf(",string field TODO ERROR MESSAGE"))
+						dec.panicType(t.jsonType(), fVal.Type(),
+							fmt.Errorf("json: invalid use of ,string struct tag, trying to unmarshal unquoted value into %v",
+								fVal.Type()))
 					}
 				} else {
 					dec.decode(fVal, true)
 				}
 			})
 		case reflect.Map:
-			switch dec.peekRuneType() {
+			switch t := dec.peekRuneType(); t {
 			case RuneTypeNullN:
 				dec.decodeNull()
 				val.Set(reflect.Zero(typ))
@@ -398,14 +484,14 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 					val.Set(reflect.MakeMap(typ))
 				}
 				var nameBuf bytes.Buffer
-				dec.decodeObject(&nameBuf, func() {
+				dec.decodeObject(typ, &nameBuf, func() {
 					nameValTyp := typ.Key()
 					nameValPtr := reflect.New(nameValTyp)
 					switch {
 					case reflect.PointerTo(nameValTyp).Implements(textUnmarshalerType):
 						obj := nameValPtr.Interface().(encoding.TextUnmarshaler)
 						if err := obj.UnmarshalText(nameBuf.Bytes()); err != nil {
-							dec.panicType(nameValTyp, err)
+							dec.panicType("string", nameValTyp, err)
 						}
 					default:
 						switch nameValTyp.Kind() {
@@ -414,20 +500,20 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 						case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 							n, err := strconv.ParseInt(nameBuf.String(), 10, kind2bits[nameValTyp.Kind()])
 							if err != nil {
-								dec.panicType(nameValTyp, err)
+								dec.panicType("number "+nameBuf.String(), nameValTyp, err)
 							}
 							nameValPtr.Elem().SetInt(n)
 						case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
 							n, err := strconv.ParseUint(nameBuf.String(), 10, kind2bits[nameValTyp.Kind()])
 							if err != nil {
-								dec.panicType(nameValTyp, err)
+								dec.panicType("number "+nameBuf.String(), nameValTyp, err)
 							}
 							nameValPtr.Elem().SetUint(n)
 						default:
-							dec.panicType(typ, fmt.Errorf("invalid map key type: %v", nameValTyp))
+							dec.panicType("object", typ, &DecodeArgumentError{nameValTyp})
 						}
 					}
-					dec.stackPush(nameValPtr.Elem())
+					dec.stackPush(typ, nameValPtr.Elem())
 					defer dec.stackPop()
 
 					fValPtr := reflect.New(typ.Elem())
@@ -436,33 +522,39 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 					val.SetMapIndex(nameValPtr.Elem(), fValPtr.Elem())
 				})
 			default:
-				dec.panicType(typ, fmt.Errorf("map: TODO"))
+				dec.panicType(t.jsonType(), typ, nil)
 			}
 		case reflect.Slice:
 			switch {
-			case typ.Elem().Kind() == reflect.Uint8:
-				switch dec.peekRuneType() {
+			case typ.Elem().Kind() == reflect.Uint8 && !(dec.peekRuneType() == RuneTypeArrayBeg && (false ||
+				reflect.PointerTo(typ.Elem()).Implements(decodableType) ||
+				reflect.PointerTo(typ.Elem()).Implements(jsonUnmarshalerType) ||
+				reflect.PointerTo(typ.Elem()).Implements(textUnmarshalerType))):
+				switch t := dec.peekRuneType(); t {
 				case RuneTypeNullN:
 					dec.decodeNull()
 					val.Set(reflect.Zero(typ))
 				case RuneTypeStringBeg:
-					var buf bytes.Buffer
-					dec.decodeString(newBase64Decoder(&buf))
 					if typ.Elem() == byteType {
+						var buf bytes.Buffer
+						dec.decodeString(typ, newBase64Decoder(&buf))
 						val.Set(reflect.ValueOf(buf.Bytes()))
 					} else {
+						// TODO: Surely there's a better way.  At the very least, we should
+						// avoid buffering.
+						var buf bytes.Buffer
+						dec.decodeString(typ, newBase64Decoder(&buf))
 						bs := buf.Bytes()
-						// TODO: Surely there's a better way.
 						val.Set(reflect.MakeSlice(typ, len(bs), len(bs)))
 						for i := 0; i < len(bs); i++ {
 							val.Index(i).Set(reflect.ValueOf(bs[i]).Convert(typ.Elem()))
 						}
 					}
 				default:
-					dec.panicType(typ, fmt.Errorf("byte slice: TODO"))
+					dec.panicType(t.jsonType(), typ, nil)
 				}
 			default:
-				switch dec.peekRuneType() {
+				switch t := dec.peekRuneType(); t {
 				case RuneTypeNullN:
 					dec.decodeNull()
 					val.Set(reflect.Zero(typ))
@@ -474,8 +566,8 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 						val.Set(val.Slice(0, 0))
 					}
 					i := 0
-					dec.decodeArray(func() {
-						dec.stackPush(i)
+					dec.decodeArray(typ, func() {
+						dec.stackPush(typ, i)
 						defer dec.stackPop()
 						mValPtr := reflect.New(typ.Elem())
 						dec.decode(mValPtr.Elem(), false)
@@ -483,7 +575,7 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 						i++
 					})
 				default:
-					dec.panicType(typ, fmt.Errorf("slice: TODO"))
+					dec.panicType(t.jsonType(), typ, nil)
 				}
 			}
 		case reflect.Array:
@@ -493,8 +585,8 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 			}
 			i := 0
 			n := val.Len()
-			dec.decodeArray(func() {
-				dec.stackPush(i)
+			dec.decodeArray(typ, func() {
+				dec.stackPush(typ, i)
 				defer dec.stackPop()
 				if i < n {
 					mValPtr := reflect.New(typ.Elem())
@@ -512,15 +604,6 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 			switch dec.peekRuneType() {
 			case RuneTypeNullN:
 				dec.decodeNull()
-				/*
-					for typ.Elem().Kind() == reflect.Pointer {
-						if val.IsNil() || !val.Elem().CanSet() {
-							val.Set(reflect.New(typ.Elem()))
-						}
-						val = val.Elem()
-						typ = val.Type()
-					}
-				*/
 				val.Set(reflect.Zero(typ))
 			default:
 				if val.IsNil() {
@@ -529,7 +612,7 @@ func (dec *Decoder) decode(val reflect.Value, nullOK bool) {
 				dec.decode(val.Elem(), false)
 			}
 		default:
-			dec.panicType(typ, fmt.Errorf("unsupported type (kind=%v)", typ.Kind()))
+			dec.panicType("", typ, fmt.Errorf("unsupported type (kind=%v)", typ.Kind()))
 		}
 	}
 }
@@ -545,9 +628,9 @@ func (dec *Decoder) scan(out io.Writer) {
 	}
 }
 
-func (dec *Decoder) scanNumber(out io.Writer) {
-	if !dec.peekRuneType().IsNumber() {
-		dec.panicType(numberType, fmt.Errorf("number: not a number"))
+func (dec *Decoder) scanNumber(gTyp reflect.Type, out io.Writer) {
+	if t := dec.peekRuneType(); !t.IsNumber() {
+		dec.panicType(t.jsonType(), gTyp, nil)
 	}
 	dec.scan(out)
 }
@@ -558,25 +641,27 @@ func (dec *Decoder) decodeAny() any {
 	switch c {
 	case '{':
 		ret := make(map[string]any)
+		typ := reflect.TypeOf(ret)
 		var nameBuf strings.Builder
-		dec.decodeObject(&nameBuf, func() {
+		dec.decodeObject(typ, &nameBuf, func() {
 			name := nameBuf.String()
-			dec.stackPush(name)
+			dec.stackPush(typ, name)
 			defer dec.stackPop()
 			ret[name] = dec.decodeAny()
 		})
 		return ret
 	case '[':
 		ret := []any{}
-		dec.decodeArray(func() {
-			dec.stackPush(len(ret))
+		typ := reflect.TypeOf(ret)
+		dec.decodeArray(typ, func() {
+			dec.stackPush(typ, len(ret))
 			defer dec.stackPop()
 			ret = append(ret, dec.decodeAny())
 		})
 		return ret
 	case '"':
 		var buf strings.Builder
-		dec.decodeString(&buf)
+		dec.decodeString(nil, &buf)
 		return buf.String()
 	case '-', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
 		var buf strings.Builder
@@ -591,7 +676,7 @@ func (dec *Decoder) decodeAny() any {
 		}
 		return f64
 	case 't', 'f':
-		return dec.decodeBool()
+		return dec.decodeBool(nil)
 	case 'n':
 		dec.decodeNull()
 		return nil
@@ -600,8 +685,8 @@ func (dec *Decoder) decodeAny() any {
 	}
 }
 
-func (dec *Decoder) decodeObject(nameBuf runeBuffer, decodeKVal func()) {
-	dec.expectRuneType('{', RuneTypeObjectBeg)
+func (dec *Decoder) decodeObject(gTyp reflect.Type, nameBuf runeBuffer, decodeKVal func()) {
+	dec.expectRuneType('{', RuneTypeObjectBeg, gTyp)
 	_, t := dec.readRune()
 	switch t {
 	case RuneTypeObjectEnd:
@@ -610,7 +695,7 @@ func (dec *Decoder) decodeObject(nameBuf runeBuffer, decodeKVal func()) {
 	decodeMember:
 		dec.unreadRune()
 		nameBuf.Reset()
-		dec.decodeString(nameBuf)
+		dec.decodeString(nil, nameBuf)
 		dec.expectRune(':', RuneTypeObjectColon)
 		decodeKVal()
 		_, t := dec.readRune()
@@ -628,8 +713,8 @@ func (dec *Decoder) decodeObject(nameBuf runeBuffer, decodeKVal func()) {
 	}
 }
 
-func (dec *Decoder) decodeArray(decodeMember func()) {
-	dec.expectRuneType('[', RuneTypeArrayBeg)
+func (dec *Decoder) decodeArray(gTyp reflect.Type, decodeMember func()) {
+	dec.expectRuneType('[', RuneTypeArrayBeg, gTyp)
 	_, t := dec.readRune()
 	switch t {
 	case RuneTypeArrayEnd:
@@ -650,8 +735,8 @@ func (dec *Decoder) decodeArray(decodeMember func()) {
 	}
 }
 
-func (dec *Decoder) decodeString(out io.Writer) {
-	dec.expectRuneType('"', RuneTypeStringBeg)
+func (dec *Decoder) decodeString(gTyp reflect.Type, out io.Writer) {
+	dec.expectRuneType('"', RuneTypeStringBeg, gTyp)
 	var uhex [4]byte
 	for {
 		c, t := dec.readRune()
@@ -694,7 +779,42 @@ func (dec *Decoder) decodeString(out io.Writer) {
 				rune(uhex[1])<<8 |
 				rune(uhex[2])<<4 |
 				rune(uhex[3])<<0
-			_, _ = writeRune(out, c)
+		handleUnicode:
+			if utf16.IsSurrogate(c) {
+				if dec.peekRuneType() != RuneTypeStringEsc {
+					_, _ = writeRune(out, utf8.RuneError)
+					break
+				}
+				dec.expectRune('\\', RuneTypeStringEsc)
+				if dec.peekRuneType() != RuneTypeStringEscU {
+					_, _ = writeRune(out, utf8.RuneError)
+					break
+				}
+				dec.expectRune('u', RuneTypeStringEscU)
+
+				b, _ := dec.readRune()
+				uhex[0], _ = hex2int(b)
+				b, _ = dec.readRune()
+				uhex[1], _ = hex2int(b)
+				b, _ = dec.readRune()
+				uhex[2], _ = hex2int(b)
+				b, _ = dec.readRune()
+				uhex[3], _ = hex2int(b)
+				c2 := 0 |
+					rune(uhex[0])<<12 |
+					rune(uhex[1])<<8 |
+					rune(uhex[2])<<4 |
+					rune(uhex[3])<<0
+				d := utf16.DecodeRune(c, c2)
+				if d == utf8.RuneError {
+					_, _ = writeRune(out, utf8.RuneError)
+					c = c2
+					goto handleUnicode
+				}
+				_, _ = writeRune(out, d)
+			} else {
+				_, _ = writeRune(out, c)
+			}
 		case RuneTypeStringEnd:
 			return
 		default:
@@ -703,8 +823,8 @@ func (dec *Decoder) decodeString(out io.Writer) {
 	}
 }
 
-func (dec *Decoder) decodeBool() bool {
-	c, _ := dec.readRune()
+func (dec *Decoder) decodeBool(gTyp reflect.Type) bool {
+	c, t := dec.readRune()
 	switch c {
 	case 't':
 		dec.expectRune('r', RuneTypeTrueR)
@@ -718,13 +838,13 @@ func (dec *Decoder) decodeBool() bool {
 		dec.expectRune('e', RuneTypeFalseE)
 		return false
 	default:
-		dec.panicType(boolType, fmt.Errorf("bool: expected %q or %q but got %q", 't', 'f', c))
+		dec.panicType(t.jsonType(), gTyp, nil)
 		panic("not reached")
 	}
 }
 
 func (dec *Decoder) decodeNull() {
-	dec.expectRuneType('n', RuneTypeNullN)
+	dec.expectRune('n', RuneTypeNullN)
 	dec.expectRune('u', RuneTypeNullU)
 	dec.expectRune('l', RuneTypeNullL1)
 	dec.expectRune('l', RuneTypeNullL2)