Source file src/k8s.io/kube-openapi/pkg/internal/third_party/go-json-experiment/json/arshal_default.go

Documentation: k8s.io/kube-openapi/pkg/internal/third_party/go-json-experiment/json

     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  package json
     6  
     7  import (
     8  	"bytes"
     9  	"encoding/base32"
    10  	"encoding/base64"
    11  	"encoding/hex"
    12  	"errors"
    13  	"fmt"
    14  	"math"
    15  	"reflect"
    16  	"sort"
    17  	"strconv"
    18  	"sync"
    19  )
    20  
    21  // optimizeCommon specifies whether to use optimizations targeted for certain
    22  // common patterns, rather than using the slower, but more general logic.
    23  // All tests should pass regardless of whether this is true or not.
    24  const optimizeCommon = true
    25  
    26  var (
    27  	// Most natural Go type that correspond with each JSON type.
    28  	anyType          = reflect.TypeOf((*any)(nil)).Elem()            // JSON value
    29  	boolType         = reflect.TypeOf((*bool)(nil)).Elem()           // JSON bool
    30  	stringType       = reflect.TypeOf((*string)(nil)).Elem()         // JSON string
    31  	float64Type      = reflect.TypeOf((*float64)(nil)).Elem()        // JSON number
    32  	mapStringAnyType = reflect.TypeOf((*map[string]any)(nil)).Elem() // JSON object
    33  	sliceAnyType     = reflect.TypeOf((*[]any)(nil)).Elem()          // JSON array
    34  
    35  	bytesType       = reflect.TypeOf((*[]byte)(nil)).Elem()
    36  	emptyStructType = reflect.TypeOf((*struct{})(nil)).Elem()
    37  )
    38  
    39  const startDetectingCyclesAfter = 1000
    40  
    41  type seenPointers map[typedPointer]struct{}
    42  
    43  type typedPointer struct {
    44  	typ reflect.Type
    45  	ptr any // always stores unsafe.Pointer, but avoids depending on unsafe
    46  }
    47  
    48  // visit visits pointer p of type t, reporting an error if seen before.
    49  // If successfully visited, then the caller must eventually call leave.
    50  func (m *seenPointers) visit(v reflect.Value) error {
    51  	p := typedPointer{v.Type(), v.UnsafePointer()}
    52  	if _, ok := (*m)[p]; ok {
    53  		return &SemanticError{action: "marshal", GoType: p.typ, Err: errors.New("encountered a cycle")}
    54  	}
    55  	if *m == nil {
    56  		*m = make(map[typedPointer]struct{})
    57  	}
    58  	(*m)[p] = struct{}{}
    59  	return nil
    60  }
    61  func (m *seenPointers) leave(v reflect.Value) {
    62  	p := typedPointer{v.Type(), v.UnsafePointer()}
    63  	delete(*m, p)
    64  }
    65  
    66  func makeDefaultArshaler(t reflect.Type) *arshaler {
    67  	switch t.Kind() {
    68  	case reflect.Bool:
    69  		return makeBoolArshaler(t)
    70  	case reflect.String:
    71  		return makeStringArshaler(t)
    72  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
    73  		return makeIntArshaler(t)
    74  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
    75  		return makeUintArshaler(t)
    76  	case reflect.Float32, reflect.Float64:
    77  		return makeFloatArshaler(t)
    78  	case reflect.Map:
    79  		return makeMapArshaler(t)
    80  	case reflect.Struct:
    81  		return makeStructArshaler(t)
    82  	case reflect.Slice:
    83  		fncs := makeSliceArshaler(t)
    84  		if t.AssignableTo(bytesType) {
    85  			return makeBytesArshaler(t, fncs)
    86  		}
    87  		return fncs
    88  	case reflect.Array:
    89  		fncs := makeArrayArshaler(t)
    90  		if reflect.SliceOf(t.Elem()).AssignableTo(bytesType) {
    91  			return makeBytesArshaler(t, fncs)
    92  		}
    93  		return fncs
    94  	case reflect.Pointer:
    95  		return makePointerArshaler(t)
    96  	case reflect.Interface:
    97  		return makeInterfaceArshaler(t)
    98  	default:
    99  		return makeInvalidArshaler(t)
   100  	}
   101  }
   102  
   103  func makeBoolArshaler(t reflect.Type) *arshaler {
   104  	var fncs arshaler
   105  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
   106  		if mo.format != "" && mo.formatDepth == enc.tokens.depth() {
   107  			return newInvalidFormatError("marshal", t, mo.format)
   108  		}
   109  
   110  		// Optimize for marshaling without preceding whitespace.
   111  		if optimizeCommon && !enc.options.multiline && !enc.tokens.last.needObjectName() {
   112  			enc.buf = enc.tokens.mayAppendDelim(enc.buf, 't')
   113  			if va.Bool() {
   114  				enc.buf = append(enc.buf, "true"...)
   115  			} else {
   116  				enc.buf = append(enc.buf, "false"...)
   117  			}
   118  			enc.tokens.last.increment()
   119  			if enc.needFlush() {
   120  				return enc.flush()
   121  			}
   122  			return nil
   123  		}
   124  
   125  		return enc.WriteToken(Bool(va.Bool()))
   126  	}
   127  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
   128  		if uo.format != "" && uo.formatDepth == dec.tokens.depth() {
   129  			return newInvalidFormatError("unmarshal", t, uo.format)
   130  		}
   131  		tok, err := dec.ReadToken()
   132  		if err != nil {
   133  			return err
   134  		}
   135  		k := tok.Kind()
   136  		switch k {
   137  		case 'n':
   138  			va.SetBool(false)
   139  			return nil
   140  		case 't', 'f':
   141  			va.SetBool(tok.Bool())
   142  			return nil
   143  		}
   144  		return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t}
   145  	}
   146  	return &fncs
   147  }
   148  
   149  func makeStringArshaler(t reflect.Type) *arshaler {
   150  	var fncs arshaler
   151  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
   152  		if mo.format != "" && mo.formatDepth == enc.tokens.depth() {
   153  			return newInvalidFormatError("marshal", t, mo.format)
   154  		}
   155  		return enc.WriteToken(String(va.String()))
   156  	}
   157  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
   158  		if uo.format != "" && uo.formatDepth == dec.tokens.depth() {
   159  			return newInvalidFormatError("unmarshal", t, uo.format)
   160  		}
   161  		var flags valueFlags
   162  		val, err := dec.readValue(&flags)
   163  		if err != nil {
   164  			return err
   165  		}
   166  		k := val.Kind()
   167  		switch k {
   168  		case 'n':
   169  			va.SetString("")
   170  			return nil
   171  		case '"':
   172  			val = unescapeStringMayCopy(val, flags.isVerbatim())
   173  			if dec.stringCache == nil {
   174  				dec.stringCache = new(stringCache)
   175  			}
   176  			str := dec.stringCache.make(val)
   177  			va.SetString(str)
   178  			return nil
   179  		}
   180  		return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t}
   181  	}
   182  	return &fncs
   183  }
   184  
   185  var (
   186  	encodeBase16        = func(dst, src []byte) { hex.Encode(dst, src) }
   187  	encodeBase32        = base32.StdEncoding.Encode
   188  	encodeBase32Hex     = base32.HexEncoding.Encode
   189  	encodeBase64        = base64.StdEncoding.Encode
   190  	encodeBase64URL     = base64.URLEncoding.Encode
   191  	encodedLenBase16    = hex.EncodedLen
   192  	encodedLenBase32    = base32.StdEncoding.EncodedLen
   193  	encodedLenBase32Hex = base32.HexEncoding.EncodedLen
   194  	encodedLenBase64    = base64.StdEncoding.EncodedLen
   195  	encodedLenBase64URL = base64.URLEncoding.EncodedLen
   196  	decodeBase16        = hex.Decode
   197  	decodeBase32        = base32.StdEncoding.Decode
   198  	decodeBase32Hex     = base32.HexEncoding.Decode
   199  	decodeBase64        = base64.StdEncoding.Decode
   200  	decodeBase64URL     = base64.URLEncoding.Decode
   201  	decodedLenBase16    = hex.DecodedLen
   202  	decodedLenBase32    = base32.StdEncoding.WithPadding(base32.NoPadding).DecodedLen
   203  	decodedLenBase32Hex = base32.HexEncoding.WithPadding(base32.NoPadding).DecodedLen
   204  	decodedLenBase64    = base64.StdEncoding.WithPadding(base64.NoPadding).DecodedLen
   205  	decodedLenBase64URL = base64.URLEncoding.WithPadding(base64.NoPadding).DecodedLen
   206  )
   207  
   208  func makeBytesArshaler(t reflect.Type, fncs *arshaler) *arshaler {
   209  	// NOTE: This handles both []byte and [N]byte.
   210  	marshalDefault := fncs.marshal
   211  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
   212  		encode, encodedLen := encodeBase64, encodedLenBase64
   213  		if mo.format != "" && mo.formatDepth == enc.tokens.depth() {
   214  			switch mo.format {
   215  			case "base64":
   216  				encode, encodedLen = encodeBase64, encodedLenBase64
   217  			case "base64url":
   218  				encode, encodedLen = encodeBase64URL, encodedLenBase64URL
   219  			case "base32":
   220  				encode, encodedLen = encodeBase32, encodedLenBase32
   221  			case "base32hex":
   222  				encode, encodedLen = encodeBase32Hex, encodedLenBase32Hex
   223  			case "base16", "hex":
   224  				encode, encodedLen = encodeBase16, encodedLenBase16
   225  			case "array":
   226  				mo.format = ""
   227  				return marshalDefault(mo, enc, va)
   228  			default:
   229  				return newInvalidFormatError("marshal", t, mo.format)
   230  			}
   231  		}
   232  		val := enc.UnusedBuffer()
   233  		b := va.Bytes()
   234  		n := len(`"`) + encodedLen(len(b)) + len(`"`)
   235  		if cap(val) < n {
   236  			val = make([]byte, n)
   237  		} else {
   238  			val = val[:n]
   239  		}
   240  		val[0] = '"'
   241  		encode(val[len(`"`):len(val)-len(`"`)], b)
   242  		val[len(val)-1] = '"'
   243  		return enc.WriteValue(val)
   244  	}
   245  	unmarshalDefault := fncs.unmarshal
   246  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
   247  		decode, decodedLen, encodedLen := decodeBase64, decodedLenBase64, encodedLenBase64
   248  		if uo.format != "" && uo.formatDepth == dec.tokens.depth() {
   249  			switch uo.format {
   250  			case "base64":
   251  				decode, decodedLen, encodedLen = decodeBase64, decodedLenBase64, encodedLenBase64
   252  			case "base64url":
   253  				decode, decodedLen, encodedLen = decodeBase64URL, decodedLenBase64URL, encodedLenBase64URL
   254  			case "base32":
   255  				decode, decodedLen, encodedLen = decodeBase32, decodedLenBase32, encodedLenBase32
   256  			case "base32hex":
   257  				decode, decodedLen, encodedLen = decodeBase32Hex, decodedLenBase32Hex, encodedLenBase32Hex
   258  			case "base16", "hex":
   259  				decode, decodedLen, encodedLen = decodeBase16, decodedLenBase16, encodedLenBase16
   260  			case "array":
   261  				uo.format = ""
   262  				return unmarshalDefault(uo, dec, va)
   263  			default:
   264  				return newInvalidFormatError("unmarshal", t, uo.format)
   265  			}
   266  		}
   267  		var flags valueFlags
   268  		val, err := dec.readValue(&flags)
   269  		if err != nil {
   270  			return err
   271  		}
   272  		k := val.Kind()
   273  		switch k {
   274  		case 'n':
   275  			va.Set(reflect.Zero(t))
   276  			return nil
   277  		case '"':
   278  			val = unescapeStringMayCopy(val, flags.isVerbatim())
   279  
   280  			// For base64 and base32, decodedLen computes the maximum output size
   281  			// when given the original input size. To compute the exact size,
   282  			// adjust the input size by excluding trailing padding characters.
   283  			// This is unnecessary for base16, but also harmless.
   284  			n := len(val)
   285  			for n > 0 && val[n-1] == '=' {
   286  				n--
   287  			}
   288  			n = decodedLen(n)
   289  			b := va.Bytes()
   290  			if va.Kind() == reflect.Array {
   291  				if n != len(b) {
   292  					err := fmt.Errorf("decoded base64 length of %d mismatches array length of %d", n, len(b))
   293  					return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t, Err: err}
   294  				}
   295  			} else {
   296  				if b == nil || cap(b) < n {
   297  					b = make([]byte, n)
   298  				} else {
   299  					b = b[:n]
   300  				}
   301  			}
   302  			n2, err := decode(b, val)
   303  			if err == nil && len(val) != encodedLen(n2) {
   304  				// TODO(https://go.dev/issue/53845): RFC 4648, section 3.3,
   305  				// specifies that non-alphabet characters must be rejected.
   306  				// Unfortunately, the "base32" and "base64" packages allow
   307  				// '\r' and '\n' characters by default.
   308  				err = errors.New("illegal data at input byte " + strconv.Itoa(bytes.IndexAny(val, "\r\n")))
   309  			}
   310  			if err != nil {
   311  				return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t, Err: err}
   312  			}
   313  			if va.Kind() == reflect.Slice {
   314  				va.SetBytes(b)
   315  			}
   316  			return nil
   317  		}
   318  		return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t}
   319  	}
   320  	return fncs
   321  }
   322  
   323  func makeIntArshaler(t reflect.Type) *arshaler {
   324  	var fncs arshaler
   325  	bits := t.Bits()
   326  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
   327  		if mo.format != "" && mo.formatDepth == enc.tokens.depth() {
   328  			return newInvalidFormatError("marshal", t, mo.format)
   329  		}
   330  
   331  		// Optimize for marshaling without preceding whitespace or string escaping.
   332  		if optimizeCommon && !enc.options.multiline && !mo.StringifyNumbers && !enc.tokens.last.needObjectName() {
   333  			enc.buf = enc.tokens.mayAppendDelim(enc.buf, '0')
   334  			enc.buf = strconv.AppendInt(enc.buf, va.Int(), 10)
   335  			enc.tokens.last.increment()
   336  			if enc.needFlush() {
   337  				return enc.flush()
   338  			}
   339  			return nil
   340  		}
   341  
   342  		x := math.Float64frombits(uint64(va.Int()))
   343  		return enc.writeNumber(x, rawIntNumber, mo.StringifyNumbers)
   344  	}
   345  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
   346  		if uo.format != "" && uo.formatDepth == dec.tokens.depth() {
   347  			return newInvalidFormatError("unmarshal", t, uo.format)
   348  		}
   349  		var flags valueFlags
   350  		val, err := dec.readValue(&flags)
   351  		if err != nil {
   352  			return err
   353  		}
   354  		k := val.Kind()
   355  		switch k {
   356  		case 'n':
   357  			va.SetInt(0)
   358  			return nil
   359  		case '"':
   360  			if !uo.StringifyNumbers {
   361  				break
   362  			}
   363  			val = unescapeStringMayCopy(val, flags.isVerbatim())
   364  			fallthrough
   365  		case '0':
   366  			var negOffset int
   367  			neg := val[0] == '-'
   368  			if neg {
   369  				negOffset = 1
   370  			}
   371  			n, ok := parseDecUint(val[negOffset:])
   372  			maxInt := uint64(1) << (bits - 1)
   373  			overflow := (neg && n > maxInt) || (!neg && n > maxInt-1)
   374  			if !ok {
   375  				if n != math.MaxUint64 {
   376  					err := fmt.Errorf("cannot parse %q as signed integer: %w", val, strconv.ErrSyntax)
   377  					return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t, Err: err}
   378  				}
   379  				overflow = true
   380  			}
   381  			if overflow {
   382  				err := fmt.Errorf("cannot parse %q as signed integer: %w", val, strconv.ErrRange)
   383  				return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t, Err: err}
   384  			}
   385  			if neg {
   386  				va.SetInt(int64(-n))
   387  			} else {
   388  				va.SetInt(int64(+n))
   389  			}
   390  			return nil
   391  		}
   392  		return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t}
   393  	}
   394  	return &fncs
   395  }
   396  
   397  func makeUintArshaler(t reflect.Type) *arshaler {
   398  	var fncs arshaler
   399  	bits := t.Bits()
   400  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
   401  		if mo.format != "" && mo.formatDepth == enc.tokens.depth() {
   402  			return newInvalidFormatError("marshal", t, mo.format)
   403  		}
   404  
   405  		// Optimize for marshaling without preceding whitespace or string escaping.
   406  		if optimizeCommon && !enc.options.multiline && !mo.StringifyNumbers && !enc.tokens.last.needObjectName() {
   407  			enc.buf = enc.tokens.mayAppendDelim(enc.buf, '0')
   408  			enc.buf = strconv.AppendUint(enc.buf, va.Uint(), 10)
   409  			enc.tokens.last.increment()
   410  			if enc.needFlush() {
   411  				return enc.flush()
   412  			}
   413  			return nil
   414  		}
   415  
   416  		x := math.Float64frombits(va.Uint())
   417  		return enc.writeNumber(x, rawUintNumber, mo.StringifyNumbers)
   418  	}
   419  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
   420  		if uo.format != "" && uo.formatDepth == dec.tokens.depth() {
   421  			return newInvalidFormatError("unmarshal", t, uo.format)
   422  		}
   423  		var flags valueFlags
   424  		val, err := dec.readValue(&flags)
   425  		if err != nil {
   426  			return err
   427  		}
   428  		k := val.Kind()
   429  		switch k {
   430  		case 'n':
   431  			va.SetUint(0)
   432  			return nil
   433  		case '"':
   434  			if !uo.StringifyNumbers {
   435  				break
   436  			}
   437  			val = unescapeStringMayCopy(val, flags.isVerbatim())
   438  			fallthrough
   439  		case '0':
   440  			n, ok := parseDecUint(val)
   441  			maxUint := uint64(1) << bits
   442  			overflow := n > maxUint-1
   443  			if !ok {
   444  				if n != math.MaxUint64 {
   445  					err := fmt.Errorf("cannot parse %q as unsigned integer: %w", val, strconv.ErrSyntax)
   446  					return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t, Err: err}
   447  				}
   448  				overflow = true
   449  			}
   450  			if overflow {
   451  				err := fmt.Errorf("cannot parse %q as unsigned integer: %w", val, strconv.ErrRange)
   452  				return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t, Err: err}
   453  			}
   454  			va.SetUint(n)
   455  			return nil
   456  		}
   457  		return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t}
   458  	}
   459  	return &fncs
   460  }
   461  
   462  func makeFloatArshaler(t reflect.Type) *arshaler {
   463  	var fncs arshaler
   464  	bits := t.Bits()
   465  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
   466  		var allowNonFinite bool
   467  		if mo.format != "" && mo.formatDepth == enc.tokens.depth() {
   468  			if mo.format == "nonfinite" {
   469  				allowNonFinite = true
   470  			} else {
   471  				return newInvalidFormatError("marshal", t, mo.format)
   472  			}
   473  		}
   474  
   475  		fv := va.Float()
   476  		if math.IsNaN(fv) || math.IsInf(fv, 0) {
   477  			if !allowNonFinite {
   478  				err := fmt.Errorf("invalid value: %v", fv)
   479  				return &SemanticError{action: "marshal", GoType: t, Err: err}
   480  			}
   481  			return enc.WriteToken(Float(fv))
   482  		}
   483  
   484  		// Optimize for marshaling without preceding whitespace or string escaping.
   485  		if optimizeCommon && !enc.options.multiline && !mo.StringifyNumbers && !enc.tokens.last.needObjectName() {
   486  			enc.buf = enc.tokens.mayAppendDelim(enc.buf, '0')
   487  			enc.buf = appendNumber(enc.buf, fv, bits)
   488  			enc.tokens.last.increment()
   489  			if enc.needFlush() {
   490  				return enc.flush()
   491  			}
   492  			return nil
   493  		}
   494  
   495  		return enc.writeNumber(fv, bits, mo.StringifyNumbers)
   496  	}
   497  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
   498  		var allowNonFinite bool
   499  		if uo.format != "" && uo.formatDepth == dec.tokens.depth() {
   500  			if uo.format == "nonfinite" {
   501  				allowNonFinite = true
   502  			} else {
   503  				return newInvalidFormatError("unmarshal", t, uo.format)
   504  			}
   505  		}
   506  		var flags valueFlags
   507  		val, err := dec.readValue(&flags)
   508  		if err != nil {
   509  			return err
   510  		}
   511  		k := val.Kind()
   512  		switch k {
   513  		case 'n':
   514  			va.SetFloat(0)
   515  			return nil
   516  		case '"':
   517  			val = unescapeStringMayCopy(val, flags.isVerbatim())
   518  			if allowNonFinite {
   519  				switch string(val) {
   520  				case "NaN":
   521  					va.SetFloat(math.NaN())
   522  					return nil
   523  				case "Infinity":
   524  					va.SetFloat(math.Inf(+1))
   525  					return nil
   526  				case "-Infinity":
   527  					va.SetFloat(math.Inf(-1))
   528  					return nil
   529  				}
   530  			}
   531  			if !uo.StringifyNumbers {
   532  				break
   533  			}
   534  			if n, err := consumeNumber(val); n != len(val) || err != nil {
   535  				err := fmt.Errorf("cannot parse %q as JSON number: %w", val, strconv.ErrSyntax)
   536  				return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t, Err: err}
   537  			}
   538  			fallthrough
   539  		case '0':
   540  			// NOTE: Floating-point parsing is by nature a lossy operation.
   541  			// We never report an overflow condition since we can always
   542  			// round the input to the closest representable finite value.
   543  			// For extremely large numbers, the closest value is ±MaxFloat.
   544  			fv, _ := parseFloat(val, bits)
   545  			va.SetFloat(fv)
   546  			return nil
   547  		}
   548  		return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t}
   549  	}
   550  	return &fncs
   551  }
   552  
   553  func makeMapArshaler(t reflect.Type) *arshaler {
   554  	// NOTE: The logic below disables namespaces for tracking duplicate names
   555  	// when handling map keys with a unique representation.
   556  
   557  	// NOTE: Values retrieved from a map are not addressable,
   558  	// so we shallow copy the values to make them addressable and
   559  	// store them back into the map afterwards.
   560  
   561  	var fncs arshaler
   562  	var (
   563  		once    sync.Once
   564  		keyFncs *arshaler
   565  		valFncs *arshaler
   566  	)
   567  	init := func() {
   568  		keyFncs = lookupArshaler(t.Key())
   569  		valFncs = lookupArshaler(t.Elem())
   570  	}
   571  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
   572  		// Check for cycles.
   573  		if enc.tokens.depth() > startDetectingCyclesAfter {
   574  			if err := enc.seenPointers.visit(va.Value); err != nil {
   575  				return err
   576  			}
   577  			defer enc.seenPointers.leave(va.Value)
   578  		}
   579  
   580  		if mo.format != "" && mo.formatDepth == enc.tokens.depth() {
   581  			if mo.format == "emitnull" {
   582  				if va.IsNil() {
   583  					return enc.WriteToken(Null)
   584  				}
   585  				mo.format = ""
   586  			} else {
   587  				return newInvalidFormatError("marshal", t, mo.format)
   588  			}
   589  		}
   590  
   591  		// Optimize for marshaling an empty map without any preceding whitespace.
   592  		n := va.Len()
   593  		if optimizeCommon && n == 0 && !enc.options.multiline && !enc.tokens.last.needObjectName() {
   594  			enc.buf = enc.tokens.mayAppendDelim(enc.buf, '{')
   595  			enc.buf = append(enc.buf, "{}"...)
   596  			enc.tokens.last.increment()
   597  			if enc.needFlush() {
   598  				return enc.flush()
   599  			}
   600  			return nil
   601  		}
   602  
   603  		once.Do(init)
   604  		if err := enc.WriteToken(ObjectStart); err != nil {
   605  			return err
   606  		}
   607  		if n > 0 {
   608  			// Handle maps with numeric key types by stringifying them.
   609  			mko := mo
   610  			mko.StringifyNumbers = true
   611  
   612  			nonDefaultKey := keyFncs.nonDefault
   613  			marshalKey := keyFncs.marshal
   614  			marshalVal := valFncs.marshal
   615  			if mo.Marshalers != nil {
   616  				var ok bool
   617  				marshalKey, ok = mo.Marshalers.lookup(marshalKey, t.Key())
   618  				marshalVal, _ = mo.Marshalers.lookup(marshalVal, t.Elem())
   619  				nonDefaultKey = nonDefaultKey || ok
   620  			}
   621  			k := newAddressableValue(t.Key())
   622  			v := newAddressableValue(t.Elem())
   623  
   624  			// A Go map guarantees that each entry has a unique key.
   625  			// As such, disable the expensive duplicate name check if we know
   626  			// that every Go key will serialize as a unique JSON string.
   627  			if !nonDefaultKey && mapKeyWithUniqueRepresentation(k.Kind(), enc.options.AllowInvalidUTF8) {
   628  				enc.tokens.last.disableNamespace()
   629  			}
   630  
   631  			switch {
   632  			case !mo.Deterministic || n <= 1:
   633  				for iter := va.Value.MapRange(); iter.Next(); {
   634  					k.SetIterKey(iter)
   635  					if err := marshalKey(mko, enc, k); err != nil {
   636  						// TODO: If err is errMissingName, then wrap it as a
   637  						// SemanticError since this key type cannot be serialized
   638  						// as a JSON string.
   639  						return err
   640  					}
   641  					v.SetIterValue(iter)
   642  					if err := marshalVal(mo, enc, v); err != nil {
   643  						return err
   644  					}
   645  				}
   646  			case !nonDefaultKey && t.Key().Kind() == reflect.String:
   647  				names := getStrings(n)
   648  				for i, iter := 0, va.Value.MapRange(); i < n && iter.Next(); i++ {
   649  					k.SetIterKey(iter)
   650  					(*names)[i] = k.String()
   651  				}
   652  				names.Sort()
   653  				for _, name := range *names {
   654  					if err := enc.WriteToken(String(name)); err != nil {
   655  						return err
   656  					}
   657  					// TODO(https://go.dev/issue/57061): Use v.SetMapIndexOf.
   658  					k.SetString(name)
   659  					v.Set(va.MapIndex(k.Value))
   660  					if err := marshalVal(mo, enc, v); err != nil {
   661  						return err
   662  					}
   663  				}
   664  				putStrings(names)
   665  			default:
   666  				type member struct {
   667  					name string // unquoted name
   668  					key  addressableValue
   669  				}
   670  				members := make([]member, n)
   671  				keys := reflect.MakeSlice(reflect.SliceOf(t.Key()), n, n)
   672  				for i, iter := 0, va.Value.MapRange(); i < n && iter.Next(); i++ {
   673  					// Marshal the member name.
   674  					k := addressableValue{keys.Index(i)} // indexed slice element is always addressable
   675  					k.SetIterKey(iter)
   676  					if err := marshalKey(mko, enc, k); err != nil {
   677  						// TODO: If err is errMissingName, then wrap it as a
   678  						// SemanticError since this key type cannot be serialized
   679  						// as a JSON string.
   680  						return err
   681  					}
   682  					name := enc.unwriteOnlyObjectMemberName()
   683  					members[i] = member{name, k}
   684  				}
   685  				// TODO: If AllowDuplicateNames is enabled, then sort according
   686  				// to reflect.Value as well if the names are equal.
   687  				// See internal/fmtsort.
   688  				// TODO(https://go.dev/issue/47619): Use slices.SortFunc instead.
   689  				sort.Slice(members, func(i, j int) bool {
   690  					return lessUTF16(members[i].name, members[j].name)
   691  				})
   692  				for _, member := range members {
   693  					if err := enc.WriteToken(String(member.name)); err != nil {
   694  						return err
   695  					}
   696  					// TODO(https://go.dev/issue/57061): Use v.SetMapIndexOf.
   697  					v.Set(va.MapIndex(member.key.Value))
   698  					if err := marshalVal(mo, enc, v); err != nil {
   699  						return err
   700  					}
   701  				}
   702  			}
   703  		}
   704  		if err := enc.WriteToken(ObjectEnd); err != nil {
   705  			return err
   706  		}
   707  		return nil
   708  	}
   709  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
   710  		if uo.format != "" && uo.formatDepth == dec.tokens.depth() {
   711  			if uo.format == "emitnull" {
   712  				uo.format = "" // only relevant for marshaling
   713  			} else {
   714  				return newInvalidFormatError("unmarshal", t, uo.format)
   715  			}
   716  		}
   717  		tok, err := dec.ReadToken()
   718  		if err != nil {
   719  			return err
   720  		}
   721  		k := tok.Kind()
   722  		switch k {
   723  		case 'n':
   724  			va.Set(reflect.Zero(t))
   725  			return nil
   726  		case '{':
   727  			once.Do(init)
   728  			if va.IsNil() {
   729  				va.Set(reflect.MakeMap(t))
   730  			}
   731  
   732  			// Handle maps with numeric key types by stringifying them.
   733  			uko := uo
   734  			uko.StringifyNumbers = true
   735  
   736  			nonDefaultKey := keyFncs.nonDefault
   737  			unmarshalKey := keyFncs.unmarshal
   738  			unmarshalVal := valFncs.unmarshal
   739  			if uo.Unmarshalers != nil {
   740  				var ok bool
   741  				unmarshalKey, ok = uo.Unmarshalers.lookup(unmarshalKey, t.Key())
   742  				unmarshalVal, _ = uo.Unmarshalers.lookup(unmarshalVal, t.Elem())
   743  				nonDefaultKey = nonDefaultKey || ok
   744  			}
   745  			k := newAddressableValue(t.Key())
   746  			v := newAddressableValue(t.Elem())
   747  
   748  			// Manually check for duplicate entries by virtue of whether the
   749  			// unmarshaled key already exists in the destination Go map.
   750  			// Consequently, syntactically different names (e.g., "0" and "-0")
   751  			// will be rejected as duplicates since they semantically refer
   752  			// to the same Go value. This is an unusual interaction
   753  			// between syntax and semantics, but is more correct.
   754  			if !nonDefaultKey && mapKeyWithUniqueRepresentation(k.Kind(), dec.options.AllowInvalidUTF8) {
   755  				dec.tokens.last.disableNamespace()
   756  			}
   757  
   758  			// In the rare case where the map is not already empty,
   759  			// then we need to manually track which keys we already saw
   760  			// since existing presence alone is insufficient to indicate
   761  			// whether the input had a duplicate name.
   762  			var seen reflect.Value
   763  			if !dec.options.AllowDuplicateNames && va.Len() > 0 {
   764  				seen = reflect.MakeMap(reflect.MapOf(k.Type(), emptyStructType))
   765  			}
   766  
   767  			for dec.PeekKind() != '}' {
   768  				k.Set(reflect.Zero(t.Key()))
   769  				if err := unmarshalKey(uko, dec, k); err != nil {
   770  					return err
   771  				}
   772  				if k.Kind() == reflect.Interface && !k.IsNil() && !k.Elem().Type().Comparable() {
   773  					err := fmt.Errorf("invalid incomparable key type %v", k.Elem().Type())
   774  					return &SemanticError{action: "unmarshal", GoType: t, Err: err}
   775  				}
   776  
   777  				if v2 := va.MapIndex(k.Value); v2.IsValid() {
   778  					if !dec.options.AllowDuplicateNames && (!seen.IsValid() || seen.MapIndex(k.Value).IsValid()) {
   779  						// TODO: Unread the object name.
   780  						name := dec.previousBuffer()
   781  						err := &SyntacticError{str: "duplicate name " + string(name) + " in object"}
   782  						return err.withOffset(dec.InputOffset() - int64(len(name)))
   783  					}
   784  					v.Set(v2)
   785  				} else {
   786  					v.Set(reflect.Zero(v.Type()))
   787  				}
   788  				err := unmarshalVal(uo, dec, v)
   789  				va.SetMapIndex(k.Value, v.Value)
   790  				if seen.IsValid() {
   791  					seen.SetMapIndex(k.Value, reflect.Zero(emptyStructType))
   792  				}
   793  				if err != nil {
   794  					return err
   795  				}
   796  			}
   797  			if _, err := dec.ReadToken(); err != nil {
   798  				return err
   799  			}
   800  			return nil
   801  		}
   802  		return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t}
   803  	}
   804  	return &fncs
   805  }
   806  
   807  // mapKeyWithUniqueRepresentation reports whether all possible values of k
   808  // marshal to a different JSON value, and whether all possible JSON values
   809  // that can unmarshal into k unmarshal to different Go values.
   810  // In other words, the representation must be a bijective.
   811  func mapKeyWithUniqueRepresentation(k reflect.Kind, allowInvalidUTF8 bool) bool {
   812  	switch k {
   813  	case reflect.Bool,
   814  		reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
   815  		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
   816  		return true
   817  	case reflect.String:
   818  		// For strings, we have to be careful since names with invalid UTF-8
   819  		// maybe unescape to the same Go string value.
   820  		return !allowInvalidUTF8
   821  	default:
   822  		// Floating-point kinds are not listed above since NaNs
   823  		// can appear multiple times and all serialize as "NaN".
   824  		return false
   825  	}
   826  }
   827  
   828  func makeStructArshaler(t reflect.Type) *arshaler {
   829  	// NOTE: The logic below disables namespaces for tracking duplicate names
   830  	// and does the tracking locally with an efficient bit-set based on which
   831  	// Go struct fields were seen.
   832  
   833  	var fncs arshaler
   834  	var (
   835  		once    sync.Once
   836  		fields  structFields
   837  		errInit *SemanticError
   838  	)
   839  	init := func() {
   840  		fields, errInit = makeStructFields(t)
   841  	}
   842  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
   843  		if mo.format != "" && mo.formatDepth == enc.tokens.depth() {
   844  			return newInvalidFormatError("marshal", t, mo.format)
   845  		}
   846  		once.Do(init)
   847  		if errInit != nil {
   848  			err := *errInit // shallow copy SemanticError
   849  			err.action = "marshal"
   850  			return &err
   851  		}
   852  		if err := enc.WriteToken(ObjectStart); err != nil {
   853  			return err
   854  		}
   855  		var seenIdxs uintSet
   856  		prevIdx := -1
   857  		enc.tokens.last.disableNamespace() // we manually ensure unique names below
   858  		for i := range fields.flattened {
   859  			f := &fields.flattened[i]
   860  			v := addressableValue{va.Field(f.index[0])} // addressable if struct value is addressable
   861  			if len(f.index) > 1 {
   862  				v = v.fieldByIndex(f.index[1:], false)
   863  				if !v.IsValid() {
   864  					continue // implies a nil inlined field
   865  				}
   866  			}
   867  
   868  			// OmitZero skips the field if the Go value is zero,
   869  			// which we can determine up front without calling the marshaler.
   870  			if f.omitzero && ((f.isZero == nil && v.IsZero()) || (f.isZero != nil && f.isZero(v))) {
   871  				continue
   872  			}
   873  
   874  			marshal := f.fncs.marshal
   875  			nonDefault := f.fncs.nonDefault
   876  			if mo.Marshalers != nil {
   877  				var ok bool
   878  				marshal, ok = mo.Marshalers.lookup(marshal, f.typ)
   879  				nonDefault = nonDefault || ok
   880  			}
   881  
   882  			// OmitEmpty skips the field if the marshaled JSON value is empty,
   883  			// which we can know up front if there are no custom marshalers,
   884  			// otherwise we must marshal the value and unwrite it if empty.
   885  			if f.omitempty && !nonDefault && f.isEmpty != nil && f.isEmpty(v) {
   886  				continue // fast path for omitempty
   887  			}
   888  
   889  			// Write the object member name.
   890  			//
   891  			// The logic below is semantically equivalent to:
   892  			//	enc.WriteToken(String(f.name))
   893  			// but specialized and simplified because:
   894  			//	1. The Encoder must be expecting an object name.
   895  			//	2. The object namespace is guaranteed to be disabled.
   896  			//	3. The object name is guaranteed to be valid and pre-escaped.
   897  			//	4. There is no need to flush the buffer (for unwrite purposes).
   898  			//	5. There is no possibility of an error occurring.
   899  			if optimizeCommon {
   900  				// Append any delimiters or optional whitespace.
   901  				if enc.tokens.last.length() > 0 {
   902  					enc.buf = append(enc.buf, ',')
   903  				}
   904  				if enc.options.multiline {
   905  					enc.buf = enc.appendIndent(enc.buf, enc.tokens.needIndent('"'))
   906  				}
   907  
   908  				// Append the token to the output and to the state machine.
   909  				n0 := len(enc.buf) // offset before calling appendString
   910  				if enc.options.EscapeRune == nil {
   911  					enc.buf = append(enc.buf, f.quotedName...)
   912  				} else {
   913  					enc.buf, _ = appendString(enc.buf, f.name, false, enc.options.EscapeRune)
   914  				}
   915  				if !enc.options.AllowDuplicateNames {
   916  					enc.names.replaceLastQuotedOffset(n0)
   917  				}
   918  				enc.tokens.last.increment()
   919  			} else {
   920  				if err := enc.WriteToken(String(f.name)); err != nil {
   921  					return err
   922  				}
   923  			}
   924  
   925  			// Write the object member value.
   926  			mo2 := mo
   927  			if f.string {
   928  				mo2.StringifyNumbers = true
   929  			}
   930  			if f.format != "" {
   931  				mo2.formatDepth = enc.tokens.depth()
   932  				mo2.format = f.format
   933  			}
   934  			if err := marshal(mo2, enc, v); err != nil {
   935  				return err
   936  			}
   937  
   938  			// Try unwriting the member if empty (slow path for omitempty).
   939  			if f.omitempty {
   940  				var prevName *string
   941  				if prevIdx >= 0 {
   942  					prevName = &fields.flattened[prevIdx].name
   943  				}
   944  				if enc.unwriteEmptyObjectMember(prevName) {
   945  					continue
   946  				}
   947  			}
   948  
   949  			// Remember the previous written object member.
   950  			// The set of seen fields only needs to be updated to detect
   951  			// duplicate names with those from the inlined fallback.
   952  			if !enc.options.AllowDuplicateNames && fields.inlinedFallback != nil {
   953  				seenIdxs.insert(uint(f.id))
   954  			}
   955  			prevIdx = f.id
   956  		}
   957  		if fields.inlinedFallback != nil && !(mo.DiscardUnknownMembers && fields.inlinedFallback.unknown) {
   958  			var insertUnquotedName func([]byte) bool
   959  			if !enc.options.AllowDuplicateNames {
   960  				insertUnquotedName = func(name []byte) bool {
   961  					// Check that the name from inlined fallback does not match
   962  					// one of the previously marshaled names from known fields.
   963  					if foldedFields := fields.byFoldedName[string(foldName(name))]; len(foldedFields) > 0 {
   964  						if f := fields.byActualName[string(name)]; f != nil {
   965  							return seenIdxs.insert(uint(f.id))
   966  						}
   967  						for _, f := range foldedFields {
   968  							if f.nocase {
   969  								return seenIdxs.insert(uint(f.id))
   970  							}
   971  						}
   972  					}
   973  
   974  					// Check that the name does not match any other name
   975  					// previously marshaled from the inlined fallback.
   976  					return enc.namespaces.last().insertUnquoted(name)
   977  				}
   978  			}
   979  			if err := marshalInlinedFallbackAll(mo, enc, va, fields.inlinedFallback, insertUnquotedName); err != nil {
   980  				return err
   981  			}
   982  		}
   983  		if err := enc.WriteToken(ObjectEnd); err != nil {
   984  			return err
   985  		}
   986  		return nil
   987  	}
   988  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
   989  		if uo.format != "" && uo.formatDepth == dec.tokens.depth() {
   990  			return newInvalidFormatError("unmarshal", t, uo.format)
   991  		}
   992  		tok, err := dec.ReadToken()
   993  		if err != nil {
   994  			return err
   995  		}
   996  		k := tok.Kind()
   997  		switch k {
   998  		case 'n':
   999  			va.Set(reflect.Zero(t))
  1000  			return nil
  1001  		case '{':
  1002  			once.Do(init)
  1003  			if errInit != nil {
  1004  				err := *errInit // shallow copy SemanticError
  1005  				err.action = "unmarshal"
  1006  				return &err
  1007  			}
  1008  			var seenIdxs uintSet
  1009  			dec.tokens.last.disableNamespace()
  1010  			for dec.PeekKind() != '}' {
  1011  				// Process the object member name.
  1012  				var flags valueFlags
  1013  				val, err := dec.readValue(&flags)
  1014  				if err != nil {
  1015  					return err
  1016  				}
  1017  				name := unescapeStringMayCopy(val, flags.isVerbatim())
  1018  				f := fields.byActualName[string(name)]
  1019  				if f == nil {
  1020  					for _, f2 := range fields.byFoldedName[string(foldName(name))] {
  1021  						if f2.nocase {
  1022  							f = f2
  1023  							break
  1024  						}
  1025  					}
  1026  					if f == nil {
  1027  						if uo.RejectUnknownMembers && (fields.inlinedFallback == nil || fields.inlinedFallback.unknown) {
  1028  							return &SemanticError{action: "unmarshal", GoType: t, Err: fmt.Errorf("unknown name %s", val)}
  1029  						}
  1030  						if !dec.options.AllowDuplicateNames && !dec.namespaces.last().insertUnquoted(name) {
  1031  							// TODO: Unread the object name.
  1032  							err := &SyntacticError{str: "duplicate name " + string(val) + " in object"}
  1033  							return err.withOffset(dec.InputOffset() - int64(len(val)))
  1034  						}
  1035  
  1036  						if fields.inlinedFallback == nil {
  1037  							// Skip unknown value since we have no place to store it.
  1038  							if err := dec.SkipValue(); err != nil {
  1039  								return err
  1040  							}
  1041  						} else {
  1042  							// Marshal into value capable of storing arbitrary object members.
  1043  							if err := unmarshalInlinedFallbackNext(uo, dec, va, fields.inlinedFallback, val, name); err != nil {
  1044  								return err
  1045  							}
  1046  						}
  1047  						continue
  1048  					}
  1049  				}
  1050  				if !dec.options.AllowDuplicateNames && !seenIdxs.insert(uint(f.id)) {
  1051  					// TODO: Unread the object name.
  1052  					err := &SyntacticError{str: "duplicate name " + string(val) + " in object"}
  1053  					return err.withOffset(dec.InputOffset() - int64(len(val)))
  1054  				}
  1055  
  1056  				// Process the object member value.
  1057  				unmarshal := f.fncs.unmarshal
  1058  				if uo.Unmarshalers != nil {
  1059  					unmarshal, _ = uo.Unmarshalers.lookup(unmarshal, f.typ)
  1060  				}
  1061  				uo2 := uo
  1062  				if f.string {
  1063  					uo2.StringifyNumbers = true
  1064  				}
  1065  				if f.format != "" {
  1066  					uo2.formatDepth = dec.tokens.depth()
  1067  					uo2.format = f.format
  1068  				}
  1069  				v := addressableValue{va.Field(f.index[0])} // addressable if struct value is addressable
  1070  				if len(f.index) > 1 {
  1071  					v = v.fieldByIndex(f.index[1:], true)
  1072  				}
  1073  				if err := unmarshal(uo2, dec, v); err != nil {
  1074  					return err
  1075  				}
  1076  			}
  1077  			if _, err := dec.ReadToken(); err != nil {
  1078  				return err
  1079  			}
  1080  			return nil
  1081  		}
  1082  		return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t}
  1083  	}
  1084  	return &fncs
  1085  }
  1086  
  1087  func (va addressableValue) fieldByIndex(index []int, mayAlloc bool) addressableValue {
  1088  	for _, i := range index {
  1089  		va = va.indirect(mayAlloc)
  1090  		if !va.IsValid() {
  1091  			return va
  1092  		}
  1093  		va = addressableValue{va.Field(i)} // addressable if struct value is addressable
  1094  	}
  1095  	return va
  1096  }
  1097  
  1098  func (va addressableValue) indirect(mayAlloc bool) addressableValue {
  1099  	if va.Kind() == reflect.Pointer {
  1100  		if va.IsNil() {
  1101  			if !mayAlloc {
  1102  				return addressableValue{}
  1103  			}
  1104  			va.Set(reflect.New(va.Type().Elem()))
  1105  		}
  1106  		va = addressableValue{va.Elem()} // dereferenced pointer is always addressable
  1107  	}
  1108  	return va
  1109  }
  1110  
  1111  func makeSliceArshaler(t reflect.Type) *arshaler {
  1112  	var fncs arshaler
  1113  	var (
  1114  		once    sync.Once
  1115  		valFncs *arshaler
  1116  	)
  1117  	init := func() {
  1118  		valFncs = lookupArshaler(t.Elem())
  1119  	}
  1120  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
  1121  		// Check for cycles.
  1122  		if enc.tokens.depth() > startDetectingCyclesAfter {
  1123  			if err := enc.seenPointers.visit(va.Value); err != nil {
  1124  				return err
  1125  			}
  1126  			defer enc.seenPointers.leave(va.Value)
  1127  		}
  1128  
  1129  		if mo.format != "" && mo.formatDepth == enc.tokens.depth() {
  1130  			if mo.format == "emitnull" {
  1131  				if va.IsNil() {
  1132  					return enc.WriteToken(Null)
  1133  				}
  1134  				mo.format = ""
  1135  			} else {
  1136  				return newInvalidFormatError("marshal", t, mo.format)
  1137  			}
  1138  		}
  1139  
  1140  		// Optimize for marshaling an empty slice without any preceding whitespace.
  1141  		n := va.Len()
  1142  		if optimizeCommon && n == 0 && !enc.options.multiline && !enc.tokens.last.needObjectName() {
  1143  			enc.buf = enc.tokens.mayAppendDelim(enc.buf, '[')
  1144  			enc.buf = append(enc.buf, "[]"...)
  1145  			enc.tokens.last.increment()
  1146  			if enc.needFlush() {
  1147  				return enc.flush()
  1148  			}
  1149  			return nil
  1150  		}
  1151  
  1152  		once.Do(init)
  1153  		if err := enc.WriteToken(ArrayStart); err != nil {
  1154  			return err
  1155  		}
  1156  		marshal := valFncs.marshal
  1157  		if mo.Marshalers != nil {
  1158  			marshal, _ = mo.Marshalers.lookup(marshal, t.Elem())
  1159  		}
  1160  		for i := 0; i < n; i++ {
  1161  			v := addressableValue{va.Index(i)} // indexed slice element is always addressable
  1162  			if err := marshal(mo, enc, v); err != nil {
  1163  				return err
  1164  			}
  1165  		}
  1166  		if err := enc.WriteToken(ArrayEnd); err != nil {
  1167  			return err
  1168  		}
  1169  		return nil
  1170  	}
  1171  	emptySlice := reflect.MakeSlice(t, 0, 0)
  1172  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
  1173  		if uo.format != "" && uo.formatDepth == dec.tokens.depth() {
  1174  			if uo.format == "emitnull" {
  1175  				uo.format = "" // only relevant for marshaling
  1176  			} else {
  1177  				return newInvalidFormatError("unmarshal", t, uo.format)
  1178  			}
  1179  		}
  1180  
  1181  		tok, err := dec.ReadToken()
  1182  		if err != nil {
  1183  			return err
  1184  		}
  1185  		k := tok.Kind()
  1186  		switch k {
  1187  		case 'n':
  1188  			va.Set(reflect.Zero(t))
  1189  			return nil
  1190  		case '[':
  1191  			once.Do(init)
  1192  			unmarshal := valFncs.unmarshal
  1193  			if uo.Unmarshalers != nil {
  1194  				unmarshal, _ = uo.Unmarshalers.lookup(unmarshal, t.Elem())
  1195  			}
  1196  			mustZero := true // we do not know the cleanliness of unused capacity
  1197  			cap := va.Cap()
  1198  			if cap > 0 {
  1199  				va.SetLen(cap)
  1200  			}
  1201  			var i int
  1202  			for dec.PeekKind() != ']' {
  1203  				if i == cap {
  1204  					// TODO(https://go.dev/issue/48000): Use reflect.Value.Append.
  1205  					va.Set(reflect.Append(va.Value, reflect.Zero(t.Elem())))
  1206  					cap = va.Cap()
  1207  					va.SetLen(cap)
  1208  					mustZero = false // append guarantees that unused capacity is zero-initialized
  1209  				}
  1210  				v := addressableValue{va.Index(i)} // indexed slice element is always addressable
  1211  				i++
  1212  				if mustZero {
  1213  					v.Set(reflect.Zero(t.Elem()))
  1214  				}
  1215  				if err := unmarshal(uo, dec, v); err != nil {
  1216  					va.SetLen(i)
  1217  					return err
  1218  				}
  1219  			}
  1220  			if i == 0 {
  1221  				va.Set(emptySlice)
  1222  			} else {
  1223  				va.SetLen(i)
  1224  			}
  1225  			if _, err := dec.ReadToken(); err != nil {
  1226  				return err
  1227  			}
  1228  			return nil
  1229  		}
  1230  		return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t}
  1231  	}
  1232  	return &fncs
  1233  }
  1234  
  1235  func makeArrayArshaler(t reflect.Type) *arshaler {
  1236  	var fncs arshaler
  1237  	var (
  1238  		once    sync.Once
  1239  		valFncs *arshaler
  1240  	)
  1241  	init := func() {
  1242  		valFncs = lookupArshaler(t.Elem())
  1243  	}
  1244  	n := t.Len()
  1245  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
  1246  		if mo.format != "" && mo.formatDepth == enc.tokens.depth() {
  1247  			return newInvalidFormatError("marshal", t, mo.format)
  1248  		}
  1249  		once.Do(init)
  1250  		if err := enc.WriteToken(ArrayStart); err != nil {
  1251  			return err
  1252  		}
  1253  		marshal := valFncs.marshal
  1254  		if mo.Marshalers != nil {
  1255  			marshal, _ = mo.Marshalers.lookup(marshal, t.Elem())
  1256  		}
  1257  		for i := 0; i < n; i++ {
  1258  			v := addressableValue{va.Index(i)} // indexed array element is addressable if array is addressable
  1259  			if err := marshal(mo, enc, v); err != nil {
  1260  				return err
  1261  			}
  1262  		}
  1263  		if err := enc.WriteToken(ArrayEnd); err != nil {
  1264  			return err
  1265  		}
  1266  		return nil
  1267  	}
  1268  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
  1269  		if uo.format != "" && uo.formatDepth == dec.tokens.depth() {
  1270  			return newInvalidFormatError("unmarshal", t, uo.format)
  1271  		}
  1272  		tok, err := dec.ReadToken()
  1273  		if err != nil {
  1274  			return err
  1275  		}
  1276  		k := tok.Kind()
  1277  		switch k {
  1278  		case 'n':
  1279  			va.Set(reflect.Zero(t))
  1280  			return nil
  1281  		case '[':
  1282  			once.Do(init)
  1283  			unmarshal := valFncs.unmarshal
  1284  			if uo.Unmarshalers != nil {
  1285  				unmarshal, _ = uo.Unmarshalers.lookup(unmarshal, t.Elem())
  1286  			}
  1287  			var i int
  1288  			for dec.PeekKind() != ']' {
  1289  				if i >= n {
  1290  					err := errors.New("too many array elements")
  1291  					return &SemanticError{action: "unmarshal", GoType: t, Err: err}
  1292  				}
  1293  				v := addressableValue{va.Index(i)} // indexed array element is addressable if array is addressable
  1294  				v.Set(reflect.Zero(v.Type()))
  1295  				if err := unmarshal(uo, dec, v); err != nil {
  1296  					return err
  1297  				}
  1298  				i++
  1299  			}
  1300  			if _, err := dec.ReadToken(); err != nil {
  1301  				return err
  1302  			}
  1303  			if i < n {
  1304  				err := errors.New("too few array elements")
  1305  				return &SemanticError{action: "unmarshal", GoType: t, Err: err}
  1306  			}
  1307  			return nil
  1308  		}
  1309  		return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t}
  1310  	}
  1311  	return &fncs
  1312  }
  1313  
  1314  func makePointerArshaler(t reflect.Type) *arshaler {
  1315  	var fncs arshaler
  1316  	var (
  1317  		once    sync.Once
  1318  		valFncs *arshaler
  1319  	)
  1320  	init := func() {
  1321  		valFncs = lookupArshaler(t.Elem())
  1322  	}
  1323  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
  1324  		// Check for cycles.
  1325  		if enc.tokens.depth() > startDetectingCyclesAfter {
  1326  			if err := enc.seenPointers.visit(va.Value); err != nil {
  1327  				return err
  1328  			}
  1329  			defer enc.seenPointers.leave(va.Value)
  1330  		}
  1331  
  1332  		// NOTE: MarshalOptions.format is forwarded to underlying marshal.
  1333  		if va.IsNil() {
  1334  			return enc.WriteToken(Null)
  1335  		}
  1336  		once.Do(init)
  1337  		marshal := valFncs.marshal
  1338  		if mo.Marshalers != nil {
  1339  			marshal, _ = mo.Marshalers.lookup(marshal, t.Elem())
  1340  		}
  1341  		v := addressableValue{va.Elem()} // dereferenced pointer is always addressable
  1342  		return marshal(mo, enc, v)
  1343  	}
  1344  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
  1345  		// NOTE: UnmarshalOptions.format is forwarded to underlying unmarshal.
  1346  		if dec.PeekKind() == 'n' {
  1347  			if _, err := dec.ReadToken(); err != nil {
  1348  				return err
  1349  			}
  1350  			va.Set(reflect.Zero(t))
  1351  			return nil
  1352  		}
  1353  		once.Do(init)
  1354  		unmarshal := valFncs.unmarshal
  1355  		if uo.Unmarshalers != nil {
  1356  			unmarshal, _ = uo.Unmarshalers.lookup(unmarshal, t.Elem())
  1357  		}
  1358  		if va.IsNil() {
  1359  			va.Set(reflect.New(t.Elem()))
  1360  		}
  1361  		v := addressableValue{va.Elem()} // dereferenced pointer is always addressable
  1362  		return unmarshal(uo, dec, v)
  1363  	}
  1364  	return &fncs
  1365  }
  1366  
  1367  func makeInterfaceArshaler(t reflect.Type) *arshaler {
  1368  	// NOTE: Values retrieved from an interface are not addressable,
  1369  	// so we shallow copy the values to make them addressable and
  1370  	// store them back into the interface afterwards.
  1371  
  1372  	var fncs arshaler
  1373  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
  1374  		if mo.format != "" && mo.formatDepth == enc.tokens.depth() {
  1375  			return newInvalidFormatError("marshal", t, mo.format)
  1376  		}
  1377  		if va.IsNil() {
  1378  			return enc.WriteToken(Null)
  1379  		}
  1380  		v := newAddressableValue(va.Elem().Type())
  1381  		v.Set(va.Elem())
  1382  		marshal := lookupArshaler(v.Type()).marshal
  1383  		if mo.Marshalers != nil {
  1384  			marshal, _ = mo.Marshalers.lookup(marshal, v.Type())
  1385  		}
  1386  		// Optimize for the any type if there are no special options.
  1387  		if optimizeCommon && t == anyType && !mo.StringifyNumbers && mo.format == "" && (mo.Marshalers == nil || !mo.Marshalers.fromAny) {
  1388  			return marshalValueAny(mo, enc, va.Elem().Interface())
  1389  		}
  1390  		return marshal(mo, enc, v)
  1391  	}
  1392  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
  1393  		if uo.format != "" && uo.formatDepth == dec.tokens.depth() {
  1394  			return newInvalidFormatError("unmarshal", t, uo.format)
  1395  		}
  1396  		if dec.PeekKind() == 'n' {
  1397  			if _, err := dec.ReadToken(); err != nil {
  1398  				return err
  1399  			}
  1400  			va.Set(reflect.Zero(t))
  1401  			return nil
  1402  		}
  1403  		var v addressableValue
  1404  		if va.IsNil() {
  1405  			// Optimize for the any type if there are no special options.
  1406  			// We do not care about stringified numbers since JSON strings
  1407  			// are always unmarshaled into an any value as Go strings.
  1408  			// Duplicate name check must be enforced since unmarshalValueAny
  1409  			// does not implement merge semantics.
  1410  			if optimizeCommon && t == anyType && uo.format == "" && (uo.Unmarshalers == nil || !uo.Unmarshalers.fromAny) && !dec.options.AllowDuplicateNames {
  1411  				v, err := unmarshalValueAny(uo, dec)
  1412  				// We must check for nil interface values up front.
  1413  				// See https://go.dev/issue/52310.
  1414  				if v != nil {
  1415  					va.Set(reflect.ValueOf(v))
  1416  				}
  1417  				return err
  1418  			}
  1419  
  1420  			k := dec.PeekKind()
  1421  			if !isAnyType(t) {
  1422  				err := errors.New("cannot derive concrete type for non-empty interface")
  1423  				return &SemanticError{action: "unmarshal", JSONKind: k, GoType: t, Err: err}
  1424  			}
  1425  			switch k {
  1426  			case 'f', 't':
  1427  				v = newAddressableValue(boolType)
  1428  			case '"':
  1429  				v = newAddressableValue(stringType)
  1430  			case '0':
  1431  				v = newAddressableValue(float64Type)
  1432  			case '{':
  1433  				v = newAddressableValue(mapStringAnyType)
  1434  			case '[':
  1435  				v = newAddressableValue(sliceAnyType)
  1436  			default:
  1437  				// If k is invalid (e.g., due to an I/O or syntax error), then
  1438  				// that will be cached by PeekKind and returned by ReadValue.
  1439  				// If k is '}' or ']', then ReadValue must error since
  1440  				// those are invalid kinds at the start of a JSON value.
  1441  				_, err := dec.ReadValue()
  1442  				return err
  1443  			}
  1444  		} else {
  1445  			// Shallow copy the existing value to keep it addressable.
  1446  			// Any mutations at the top-level of the value will be observable
  1447  			// since we always store this value back into the interface value.
  1448  			v = newAddressableValue(va.Elem().Type())
  1449  			v.Set(va.Elem())
  1450  		}
  1451  		unmarshal := lookupArshaler(v.Type()).unmarshal
  1452  		if uo.Unmarshalers != nil {
  1453  			unmarshal, _ = uo.Unmarshalers.lookup(unmarshal, v.Type())
  1454  		}
  1455  		err := unmarshal(uo, dec, v)
  1456  		va.Set(v.Value)
  1457  		return err
  1458  	}
  1459  	return &fncs
  1460  }
  1461  
  1462  // isAnyType reports wether t is equivalent to the any interface type.
  1463  func isAnyType(t reflect.Type) bool {
  1464  	// This is forward compatible if the Go language permits type sets within
  1465  	// ordinary interfaces where an interface with zero methods does not
  1466  	// necessarily mean it can hold every possible Go type.
  1467  	// See https://go.dev/issue/45346.
  1468  	return t == anyType || anyType.Implements(t)
  1469  }
  1470  
  1471  func makeInvalidArshaler(t reflect.Type) *arshaler {
  1472  	var fncs arshaler
  1473  	fncs.marshal = func(mo MarshalOptions, enc *Encoder, va addressableValue) error {
  1474  		return &SemanticError{action: "marshal", GoType: t}
  1475  	}
  1476  	fncs.unmarshal = func(uo UnmarshalOptions, dec *Decoder, va addressableValue) error {
  1477  		return &SemanticError{action: "unmarshal", GoType: t}
  1478  	}
  1479  	return &fncs
  1480  }
  1481  
  1482  func newInvalidFormatError(action string, t reflect.Type, format string) error {
  1483  	err := fmt.Errorf("invalid format flag: %q", format)
  1484  	return &SemanticError{action: action, GoType: t, Err: err}
  1485  }
  1486  

View as plain text