@ttsc/win32-arm64 0.33.0 → 0.34.0

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

@@ -56,7 +56,7 @@ func makeString(c *stringCache, b []byte) string {
 
 // hash64 returns the hash of two uint32s as a single uint32.
 func hash64(lo, hi uint32) uint32 {
-	// If avalanche=true, this is identical to XXH32 hash on a 8B string:
+	// If avalanche=true, this is identical to XXH32 hash on an 8B string:
 	//	var b [8]byte
 	//	binary.LittleEndian.PutUint32(b[:4], lo)
 	//	binary.LittleEndian.PutUint32(b[4:], hi)
@@ -75,7 +75,7 @@ func hash64(lo, hi uint32) uint32 {
 	h = bits.RotateLeft32(h, 17) * prime4
 	// Skip final mix (avalanche) step of XXH32 for performance reasons.
 	// Empirical testing shows that the improvements in unbiased distribution
-	// does not outweigh the extra cost in computational complexity.
+	// do not outweigh the extra cost in computational complexity.
 	const avalanche = false
 	if avalanche {
 		h ^= h >> 15

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

@@ -23,11 +23,11 @@ import (
 // [encoding/json/jsontext.Options]. Options from the other packages can
 // be used interchangeably with functionality in this package.
 //
-// Options represent either a singular option or a set of options.
-// It can be functionally thought of as a Go map of option properties
+// An Options value represents either a single option or a set of options.
+// It can be thought of as a Go map of option properties
 // (even though the underlying implementation avoids Go maps for performance).
 //
-// The constructors (e.g., [Deterministic]) return a singular option value:
+// The constructors (e.g., [Deterministic]) return a value for a single option:
 //
 //	opt := Deterministic(true)
 //
@@ -35,7 +35,7 @@ import (
 //
 //	opt := Options{"Deterministic": true}
 //
-// [JoinOptions] composes multiple options values to together:
+// [JoinOptions] composes multiple options values together:
 //
 //	out := JoinOptions(opts...)
 //
@@ -48,7 +48,7 @@ import (
 //		}
 //	}
 //
-// [GetOption] looks up the value of options parameter:
+// [GetOption] looks up the value of an options parameter:
 //
 //	v, ok := GetOption(opts, Deterministic)
 //
@@ -65,7 +65,6 @@ import (
 //   - [FormatNilMapAsNull] affects marshaling only
 //   - [OmitZeroStructFields] affects marshaling only
 //   - [MatchCaseInsensitiveNames] affects marshaling and unmarshaling
-//   - [DiscardUnknownMembers] affects marshaling only
 //   - [RejectUnknownMembers] affects unmarshaling only
 //   - [WithMarshalers] affects marshaling only
 //   - [WithUnmarshalers] affects unmarshaling only
@@ -83,6 +82,7 @@ func JoinOptions(srcs ...Options) Options {
 
 // GetOption returns the value stored in opts with the provided setter,
 // reporting whether the value is present.
+// If not present, the returned value is the zero value for type T.
 //
 // Example usage:
 //
@@ -103,11 +103,27 @@ func DefaultOptionsV2() Options {
 	return &jsonopts.DefaultOptionsV2
 }
 
-// StringifyNumbers specifies that numeric Go types should be marshaled
-// as a JSON string containing the equivalent JSON number value.
-// When unmarshaling, numeric Go types are parsed from a JSON string
+// StringifyNumbers specifies that types that would normally be
+// encoded as a JSON number instead be encoded as a JSON string
+// containing the equivalent JSON number value.
+// When unmarshaling, the value is parsed from a JSON string
 // containing the JSON number without any surrounding whitespace.
 //
+// Specifying the `string` tag option on a Go struct field applies this option
+// to the top-level JSON value for that field. When applied via the `string`
+// tag option, StringifyNumbers option does not recursively apply to nested
+// JSON numbers within a JSON object or array.
+//
+// Like all options, explicitly specifying this option in a call to [Marshal],
+// [Unmarshal], etc, will apply recursively.
+//
+// A Go type with custom marshal/unmarshal that represents a JSON number
+// should respect the StringifyNumbers option and if specified
+// serialize as a JSON number within a JSON string.
+// Custom marshal/unmarshal should handle nested JSON objects using
+// [MarshalEncode]/[UnmarshalDecode], which will automatically apply the
+// non-recursive `string` tag option behavior.
+//
 // According to RFC 8259, section 6, a JSON implementation may choose to
 // limit the representation of a JSON number to an IEEE 754 binary64 value.
 // This may cause decoders to lose precision for int64 and uint64 types.
@@ -122,11 +138,18 @@ func StringifyNumbers(v bool) Options {
 	}
 }
 
-// Deterministic specifies that the same input value will be serialized
-// as the exact same output bytes. Different processes of
-// the same program will serialize equal values to the same bytes,
-// but different versions of the same program are not guaranteed
-// to produce the exact same sequence of bytes.
+// Deterministic specifies that marshaling the same input value will always
+// serialize as the same output bytes.
+//
+// For example, Go maps are marshaled sorted by key.
+//
+// For native Go types, Determinism is guaranteed across different instances of
+// identical binaries, but not across different builds of a program (such as
+// different source or toolchain version, different GOOS/GOARCH, different
+// build flags).
+//
+// A Go type with a custom marshaler should also respect the Deterministic
+// option and serialize deterministically if it is true.
 //
 // This only affects marshaling and is ignored when unmarshaling.
 func Deterministic(v bool) Options {
@@ -140,8 +163,6 @@ func Deterministic(v bool) Options {
 // FormatNilSliceAsNull specifies that a nil Go slice should marshal as a
 // JSON null instead of the default representation as an empty JSON array
 // (or an empty JSON string in the case of ~[]byte).
-// Slice fields explicitly marked with `format:emitempty` still marshal
-// as an empty JSON array.
 //
 // This only affects marshaling and is ignored when unmarshaling.
 func FormatNilSliceAsNull(v bool) Options {
@@ -154,8 +175,6 @@ func FormatNilSliceAsNull(v bool) Options {
 
 // FormatNilMapAsNull specifies that a nil Go map should marshal as a
 // JSON null instead of the default representation as an empty JSON object.
-// Map fields explicitly marked with `format:emitempty` still marshal
-// as an empty JSON object.
 //
 // This only affects marshaling and is ignored when unmarshaling.
 func FormatNilMapAsNull(v bool) Options {
@@ -166,11 +185,11 @@ func FormatNilMapAsNull(v bool) Options {
 	}
 }
 
-// OmitZeroStructFields specifies that a Go struct should marshal in such a way
-// that all struct fields that are zero are omitted from the marshaled output
-// if the value is zero as determined by the "IsZero() bool" method if present,
-// otherwise based on whether the field is the zero Go value.
-// This is semantically equivalent to specifying the `omitzero` tag option
+// OmitZeroStructFields specifies that zero-valued fields of Go struct should be
+// omitted from the marshaled output.
+// A value is considered zero if its type has an "IsZero() bool" method that returns true,
+// or if it lacks such a method and the value is a Go zero value.
+// This option is equivalent to specifying the `omitzero` tag option
 // on every field in a Go struct.
 //
 // This only affects marshaling and is ignored when unmarshaling.
@@ -184,14 +203,25 @@ func OmitZeroStructFields(v bool) Options {
 
 // MatchCaseInsensitiveNames specifies that JSON object members are matched
 // against Go struct fields using a case-insensitive match of the name.
+// If a name matches multiple fields, the field whose name matches exactly is chosen.
+// If there is none, an error is reported.
 // Go struct fields explicitly marked with `case:strict` or `case:ignore`
 // always use case-sensitive (or case-insensitive) name matching,
 // regardless of the value of this option.
 //
 // This affects either marshaling or unmarshaling.
-// For marshaling, this option may alter the detection of duplicate names
-// (assuming [jsontext.AllowDuplicateNames] is false) from inlined fields
-// if it matches one of the declared fields in the Go struct.
+//
+// Matching names case-insensitively also affects duplicate name detection
+// (assuming [jsontext.AllowDuplicateNames] is false) since
+// variations of the same name may match the same Go struct field.
+// For example, when unmarshaling, the names "foo" and "Foo" may both
+// match the same Go struct field and therefore be considered a duplicate name.
+// When marshaling, normally it is impossible for any two Go struct fields to
+// serialize in a way where they unmarshal into the same Go struct field
+// since they all have unique exact names.
+// However, it is possible for an
+// embedded fallback to contain a name that also matches the name for
+// a Go struct field, resulting in a duplicate name error.
 func MatchCaseInsensitiveNames(v bool) Options {
 	if v {
 		return jsonflags.MatchCaseInsensitiveNames | 1
@@ -200,22 +230,8 @@ func MatchCaseInsensitiveNames(v bool) Options {
 	}
 }
 
-// DiscardUnknownMembers specifies that marshaling should ignore any
-// JSON object members stored in Go struct fields dedicated to storing
-// unknown JSON object members.
-//
-// This only affects marshaling and is ignored when unmarshaling.
-func DiscardUnknownMembers(v bool) Options {
-	if v {
-		return jsonflags.DiscardUnknownMembers | 1
-	} else {
-		return jsonflags.DiscardUnknownMembers | 0
-	}
-}
-
 // RejectUnknownMembers specifies that unknown members should be rejected
-// when unmarshaling a JSON object, regardless of whether there is a field
-// to store unknown members.
+// when unmarshaling a JSON object.
 //
 // This only affects unmarshaling and is ignored when marshaling.
 func RejectUnknownMembers(v bool) Options {

package/bin/go/src/encoding/json/v2_decode.go

@@ -35,12 +35,22 @@ import (
 // the value pointed at by the pointer. If the pointer is nil, Unmarshal
 // allocates a new value for it to point to.
 //
-// To unmarshal JSON into a value implementing [Unmarshaler],
-// Unmarshal calls that value's [Unmarshaler.UnmarshalJSON] method, including
-// when the input is a JSON null.
-// Otherwise, if the value implements [encoding.TextUnmarshaler]
-// and the input is a JSON quoted string, Unmarshal calls
-// [encoding.TextUnmarshaler.UnmarshalText] with the unquoted form of the string.
+// The JSON input is decoded according the following rules:
+//
+//   - If the value type implements [jsonv2.UnmarshalerFrom],
+//     then the UnmarshalJSONFrom method is called to decode the JSON value.
+//     If the method returns [errors.ErrUnsupported],
+//     then the input is decoded according to subsequent rules.
+//
+//   - If the value type implements [Unmarshaler],
+//     then the UnmarshalJSON method is called to decode the JSON value,
+//     including when the input is a JSON null.
+//
+//   - If the value implements [encoding.TextUnmarshaler] and
+//     the input is a JSON string, then the UnmarshalText method
+//     is called with the unquoted form of the string.
+//
+// Otherwise, Unmarshal uses the following type-dependent default decodings:
 //
 // To unmarshal JSON into a struct, Unmarshal matches incoming object
 // keys to the keys used by [Marshal] (either the struct field name or its tag),
@@ -58,8 +68,10 @@ import (
 //   - map[string]any, for JSON objects
 //   - nil for JSON null
 //
-// To unmarshal a JSON array into a slice, Unmarshal resets the slice length
-// to zero and then appends each element to the slice.
+// To unmarshal a JSON array into a slice, Unmarshal decodes each JSON array
+// element into the corresponding slice element, reusing existing slice
+// elements in-place. The slice grows to accommodate additional elements,
+// or is truncated if the JSON array is shorter.
 // As a special case, to unmarshal an empty JSON array into a slice,
 // Unmarshal replaces the slice with a new empty slice.
 //
@@ -124,7 +136,7 @@ func (e *UnmarshalTypeError) Error() string {
 		// Go representation for the JSON value.
 		// The logic in jsontext represents paths using a JSON Pointer,
 		// which is agnostic to the Go type system.
-		// Trying to convert a JSON Pointer into a UnmarshalTypeError.Field
+		// Trying to convert a JSON Pointer into an UnmarshalTypeError.Field
 		// is difficult. As a heuristic, if the last path token looks like
 		// an index into a JSON array (e.g., ".foo.bar.0"),
 		// avoid the phrase "Go struct field ".

package/bin/go/src/encoding/json/v2_encode.go

@@ -8,8 +8,7 @@
 // RFC 7159. The mapping between JSON and Go values is described
 // in the documentation for the Marshal and Unmarshal functions.
 //
-// See "JSON and Go" for an introduction to this package:
-// https://golang.org/doc/articles/json_and_go.html
+// See [JSON and Go] for an introduction to this package.
 //
 // # Security Considerations
 //
@@ -18,6 +17,8 @@
 // For historical reasons, the default behavior of v1 [encoding/json]
 // unfortunately operates with less secure defaults.
 // New usages of JSON in Go are encouraged to use [encoding/json/v2] instead.
+//
+// [JSON and Go]: https://go.dev/blog/json
 package json
 
 import (
@@ -30,14 +31,24 @@ import (
 // Marshal returns the JSON encoding of v.
 //
 // Marshal traverses the value v recursively.
-// If an encountered value implements [Marshaler]
-// and is not a nil pointer, Marshal calls [Marshaler.MarshalJSON]
-// to produce JSON. If no [Marshaler.MarshalJSON] method is present but the
-// value implements [encoding.TextMarshaler] instead, Marshal calls
-// [encoding.TextMarshaler.MarshalText] and encodes the result as a JSON string.
-// The nil pointer exception is not strictly necessary
-// but mimics a similar, necessary exception in the behavior of
-// [Unmarshaler.UnmarshalJSON].
+//
+// The input value is encoded as JSON according the following rules:
+//
+//   - If the value type implements [jsonv2.MarshalerTo],
+//     then the MarshalJSONTo method is called to encode the value.
+//     If the method returns [errors.ErrUnsupported],
+//     then the input is encoded according to subsequent rules.
+//
+//   - If the value type implements [Marshaler],
+//     then the MarshalJSON method is called to encode the value.
+//
+//   - If the value type implements [encoding.TextAppender],
+//     then the AppendText method is called to encode the value and
+//     subsequently encode its result as a JSON string.
+//
+//   - If the value type implements [encoding.TextMarshaler],
+//     then the MarshalText method is called to encode the value and
+//     subsequently encode its result as a JSON string.
 //
 // Otherwise, Marshal uses the following type-dependent default encodings:
 //

package/bin/go/src/encoding/json/v2_indent.go

@@ -50,6 +50,7 @@ func Compact(dst *bytes.Buffer, src []byte) error {
 	dst.Grow(len(src))
 	b := dst.AvailableBuffer()
 	b, err := jsontext.AppendFormat(b, src,
+		ReportErrorsWithLegacySemantics(true),
 		jsontext.AllowDuplicateNames(true),
 		jsontext.AllowInvalidUTF8(true),
 		jsontext.PreserveRawStrings(true))
@@ -111,6 +112,7 @@ func appendIndent(dst, src []byte, prefix, indent string) ([]byte, error) {
 	}
 
 	dst, err := jsontext.AppendFormat(dst, src,
+		ReportErrorsWithLegacySemantics(true),
 		jsontext.AllowDuplicateNames(true),
 		jsontext.AllowInvalidUTF8(true),
 		jsontext.PreserveRawStrings(true),

package/bin/go/src/encoding/json/v2_inject.go

@@ -7,6 +7,7 @@
 package json
 
 import (
+	"errors"
 	"fmt"
 	"reflect"
 	"strconv"
@@ -44,14 +45,16 @@ func transformMarshalError(root any, err error) error {
 		} else {
 			// Historically, this was only reported for NaN or ±Inf values
 			// and cycles detected in the value.
-			// The Val used to be populated with the reflect.Value,
-			// but this is no longer supported.
+			var v reflect.Value
+			if err, ok := errors.AsType[*internal.ValueError](err.Err); ok {
+				v = reflect.ValueOf(err.Val)
+			}
 			errStr := err.Err.Error()
 			if err.Err == internal.ErrCycle && err.GoType != nil {
 				errStr += " via " + err.GoType.String()
 			}
 			errStr = strings.TrimPrefix(errStr, "unsupported value: ")
-			return &UnsupportedValueError{Str: errStr}
+			return &UnsupportedValueError{Value: v, Str: errStr}
 		}
 	} else if ok {
 		return (*UnsupportedValueError)(nil)
@@ -92,7 +95,7 @@ func transformUnmarshalError(root any, err error) error {
 		// Users that care about precise positions should use v2 errors
 		// by disabling [ReportErrorsWithLegacySemantics].
 		//
-		// The introduction of a Err field is new to the v1-to-v2 migration
+		// The introduction of an Err field is new to the v1-to-v2 migration
 		// and allows us to preserve stronger error information
 		// that may be surfaced by the v2 package.
 		//

package/bin/go/src/encoding/json/v2_options.go

@@ -44,20 +44,18 @@
 //     `omitzero` instead (which is identically supported in both v1 and v2).
 //
 //   - In v1, a Go struct field marked as `string` can be used to quote a
-//     Go string, bool, or number as a JSON string. It does not recursively
-//     take effect on composite Go types. In contrast, v2 restricts
-//     the `string` option to only quote a Go number as a JSON string.
-//     It does recursively take effect on Go numbers within a composite Go type.
+//     Go string, bool, number, or pointer to such as a JSON string.
+//     In contrast, v2 restricts the `string` option to only quote a value
+//     that would normally be represented as a JSON number,
+//     but also expands support for it to operate with any Go type
+//     that would normally be represented as a JSON number.
 //     The [StringifyWithLegacySemantics] option controls this behavior difference.
 //
 //   - In v1, a nil Go slice or Go map is marshaled as a JSON null.
 //     In contrast, v2 marshals a nil Go slice or Go map as
 //     an empty JSON array or JSON object, respectively.
 //     The [jsonv2.FormatNilSliceAsNull] and [jsonv2.FormatNilMapAsNull] options
-//     control this behavior difference. To explicitly specify a Go struct field
-//     to use a particular representation for nil, either the `format:emitempty`
-//     or `format:emitnull` field option can be specified.
-//     Field-specified options take precedence over caller-specified options.
+//     control this behavior difference.
 //
 //   - In v1, a Go array may be unmarshaled from a JSON array of any length.
 //     In contrast, in v2 a Go array must be unmarshaled from a JSON array
@@ -67,9 +65,6 @@
 //   - In v1, a Go byte array is represented as a JSON array of JSON numbers.
 //     In contrast, in v2 a Go byte array is represented as a Base64-encoded JSON string.
 //     The [FormatByteArrayAsArray] option controls this behavior difference.
-//     To explicitly specify a Go struct field to use a particular representation,
-//     either the `format:array` or `format:base64` field option can be specified.
-//     Field-specified options take precedence over caller-specified options.
 //
 //   - In v1, MarshalJSON methods declared on a pointer receiver are only called
 //     if the Go value is addressable. In contrast, in v2 a MarshalJSON method
@@ -120,9 +115,6 @@
 //     the decimal number of nanoseconds. In contrast, in v2 a [time.Duration]
 //     has no default representation and results in a runtime error.
 //     The [FormatDurationAsNano] option controls this behavior difference.
-//     To explicitly specify a Go struct field to use a particular representation,
-//     either the `format:nano` or `format:units` field option can be specified.
-//     Field-specified options take precedence over caller-specified options.
 //
 //   - In v1, errors are never reported at runtime for Go struct types
 //     that have some form of structural error (e.g., a malformed tag option).
@@ -169,6 +161,10 @@
 //
 // All new usages of "json" in Go should use the v2 package,
 // but the v1 package will forever remain supported.
+//
+// See the [encoding/json/v2 Migration Guide] for additional detail on migration approaches.
+//
+// [encoding/json/v2 Migration Guide]: https://go.dev/doc/jsonv2-migration
 package json
 
 // TODO(https://go.dev/issue/71631): Update the "Migrating to v2" documentation
@@ -282,10 +278,8 @@ func CallMethodsWithLegacySemantics(v bool) Options {
 }
 
 // FormatByteArrayAsArray specifies that a Go [N]byte is
-// formatted as as a normal Go array in contrast to the v2 default of
+// formatted as a normal Go array in contrast to the v2 default of
 // formatting [N]byte as using binary data encoding (RFC 4648).
-// If a struct field has a `format` tag option,
-// then the specified formatting takes precedence.
 //
 // This affects either marshaling or unmarshaling.
 // The v1 default is true.
@@ -327,8 +321,6 @@ func FormatBytesWithLegacySemantics(v bool) Options {
 // FormatDurationAsNano specifies that a [time.Duration] is
 // formatted as a JSON number representing the number of nanoseconds
 // in contrast to the v2 default of reporting an error.
-// If a duration field has a `format` tag option,
-// then the specified formatting takes precedence.
 //
 // This affects either marshaling or unmarshaling.
 // The v1 default is true.
@@ -346,7 +338,7 @@ func FormatDurationAsNano(v bool) Options {
 // occurs under [jsonv2.MatchCaseInsensitiveNames] or the `case:ignore` tag option.
 // Thus, case-insensitive name matching is identical to [strings.EqualFold].
 // Use of this option diminishes the ability of case-insensitive matching
-// to be able to match common case variants (e.g, "foo_bar" with "fooBar").
+// to be able to match common case variants (e.g., "foo_bar" with "fooBar").
 //
 // This affects either marshaling or unmarshaling.
 // The v1 default is true.
@@ -371,6 +363,9 @@ func MatchCaseSensitiveDelimiter(v bool) Options {
 //     the original Go value for array elements, slice elements,
 //     struct fields (but not map values),
 //     pointer values, and interface values (only if a non-nil pointer).
+//     For slices, it will merge into the pre-existing value of slice elements
+//     even for those past the slice length. If the original slice length
+//     was longer than the JSON array, then it is truncated to match.
 //     In contrast, the default v2 behavior is to merge into the Go value
 //     for struct fields, map values, pointer values, and interface values.
 //     In general, the v2 semantic merges when unmarshaling a JSON object,
@@ -395,7 +390,7 @@ func MergeWithLegacySemantics(v bool) Options {
 //
 // The v1 and v2 definitions of `omitempty` are practically the same for
 // Go strings, slices, arrays, and maps. Usages of `omitempty` on
-// Go bools, ints, uints floats, pointers, and interfaces should migrate to use
+// Go bools, ints, uints, floats, pointers, and interfaces should migrate to use
 // the `omitzero` tag option, which omits a field if it is the zero Go value.
 //
 // This only affects marshaling and is ignored when unmarshaling.
@@ -469,6 +464,11 @@ func ParseTimeWithLooseRFC3339(v bool) Options {
 //     are ignored and the Go struct uses a best-effort representation.
 //     In contrast, the v2 semantic is to report a runtime error.
 //
+//   - When unmarshaling with [jsonv2.MatchCaseInsensitiveNames], if a JSON
+//     object name has a non-exact match with multiple Go struct fields, then
+//     an error is not reported and instead the first declared field is used.
+//     In contrast, the v2 semantic is to report a runtime error.
+//
 //   - When unmarshaling, the syntactic structure of the JSON input
 //     is fully validated before performing the semantic unmarshaling
 //     of the JSON data into the Go value. Practically speaking,
@@ -497,18 +497,23 @@ func ReportErrorsWithLegacySemantics(v bool) Options {
 // StringifyWithLegacySemantics specifies that the `string` tag option
 // may stringify bools and string values. It only takes effect on fields
 // where the top-level type is a bool, string, numeric kind, or a pointer to
-// such a kind. Specifically, `string` will not stringify bool, string,
-// or numeric kinds within a composite data type
-// (e.g., array, slice, struct, map, or interface).
-//
-// When marshaling, such Go values are serialized as their usual
-// JSON representation, but quoted within a JSON string.
-// When unmarshaling, such Go values must be deserialized from
-// a JSON string containing their usual JSON representation or
-// Go number representation for that numeric kind.
+// such a kind. In contrast, the v2 default only allows the `string` tag option
+// on Go types that would have otherwise serialized as a JSON number,
+// and stringifies the JSON number within a JSON string. In particular,
+// the v2 default does not stringify Go bools and strings.
+// If [ReportErrorsWithLegacySemantics] is false,
+// then incorrect usages of `string` result in a runtime error.
+//
+// When marshaling, such Go values are serialized as their usual JSON
+// representation, but quoted within a JSON string.
+// When unmarshaling, such Go values must be deserialized from a JSON string
+// containing their usual JSON representation or Go number representation for
+// that numeric kind.
 // Note that the Go number grammar is a superset of the JSON number grammar.
 // A JSON null quoted in a JSON string is a valid substitute for JSON null
 // while unmarshaling into a Go value that `string` takes effect on.
+// In contrast, the v2 default rejects stringified numbers outside of the
+// grammar for a JSON number and also rejects a JSON null quoted in a JSON string.
 //
 // This affects either marshaling or unmarshaling.
 // The v1 default is true.
@@ -524,6 +529,8 @@ func StringifyWithLegacySemantics(v bool) Options {
 // from input JSON arrays of any length. If the JSON array is too short,
 // then the remaining Go array elements are zeroed. If the JSON array
 // is too long, then the excess JSON array elements are skipped over.
+// In contrast, the v2 default expects that Go arrays be unmarshaled
+// from input JSON arrays of the exact same length.
 //
 // This only affects unmarshaling and is ignored when marshaling.
 // The v1 default is true.

package/bin/go/src/encoding/json/v2_scanner.go

@@ -28,7 +28,7 @@ func checkValid(data []byte) error {
 	d := export.GetBufferedDecoder(data)
 	defer export.PutBufferedDecoder(d)
 	xd := export.Decoder(d)
-	xd.Struct.Flags.Set(jsonflags.AllowDuplicateNames | jsonflags.AllowInvalidUTF8 | 1)
+	xd.Struct.Flags.Set(jsonflags.ReportErrorsWithLegacySemantics | jsonflags.AllowDuplicateNames | jsonflags.AllowInvalidUTF8 | 1)
 	if _, err := d.ReadValue(); err != nil {
 		if err == io.EOF {
 			offset := d.InputOffset() + int64(len(d.UnreadBuffer()))
@@ -56,6 +56,11 @@ var errUnexpectedEnd = errors.New("unexpected end of JSON input")
 func transformSyntacticError(err error) error {
 	switch serr, ok := err.(*jsontext.SyntacticError); {
 	case serr != nil:
+		// If the SyntacticError wraps an IO error, unwrap it
+		// to match v1 behavior which returned IO errors directly.
+		if export.IsIOError(serr.Err) {
+			return errors.Unwrap(serr.Err)
+		}
 		if serr.Err == io.ErrUnexpectedEOF {
 			serr.Err = errUnexpectedEnd
 		}