arshal_default.go 59 KB

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