Source file src/encoding/json/v2/arshal_default.go

     1  // Copyright 2020 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  //go:build goexperiment.jsonv2
     6  
     7  package json
     8  
     9  import (
    10  	"bytes"
    11  	"cmp"
    12  	"encoding"
    13  	"encoding/base32"
    14  	"encoding/base64"
    15  	"encoding/hex"
    16  	"errors"
    17  	"fmt"
    18  	"math"
    19  	"reflect"
    20  	"slices"
    21  	"strconv"
    22  	"strings"
    23  	"sync"
    24  
    25  	"encoding/json/internal"
    26  	"encoding/json/internal/jsonflags"
    27  	"encoding/json/internal/jsonopts"
    28  	"encoding/json/internal/jsonwire"
    29  	"encoding/json/jsontext"
    30  )
    31  
    32  // optimizeCommon specifies whether to use optimizations targeted for certain
    33  // common patterns, rather than using the slower, but more general logic.
    34  // All tests should pass regardless of whether this is true or not.
    35  const optimizeCommon = true
    36  
    37  var (
    38  	// Most natural Go type that correspond with each JSON type.
    39  	anyType          = reflect.TypeFor[any]()            // JSON value
    40  	boolType         = reflect.TypeFor[bool]()           // JSON bool
    41  	stringType       = reflect.TypeFor[string]()         // JSON string
    42  	float64Type      = reflect.TypeFor[float64]()        // JSON number
    43  	mapStringAnyType = reflect.TypeFor[map[string]any]() // JSON object
    44  	sliceAnyType     = reflect.TypeFor[[]any]()          // JSON array
    45  
    46  	bytesType       = reflect.TypeFor[[]byte]()
    47  	emptyStructType = reflect.TypeFor[struct{}]()
    48  )
    49  
    50  const startDetectingCyclesAfter = 1000
    51  
    52  type seenPointers = map[any]struct{}
    53  
    54  type typedPointer struct {
    55  	typ reflect.Type
    56  	ptr any // always stores unsafe.Pointer, but avoids depending on unsafe
    57  	len int // remember slice length to avoid false positives
    58  }
    59  
    60  // visitPointer visits pointer p of type t, reporting an error if seen before.
    61  // If successfully visited, then the caller must eventually call leave.
    62  func visitPointer(m *seenPointers, v reflect.Value) error {
    63  	p := typedPointer{v.Type(), v.UnsafePointer(), sliceLen(v)}
    64  	if _, ok := (*m)[p]; ok {
    65  		return internal.ErrCycle
    66  	}
    67  	if *m == nil {
    68  		*m = make(seenPointers)
    69  	}
    70  	(*m)[p] = struct{}{}
    71  	return nil
    72  }
    73  func leavePointer(m *seenPointers, v reflect.Value) {
    74  	p := typedPointer{v.Type(), v.UnsafePointer(), sliceLen(v)}
    75  	delete(*m, p)
    76  }
    77  
    78  func sliceLen(v reflect.Value) int {
    79  	if v.Kind() == reflect.Slice {
    80  		return v.Len()
    81  	}
    82  	return 0
    83  }
    84  
    85  func len64[Bytes ~[]byte | ~string](in Bytes) int64 {
    86  	return int64(len(in))
    87  }
    88  
    89  func makeDefaultArshaler(t reflect.Type) *arshaler {
    90  	switch t.Kind() {
    91  	case reflect.Bool:
    92  		return makeBoolArshaler(t)
    93  	case reflect.String:
    94  		return makeStringArshaler(t)
    95  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    96  		return makeIntArshaler(t)
    97  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
    98  		return makeUintArshaler(t)
    99  	case reflect.Float32, reflect.Float64:
   100  		return makeFloatArshaler(t)
   101  	case reflect.Map:
   102  		return makeMapArshaler(t)
   103  	case reflect.Struct:
   104  		return makeStructArshaler(t)
   105  	case reflect.Slice:
   106  		fncs := makeSliceArshaler(t)
   107  		if t.Elem().Kind() == reflect.Uint8 {
   108  			return makeBytesArshaler(t, fncs)
   109  		}
   110  		return fncs
   111  	case reflect.Array:
   112  		fncs := makeArrayArshaler(t)
   113  		if t.Elem().Kind() == reflect.Uint8 {
   114  			return makeBytesArshaler(t, fncs)
   115  		}
   116  		return fncs
   117  	case reflect.Pointer:
   118  		return makePointerArshaler(t)
   119  	case reflect.Interface:
   120  		return makeInterfaceArshaler(t)
   121  	default:
   122  		return makeInvalidArshaler(t)
   123  	}
   124  }
   125  
   126  func makeBoolArshaler(t reflect.Type) *arshaler {
   127  	var fncs arshaler
   128  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
   129  		xe := export.Encoder(enc)
   130  		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
   131  			return newInvalidFormatError(enc, t, mo)
   132  		}
   133  
   134  		// Optimize for marshaling without preceding whitespace.
   135  		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyBoolsAndStrings) && !xe.Tokens.Last.NeedObjectName() {
   136  			xe.Buf = strconv.AppendBool(xe.Tokens.MayAppendDelim(xe.Buf, 't'), va.Bool())
   137  			xe.Tokens.Last.Increment()
   138  			if xe.NeedFlush() {
   139  				return xe.Flush()
   140  			}
   141  			return nil
   142  		}
   143  
   144  		if mo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
   145  			if va.Bool() {
   146  				return enc.WriteToken(jsontext.String("true"))
   147  			} else {
   148  				return enc.WriteToken(jsontext.String("false"))
   149  			}
   150  		}
   151  		return enc.WriteToken(jsontext.Bool(va.Bool()))
   152  	}
   153  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
   154  		xd := export.Decoder(dec)
   155  		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
   156  			return newInvalidFormatError(dec, t, uo)
   157  		}
   158  		tok, err := dec.ReadToken()
   159  		if err != nil {
   160  			return err
   161  		}
   162  		k := tok.Kind()
   163  		switch k {
   164  		case 'n':
   165  			if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
   166  				va.SetBool(false)
   167  			}
   168  			return nil
   169  		case 't', 'f':
   170  			if !uo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
   171  				va.SetBool(tok.Bool())
   172  				return nil
   173  			}
   174  		case '"':
   175  			if uo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
   176  				switch tok.String() {
   177  				case "true":
   178  					va.SetBool(true)
   179  				case "false":
   180  					va.SetBool(false)
   181  				default:
   182  					if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && tok.String() == "null" {
   183  						if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
   184  							va.SetBool(false)
   185  						}
   186  						return nil
   187  					}
   188  					return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrSyntax)
   189  				}
   190  				return nil
   191  			}
   192  		}
   193  		return newUnmarshalErrorAfterWithSkipping(dec, uo, t, nil)
   194  	}
   195  	return &fncs
   196  }
   197  
   198  func makeStringArshaler(t reflect.Type) *arshaler {
   199  	var fncs arshaler
   200  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
   201  		xe := export.Encoder(enc)
   202  		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
   203  			return newInvalidFormatError(enc, t, mo)
   204  		}
   205  
   206  		// Optimize for marshaling without preceding whitespace.
   207  		s := va.String()
   208  		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyBoolsAndStrings) && !xe.Tokens.Last.NeedObjectName() {
   209  			b := xe.Buf
   210  			b = xe.Tokens.MayAppendDelim(b, '"')
   211  			b, err := jsonwire.AppendQuote(b, s, &mo.Flags)
   212  			if err == nil {
   213  				xe.Buf = b
   214  				xe.Tokens.Last.Increment()
   215  				if xe.NeedFlush() {
   216  					return xe.Flush()
   217  				}
   218  				return nil
   219  			}
   220  			// Otherwise, the string contains invalid UTF-8,
   221  			// so let the logic below construct the proper error.
   222  		}
   223  
   224  		if mo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
   225  			b, err := jsonwire.AppendQuote(nil, s, &mo.Flags)
   226  			if err != nil {
   227  				return newMarshalErrorBefore(enc, t, &jsontext.SyntacticError{Err: err})
   228  			}
   229  			q, err := jsontext.AppendQuote(nil, b)
   230  			if err != nil {
   231  				panic("BUG: second AppendQuote should never fail: " + err.Error())
   232  			}
   233  			return enc.WriteValue(q)
   234  		}
   235  		return enc.WriteToken(jsontext.String(s))
   236  	}
   237  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
   238  		xd := export.Decoder(dec)
   239  		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
   240  			return newInvalidFormatError(dec, t, uo)
   241  		}
   242  		var flags jsonwire.ValueFlags
   243  		val, err := xd.ReadValue(&flags)
   244  		if err != nil {
   245  			return err
   246  		}
   247  		k := val.Kind()
   248  		switch k {
   249  		case 'n':
   250  			if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
   251  				va.SetString("")
   252  			}
   253  			return nil
   254  		case '"':
   255  			val = jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
   256  			if uo.Flags.Get(jsonflags.StringifyBoolsAndStrings) {
   257  				val, err = jsontext.AppendUnquote(nil, val)
   258  				if err != nil {
   259  					return newUnmarshalErrorAfter(dec, t, err)
   260  				}
   261  				if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && string(val) == "null" {
   262  					if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
   263  						va.SetString("")
   264  					}
   265  					return nil
   266  				}
   267  			}
   268  			if xd.StringCache == nil {
   269  				xd.StringCache = new(stringCache)
   270  			}
   271  			str := makeString(xd.StringCache, val)
   272  			va.SetString(str)
   273  			return nil
   274  		}
   275  		return newUnmarshalErrorAfter(dec, t, nil)
   276  	}
   277  	return &fncs
   278  }
   279  
   280  var (
   281  	appendEncodeBase16    = hex.AppendEncode
   282  	appendEncodeBase32    = base32.StdEncoding.AppendEncode
   283  	appendEncodeBase32Hex = base32.HexEncoding.AppendEncode
   284  	appendEncodeBase64    = base64.StdEncoding.AppendEncode
   285  	appendEncodeBase64URL = base64.URLEncoding.AppendEncode
   286  	encodedLenBase16      = hex.EncodedLen
   287  	encodedLenBase32      = base32.StdEncoding.EncodedLen
   288  	encodedLenBase32Hex   = base32.HexEncoding.EncodedLen
   289  	encodedLenBase64      = base64.StdEncoding.EncodedLen
   290  	encodedLenBase64URL   = base64.URLEncoding.EncodedLen
   291  	appendDecodeBase16    = hex.AppendDecode
   292  	appendDecodeBase32    = base32.StdEncoding.AppendDecode
   293  	appendDecodeBase32Hex = base32.HexEncoding.AppendDecode
   294  	appendDecodeBase64    = base64.StdEncoding.AppendDecode
   295  	appendDecodeBase64URL = base64.URLEncoding.AppendDecode
   296  )
   297  
   298  func makeBytesArshaler(t reflect.Type, fncs *arshaler) *arshaler {
   299  	// NOTE: This handles both []~byte and [N]~byte.
   300  	// The v2 default is to treat a []namedByte as equivalent to []T
   301  	// since being able to convert []namedByte to []byte relies on
   302  	// dubious Go reflection behavior (see https://go.dev/issue/24746).
   303  	// For v1 emulation, we use jsonflags.FormatBytesWithLegacySemantics
   304  	// to forcibly treat []namedByte as a []byte.
   305  	marshalArray := fncs.marshal
   306  	isNamedByte := t.Elem().PkgPath() != ""
   307  	hasMarshaler := implementsAny(t.Elem(), allMarshalerTypes...)
   308  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
   309  		if !mo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) && isNamedByte {
   310  			return marshalArray(enc, va, mo) // treat as []T or [N]T
   311  		}
   312  		xe := export.Encoder(enc)
   313  		appendEncode := appendEncodeBase64
   314  		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
   315  			switch mo.Format {
   316  			case "base64":
   317  				appendEncode = appendEncodeBase64
   318  			case "base64url":
   319  				appendEncode = appendEncodeBase64URL
   320  			case "base32":
   321  				appendEncode = appendEncodeBase32
   322  			case "base32hex":
   323  				appendEncode = appendEncodeBase32Hex
   324  			case "base16", "hex":
   325  				appendEncode = appendEncodeBase16
   326  			case "array":
   327  				mo.Format = ""
   328  				return marshalArray(enc, va, mo)
   329  			default:
   330  				return newInvalidFormatError(enc, t, mo)
   331  			}
   332  		} else if mo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) &&
   333  			(va.Kind() == reflect.Array || hasMarshaler) {
   334  			return marshalArray(enc, va, mo)
   335  		}
   336  		if mo.Flags.Get(jsonflags.FormatNilSliceAsNull) && va.Kind() == reflect.Slice && va.IsNil() {
   337  			// TODO: Provide a "emitempty" format override?
   338  			return enc.WriteToken(jsontext.Null)
   339  		}
   340  		return xe.AppendRaw('"', true, func(b []byte) ([]byte, error) {
   341  			return appendEncode(b, va.Bytes()), nil
   342  		})
   343  	}
   344  	unmarshalArray := fncs.unmarshal
   345  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
   346  		if !uo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) && isNamedByte {
   347  			return unmarshalArray(dec, va, uo) // treat as []T or [N]T
   348  		}
   349  		xd := export.Decoder(dec)
   350  		appendDecode, encodedLen := appendDecodeBase64, encodedLenBase64
   351  		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
   352  			switch uo.Format {
   353  			case "base64":
   354  				appendDecode, encodedLen = appendDecodeBase64, encodedLenBase64
   355  			case "base64url":
   356  				appendDecode, encodedLen = appendDecodeBase64URL, encodedLenBase64URL
   357  			case "base32":
   358  				appendDecode, encodedLen = appendDecodeBase32, encodedLenBase32
   359  			case "base32hex":
   360  				appendDecode, encodedLen = appendDecodeBase32Hex, encodedLenBase32Hex
   361  			case "base16", "hex":
   362  				appendDecode, encodedLen = appendDecodeBase16, encodedLenBase16
   363  			case "array":
   364  				uo.Format = ""
   365  				return unmarshalArray(dec, va, uo)
   366  			default:
   367  				return newInvalidFormatError(dec, t, uo)
   368  			}
   369  		} else if uo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) &&
   370  			(va.Kind() == reflect.Array || dec.PeekKind() == '[') {
   371  			return unmarshalArray(dec, va, uo)
   372  		}
   373  		var flags jsonwire.ValueFlags
   374  		val, err := xd.ReadValue(&flags)
   375  		if err != nil {
   376  			return err
   377  		}
   378  		k := val.Kind()
   379  		switch k {
   380  		case 'n':
   381  			if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) || va.Kind() != reflect.Array {
   382  				va.SetZero()
   383  			}
   384  			return nil
   385  		case '"':
   386  			// NOTE: The v2 default is to strictly comply with RFC 4648.
   387  			// Section 3.2 specifies that padding is required.
   388  			// Section 3.3 specifies that non-alphabet characters
   389  			// (e.g., '\r' or '\n') must be rejected.
   390  			// Section 3.5 specifies that unnecessary non-zero bits in
   391  			// the last quantum may be rejected. Since this is optional,
   392  			// we do not reject such inputs.
   393  			val = jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
   394  			b, err := appendDecode(va.Bytes()[:0], val)
   395  			if err != nil {
   396  				return newUnmarshalErrorAfter(dec, t, err)
   397  			}
   398  			if len(val) != encodedLen(len(b)) && !uo.Flags.Get(jsonflags.FormatBytesWithLegacySemantics) {
   399  				// TODO(https://go.dev/issue/53845): RFC 4648, section 3.3,
   400  				// specifies that non-alphabet characters must be rejected.
   401  				// Unfortunately, the "base32" and "base64" packages allow
   402  				// '\r' and '\n' characters by default.
   403  				i := bytes.IndexAny(val, "\r\n")
   404  				err := fmt.Errorf("illegal character %s at offset %d", jsonwire.QuoteRune(val[i:]), i)
   405  				return newUnmarshalErrorAfter(dec, t, err)
   406  			}
   407  
   408  			if va.Kind() == reflect.Array {
   409  				dst := va.Bytes()
   410  				clear(dst[copy(dst, b):]) // noop if len(b) <= len(dst)
   411  				if len(b) != len(dst) && !uo.Flags.Get(jsonflags.UnmarshalArrayFromAnyLength) {
   412  					err := fmt.Errorf("decoded length of %d mismatches array length of %d", len(b), len(dst))
   413  					return newUnmarshalErrorAfter(dec, t, err)
   414  				}
   415  			} else {
   416  				if b == nil {
   417  					b = []byte{}
   418  				}
   419  				va.SetBytes(b)
   420  			}
   421  			return nil
   422  		}
   423  		return newUnmarshalErrorAfter(dec, t, nil)
   424  	}
   425  	return fncs
   426  }
   427  
   428  func makeIntArshaler(t reflect.Type) *arshaler {
   429  	var fncs arshaler
   430  	bits := t.Bits()
   431  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
   432  		xe := export.Encoder(enc)
   433  		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
   434  			return newInvalidFormatError(enc, t, mo)
   435  		}
   436  
   437  		// Optimize for marshaling without preceding whitespace or string escaping.
   438  		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyNumbers) && !xe.Tokens.Last.NeedObjectName() {
   439  			xe.Buf = strconv.AppendInt(xe.Tokens.MayAppendDelim(xe.Buf, '0'), va.Int(), 10)
   440  			xe.Tokens.Last.Increment()
   441  			if xe.NeedFlush() {
   442  				return xe.Flush()
   443  			}
   444  			return nil
   445  		}
   446  
   447  		k := stringOrNumberKind(xe.Tokens.Last.NeedObjectName() || mo.Flags.Get(jsonflags.StringifyNumbers))
   448  		return xe.AppendRaw(k, true, func(b []byte) ([]byte, error) {
   449  			return strconv.AppendInt(b, va.Int(), 10), nil
   450  		})
   451  	}
   452  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
   453  		xd := export.Decoder(dec)
   454  		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
   455  			return newInvalidFormatError(dec, t, uo)
   456  		}
   457  		stringify := xd.Tokens.Last.NeedObjectName() || uo.Flags.Get(jsonflags.StringifyNumbers)
   458  		var flags jsonwire.ValueFlags
   459  		val, err := xd.ReadValue(&flags)
   460  		if err != nil {
   461  			return err
   462  		}
   463  		k := val.Kind()
   464  		switch k {
   465  		case 'n':
   466  			if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
   467  				va.SetInt(0)
   468  			}
   469  			return nil
   470  		case '"':
   471  			if !stringify {
   472  				break
   473  			}
   474  			val = jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
   475  			if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && string(val) == "null" {
   476  				if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
   477  					va.SetInt(0)
   478  				}
   479  				return nil
   480  			}
   481  			fallthrough
   482  		case '0':
   483  			if stringify && k == '0' {
   484  				break
   485  			}
   486  			var negOffset int
   487  			neg := len(val) > 0 && val[0] == '-'
   488  			if neg {
   489  				negOffset = 1
   490  			}
   491  			n, ok := jsonwire.ParseUint(val[negOffset:])
   492  			maxInt := uint64(1) << (bits - 1)
   493  			overflow := (neg && n > maxInt) || (!neg && n > maxInt-1)
   494  			if !ok {
   495  				if n != math.MaxUint64 {
   496  					return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrSyntax)
   497  				}
   498  				overflow = true
   499  			}
   500  			if overflow {
   501  				return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrRange)
   502  			}
   503  			if neg {
   504  				va.SetInt(int64(-n))
   505  			} else {
   506  				va.SetInt(int64(+n))
   507  			}
   508  			return nil
   509  		}
   510  		return newUnmarshalErrorAfter(dec, t, nil)
   511  	}
   512  	return &fncs
   513  }
   514  
   515  func makeUintArshaler(t reflect.Type) *arshaler {
   516  	var fncs arshaler
   517  	bits := t.Bits()
   518  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
   519  		xe := export.Encoder(enc)
   520  		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
   521  			return newInvalidFormatError(enc, t, mo)
   522  		}
   523  
   524  		// Optimize for marshaling without preceding whitespace or string escaping.
   525  		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyNumbers) && !xe.Tokens.Last.NeedObjectName() {
   526  			xe.Buf = strconv.AppendUint(xe.Tokens.MayAppendDelim(xe.Buf, '0'), va.Uint(), 10)
   527  			xe.Tokens.Last.Increment()
   528  			if xe.NeedFlush() {
   529  				return xe.Flush()
   530  			}
   531  			return nil
   532  		}
   533  
   534  		k := stringOrNumberKind(xe.Tokens.Last.NeedObjectName() || mo.Flags.Get(jsonflags.StringifyNumbers))
   535  		return xe.AppendRaw(k, true, func(b []byte) ([]byte, error) {
   536  			return strconv.AppendUint(b, va.Uint(), 10), nil
   537  		})
   538  	}
   539  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
   540  		xd := export.Decoder(dec)
   541  		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
   542  			return newInvalidFormatError(dec, t, uo)
   543  		}
   544  		stringify := xd.Tokens.Last.NeedObjectName() || uo.Flags.Get(jsonflags.StringifyNumbers)
   545  		var flags jsonwire.ValueFlags
   546  		val, err := xd.ReadValue(&flags)
   547  		if err != nil {
   548  			return err
   549  		}
   550  		k := val.Kind()
   551  		switch k {
   552  		case 'n':
   553  			if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
   554  				va.SetUint(0)
   555  			}
   556  			return nil
   557  		case '"':
   558  			if !stringify {
   559  				break
   560  			}
   561  			val = jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
   562  			if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && string(val) == "null" {
   563  				if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
   564  					va.SetUint(0)
   565  				}
   566  				return nil
   567  			}
   568  			fallthrough
   569  		case '0':
   570  			if stringify && k == '0' {
   571  				break
   572  			}
   573  			n, ok := jsonwire.ParseUint(val)
   574  			maxUint := uint64(1) << bits
   575  			overflow := n > maxUint-1
   576  			if !ok {
   577  				if n != math.MaxUint64 {
   578  					return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrSyntax)
   579  				}
   580  				overflow = true
   581  			}
   582  			if overflow {
   583  				return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrRange)
   584  			}
   585  			va.SetUint(n)
   586  			return nil
   587  		}
   588  		return newUnmarshalErrorAfter(dec, t, nil)
   589  	}
   590  	return &fncs
   591  }
   592  
   593  func makeFloatArshaler(t reflect.Type) *arshaler {
   594  	var fncs arshaler
   595  	bits := t.Bits()
   596  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
   597  		xe := export.Encoder(enc)
   598  		var allowNonFinite bool
   599  		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
   600  			if mo.Format == "nonfinite" {
   601  				allowNonFinite = true
   602  			} else {
   603  				return newInvalidFormatError(enc, t, mo)
   604  			}
   605  		}
   606  
   607  		fv := va.Float()
   608  		if math.IsNaN(fv) || math.IsInf(fv, 0) {
   609  			if !allowNonFinite {
   610  				err := fmt.Errorf("unsupported value: %v", fv)
   611  				return newMarshalErrorBefore(enc, t, err)
   612  			}
   613  			return enc.WriteToken(jsontext.Float(fv))
   614  		}
   615  
   616  		// Optimize for marshaling without preceding whitespace or string escaping.
   617  		if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace|jsonflags.StringifyNumbers) && !xe.Tokens.Last.NeedObjectName() {
   618  			xe.Buf = jsonwire.AppendFloat(xe.Tokens.MayAppendDelim(xe.Buf, '0'), fv, bits)
   619  			xe.Tokens.Last.Increment()
   620  			if xe.NeedFlush() {
   621  				return xe.Flush()
   622  			}
   623  			return nil
   624  		}
   625  
   626  		k := stringOrNumberKind(xe.Tokens.Last.NeedObjectName() || mo.Flags.Get(jsonflags.StringifyNumbers))
   627  		return xe.AppendRaw(k, true, func(b []byte) ([]byte, error) {
   628  			return jsonwire.AppendFloat(b, va.Float(), bits), nil
   629  		})
   630  	}
   631  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
   632  		xd := export.Decoder(dec)
   633  		var allowNonFinite bool
   634  		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
   635  			if uo.Format == "nonfinite" {
   636  				allowNonFinite = true
   637  			} else {
   638  				return newInvalidFormatError(dec, t, uo)
   639  			}
   640  		}
   641  		stringify := xd.Tokens.Last.NeedObjectName() || uo.Flags.Get(jsonflags.StringifyNumbers)
   642  		var flags jsonwire.ValueFlags
   643  		val, err := xd.ReadValue(&flags)
   644  		if err != nil {
   645  			return err
   646  		}
   647  		k := val.Kind()
   648  		switch k {
   649  		case 'n':
   650  			if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
   651  				va.SetFloat(0)
   652  			}
   653  			return nil
   654  		case '"':
   655  			val = jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
   656  			if allowNonFinite {
   657  				switch string(val) {
   658  				case "NaN":
   659  					va.SetFloat(math.NaN())
   660  					return nil
   661  				case "Infinity":
   662  					va.SetFloat(math.Inf(+1))
   663  					return nil
   664  				case "-Infinity":
   665  					va.SetFloat(math.Inf(-1))
   666  					return nil
   667  				}
   668  			}
   669  			if !stringify {
   670  				break
   671  			}
   672  			if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) && string(val) == "null" {
   673  				if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
   674  					va.SetFloat(0)
   675  				}
   676  				return nil
   677  			}
   678  			if n, err := jsonwire.ConsumeNumber(val); n != len(val) || err != nil {
   679  				return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrSyntax)
   680  			}
   681  			fallthrough
   682  		case '0':
   683  			if stringify && k == '0' {
   684  				break
   685  			}
   686  			fv, ok := jsonwire.ParseFloat(val, bits)
   687  			va.SetFloat(fv)
   688  			if !ok {
   689  				return newUnmarshalErrorAfterWithValue(dec, t, strconv.ErrRange)
   690  			}
   691  			return nil
   692  		}
   693  		return newUnmarshalErrorAfter(dec, t, nil)
   694  	}
   695  	return &fncs
   696  }
   697  
   698  func makeMapArshaler(t reflect.Type) *arshaler {
   699  	// NOTE: The logic below disables namespaces for tracking duplicate names
   700  	// when handling map keys with a unique representation.
   701  
   702  	// NOTE: Values retrieved from a map are not addressable,
   703  	// so we shallow copy the values to make them addressable and
   704  	// store them back into the map afterwards.
   705  
   706  	var fncs arshaler
   707  	var (
   708  		once    sync.Once
   709  		keyFncs *arshaler
   710  		valFncs *arshaler
   711  	)
   712  	init := func() {
   713  		keyFncs = lookupArshaler(t.Key())
   714  		valFncs = lookupArshaler(t.Elem())
   715  	}
   716  	nillableLegacyKey := t.Key().Kind() == reflect.Pointer &&
   717  		implementsAny(t.Key(), textMarshalerType, textAppenderType)
   718  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
   719  		// Check for cycles.
   720  		xe := export.Encoder(enc)
   721  		if xe.Tokens.Depth() > startDetectingCyclesAfter {
   722  			if err := visitPointer(&xe.SeenPointers, va.Value); err != nil {
   723  				return newMarshalErrorBefore(enc, t, err)
   724  			}
   725  			defer leavePointer(&xe.SeenPointers, va.Value)
   726  		}
   727  
   728  		emitNull := mo.Flags.Get(jsonflags.FormatNilMapAsNull)
   729  		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
   730  			switch mo.Format {
   731  			case "emitnull":
   732  				emitNull = true
   733  				mo.Format = ""
   734  			case "emitempty":
   735  				emitNull = false
   736  				mo.Format = ""
   737  			default:
   738  				return newInvalidFormatError(enc, t, mo)
   739  			}
   740  		}
   741  
   742  		// Handle empty maps.
   743  		n := va.Len()
   744  		if n == 0 {
   745  			if emitNull && va.IsNil() {
   746  				return enc.WriteToken(jsontext.Null)
   747  			}
   748  			// Optimize for marshaling an empty map without any preceding whitespace.
   749  			if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace) && !xe.Tokens.Last.NeedObjectName() {
   750  				xe.Buf = append(xe.Tokens.MayAppendDelim(xe.Buf, '{'), "{}"...)
   751  				xe.Tokens.Last.Increment()
   752  				if xe.NeedFlush() {
   753  					return xe.Flush()
   754  				}
   755  				return nil
   756  			}
   757  		}
   758  
   759  		once.Do(init)
   760  		if err := enc.WriteToken(jsontext.BeginObject); err != nil {
   761  			return err
   762  		}
   763  		if n > 0 {
   764  			nonDefaultKey := keyFncs.nonDefault
   765  			marshalKey := keyFncs.marshal
   766  			marshalVal := valFncs.marshal
   767  			if mo.Marshalers != nil {
   768  				var ok bool
   769  				marshalKey, ok = mo.Marshalers.(*Marshalers).lookup(marshalKey, t.Key())
   770  				marshalVal, _ = mo.Marshalers.(*Marshalers).lookup(marshalVal, t.Elem())
   771  				nonDefaultKey = nonDefaultKey || ok
   772  			}
   773  			k := newAddressableValue(t.Key())
   774  			v := newAddressableValue(t.Elem())
   775  
   776  			// A Go map guarantees that each entry has a unique key.
   777  			// As such, disable the expensive duplicate name check if we know
   778  			// that every Go key will serialize as a unique JSON string.
   779  			if !nonDefaultKey && mapKeyWithUniqueRepresentation(k.Kind(), mo.Flags.Get(jsonflags.AllowInvalidUTF8)) {
   780  				xe.Tokens.Last.DisableNamespace()
   781  			}
   782  
   783  			switch {
   784  			case !mo.Flags.Get(jsonflags.Deterministic) || n <= 1:
   785  				for iter := va.Value.MapRange(); iter.Next(); {
   786  					k.SetIterKey(iter)
   787  					err := marshalKey(enc, k, mo)
   788  					if err != nil {
   789  						if mo.Flags.Get(jsonflags.CallMethodsWithLegacySemantics) &&
   790  							errors.Is(err, jsontext.ErrNonStringName) && nillableLegacyKey && k.IsNil() {
   791  							err = enc.WriteToken(jsontext.String(""))
   792  						}
   793  						if err != nil {
   794  							if serr, ok := err.(*jsontext.SyntacticError); ok && serr.Err == jsontext.ErrNonStringName {
   795  								err = newMarshalErrorBefore(enc, k.Type(), err)
   796  							}
   797  							return err
   798  						}
   799  					}
   800  					v.SetIterValue(iter)
   801  					if err := marshalVal(enc, v, mo); err != nil {
   802  						return err
   803  					}
   804  				}
   805  			case !nonDefaultKey && t.Key().Kind() == reflect.String:
   806  				names := getStrings(n)
   807  				for i, iter := 0, va.Value.MapRange(); i < n && iter.Next(); i++ {
   808  					k.SetIterKey(iter)
   809  					(*names)[i] = k.String()
   810  				}
   811  				names.Sort()
   812  				for _, name := range *names {
   813  					if err := enc.WriteToken(jsontext.String(name)); err != nil {
   814  						return err
   815  					}
   816  					// TODO(https://go.dev/issue/57061): Use v.SetMapIndexOf.
   817  					k.SetString(name)
   818  					v.Set(va.MapIndex(k.Value))
   819  					if err := marshalVal(enc, v, mo); err != nil {
   820  						return err
   821  					}
   822  				}
   823  				putStrings(names)
   824  			default:
   825  				type member struct {
   826  					name string // unquoted name
   827  					key  addressableValue
   828  					val  addressableValue
   829  				}
   830  				members := make([]member, n)
   831  				keys := reflect.MakeSlice(reflect.SliceOf(t.Key()), n, n)
   832  				vals := reflect.MakeSlice(reflect.SliceOf(t.Elem()), n, n)
   833  				for i, iter := 0, va.Value.MapRange(); i < n && iter.Next(); i++ {
   834  					// Marshal the member name.
   835  					k := addressableValue{keys.Index(i), true} // indexed slice element is always addressable
   836  					k.SetIterKey(iter)
   837  					v := addressableValue{vals.Index(i), true} // indexed slice element is always addressable
   838  					v.SetIterValue(iter)
   839  					err := marshalKey(enc, k, mo)
   840  					if err != nil {
   841  						if mo.Flags.Get(jsonflags.CallMethodsWithLegacySemantics) &&
   842  							errors.Is(err, jsontext.ErrNonStringName) && nillableLegacyKey && k.IsNil() {
   843  							err = enc.WriteToken(jsontext.String(""))
   844  						}
   845  						if err != nil {
   846  							if serr, ok := err.(*jsontext.SyntacticError); ok && serr.Err == jsontext.ErrNonStringName {
   847  								err = newMarshalErrorBefore(enc, k.Type(), err)
   848  							}
   849  							return err
   850  						}
   851  					}
   852  					name := xe.UnwriteOnlyObjectMemberName()
   853  					members[i] = member{name, k, v}
   854  				}
   855  				// TODO: If AllowDuplicateNames is enabled, then sort according
   856  				// to reflect.Value as well if the names are equal.
   857  				// See internal/fmtsort.
   858  				slices.SortFunc(members, func(x, y member) int {
   859  					return strings.Compare(x.name, y.name)
   860  				})
   861  				for _, member := range members {
   862  					if err := enc.WriteToken(jsontext.String(member.name)); err != nil {
   863  						return err
   864  					}
   865  					if err := marshalVal(enc, member.val, mo); err != nil {
   866  						return err
   867  					}
   868  				}
   869  			}
   870  		}
   871  		if err := enc.WriteToken(jsontext.EndObject); err != nil {
   872  			return err
   873  		}
   874  		return nil
   875  	}
   876  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
   877  		xd := export.Decoder(dec)
   878  		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
   879  			switch uo.Format {
   880  			case "emitnull", "emitempty":
   881  				uo.Format = "" // only relevant for marshaling
   882  			default:
   883  				return newInvalidFormatError(dec, t, uo)
   884  			}
   885  		}
   886  		tok, err := dec.ReadToken()
   887  		if err != nil {
   888  			return err
   889  		}
   890  		k := tok.Kind()
   891  		switch k {
   892  		case 'n':
   893  			va.SetZero()
   894  			return nil
   895  		case '{':
   896  			once.Do(init)
   897  			if va.IsNil() {
   898  				va.Set(reflect.MakeMap(t))
   899  			}
   900  
   901  			nonDefaultKey := keyFncs.nonDefault
   902  			unmarshalKey := keyFncs.unmarshal
   903  			unmarshalVal := valFncs.unmarshal
   904  			if uo.Unmarshalers != nil {
   905  				var ok bool
   906  				unmarshalKey, ok = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshalKey, t.Key())
   907  				unmarshalVal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshalVal, t.Elem())
   908  				nonDefaultKey = nonDefaultKey || ok
   909  			}
   910  			k := newAddressableValue(t.Key())
   911  			v := newAddressableValue(t.Elem())
   912  
   913  			// Manually check for duplicate entries by virtue of whether the
   914  			// unmarshaled key already exists in the destination Go map.
   915  			// Consequently, syntactically different names (e.g., "0" and "-0")
   916  			// will be rejected as duplicates since they semantically refer
   917  			// to the same Go value. This is an unusual interaction
   918  			// between syntax and semantics, but is more correct.
   919  			if !nonDefaultKey && mapKeyWithUniqueRepresentation(k.Kind(), uo.Flags.Get(jsonflags.AllowInvalidUTF8)) {
   920  				xd.Tokens.Last.DisableNamespace()
   921  			}
   922  
   923  			// In the rare case where the map is not already empty,
   924  			// then we need to manually track which keys we already saw
   925  			// since existing presence alone is insufficient to indicate
   926  			// whether the input had a duplicate name.
   927  			var seen reflect.Value
   928  			if !uo.Flags.Get(jsonflags.AllowDuplicateNames) && va.Len() > 0 {
   929  				seen = reflect.MakeMap(reflect.MapOf(k.Type(), emptyStructType))
   930  			}
   931  
   932  			var errUnmarshal error
   933  			for dec.PeekKind() != '}' {
   934  				// Unmarshal the map entry key.
   935  				k.SetZero()
   936  				err := unmarshalKey(dec, k, uo)
   937  				if err != nil {
   938  					if isFatalError(err, uo.Flags) {
   939  						return err
   940  					}
   941  					if err := dec.SkipValue(); err != nil {
   942  						return err
   943  					}
   944  					errUnmarshal = cmp.Or(errUnmarshal, err)
   945  					continue
   946  				}
   947  				if k.Kind() == reflect.Interface && !k.IsNil() && !k.Elem().Type().Comparable() {
   948  					err := newUnmarshalErrorAfter(dec, t, fmt.Errorf("invalid incomparable key type %v", k.Elem().Type()))
   949  					if !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
   950  						return err
   951  					}
   952  					if err2 := dec.SkipValue(); err2 != nil {
   953  						return err2
   954  					}
   955  					errUnmarshal = cmp.Or(errUnmarshal, err)
   956  					continue
   957  				}
   958  
   959  				// Check if a pre-existing map entry value exists for this key.
   960  				if v2 := va.MapIndex(k.Value); v2.IsValid() {
   961  					if !uo.Flags.Get(jsonflags.AllowDuplicateNames) && (!seen.IsValid() || seen.MapIndex(k.Value).IsValid()) {
   962  						// TODO: Unread the object name.
   963  						name := xd.PreviousTokenOrValue()
   964  						return newDuplicateNameError(dec.StackPointer(), nil, dec.InputOffset()-len64(name))
   965  					}
   966  					if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
   967  						v.Set(v2)
   968  					} else {
   969  						v.SetZero()
   970  					}
   971  				} else {
   972  					v.SetZero()
   973  				}
   974  
   975  				// Unmarshal the map entry value.
   976  				err = unmarshalVal(dec, v, uo)
   977  				va.SetMapIndex(k.Value, v.Value)
   978  				if seen.IsValid() {
   979  					seen.SetMapIndex(k.Value, reflect.Zero(emptyStructType))
   980  				}
   981  				if err != nil {
   982  					if isFatalError(err, uo.Flags) {
   983  						return err
   984  					}
   985  					errUnmarshal = cmp.Or(errUnmarshal, err)
   986  				}
   987  			}
   988  			if _, err := dec.ReadToken(); err != nil {
   989  				return err
   990  			}
   991  			return errUnmarshal
   992  		}
   993  		return newUnmarshalErrorAfterWithSkipping(dec, uo, t, nil)
   994  	}
   995  	return &fncs
   996  }
   997  
   998  // mapKeyWithUniqueRepresentation reports whether all possible values of k
   999  // marshal to a different JSON value, and whether all possible JSON values
  1000  // that can unmarshal into k unmarshal to different Go values.
  1001  // In other words, the representation must be a bijective.
  1002  func mapKeyWithUniqueRepresentation(k reflect.Kind, allowInvalidUTF8 bool) bool {
  1003  	switch k {
  1004  	case reflect.Bool,
  1005  		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
  1006  		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
  1007  		return true
  1008  	case reflect.String:
  1009  		// For strings, we have to be careful since names with invalid UTF-8
  1010  		// maybe unescape to the same Go string value.
  1011  		return !allowInvalidUTF8
  1012  	default:
  1013  		// Floating-point kinds are not listed above since NaNs
  1014  		// can appear multiple times and all serialize as "NaN".
  1015  		return false
  1016  	}
  1017  }
  1018  
  1019  var errNilField = errors.New("cannot set embedded pointer to unexported struct type")
  1020  
  1021  func makeStructArshaler(t reflect.Type) *arshaler {
  1022  	// NOTE: The logic below disables namespaces for tracking duplicate names
  1023  	// and does the tracking locally with an efficient bit-set based on which
  1024  	// Go struct fields were seen.
  1025  
  1026  	var fncs arshaler
  1027  	var (
  1028  		once    sync.Once
  1029  		fields  structFields
  1030  		errInit *SemanticError
  1031  	)
  1032  	init := func() {
  1033  		fields, errInit = makeStructFields(t)
  1034  	}
  1035  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
  1036  		xe := export.Encoder(enc)
  1037  		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
  1038  			return newInvalidFormatError(enc, t, mo)
  1039  		}
  1040  		once.Do(init)
  1041  		if errInit != nil && !mo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
  1042  			return newMarshalErrorBefore(enc, errInit.GoType, errInit.Err)
  1043  		}
  1044  		if err := enc.WriteToken(jsontext.BeginObject); err != nil {
  1045  			return err
  1046  		}
  1047  		var seenIdxs uintSet
  1048  		prevIdx := -1
  1049  		xe.Tokens.Last.DisableNamespace() // we manually ensure unique names below
  1050  		for i := range fields.flattened {
  1051  			f := &fields.flattened[i]
  1052  			v := addressableValue{va.Field(f.index0), va.forcedAddr} // addressable if struct value is addressable
  1053  			if len(f.index) > 0 {
  1054  				v = v.fieldByIndex(f.index, false)
  1055  				if !v.IsValid() {
  1056  					continue // implies a nil inlined field
  1057  				}
  1058  			}
  1059  
  1060  			// OmitZero skips the field if the Go value is zero,
  1061  			// which we can determine up front without calling the marshaler.
  1062  			if (f.omitzero || mo.Flags.Get(jsonflags.OmitZeroStructFields)) &&
  1063  				((f.isZero == nil && v.IsZero()) || (f.isZero != nil && f.isZero(v))) {
  1064  				continue
  1065  			}
  1066  
  1067  			// Check for the legacy definition of omitempty.
  1068  			if f.omitempty && mo.Flags.Get(jsonflags.OmitEmptyWithLegacyDefinition) && isLegacyEmpty(v) {
  1069  				continue
  1070  			}
  1071  
  1072  			marshal := f.fncs.marshal
  1073  			nonDefault := f.fncs.nonDefault
  1074  			if mo.Marshalers != nil {
  1075  				var ok bool
  1076  				marshal, ok = mo.Marshalers.(*Marshalers).lookup(marshal, f.typ)
  1077  				nonDefault = nonDefault || ok
  1078  			}
  1079  
  1080  			// OmitEmpty skips the field if the marshaled JSON value is empty,
  1081  			// which we can know up front if there are no custom marshalers,
  1082  			// otherwise we must marshal the value and unwrite it if empty.
  1083  			if f.omitempty && !mo.Flags.Get(jsonflags.OmitEmptyWithLegacyDefinition) &&
  1084  				!nonDefault && f.isEmpty != nil && f.isEmpty(v) {
  1085  				continue // fast path for omitempty
  1086  			}
  1087  
  1088  			// Write the object member name.
  1089  			//
  1090  			// The logic below is semantically equivalent to:
  1091  			//	enc.WriteToken(String(f.name))
  1092  			// but specialized and simplified because:
  1093  			//	1. The Encoder must be expecting an object name.
  1094  			//	2. The object namespace is guaranteed to be disabled.
  1095  			//	3. The object name is guaranteed to be valid and pre-escaped.
  1096  			//	4. There is no need to flush the buffer (for unwrite purposes).
  1097  			//	5. There is no possibility of an error occurring.
  1098  			if optimizeCommon {
  1099  				// Append any delimiters or optional whitespace.
  1100  				b := xe.Buf
  1101  				if xe.Tokens.Last.Length() > 0 {
  1102  					b = append(b, ',')
  1103  					if mo.Flags.Get(jsonflags.SpaceAfterComma) {
  1104  						b = append(b, ' ')
  1105  					}
  1106  				}
  1107  				if mo.Flags.Get(jsonflags.Multiline) {
  1108  					b = xe.AppendIndent(b, xe.Tokens.NeedIndent('"'))
  1109  				}
  1110  
  1111  				// Append the token to the output and to the state machine.
  1112  				n0 := len(b) // offset before calling AppendQuote
  1113  				if !f.nameNeedEscape {
  1114  					b = append(b, f.quotedName...)
  1115  				} else {
  1116  					b, _ = jsonwire.AppendQuote(b, f.name, &mo.Flags)
  1117  				}
  1118  				xe.Buf = b
  1119  				xe.Names.ReplaceLastQuotedOffset(n0)
  1120  				xe.Tokens.Last.Increment()
  1121  			} else {
  1122  				if err := enc.WriteToken(jsontext.String(f.name)); err != nil {
  1123  					return err
  1124  				}
  1125  			}
  1126  
  1127  			// Write the object member value.
  1128  			flagsOriginal := mo.Flags
  1129  			if f.string {
  1130  				if !mo.Flags.Get(jsonflags.StringifyWithLegacySemantics) {
  1131  					mo.Flags.Set(jsonflags.StringifyNumbers | 1)
  1132  				} else if canLegacyStringify(f.typ) {
  1133  					mo.Flags.Set(jsonflags.StringifyNumbers | jsonflags.StringifyBoolsAndStrings | 1)
  1134  				}
  1135  			}
  1136  			if f.format != "" {
  1137  				mo.FormatDepth = xe.Tokens.Depth()
  1138  				mo.Format = f.format
  1139  			}
  1140  			err := marshal(enc, v, mo)
  1141  			mo.Flags = flagsOriginal
  1142  			mo.Format = ""
  1143  			if err != nil {
  1144  				return err
  1145  			}
  1146  
  1147  			// Try unwriting the member if empty (slow path for omitempty).
  1148  			if f.omitempty && !mo.Flags.Get(jsonflags.OmitEmptyWithLegacyDefinition) {
  1149  				var prevName *string
  1150  				if prevIdx >= 0 {
  1151  					prevName = &fields.flattened[prevIdx].name
  1152  				}
  1153  				if xe.UnwriteEmptyObjectMember(prevName) {
  1154  					continue
  1155  				}
  1156  			}
  1157  
  1158  			// Remember the previous written object member.
  1159  			// The set of seen fields only needs to be updated to detect
  1160  			// duplicate names with those from the inlined fallback.
  1161  			if !mo.Flags.Get(jsonflags.AllowDuplicateNames) && fields.inlinedFallback != nil {
  1162  				seenIdxs.insert(uint(f.id))
  1163  			}
  1164  			prevIdx = f.id
  1165  		}
  1166  		if fields.inlinedFallback != nil && !(mo.Flags.Get(jsonflags.DiscardUnknownMembers) && fields.inlinedFallback.unknown) {
  1167  			var insertUnquotedName func([]byte) bool
  1168  			if !mo.Flags.Get(jsonflags.AllowDuplicateNames) {
  1169  				insertUnquotedName = func(name []byte) bool {
  1170  					// Check that the name from inlined fallback does not match
  1171  					// one of the previously marshaled names from known fields.
  1172  					if foldedFields := fields.lookupByFoldedName(name); len(foldedFields) > 0 {
  1173  						if f := fields.byActualName[string(name)]; f != nil {
  1174  							return seenIdxs.insert(uint(f.id))
  1175  						}
  1176  						for _, f := range foldedFields {
  1177  							if f.matchFoldedName(name, &mo.Flags) {
  1178  								return seenIdxs.insert(uint(f.id))
  1179  							}
  1180  						}
  1181  					}
  1182  
  1183  					// Check that the name does not match any other name
  1184  					// previously marshaled from the inlined fallback.
  1185  					return xe.Namespaces.Last().InsertUnquoted(name)
  1186  				}
  1187  			}
  1188  			if err := marshalInlinedFallbackAll(enc, va, mo, fields.inlinedFallback, insertUnquotedName); err != nil {
  1189  				return err
  1190  			}
  1191  		}
  1192  		if err := enc.WriteToken(jsontext.EndObject); err != nil {
  1193  			return err
  1194  		}
  1195  		return nil
  1196  	}
  1197  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
  1198  		xd := export.Decoder(dec)
  1199  		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
  1200  			return newInvalidFormatError(dec, t, uo)
  1201  		}
  1202  		tok, err := dec.ReadToken()
  1203  		if err != nil {
  1204  			return err
  1205  		}
  1206  		k := tok.Kind()
  1207  		switch k {
  1208  		case 'n':
  1209  			if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
  1210  				va.SetZero()
  1211  			}
  1212  			return nil
  1213  		case '{':
  1214  			once.Do(init)
  1215  			if errInit != nil && !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
  1216  				return newUnmarshalErrorAfter(dec, errInit.GoType, errInit.Err)
  1217  			}
  1218  			var seenIdxs uintSet
  1219  			xd.Tokens.Last.DisableNamespace()
  1220  			var errUnmarshal error
  1221  			for dec.PeekKind() != '}' {
  1222  				// Process the object member name.
  1223  				var flags jsonwire.ValueFlags
  1224  				val, err := xd.ReadValue(&flags)
  1225  				if err != nil {
  1226  					return err
  1227  				}
  1228  				name := jsonwire.UnquoteMayCopy(val, flags.IsVerbatim())
  1229  				f := fields.byActualName[string(name)]
  1230  				if f == nil {
  1231  					for _, f2 := range fields.lookupByFoldedName(name) {
  1232  						if f2.matchFoldedName(name, &uo.Flags) {
  1233  							f = f2
  1234  							break
  1235  						}
  1236  					}
  1237  					if f == nil {
  1238  						if uo.Flags.Get(jsonflags.RejectUnknownMembers) && (fields.inlinedFallback == nil || fields.inlinedFallback.unknown) {
  1239  							err := newUnmarshalErrorAfter(dec, t, ErrUnknownName)
  1240  							if !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
  1241  								return err
  1242  							}
  1243  							errUnmarshal = cmp.Or(errUnmarshal, err)
  1244  						}
  1245  						if !uo.Flags.Get(jsonflags.AllowDuplicateNames) && !xd.Namespaces.Last().InsertUnquoted(name) {
  1246  							// TODO: Unread the object name.
  1247  							return newDuplicateNameError(dec.StackPointer(), nil, dec.InputOffset()-len64(val))
  1248  						}
  1249  
  1250  						if fields.inlinedFallback == nil {
  1251  							// Skip unknown value since we have no place to store it.
  1252  							if err := dec.SkipValue(); err != nil {
  1253  								return err
  1254  							}
  1255  						} else {
  1256  							// Marshal into value capable of storing arbitrary object members.
  1257  							if err := unmarshalInlinedFallbackNext(dec, va, uo, fields.inlinedFallback, val, name); err != nil {
  1258  								if isFatalError(err, uo.Flags) {
  1259  									return err
  1260  								}
  1261  								errUnmarshal = cmp.Or(errUnmarshal, err)
  1262  							}
  1263  						}
  1264  						continue
  1265  					}
  1266  				}
  1267  				if !uo.Flags.Get(jsonflags.AllowDuplicateNames) && !seenIdxs.insert(uint(f.id)) {
  1268  					// TODO: Unread the object name.
  1269  					return newDuplicateNameError(dec.StackPointer(), nil, dec.InputOffset()-len64(val))
  1270  				}
  1271  
  1272  				// Process the object member value.
  1273  				unmarshal := f.fncs.unmarshal
  1274  				if uo.Unmarshalers != nil {
  1275  					unmarshal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshal, f.typ)
  1276  				}
  1277  				flagsOriginal := uo.Flags
  1278  				if f.string {
  1279  					if !uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) {
  1280  						uo.Flags.Set(jsonflags.StringifyNumbers | 1)
  1281  					} else if canLegacyStringify(f.typ) {
  1282  						uo.Flags.Set(jsonflags.StringifyNumbers | jsonflags.StringifyBoolsAndStrings | 1)
  1283  					}
  1284  				}
  1285  				if f.format != "" {
  1286  					uo.FormatDepth = xd.Tokens.Depth()
  1287  					uo.Format = f.format
  1288  				}
  1289  				v := addressableValue{va.Field(f.index0), va.forcedAddr} // addressable if struct value is addressable
  1290  				if len(f.index) > 0 {
  1291  					v = v.fieldByIndex(f.index, true)
  1292  					if !v.IsValid() {
  1293  						err := newUnmarshalErrorBefore(dec, t, errNilField)
  1294  						if !uo.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
  1295  							return err
  1296  						}
  1297  						errUnmarshal = cmp.Or(errUnmarshal, err)
  1298  						unmarshal = func(dec *jsontext.Decoder, _ addressableValue, _ *jsonopts.Struct) error {
  1299  							return dec.SkipValue()
  1300  						}
  1301  					}
  1302  				}
  1303  				err = unmarshal(dec, v, uo)
  1304  				uo.Flags = flagsOriginal
  1305  				uo.Format = ""
  1306  				if err != nil {
  1307  					if isFatalError(err, uo.Flags) {
  1308  						return err
  1309  					}
  1310  					errUnmarshal = cmp.Or(errUnmarshal, err)
  1311  				}
  1312  			}
  1313  			if _, err := dec.ReadToken(); err != nil {
  1314  				return err
  1315  			}
  1316  			return errUnmarshal
  1317  		}
  1318  		return newUnmarshalErrorAfterWithSkipping(dec, uo, t, nil)
  1319  	}
  1320  	return &fncs
  1321  }
  1322  
  1323  func (va addressableValue) fieldByIndex(index []int, mayAlloc bool) addressableValue {
  1324  	for _, i := range index {
  1325  		va = va.indirect(mayAlloc)
  1326  		if !va.IsValid() {
  1327  			return va
  1328  		}
  1329  		va = addressableValue{va.Field(i), va.forcedAddr} // addressable if struct value is addressable
  1330  	}
  1331  	return va
  1332  }
  1333  
  1334  func (va addressableValue) indirect(mayAlloc bool) addressableValue {
  1335  	if va.Kind() == reflect.Pointer {
  1336  		if va.IsNil() {
  1337  			if !mayAlloc || !va.CanSet() {
  1338  				return addressableValue{}
  1339  			}
  1340  			va.Set(reflect.New(va.Type().Elem()))
  1341  		}
  1342  		va = addressableValue{va.Elem(), false} // dereferenced pointer is always addressable
  1343  	}
  1344  	return va
  1345  }
  1346  
  1347  // isLegacyEmpty reports whether a value is empty according to the v1 definition.
  1348  func isLegacyEmpty(v addressableValue) bool {
  1349  	// Equivalent to encoding/json.isEmptyValue@v1.21.0.
  1350  	switch v.Kind() {
  1351  	case reflect.Bool:
  1352  		return v.Bool() == false
  1353  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
  1354  		return v.Int() == 0
  1355  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
  1356  		return v.Uint() == 0
  1357  	case reflect.Float32, reflect.Float64:
  1358  		return v.Float() == 0
  1359  	case reflect.String, reflect.Map, reflect.Slice, reflect.Array:
  1360  		return v.Len() == 0
  1361  	case reflect.Pointer, reflect.Interface:
  1362  		return v.IsNil()
  1363  	}
  1364  	return false
  1365  }
  1366  
  1367  // canLegacyStringify reports whether t can be stringified according to v1,
  1368  // where t is a bool, string, or number (or unnamed pointer to such).
  1369  // In v1, the `string` option does not apply recursively to nested types within
  1370  // a composite Go type (e.g., an array, slice, struct, map, or interface).
  1371  func canLegacyStringify(t reflect.Type) bool {
  1372  	// Based on encoding/json.typeFields#L1126-L1143@v1.23.0
  1373  	if t.Name() == "" && t.Kind() == reflect.Ptr {
  1374  		t = t.Elem()
  1375  	}
  1376  	switch t.Kind() {
  1377  	case reflect.Bool, reflect.String,
  1378  		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
  1379  		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr,
  1380  		reflect.Float32, reflect.Float64:
  1381  		return true
  1382  	}
  1383  	return false
  1384  }
  1385  
  1386  func makeSliceArshaler(t reflect.Type) *arshaler {
  1387  	var fncs arshaler
  1388  	var (
  1389  		once    sync.Once
  1390  		valFncs *arshaler
  1391  	)
  1392  	init := func() {
  1393  		valFncs = lookupArshaler(t.Elem())
  1394  	}
  1395  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
  1396  		// Check for cycles.
  1397  		xe := export.Encoder(enc)
  1398  		if xe.Tokens.Depth() > startDetectingCyclesAfter {
  1399  			if err := visitPointer(&xe.SeenPointers, va.Value); err != nil {
  1400  				return newMarshalErrorBefore(enc, t, err)
  1401  			}
  1402  			defer leavePointer(&xe.SeenPointers, va.Value)
  1403  		}
  1404  
  1405  		emitNull := mo.Flags.Get(jsonflags.FormatNilSliceAsNull)
  1406  		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
  1407  			switch mo.Format {
  1408  			case "emitnull":
  1409  				emitNull = true
  1410  				mo.Format = ""
  1411  			case "emitempty":
  1412  				emitNull = false
  1413  				mo.Format = ""
  1414  			default:
  1415  				return newInvalidFormatError(enc, t, mo)
  1416  			}
  1417  		}
  1418  
  1419  		// Handle empty slices.
  1420  		n := va.Len()
  1421  		if n == 0 {
  1422  			if emitNull && va.IsNil() {
  1423  				return enc.WriteToken(jsontext.Null)
  1424  			}
  1425  			// Optimize for marshaling an empty slice without any preceding whitespace.
  1426  			if optimizeCommon && !mo.Flags.Get(jsonflags.AnyWhitespace) && !xe.Tokens.Last.NeedObjectName() {
  1427  				xe.Buf = append(xe.Tokens.MayAppendDelim(xe.Buf, '['), "[]"...)
  1428  				xe.Tokens.Last.Increment()
  1429  				if xe.NeedFlush() {
  1430  					return xe.Flush()
  1431  				}
  1432  				return nil
  1433  			}
  1434  		}
  1435  
  1436  		once.Do(init)
  1437  		if err := enc.WriteToken(jsontext.BeginArray); err != nil {
  1438  			return err
  1439  		}
  1440  		marshal := valFncs.marshal
  1441  		if mo.Marshalers != nil {
  1442  			marshal, _ = mo.Marshalers.(*Marshalers).lookup(marshal, t.Elem())
  1443  		}
  1444  		for i := range n {
  1445  			v := addressableValue{va.Index(i), false} // indexed slice element is always addressable
  1446  			if err := marshal(enc, v, mo); err != nil {
  1447  				return err
  1448  			}
  1449  		}
  1450  		if err := enc.WriteToken(jsontext.EndArray); err != nil {
  1451  			return err
  1452  		}
  1453  		return nil
  1454  	}
  1455  	emptySlice := reflect.MakeSlice(t, 0, 0)
  1456  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
  1457  		xd := export.Decoder(dec)
  1458  		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
  1459  			switch uo.Format {
  1460  			case "emitnull", "emitempty":
  1461  				uo.Format = "" // only relevant for marshaling
  1462  			default:
  1463  				return newInvalidFormatError(dec, t, uo)
  1464  			}
  1465  		}
  1466  
  1467  		tok, err := dec.ReadToken()
  1468  		if err != nil {
  1469  			return err
  1470  		}
  1471  		k := tok.Kind()
  1472  		switch k {
  1473  		case 'n':
  1474  			va.SetZero()
  1475  			return nil
  1476  		case '[':
  1477  			once.Do(init)
  1478  			unmarshal := valFncs.unmarshal
  1479  			if uo.Unmarshalers != nil {
  1480  				unmarshal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshal, t.Elem())
  1481  			}
  1482  			mustZero := true // we do not know the cleanliness of unused capacity
  1483  			cap := va.Cap()
  1484  			if cap > 0 {
  1485  				va.SetLen(cap)
  1486  			}
  1487  			var i int
  1488  			var errUnmarshal error
  1489  			for dec.PeekKind() != ']' {
  1490  				if i == cap {
  1491  					va.Value.Grow(1)
  1492  					cap = va.Cap()
  1493  					va.SetLen(cap)
  1494  					mustZero = false // reflect.Value.Grow ensures new capacity is zero-initialized
  1495  				}
  1496  				v := addressableValue{va.Index(i), false} // indexed slice element is always addressable
  1497  				i++
  1498  				if mustZero && !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
  1499  					v.SetZero()
  1500  				}
  1501  				if err := unmarshal(dec, v, uo); err != nil {
  1502  					if isFatalError(err, uo.Flags) {
  1503  						va.SetLen(i)
  1504  						return err
  1505  					}
  1506  					errUnmarshal = cmp.Or(errUnmarshal, err)
  1507  				}
  1508  			}
  1509  			if i == 0 {
  1510  				va.Set(emptySlice)
  1511  			} else {
  1512  				va.SetLen(i)
  1513  			}
  1514  			if _, err := dec.ReadToken(); err != nil {
  1515  				return err
  1516  			}
  1517  			return errUnmarshal
  1518  		}
  1519  		return newUnmarshalErrorAfterWithSkipping(dec, uo, t, nil)
  1520  	}
  1521  	return &fncs
  1522  }
  1523  
  1524  var errArrayUnderflow = errors.New("too few array elements")
  1525  var errArrayOverflow = errors.New("too many array elements")
  1526  
  1527  func makeArrayArshaler(t reflect.Type) *arshaler {
  1528  	var fncs arshaler
  1529  	var (
  1530  		once    sync.Once
  1531  		valFncs *arshaler
  1532  	)
  1533  	init := func() {
  1534  		valFncs = lookupArshaler(t.Elem())
  1535  	}
  1536  	n := t.Len()
  1537  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
  1538  		xe := export.Encoder(enc)
  1539  		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
  1540  			return newInvalidFormatError(enc, t, mo)
  1541  		}
  1542  		once.Do(init)
  1543  		if err := enc.WriteToken(jsontext.BeginArray); err != nil {
  1544  			return err
  1545  		}
  1546  		marshal := valFncs.marshal
  1547  		if mo.Marshalers != nil {
  1548  			marshal, _ = mo.Marshalers.(*Marshalers).lookup(marshal, t.Elem())
  1549  		}
  1550  		for i := range n {
  1551  			v := addressableValue{va.Index(i), va.forcedAddr} // indexed array element is addressable if array is addressable
  1552  			if err := marshal(enc, v, mo); err != nil {
  1553  				return err
  1554  			}
  1555  		}
  1556  		if err := enc.WriteToken(jsontext.EndArray); err != nil {
  1557  			return err
  1558  		}
  1559  		return nil
  1560  	}
  1561  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
  1562  		xd := export.Decoder(dec)
  1563  		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
  1564  			return newInvalidFormatError(dec, t, uo)
  1565  		}
  1566  		tok, err := dec.ReadToken()
  1567  		if err != nil {
  1568  			return err
  1569  		}
  1570  		k := tok.Kind()
  1571  		switch k {
  1572  		case 'n':
  1573  			if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
  1574  				va.SetZero()
  1575  			}
  1576  			return nil
  1577  		case '[':
  1578  			once.Do(init)
  1579  			unmarshal := valFncs.unmarshal
  1580  			if uo.Unmarshalers != nil {
  1581  				unmarshal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshal, t.Elem())
  1582  			}
  1583  			var i int
  1584  			var errUnmarshal error
  1585  			for dec.PeekKind() != ']' {
  1586  				if i >= n {
  1587  					if err := dec.SkipValue(); err != nil {
  1588  						return err
  1589  					}
  1590  					err = errArrayOverflow
  1591  					continue
  1592  				}
  1593  				v := addressableValue{va.Index(i), va.forcedAddr} // indexed array element is addressable if array is addressable
  1594  				if !uo.Flags.Get(jsonflags.MergeWithLegacySemantics) {
  1595  					v.SetZero()
  1596  				}
  1597  				if err := unmarshal(dec, v, uo); err != nil {
  1598  					if isFatalError(err, uo.Flags) {
  1599  						return err
  1600  					}
  1601  					errUnmarshal = cmp.Or(errUnmarshal, err)
  1602  				}
  1603  				i++
  1604  			}
  1605  			for ; i < n; i++ {
  1606  				va.Index(i).SetZero()
  1607  				err = errArrayUnderflow
  1608  			}
  1609  			if _, err := dec.ReadToken(); err != nil {
  1610  				return err
  1611  			}
  1612  			if err != nil && !uo.Flags.Get(jsonflags.UnmarshalArrayFromAnyLength) {
  1613  				return newUnmarshalErrorAfter(dec, t, err)
  1614  			}
  1615  			return errUnmarshal
  1616  		}
  1617  		return newUnmarshalErrorAfterWithSkipping(dec, uo, t, nil)
  1618  	}
  1619  	return &fncs
  1620  }
  1621  
  1622  func makePointerArshaler(t reflect.Type) *arshaler {
  1623  	var fncs arshaler
  1624  	var (
  1625  		once    sync.Once
  1626  		valFncs *arshaler
  1627  	)
  1628  	init := func() {
  1629  		valFncs = lookupArshaler(t.Elem())
  1630  	}
  1631  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
  1632  		// Check for cycles.
  1633  		xe := export.Encoder(enc)
  1634  		if xe.Tokens.Depth() > startDetectingCyclesAfter {
  1635  			if err := visitPointer(&xe.SeenPointers, va.Value); err != nil {
  1636  				return newMarshalErrorBefore(enc, t, err)
  1637  			}
  1638  			defer leavePointer(&xe.SeenPointers, va.Value)
  1639  		}
  1640  
  1641  		// NOTE: Struct.Format is forwarded to underlying marshal.
  1642  		if va.IsNil() {
  1643  			return enc.WriteToken(jsontext.Null)
  1644  		}
  1645  		once.Do(init)
  1646  		marshal := valFncs.marshal
  1647  		if mo.Marshalers != nil {
  1648  			marshal, _ = mo.Marshalers.(*Marshalers).lookup(marshal, t.Elem())
  1649  		}
  1650  		v := addressableValue{va.Elem(), false} // dereferenced pointer is always addressable
  1651  		return marshal(enc, v, mo)
  1652  	}
  1653  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
  1654  		// NOTE: Struct.Format is forwarded to underlying unmarshal.
  1655  		if dec.PeekKind() == 'n' {
  1656  			if _, err := dec.ReadToken(); err != nil {
  1657  				return err
  1658  			}
  1659  			va.SetZero()
  1660  			return nil
  1661  		}
  1662  		once.Do(init)
  1663  		unmarshal := valFncs.unmarshal
  1664  		if uo.Unmarshalers != nil {
  1665  			unmarshal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshal, t.Elem())
  1666  		}
  1667  		if va.IsNil() {
  1668  			va.Set(reflect.New(t.Elem()))
  1669  		}
  1670  		v := addressableValue{va.Elem(), false} // dereferenced pointer is always addressable
  1671  		if err := unmarshal(dec, v, uo); err != nil {
  1672  			return err
  1673  		}
  1674  		if uo.Flags.Get(jsonflags.StringifyWithLegacySemantics) &&
  1675  			uo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.StringifyBoolsAndStrings) {
  1676  			// A JSON null quoted within a JSON string should take effect
  1677  			// within the pointer value, rather than the indirect value.
  1678  			//
  1679  			// TODO: This does not correctly handle escaped nulls
  1680  			// (e.g., "\u006e\u0075\u006c\u006c"), but is good enough
  1681  			// for such an esoteric use case of the `string` option.
  1682  			if string(export.Decoder(dec).PreviousTokenOrValue()) == `"null"` {
  1683  				va.SetZero()
  1684  			}
  1685  		}
  1686  		return nil
  1687  	}
  1688  	return &fncs
  1689  }
  1690  
  1691  var errNilInterface = errors.New("cannot derive concrete type for nil interface with finite type set")
  1692  
  1693  func makeInterfaceArshaler(t reflect.Type) *arshaler {
  1694  	// NOTE: Values retrieved from an interface are not addressable,
  1695  	// so we shallow copy the values to make them addressable and
  1696  	// store them back into the interface afterwards.
  1697  
  1698  	var fncs arshaler
  1699  	var whichMarshaler reflect.Type
  1700  	for _, iface := range allMarshalerTypes {
  1701  		if t.Implements(iface) {
  1702  			whichMarshaler = t
  1703  			break
  1704  		}
  1705  	}
  1706  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
  1707  		xe := export.Encoder(enc)
  1708  		if mo.Format != "" && mo.FormatDepth == xe.Tokens.Depth() {
  1709  			return newInvalidFormatError(enc, t, mo)
  1710  		}
  1711  		if va.IsNil() {
  1712  			return enc.WriteToken(jsontext.Null)
  1713  		} else if mo.Flags.Get(jsonflags.CallMethodsWithLegacySemantics) && whichMarshaler != nil {
  1714  			// The marshaler for a pointer never calls the method on a nil receiver.
  1715  			// Wrap the nil pointer within a struct type so that marshal
  1716  			// instead appears on a value receiver and may be called.
  1717  			if va.Elem().Kind() == reflect.Pointer && va.Elem().IsNil() {
  1718  				v2 := newAddressableValue(whichMarshaler)
  1719  				switch whichMarshaler {
  1720  				case jsonMarshalerToType:
  1721  					v2.Set(reflect.ValueOf(struct{ MarshalerTo }{va.Elem().Interface().(MarshalerTo)}))
  1722  				case jsonMarshalerType:
  1723  					v2.Set(reflect.ValueOf(struct{ Marshaler }{va.Elem().Interface().(Marshaler)}))
  1724  				case textAppenderType:
  1725  					v2.Set(reflect.ValueOf(struct{ encoding.TextAppender }{va.Elem().Interface().(encoding.TextAppender)}))
  1726  				case textMarshalerType:
  1727  					v2.Set(reflect.ValueOf(struct{ encoding.TextMarshaler }{va.Elem().Interface().(encoding.TextMarshaler)}))
  1728  				}
  1729  				va = v2
  1730  			}
  1731  		}
  1732  		v := newAddressableValue(va.Elem().Type())
  1733  		v.Set(va.Elem())
  1734  		marshal := lookupArshaler(v.Type()).marshal
  1735  		if mo.Marshalers != nil {
  1736  			marshal, _ = mo.Marshalers.(*Marshalers).lookup(marshal, v.Type())
  1737  		}
  1738  		// Optimize for the any type if there are no special options.
  1739  		if optimizeCommon &&
  1740  			t == anyType && !mo.Flags.Get(jsonflags.StringifyNumbers|jsonflags.StringifyBoolsAndStrings) && mo.Format == "" &&
  1741  			(mo.Marshalers == nil || !mo.Marshalers.(*Marshalers).fromAny) {
  1742  			return marshalValueAny(enc, va.Elem().Interface(), mo)
  1743  		}
  1744  		return marshal(enc, v, mo)
  1745  	}
  1746  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
  1747  		xd := export.Decoder(dec)
  1748  		if uo.Format != "" && uo.FormatDepth == xd.Tokens.Depth() {
  1749  			return newInvalidFormatError(dec, t, uo)
  1750  		}
  1751  		if uo.Flags.Get(jsonflags.MergeWithLegacySemantics) && !va.IsNil() {
  1752  			// Legacy merge behavior is difficult to explain.
  1753  			// In general, it only merges for non-nil pointer kinds.
  1754  			// As a special case, unmarshaling a JSON null into a pointer
  1755  			// sets a concrete nil pointer of the underlying type
  1756  			// (rather than setting the interface value itself to nil).
  1757  			e := va.Elem()
  1758  			if e.Kind() == reflect.Pointer && !e.IsNil() {
  1759  				if dec.PeekKind() == 'n' && e.Elem().Kind() == reflect.Pointer {
  1760  					if _, err := dec.ReadToken(); err != nil {
  1761  						return err
  1762  					}
  1763  					va.Elem().Elem().SetZero()
  1764  					return nil
  1765  				}
  1766  			} else {
  1767  				va.SetZero()
  1768  			}
  1769  		}
  1770  		if dec.PeekKind() == 'n' {
  1771  			if _, err := dec.ReadToken(); err != nil {
  1772  				return err
  1773  			}
  1774  			va.SetZero()
  1775  			return nil
  1776  		}
  1777  		var v addressableValue
  1778  		if va.IsNil() {
  1779  			// Optimize for the any type if there are no special options.
  1780  			// We do not care about stringified numbers since JSON strings
  1781  			// are always unmarshaled into an any value as Go strings.
  1782  			// Duplicate name check must be enforced since unmarshalValueAny
  1783  			// does not implement merge semantics.
  1784  			if optimizeCommon &&
  1785  				t == anyType && !uo.Flags.Get(jsonflags.AllowDuplicateNames) && uo.Format == "" &&
  1786  				(uo.Unmarshalers == nil || !uo.Unmarshalers.(*Unmarshalers).fromAny) {
  1787  				v, err := unmarshalValueAny(dec, uo)
  1788  				// We must check for nil interface values up front.
  1789  				// See https://go.dev/issue/52310.
  1790  				if v != nil {
  1791  					va.Set(reflect.ValueOf(v))
  1792  				}
  1793  				return err
  1794  			}
  1795  
  1796  			k := dec.PeekKind()
  1797  			if !isAnyType(t) {
  1798  				return newUnmarshalErrorBeforeWithSkipping(dec, uo, t, errNilInterface)
  1799  			}
  1800  			switch k {
  1801  			case 'f', 't':
  1802  				v = newAddressableValue(boolType)
  1803  			case '"':
  1804  				v = newAddressableValue(stringType)
  1805  			case '0':
  1806  				if uo.Flags.Get(jsonflags.UnmarshalAnyWithRawNumber) {
  1807  					v = addressableValue{reflect.ValueOf(internal.NewRawNumber()).Elem(), true}
  1808  				} else {
  1809  					v = newAddressableValue(float64Type)
  1810  				}
  1811  			case '{':
  1812  				v = newAddressableValue(mapStringAnyType)
  1813  			case '[':
  1814  				v = newAddressableValue(sliceAnyType)
  1815  			default:
  1816  				// If k is invalid (e.g., due to an I/O or syntax error), then
  1817  				// that will be cached by PeekKind and returned by ReadValue.
  1818  				// If k is '}' or ']', then ReadValue must error since
  1819  				// those are invalid kinds at the start of a JSON value.
  1820  				_, err := dec.ReadValue()
  1821  				return err
  1822  			}
  1823  		} else {
  1824  			// Shallow copy the existing value to keep it addressable.
  1825  			// Any mutations at the top-level of the value will be observable
  1826  			// since we always store this value back into the interface value.
  1827  			v = newAddressableValue(va.Elem().Type())
  1828  			v.Set(va.Elem())
  1829  		}
  1830  		unmarshal := lookupArshaler(v.Type()).unmarshal
  1831  		if uo.Unmarshalers != nil {
  1832  			unmarshal, _ = uo.Unmarshalers.(*Unmarshalers).lookup(unmarshal, v.Type())
  1833  		}
  1834  		err := unmarshal(dec, v, uo)
  1835  		va.Set(v.Value)
  1836  		return err
  1837  	}
  1838  	return &fncs
  1839  }
  1840  
  1841  // isAnyType reports wether t is equivalent to the any interface type.
  1842  func isAnyType(t reflect.Type) bool {
  1843  	// This is forward compatible if the Go language permits type sets within
  1844  	// ordinary interfaces where an interface with zero methods does not
  1845  	// necessarily mean it can hold every possible Go type.
  1846  	// See https://go.dev/issue/45346.
  1847  	return t == anyType || anyType.Implements(t)
  1848  }
  1849  
  1850  func makeInvalidArshaler(t reflect.Type) *arshaler {
  1851  	var fncs arshaler
  1852  	fncs.marshal = func(enc *jsontext.Encoder, va addressableValue, mo *jsonopts.Struct) error {
  1853  		return newMarshalErrorBefore(enc, t, nil)
  1854  	}
  1855  	fncs.unmarshal = func(dec *jsontext.Decoder, va addressableValue, uo *jsonopts.Struct) error {
  1856  		return newUnmarshalErrorBefore(dec, t, nil)
  1857  	}
  1858  	return &fncs
  1859  }
  1860  
  1861  func stringOrNumberKind(isString bool) jsontext.Kind {
  1862  	if isString {
  1863  		return '"'
  1864  	} else {
  1865  		return '0'
  1866  	}
  1867  }
  1868  
  1869  type uintSet64 uint64
  1870  
  1871  func (s uintSet64) has(i uint) bool { return s&(1<<i) > 0 }
  1872  func (s *uintSet64) set(i uint)     { *s |= 1 << i }
  1873  
  1874  // uintSet is a set of unsigned integers.
  1875  // It is optimized for most integers being close to zero.
  1876  type uintSet struct {
  1877  	lo uintSet64
  1878  	hi []uintSet64
  1879  }
  1880  
  1881  // has reports whether i is in the set.
  1882  func (s *uintSet) has(i uint) bool {
  1883  	if i < 64 {
  1884  		return s.lo.has(i)
  1885  	} else {
  1886  		i -= 64
  1887  		iHi, iLo := int(i/64), i%64
  1888  		return iHi < len(s.hi) && s.hi[iHi].has(iLo)
  1889  	}
  1890  }
  1891  
  1892  // insert inserts i into the set and reports whether it was the first insertion.
  1893  func (s *uintSet) insert(i uint) bool {
  1894  	// TODO: Make this inlinable at least for the lower 64-bit case.
  1895  	if i < 64 {
  1896  		has := s.lo.has(i)
  1897  		s.lo.set(i)
  1898  		return !has
  1899  	} else {
  1900  		i -= 64
  1901  		iHi, iLo := int(i/64), i%64
  1902  		if iHi >= len(s.hi) {
  1903  			s.hi = append(s.hi, make([]uintSet64, iHi+1-len(s.hi))...)
  1904  			s.hi = s.hi[:cap(s.hi)]
  1905  		}
  1906  		has := s.hi[iHi].has(iLo)
  1907  		s.hi[iHi].set(iLo)
  1908  		return !has
  1909  	}
  1910  }
  1911  

View as plain text