@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/encoding/json/v2/arshal_default.go

@@ -35,7 +35,7 @@ import (
 const optimizeCommon = true
 
 var (
-	// Most natural Go type that correspond with each JSON type.
+	// Most natural Go types that correspond with each JSON type.
 	anyType          = reflect.TypeFor[any]()            // JSON value
 	boolType         = reflect.TypeFor[bool]()           // JSON bool
 	stringType       = reflect.TypeFor[string]()         // JSON string
@@ -127,12 +127,19 @@ func makeBoolArshaler(t reflect.Type) *arshaler {
 	var fncs arshaler
 	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
 		xe := export.Encoder(enc)
-		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
-			return newInvalidFormatError(enc, t)
+		var stringify bool // always false except `string` tag with StringifyWithLegacySemantics
+		if mo.Flags.Has(jsonflags.TagFlags) {
+			stringify = mo.Flags.Get(jsonflags.StringTag) && mo.Flags.Get(jsonflags.StringifyWithLegacySemantics)
+			if mo.Flags.Get(jsonflags.StringTag) && !mo.Flags.Get(jsonflags.StringifyWithLegacySemantics|jsonflags.ReportErrorsWithLegacySemantics) {
+				return newMarshalErrorBefore(enc, t, errInvalidStringTag)
+			}
+			if mo.Flags.Has(jsonflags.FormatTag) {
+				return newInvalidFormatError(enc, t)
+			}
 		}
 
 		// Optimize for marshaling without preceding whitespace.
-		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyBoolsAndStrings) && !xe.Tokens.Last.NeedObjectName() {
+		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace) && !stringify && !xe.Tokens.Last.NeedObjectName() {
 			xe.Buf = strconv.AppendBool(xe.Tokens.MayAppendDelim(xe.Buf, 't'), va.Bool())
 			xe.Tokens.Last.Increment()
 			if xe.NeedFlush() {
@@ -141,7 +148,7 @@ func makeBoolArshaler(t reflect.Type) *arshaler {
 			return nil
 		}
 
-		if mo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
+		if stringify {
 			if va.Bool() {
 				return enc.WriteToken(jsontext.String("true"))
 			} else {
@@ -151,9 +158,15 @@ func makeBoolArshaler(t reflect.Type) *arshaler {
 		return enc.WriteToken(jsontext.Bool(va.Bool()))
 	}
 	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
-		xd := export.Decoder(dec)
-		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
-			return newInvalidFormatError(dec, t)
+		var stringify bool // always false except `string` tag with StringifyWithLegacySemantics
+		if uo.Flags.Has(jsonflags.TagFlags) {
+			stringify = uo.Flags.Get(jsonflags.StringTag) && uo.Flags.Get(jsonflags.StringifyWithLegacySemantics)
+			if uo.Flags.Get(jsonflags.StringTag) && !uo.Flags.Get(jsonflags.StringifyWithLegacySemantics|jsonflags.ReportErrorsWithLegacySemantics) {
+				return newUnmarshalErrorBeforeWithSkipping(dec, t, errInvalidStringTag)
+			}
+			if uo.Flags.Has(jsonflags.FormatTag) {
+				return newInvalidFormatError(dec, t)
+			}
 		}
 		tok, err := dec.ReadToken()
 		if err != nil {
@@ -167,12 +180,12 @@ func makeBoolArshaler(t reflect.Type) *arshaler {
 			}
 			return nil
 		case 't', 'f':
-			if !uo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
+			if !stringify {
 				va.SetBool(tok.Bool())
 				return nil
 			}
 		case '"':
-			if uo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
+			if stringify {
 				switch tok.String() {
 				case "true":
 					va.SetBool(true)
@@ -199,16 +212,23 @@ func makeStringArshaler(t reflect.Type) *arshaler {
 	var fncs arshaler
 	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
 		xe := export.Encoder(enc)
-		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
-			return newInvalidFormatError(enc, t)
+		var stringify bool // always false except `string` tag with StringifyWithLegacySemantics
+		if mo.Flags.Has(jsonflags.TagFlags) {
+			stringify = mo.Flags.Get(jsonflags.StringTag) && mo.Flags.Get(jsonflags.StringifyWithLegacySemantics)
+			if mo.Flags.Get(jsonflags.StringTag) && !mo.Flags.Get(jsonflags.StringifyWithLegacySemantics|jsonflags.ReportErrorsWithLegacySemantics) {
+				return newMarshalErrorBefore(enc, t, errInvalidStringTag)
+			}
+			if mo.Flags.Has(jsonflags.FormatTag) {
+				return newInvalidFormatError(enc, t)
+			}
 		}
 
 		// Optimize for marshaling without preceding whitespace.
 		s := va.String()
-		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyBoolsAndStrings) && !xe.Tokens.Last.NeedObjectName() {
+		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace) && !stringify && !xe.Tokens.Last.NeedObjectName() {
 			b := xe.Buf
 			b = xe.Tokens.MayAppendDelim(b, '"')
-			b, err := jsonwire.AppendQuote(b, s, &mo.Flags)
+			b, err := jsonwire.AppendQuote(b, []byte(s), &mo.Flags)
 			if err == nil {
 				xe.Buf = b
 				xe.Tokens.Last.Increment()
@@ -221,8 +241,8 @@ func makeStringArshaler(t reflect.Type) *arshaler {
 			// so let the logic below construct the proper error.
 		}
 
-		if mo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
-			b, err := jsonwire.AppendQuote(nil, s, &mo.Flags)
+		if stringify {
+			b, err := jsonwire.AppendQuote(nil, []byte(s), &mo.Flags)
 			if err != nil {
 				return newMarshalErrorBefore(enc, t, &jsontext.SyntacticError{Err: err})
 			}
@@ -236,8 +256,15 @@ func makeStringArshaler(t reflect.Type) *arshaler {
 	}
 	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
 		xd := export.Decoder(dec)
-		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
-			return newInvalidFormatError(dec, t)
+		var stringify bool // always false except `string` tag with StringifyWithLegacySemantics
+		if uo.Flags.Has(jsonflags.TagFlags) {
+			stringify = uo.Flags.Get(jsonflags.StringTag) && uo.Flags.Get(jsonflags.StringifyWithLegacySemantics)
+			if uo.Flags.Get(jsonflags.StringTag) && !uo.Flags.Get(jsonflags.StringifyWithLegacySemantics|jsonflags.ReportErrorsWithLegacySemantics) {
+				return newUnmarshalErrorBeforeWithSkipping(dec, t, errInvalidStringTag)
+			}
+			if uo.Flags.Has(jsonflags.FormatTag) {
+				return newInvalidFormatError(dec, t)
+			}
 		}
 		var flags jsonwire.ValueFlags
 		val, err := xd.ReadValue(&flags)
@@ -253,17 +280,17 @@ func makeStringArshaler(t reflect.Type) *arshaler {
 			return nil
 		case '"':
 			val = jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
-			if uo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
-				val, err = jsontext.AppendUnquote(nil, val)
-				if err != nil {
-					return newUnmarshalErrorAfter(dec, t, err)
-				}
-				if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && string(val) == "null" {
+			if stringify {
+				if string(val) == "null" {
 					if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
 						va.SetString("")
 					}
 					return nil
 				}
+				val, err = jsontext.AppendUnquote(nil, val)
+				if err != nil {
+					return newUnmarshalErrorAfter(dec, t, err)
+				}
 			}
 			if xd.StringCache == nil {
 				xd.StringCache = new(stringCache)
@@ -311,32 +338,37 @@ func makeBytesArshaler(t reflect.Type, fncs *arshaler) *arshaler {
 		}
 		xe := export.Encoder(enc)
 		appendEncode := appendEncodeBase64
-		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
-			switch mo.Format {
-			case "base64":
-				appendEncode = appendEncodeBase64
-			case "base64url":
-				appendEncode = appendEncodeBase64URL
-			case "base32":
-				appendEncode = appendEncodeBase32
-			case "base32hex":
-				appendEncode = appendEncodeBase32Hex
-			case "base16", "hex":
-				appendEncode = appendEncodeBase16
-			case "array":
-				mo.Format = ""
+		if mo.Flags.Has(jsonflags.TagFlags | jsonflags.FormatByteArrayAsArray | jsonflags.FormatBytesWithLegacySemantics | jsonflags.FormatNilSliceAsNull) {
+			switch {
+			case mo.Flags.Get(jsonflags.StringTag) && !mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics):
+				return newMarshalErrorBefore(enc, t, errInvalidStringTag)
+			case mo.Flags.Has(jsonflags.FormatTag):
+				switch mo.Format {
+				case "base64":
+					appendEncode = appendEncodeBase64
+				case "base64url":
+					appendEncode = appendEncodeBase64URL
+				case "base32":
+					appendEncode = appendEncodeBase32
+				case "base32hex":
+					appendEncode = appendEncodeBase32Hex
+				case "base16", "hex":
+					appendEncode = appendEncodeBase16
+				case "array":
+					mo.Flags.Clear(jsonflags.FormatTag)
+					return marshalArray(enc, va, mo)
+				default:
+					return newInvalidFormatError(enc, t)
+				}
+			case mo.Flags.Get(jsonflags.FormatByteArrayAsArray) && va.Kind() == reflect.Array:
+				return marshalArray(enc, va, mo)
+			case mo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) && hasMarshaler:
 				return marshalArray(enc, va, mo)
-			default:
-				return newInvalidFormatError(enc, t)
 			}
-		} else if mo.Flags.Get(jsonflags.FormatByteArrayAsArray) && va.Kind() == reflect.Array {
-			return marshalArray(enc, va, mo)
-		} else if mo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) && hasMarshaler {
-			return marshalArray(enc, va, mo)
-		}
-		if mo.Flags.Get(jsonflags.FormatNilSliceAsNull) && va.Kind() == reflect.Slice && va.IsNil() {
-			// TODO: Provide a "emitempty" format override?
-			return enc.WriteToken(jsontext.Null)
+			if mo.Flags.Get(jsonflags.FormatNilSliceAsNull) && va.Kind() == reflect.Slice && va.IsNil() {
+				// TODO: Provide an "emitempty" format override?
+				return enc.WriteToken(jsontext.Null)
+			}
 		}
 		return xe.AppendRaw('"', true, func(b []byte) ([]byte, error) {
 			return appendEncode(b, va.Bytes()), nil
@@ -349,28 +381,33 @@ func makeBytesArshaler(t reflect.Type, fncs *arshaler) *arshaler {
 		}
 		xd := export.Decoder(dec)
 		appendDecode, encodedLen := appendDecodeBase64, encodedLenBase64
-		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
-			switch uo.Format {
-			case "base64":
-				appendDecode, encodedLen = appendDecodeBase64, encodedLenBase64
-			case "base64url":
-				appendDecode, encodedLen = appendDecodeBase64URL, encodedLenBase64URL
-			case "base32":
-				appendDecode, encodedLen = appendDecodeBase32, encodedLenBase32
-			case "base32hex":
-				appendDecode, encodedLen = appendDecodeBase32Hex, encodedLenBase32Hex
-			case "base16", "hex":
-				appendDecode, encodedLen = appendDecodeBase16, encodedLenBase16
-			case "array":
-				uo.Format = ""
+		if uo.Flags.Has(jsonflags.TagFlags | jsonflags.FormatByteArrayAsArray | jsonflags.FormatBytesWithLegacySemantics) {
+			switch {
+			case uo.Flags.Get(jsonflags.StringTag) && !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics):
+				return newUnmarshalErrorBeforeWithSkipping(dec, t, errInvalidStringTag)
+			case uo.Flags.Has(jsonflags.FormatTag):
+				switch uo.Format {
+				case "base64":
+					appendDecode, encodedLen = appendDecodeBase64, encodedLenBase64
+				case "base64url":
+					appendDecode, encodedLen = appendDecodeBase64URL, encodedLenBase64URL
+				case "base32":
+					appendDecode, encodedLen = appendDecodeBase32, encodedLenBase32
+				case "base32hex":
+					appendDecode, encodedLen = appendDecodeBase32Hex, encodedLenBase32Hex
+				case "base16", "hex":
+					appendDecode, encodedLen = appendDecodeBase16, encodedLenBase16
+				case "array":
+					uo.Flags.Clear(jsonflags.FormatTag)
+					return unmarshalArray(dec, va, uo)
+				default:
+					return newInvalidFormatError(dec, t)
+				}
+			case uo.Flags.Get(jsonflags.FormatByteArrayAsArray) && va.Kind() == reflect.Array:
+				return unmarshalArray(dec, va, uo)
+			case uo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) && dec.PeekKind() == '[':
 				return unmarshalArray(dec, va, uo)
-			default:
-				return newInvalidFormatError(dec, t)
 			}
-		} else if uo.Flags.Get(jsonflags.FormatByteArrayAsArray) && va.Kind() == reflect.Array {
-			return unmarshalArray(dec, va, uo)
-		} else if uo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) && dec.PeekKind() == '[' {
-			return unmarshalArray(dec, va, uo)
 		}
 		var flags jsonwire.ValueFlags
 		val, err := xd.ReadValue(&flags)
@@ -409,7 +446,7 @@ func makeBytesArshaler(t reflect.Type, fncs *arshaler) *arshaler {
 
 			if va.Kind() == reflect.Array {
 				dst := va.Bytes()
-				clear(dst[copy(dst, b):]) // noop if len(b) <= len(dst)
+				clear(dst[copy(dst, b):]) // noop if len(b) >= len(dst)
 				if len(b) != len(dst) && !uo.Flags.Get(jsonflags.UnmarshalArrayFromAnyLength) {
 					err := fmt.Errorf("decoded length of %d mismatches array length of %d", len(b), len(dst))
 					return newUnmarshalErrorAfter(dec, t, err)
@@ -432,12 +469,13 @@ func makeIntArshaler(t reflect.Type) *arshaler {
 	bits := t.Bits()
 	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
 		xe := export.Encoder(enc)
-		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
+		stringify := xe.Tokens.Last.NeedObjectName() || mo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.StringTag)
+		if mo.Flags.Has(jsonflags.FormatTag) {
 			return newInvalidFormatError(enc, t)
 		}
 
 		// Optimize for marshaling without preceding whitespace or string escaping.
-		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyNumbers) && !xe.Tokens.Last.NeedObjectName() {
+		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace) && !stringify {
 			xe.Buf = strconv.AppendInt(xe.Tokens.MayAppendDelim(xe.Buf, '0'), va.Int(), 10)
 			xe.Tokens.Last.Increment()
 			if xe.NeedFlush() {
@@ -446,17 +484,17 @@ func makeIntArshaler(t reflect.Type) *arshaler {
 			return nil
 		}
 
-		k := stringOrNumberKind(xe.Tokens.Last.NeedObjectName() || mo.Flags.Get(jsonflags.StringifyNumbers))
+		k := stringOrNumberKind(stringify)
 		return xe.AppendRaw(k, true, func(b []byte) ([]byte, error) {
 			return strconv.AppendInt(b, va.Int(), 10), nil
 		})
 	}
 	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
 		xd := export.Decoder(dec)
-		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
+		stringify := xd.Tokens.Last.NeedObjectName() || uo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.StringTag)
+		if uo.Flags.Has(jsonflags.FormatTag) {
 			return newInvalidFormatError(dec, t)
 		}
-		stringify := xd.Tokens.Last.NeedObjectName() || uo.Flags.Get(jsonflags.StringifyNumbers)
 		var flags jsonwire.ValueFlags
 		val, err := xd.ReadValue(&flags)
 		if err != nil {
@@ -530,12 +568,13 @@ func makeUintArshaler(t reflect.Type) *arshaler {
 	bits := t.Bits()
 	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
 		xe := export.Encoder(enc)
-		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
+		stringify := xe.Tokens.Last.NeedObjectName() || mo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.StringTag)
+		if mo.Flags.Has(jsonflags.FormatTag) {
 			return newInvalidFormatError(enc, t)
 		}
 
 		// Optimize for marshaling without preceding whitespace or string escaping.
-		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyNumbers) && !xe.Tokens.Last.NeedObjectName() {
+		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace) && !stringify {
 			xe.Buf = strconv.AppendUint(xe.Tokens.MayAppendDelim(xe.Buf, '0'), va.Uint(), 10)
 			xe.Tokens.Last.Increment()
 			if xe.NeedFlush() {
@@ -544,17 +583,17 @@ func makeUintArshaler(t reflect.Type) *arshaler {
 			return nil
 		}
 
-		k := stringOrNumberKind(xe.Tokens.Last.NeedObjectName() || mo.Flags.Get(jsonflags.StringifyNumbers))
+		k := stringOrNumberKind(stringify)
 		return xe.AppendRaw(k, true, func(b []byte) ([]byte, error) {
 			return strconv.AppendUint(b, va.Uint(), 10), nil
 		})
 	}
 	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
 		xd := export.Decoder(dec)
-		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
+		stringify := xd.Tokens.Last.NeedObjectName() || uo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.StringTag)
+		if uo.Flags.Has(jsonflags.FormatTag) {
 			return newInvalidFormatError(dec, t)
 		}
-		stringify := xd.Tokens.Last.NeedObjectName() || uo.Flags.Get(jsonflags.StringifyNumbers)
 		var flags jsonwire.ValueFlags
 		val, err := xd.ReadValue(&flags)
 		if err != nil {
@@ -619,8 +658,9 @@ func makeFloatArshaler(t reflect.Type) *arshaler {
 	bits := t.Bits()
 	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
 		xe := export.Encoder(enc)
+		stringify := xe.Tokens.Last.NeedObjectName() || mo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.StringTag)
 		var allowNonFinite bool
-		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
+		if mo.Flags.Has(jsonflags.FormatTag) {
 			if mo.Format == "nonfinite" {
 				allowNonFinite = true
 			} else {
@@ -632,13 +672,16 @@ func makeFloatArshaler(t reflect.Type) *arshaler {
 		if math.IsNaN(fv) || math.IsInf(fv, 0) {
 			if !allowNonFinite {
 				err := fmt.Errorf("unsupported value: %v", fv)
+				if mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+					err = &internal.ValueError{Val: va.Interface(), Err: err}
+				}
 				return newMarshalErrorBefore(enc, t, err)
 			}
 			return enc.WriteToken(jsontext.Float(fv))
 		}
 
 		// Optimize for marshaling without preceding whitespace or string escaping.
-		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyNumbers) && !xe.Tokens.Last.NeedObjectName() {
+		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace) && !stringify {
 			xe.Buf = jsonwire.AppendFloat(xe.Tokens.MayAppendDelim(xe.Buf, '0'), fv, bits)
 			xe.Tokens.Last.Increment()
 			if xe.NeedFlush() {
@@ -647,22 +690,23 @@ func makeFloatArshaler(t reflect.Type) *arshaler {
 			return nil
 		}
 
-		k := stringOrNumberKind(xe.Tokens.Last.NeedObjectName() || mo.Flags.Get(jsonflags.StringifyNumbers))
+		k := stringOrNumberKind(stringify)
 		return xe.AppendRaw(k, true, func(b []byte) ([]byte, error) {
 			return jsonwire.AppendFloat(b, va.Float(), bits), nil
 		})
 	}
 	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
 		xd := export.Decoder(dec)
+		stringify := xd.Tokens.Last.NeedObjectName() || uo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.StringTag)
 		var allowNonFinite bool
-		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
+		if uo.Flags.Has(jsonflags.FormatTag) {
 			if uo.Format == "nonfinite" {
 				allowNonFinite = true
 			} else {
 				return newInvalidFormatError(dec, t)
 			}
 		}
-		stringify := xd.Tokens.Last.NeedObjectName() || uo.Flags.Get(jsonflags.StringifyNumbers)
+
 		var flags jsonwire.ValueFlags
 		val, err := xd.ReadValue(&flags)
 		if err != nil {
@@ -718,11 +762,11 @@ func makeFloatArshaler(t reflect.Type) *arshaler {
 			if stringify && k == '0' {
 				break
 			}
-			fv, ok := jsonwire.ParseFloat(val, bits)
-			va.SetFloat(fv)
-			if !ok {
-				return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrRange)
+			fv, err := strconv.ParseFloat(string(val), bits)
+			if err != nil {
+				return newUnmarshalErrorAfterWithValue(dec, t, errors.Unwrap(err))
 			}
+			va.SetFloat(fv)
 			return nil
 		}
 		return newUnmarshalErrorAfter(dec, t, nil)
@@ -761,16 +805,19 @@ func makeMapArshaler(t reflect.Type) *arshaler {
 		}
 
 		emitNull := mo.Flags.Get(jsonflags.FormatNilMapAsNull)
-		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
-			switch mo.Format {
-			case "emitnull":
-				emitNull = true
-				mo.Format = ""
-			case "emitempty":
-				emitNull = false
-				mo.Format = ""
-			default:
-				return newInvalidFormatError(enc, t)
+		if mo.Flags.Has(jsonflags.TagFlags) {
+			if mo.Flags.Get(jsonflags.StringTag) && !mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+				return newMarshalErrorBefore(enc, t, errInvalidStringTag)
+			}
+			if mo.Flags.Has(jsonflags.FormatTag) {
+				switch mo.Format {
+				case "emitnull":
+					emitNull = true
+				case "emitempty":
+					emitNull = false
+				default:
+					return newInvalidFormatError(enc, t)
+				}
 			}
 		}
 
@@ -910,12 +957,16 @@ func makeMapArshaler(t reflect.Type) *arshaler {
 	}
 	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
 		xd := export.Decoder(dec)
-		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
-			switch uo.Format {
-			case "emitnull", "emitempty":
-				uo.Format = "" // only relevant for marshaling
-			default:
-				return newInvalidFormatError(dec, t)
+		if uo.Flags.Has(jsonflags.TagFlags) {
+			if uo.Flags.Get(jsonflags.StringTag) && !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+				return newUnmarshalErrorBeforeWithSkipping(dec, t, errInvalidStringTag)
+			}
+			if uo.Flags.Has(jsonflags.FormatTag) {
+				switch uo.Format {
+				case "emitnull", "emitempty":
+				default:
+					return newInvalidFormatError(dec, t)
+				}
 			}
 		}
 		tok, err := dec.ReadToken()
@@ -1033,7 +1084,7 @@ func makeMapArshaler(t reflect.Type) *arshaler {
 // mapKeyWithUniqueRepresentation reports whether all possible values of k
 // marshal to a different JSON value, and whether all possible JSON values
 // that can unmarshal into k unmarshal to different Go values.
-// In other words, the representation must be a bijective.
+// In other words, the representation must be a bijection.
 func mapKeyWithUniqueRepresentation(k reflect.Kind, allowInvalidUTF8 bool) bool {
 	switch k {
 	case reflect.Bool,
@@ -1042,7 +1093,7 @@ func mapKeyWithUniqueRepresentation(k reflect.Kind, allowInvalidUTF8 bool) bool
 		return true
 	case reflect.String:
 		// For strings, we have to be careful since names with invalid UTF-8
-		// maybe unescape to the same Go string value.
+		// may unescape to the same Go string value.
 		return !allowInvalidUTF8
 	default:
 		// Floating-point kinds are not listed above since NaNs
@@ -1052,6 +1103,7 @@ func mapKeyWithUniqueRepresentation(k reflect.Kind, allowInvalidUTF8 bool) bool
 }
 
 var errNilField = errors.New("cannot set embedded pointer to unexported struct type")
+var errInvalidStringTag = errors.New("invalid use of `string` tag option")
 
 func makeStructArshaler(t reflect.Type) *arshaler {
 	// NOTE: The logic below disables namespaces for tracking duplicate names
@@ -1069,13 +1121,21 @@ func makeStructArshaler(t reflect.Type) *arshaler {
 	}
 	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
 		xe := export.Encoder(enc)
-		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
-			return newInvalidFormatError(enc, t)
+		if mo.Flags.Has(jsonflags.TagFlags) {
+			if mo.Flags.Get(jsonflags.StringTag) && !mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+				return newMarshalErrorBefore(enc, t, errInvalidStringTag)
+			}
+			if mo.Flags.Has(jsonflags.FormatTag) {
+				return newInvalidFormatError(enc, t)
+			}
 		}
 		once.Do(init)
 		if errInit != nil && !mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
 			return newMarshalErrorBefore(enc, errInit.GoType, errInit.Err)
+		} else if fields.errUnsupportedFormat != nil && !mo.Flags.Get(jsonflags.FormatTagSupported) {
+			return newMarshalErrorBefore(enc, fields.errUnsupportedFormat.GoType, fields.errUnsupportedFormat.Err)
 		}
+
 		if err := enc.WriteToken(jsontext.BeginObject); err != nil {
 			return err
 		}
@@ -1088,7 +1148,7 @@ func makeStructArshaler(t reflect.Type) *arshaler {
 			if len(f.index) > 0 {
 				v = v.fieldByIndex(f.index, false)
 				if !v.IsValid() {
-					continue // implies a nil inlined field
+					continue // implies a nil embedded field
 				}
 			}
 
@@ -1148,7 +1208,7 @@ func makeStructArshaler(t reflect.Type) *arshaler {
 				if !f.nameNeedEscape {
 					b = append(b, f.quotedName...)
 				} else {
-					b, _ = jsonwire.AppendQuote(b, f.name, &mo.Flags)
+					b, _ = jsonwire.AppendQuote(b, []byte(f.name), &mo.Flags)
 				}
 				xe.Buf = b
 				xe.Names.ReplaceLastQuotedOffset(n0)
@@ -1162,14 +1222,10 @@ func makeStructArshaler(t reflect.Type) *arshaler {
 			// Write the object member value.
 			flagsOriginal := mo.Flags
 			if f.string {
-				if !mo.Flags.Get(jsonflags.StringifyWithLegacySemantics) {
-					mo.Flags.Set(jsonflags.StringifyNumbers | 1)
-				} else if canLegacyStringify(f.typ) {
-					mo.Flags.Set(jsonflags.StringifyNumbers | jsonflags.StringifyBoolsAndStrings | 1)
-				}
+				mo.Flags.Set(jsonflags.StringTag | 1)
 			}
 			if f.format != "" {
-				mo.FormatDepth = xe.Tokens.Depth()
+				mo.Flags.Set(jsonflags.FormatTag | 1)
 				mo.Format = f.format
 			}
 			err := marshal(enc, v, mo)
@@ -1192,17 +1248,17 @@ func makeStructArshaler(t reflect.Type) *arshaler {
 
 			// Remember the previous written object member.
 			// The set of seen fields only needs to be updated to detect
-			// duplicate names with those from the inlined fallback.
-			if !mo.Flags.Get(jsonflags.AllowDuplicateNames) && fields.inlinedFallback != nil {
+			// duplicate names with those from the embedded fallback.
+			if !mo.Flags.Get(jsonflags.AllowDuplicateNames) && fields.embeddedFallback != nil {
 				seenIdxs.insert(uint(f.id))
 			}
 			prevIdx = f.id
 		}
-		if fields.inlinedFallback != nil && !(mo.Flags.Get(jsonflags.DiscardUnknownMembers) && fields.inlinedFallback.unknown) {
+		if fields.embeddedFallback != nil {
 			var insertUnquotedName func([]byte) bool
 			if !mo.Flags.Get(jsonflags.AllowDuplicateNames) {
 				insertUnquotedName = func(name []byte) bool {
-					// Check that the name from inlined fallback does not match
+					// Check that the name from embedded fallback does not match
 					// one of the previously marshaled names from known fields.
 					if foldedFields := fields.lookupByFoldedName(name); len(foldedFields) > 0 {
 						if f := fields.byActualName[string(name)]; f != nil {
@@ -1216,11 +1272,11 @@ func makeStructArshaler(t reflect.Type) *arshaler {
 					}
 
 					// Check that the name does not match any other name
-					// previously marshaled from the inlined fallback.
+					// previously marshaled from the embedded fallback.
 					return xe.Namespaces.Last().InsertUnquoted(name)
 				}
 			}
-			if err := marshalInlinedFallbackAll(enc, va, mo, fields.inlinedFallback, insertUnquotedName); err != nil {
+			if err := marshalEmbeddedFallbackAll(enc, va, mo, fields.embeddedFallback, insertUnquotedName); err != nil {
 				return err
 			}
 		}
@@ -1231,8 +1287,13 @@ func makeStructArshaler(t reflect.Type) *arshaler {
 	}
 	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
 		xd := export.Decoder(dec)
-		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
-			return newInvalidFormatError(dec, t)
+		if uo.Flags.Has(jsonflags.TagFlags) {
+			if uo.Flags.Get(jsonflags.StringTag) && !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+				return newUnmarshalErrorBeforeWithSkipping(dec, t, errInvalidStringTag)
+			}
+			if uo.Flags.Has(jsonflags.FormatTag) {
+				return newInvalidFormatError(dec, t)
+			}
 		}
 		tok, err := dec.ReadToken()
 		if err != nil {
@@ -1249,7 +1310,10 @@ func makeStructArshaler(t reflect.Type) *arshaler {
 			once.Do(init)
 			if errInit != nil && !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
 				return newUnmarshalErrorAfter(dec, errInit.GoType, errInit.Err)
+			} else if fields.errUnsupportedFormat != nil && !uo.Flags.Get(jsonflags.FormatTagSupported) {
+				return newUnmarshalErrorAfter(dec, fields.errUnsupportedFormat.GoType, fields.errUnsupportedFormat.Err)
 			}
+
 			var seenIdxs uintSet
 			xd.Tokens.Last.DisableNamespace()
 			var errUnmarshal error
@@ -1263,14 +1327,20 @@ func makeStructArshaler(t reflect.Type) *arshaler {
 				name := jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
 				f := fields.byActualName[string(name)]
 				if f == nil {
+					var numMatch int
 					for _, f2 := range fields.lookupByFoldedName(name) {
 						if f2.matchFoldedName(name, &uo.Flags) {
-							f = f2
-							break
+							if f == nil {
+								f = f2 // use first seen name by breadth-first order
+							}
+							numMatch++
 						}
 					}
+					if numMatch > 1 && !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+						return newUnmarshalErrorAfter(dec, t, errAmbiguousName)
+					}
 					if f == nil {
-						if uo.Flags.Get(jsonflags.RejectUnknownMembers) && (fields.inlinedFallback == nil || fields.inlinedFallback.unknown) {
+						if uo.Flags.Get(jsonflags.RejectUnknownMembers) && fields.embeddedFallback == nil {
 							err := newUnmarshalErrorAfter(dec, t, ErrUnknownName)
 							if !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
 								return err
@@ -1282,14 +1352,14 @@ func makeStructArshaler(t reflect.Type) *arshaler {
 							return newDuplicateNameError(dec.StackPointer(), nil, dec.InputOffset()-len64(val))
 						}
 
-						if fields.inlinedFallback == nil {
+						if fields.embeddedFallback == nil {
 							// Skip unknown value since we have no place to store it.
 							if err := dec.SkipValue(); err != nil {
 								return err
 							}
 						} else {
-							// Marshal into value capable of storing arbitrary object members.
-							if err := unmarshalInlinedFallbackNext(dec, va, uo, fields.inlinedFallback, val, name); err != nil {
+							// Unmarshal into a value capable of storing arbitrary object members.
+							if err := unmarshalEmbeddedFallbackNext(dec, va, uo, fields.embeddedFallback, val, name); err != nil {
 								if isFatalError(err, uo.Flags) {
 									return err
 								}
@@ -1311,14 +1381,10 @@ func makeStructArshaler(t reflect.Type) *arshaler {
 				}
 				flagsOriginal := uo.Flags
 				if f.string {
-					if !uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) {
-						uo.Flags.Set(jsonflags.StringifyNumbers | 1)
-					} else if canLegacyStringify(f.typ) {
-						uo.Flags.Set(jsonflags.StringifyNumbers | jsonflags.StringifyBoolsAndStrings | 1)
-					}
+					uo.Flags.Set(jsonflags.StringTag | 1)
 				}
 				if f.format != "" {
-					uo.FormatDepth = xd.Tokens.Depth()
+					uo.Flags.Set(jsonflags.FormatTag | 1)
 					uo.Format = f.format
 				}
 				v := addressableValue{va.Field(f.index0), va.forcedAddr} // addressable if struct value is addressable
@@ -1399,25 +1465,6 @@ func isLegacyEmpty(v addressableValue) bool {
 	return false
 }
 
-// canLegacyStringify reports whether t can be stringified according to v1,
-// where t is a bool, string, or number (or unnamed pointer to such).
-// In v1, the `string` option does not apply recursively to nested types within
-// a composite Go type (e.g., an array, slice, struct, map, or interface).
-func canLegacyStringify(t reflect.Type) bool {
-	// Based on encoding/json.typeFields#L1126-L1143@v1.23.0
-	if t.Name() == "" && t.Kind() == reflect.Ptr {
-		t = t.Elem()
-	}
-	switch t.Kind() {
-	case reflect.Bool, reflect.String,
-		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
-		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
-		reflect.Float32, reflect.Float64:
-		return true
-	}
-	return false
-}
-
 func makeSliceArshaler(t reflect.Type) *arshaler {
 	var fncs arshaler
 	var (
@@ -1438,16 +1485,19 @@ func makeSliceArshaler(t reflect.Type) *arshaler {
 		}
 
 		emitNull := mo.Flags.Get(jsonflags.FormatNilSliceAsNull)
-		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
-			switch mo.Format {
-			case "emitnull":
-				emitNull = true
-				mo.Format = ""
-			case "emitempty":
-				emitNull = false
-				mo.Format = ""
-			default:
-				return newInvalidFormatError(enc, t)
+		if mo.Flags.Has(jsonflags.TagFlags) {
+			if mo.Flags.Get(jsonflags.StringTag) && !mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+				return newMarshalErrorBefore(enc, t, errInvalidStringTag)
+			}
+			if mo.Flags.Has(jsonflags.FormatTag) {
+				switch mo.Format {
+				case "emitnull":
+					emitNull = true
+				case "emitempty":
+					emitNull = false
+				default:
+					return newInvalidFormatError(enc, t)
+				}
 			}
 		}
 
@@ -1489,13 +1539,16 @@ func makeSliceArshaler(t reflect.Type) *arshaler {
 	}
 	emptySlice := reflect.MakeSlice(t, 0, 0)
 	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
-		xd := export.Decoder(dec)
-		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
-			switch uo.Format {
-			case "emitnull", "emitempty":
-				uo.Format = "" // only relevant for marshaling
-			default:
-				return newInvalidFormatError(dec, t)
+		if uo.Flags.Has(jsonflags.TagFlags) {
+			if uo.Flags.Get(jsonflags.StringTag) && !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+				return newUnmarshalErrorBeforeWithSkipping(dec, t, errInvalidStringTag)
+			}
+			if uo.Flags.Has(jsonflags.FormatTag) {
+				switch uo.Format {
+				case "emitnull", "emitempty":
+				default:
+					return newInvalidFormatError(dec, t)
+				}
 			}
 		}
 
@@ -1570,9 +1623,13 @@ func makeArrayArshaler(t reflect.Type) *arshaler {
 	}
 	n := t.Len()
 	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
-		xe := export.Encoder(enc)
-		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
-			return newInvalidFormatError(enc, t)
+		if mo.Flags.Has(jsonflags.TagFlags) {
+			if mo.Flags.Get(jsonflags.StringTag) && !mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+				return newMarshalErrorBefore(enc, t, errInvalidStringTag)
+			}
+			if mo.Flags.Has(jsonflags.FormatTag) {
+				return newInvalidFormatError(enc, t)
+			}
 		}
 		once.Do(init)
 		if err := enc.WriteToken(jsontext.BeginArray); err != nil {
@@ -1594,9 +1651,13 @@ func makeArrayArshaler(t reflect.Type) *arshaler {
 		return nil
 	}
 	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
-		xd := export.Decoder(dec)
-		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
-			return newInvalidFormatError(dec, t)
+		if uo.Flags.Has(jsonflags.TagFlags) {
+			if uo.Flags.Get(jsonflags.StringTag) && !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+				return newUnmarshalErrorBeforeWithSkipping(dec, t, errInvalidStringTag)
+			}
+			if uo.Flags.Has(jsonflags.FormatTag) {
+				return newInvalidFormatError(dec, t)
+			}
 		}
 		tok, err := dec.ReadToken()
 		if err != nil {
@@ -1674,6 +1735,12 @@ func makePointerArshaler(t reflect.Type) *arshaler {
 		}
 
 		// NOTE: Struct.Format is forwarded to underlying marshal.
+		if mo.Flags.Get(jsonflags.StringTag) && mo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && t.Elem().Kind() == reflect.Pointer {
+			if !mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+				return newMarshalErrorBefore(enc, t, errInvalidStringTag)
+			}
+			mo.Flags.Clear(jsonflags.StringTag) // the `string` tag option does not apply to nested pointers
+		}
 		if va.IsNil() {
 			return enc.WriteToken(jsontext.Null)
 		}
@@ -1694,6 +1761,12 @@ func makePointerArshaler(t reflect.Type) *arshaler {
 			va.SetZero()
 			return nil
 		}
+		if uo.Flags.Get(jsonflags.StringTag) && uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && t.Elem().Kind() == reflect.Pointer {
+			if !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+				return newUnmarshalErrorBeforeWithSkipping(dec, t, errInvalidStringTag)
+			}
+			uo.Flags.Clear(jsonflags.StringTag) // the `string` tag option does not apply to nested pointers
+		}
 		once.Do(init)
 		unmarshal := valFncs.unmarshal
 		if uo.Unmarshalers != nil {
@@ -1706,8 +1779,7 @@ func makePointerArshaler(t reflect.Type) *arshaler {
 		if err := unmarshal(dec, v, uo); err != nil {
 			return err
 		}
-		if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) &&
-			uo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.StringifyBoolsAndStrings) {
+		if uo.Flags.Get(jsonflags.StringTag) && uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) {
 			// A JSON null quoted within a JSON string should take effect
 			// within the pointer value, rather than the indirect value.
 			//
@@ -1737,9 +1809,18 @@ func makeInterfaceArshaler(t reflect.Type) *arshaler {
 		}
 	}
 	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
-		xe := export.Encoder(enc)
-		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
-			return newInvalidFormatError(enc, t)
+		if mo.Flags.Has(jsonflags.TagFlags) {
+			if mo.Flags.Get(jsonflags.StringTag) {
+				if !mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+					return newMarshalErrorBefore(enc, t, errInvalidStringTag)
+				}
+				if mo.Flags.Get(jsonflags.StringifyWithLegacySemantics) {
+					mo.Flags.Clear(jsonflags.StringTag) // the `string` tag option does not apply to interface types
+				}
+			}
+			if mo.Flags.Has(jsonflags.FormatTag) {
+				return newInvalidFormatError(enc, t)
+			}
 		}
 		if va.IsNil() {
 			return enc.WriteToken(jsontext.Null)
@@ -1770,16 +1851,25 @@ func makeInterfaceArshaler(t reflect.Type) *arshaler {
 		}
 		// Optimize for the any type if there are no special options.
 		if optimizeCommon &&
-			t == anyType && !mo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.StringifyBoolsAndStrings) && mo.Format == "" &&
+			t == anyType && !mo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.TagFlags) &&
 			(mo.Marshalers == nil || !mo.Marshalers.(*Marshalers).fromAny) {
 			return marshalValueAny(enc, va.Elem().Interface(), mo)
 		}
 		return marshal(enc, v, mo)
 	}
 	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
-		xd := export.Decoder(dec)
-		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
-			return newInvalidFormatError(dec, t)
+		if uo.Flags.Has(jsonflags.TagFlags) {
+			if uo.Flags.Get(jsonflags.StringTag) {
+				if !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+					return newUnmarshalErrorBeforeWithSkipping(dec, t, errInvalidStringTag)
+				}
+				if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) {
+					uo.Flags.Clear(jsonflags.StringTag) // the `string` tag option does not apply to interface types
+				}
+			}
+			if uo.Flags.Has(jsonflags.FormatTag) {
+				return newInvalidFormatError(dec, t)
+			}
 		}
 		if uo.Flags.Get(jsonflags.MergeWithLegacySemantics) && !va.IsNil() {
 			// Legacy merge behavior is difficult to explain.
@@ -1815,7 +1905,7 @@ func makeInterfaceArshaler(t reflect.Type) *arshaler {
 			// Duplicate name check must be enforced since unmarshalValueAny
 			// does not implement merge semantics.
 			if optimizeCommon &&
-				t == anyType && !uo.Flags.Get(jsonflags.AllowDuplicateNames) && uo.Format == "" &&
+				t == anyType && !uo.Flags.Get(jsonflags.AllowDuplicateNames|jsonflags.FormatTag) &&
 				(uo.Unmarshalers == nil || !uo.Unmarshalers.(*Unmarshalers).fromAny) {
 				v, err := unmarshalValueAny(dec, uo)
 				// We must check for nil interface values up front.
@@ -1871,7 +1961,7 @@ func makeInterfaceArshaler(t reflect.Type) *arshaler {
 	return &fncs
 }
 
-// isAnyType reports wether t is equivalent to the any interface type.
+// isAnyType reports whether t is equivalent to the any interface type.
 func isAnyType(t reflect.Type) bool {
 	// This is forward compatible if the Go language permits type sets within
 	// ordinary interfaces where an interface with zero methods does not
@@ -1886,6 +1976,19 @@ func makeInvalidArshaler(t reflect.Type) *arshaler {
 		return newMarshalErrorBefore(enc, t, nil)
 	}
 	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
+		// Under legacy error semantics, unmarshal continues on even with errors.
+		// Thus, always consume the value first.
+		// As a special-case, null is permitted for unsupported types.
+		if uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
+			switch val, err := dec.ReadValue(); {
+			case err != nil:
+				return err
+			case val.Kind() == 'n':
+				return nil
+			default:
+				return newUnmarshalErrorAfter(dec, t, nil)
+			}
+		}
 		return newUnmarshalErrorBefore(dec, t, nil)
 	}
 	return &fncs