Merge pull request #59 from golang/master

[pull] master from golang:master

Author: pull[bot]

src/encoding/json/internal/jsonopts/options.go

@@ -114,70 +114,43 @@ func GetOption[T any](opts Options, setter func(T) Options) (T, bool) {
 var JoinUnknownOption = func(Struct, Options) Struct { panic("unknown option") }
 
 func (dst *Struct) Join(srcs ...Options) {
-	dst.join(false, srcs...)
-}
-
-func (dst *Struct) JoinWithoutCoderOptions(srcs ...Options) {
-	dst.join(true, srcs...)
-}
-
-func (dst *Struct) join(excludeCoderOptions bool, srcs ...Options) {
 	for _, src := range srcs {
 		switch src := src.(type) {
 		case nil:
 			continue
 		case jsonflags.Bools:
-			if excludeCoderOptions {
-				src &= ^jsonflags.AllCoderFlags
-			}
 			dst.Flags.Set(src)
 		case Indent:
-			if excludeCoderOptions {
-				continue
-			}
 			dst.Flags.Set(jsonflags.Multiline | jsonflags.Indent | 1)
 			dst.Indent = string(src)
 		case IndentPrefix:
-			if excludeCoderOptions {
-				continue
-			}
 			dst.Flags.Set(jsonflags.Multiline | jsonflags.IndentPrefix | 1)
 			dst.IndentPrefix = string(src)
 		case ByteLimit:
-			if excludeCoderOptions {
-				continue
-			}
 			dst.Flags.Set(jsonflags.ByteLimit | 1)
 			dst.ByteLimit = int64(src)
 		case DepthLimit:
-			if excludeCoderOptions {
-				continue
-			}
 			dst.Flags.Set(jsonflags.DepthLimit | 1)
 			dst.DepthLimit = int(src)
 		case *Struct:
-			srcFlags := src.Flags // shallow copy the flags
-			if excludeCoderOptions {
-				srcFlags.Clear(jsonflags.AllCoderFlags)
-			}
-			dst.Flags.Join(srcFlags)
-			if srcFlags.Has(jsonflags.NonBooleanFlags) {
-				if srcFlags.Has(jsonflags.Indent) {
+			dst.Flags.Join(src.Flags)
+			if src.Flags.Has(jsonflags.NonBooleanFlags) {
+				if src.Flags.Has(jsonflags.Indent) {
 					dst.Indent = src.Indent
 				}
-				if srcFlags.Has(jsonflags.IndentPrefix) {
+				if src.Flags.Has(jsonflags.IndentPrefix) {
 					dst.IndentPrefix = src.IndentPrefix
 				}
-				if srcFlags.Has(jsonflags.ByteLimit) {
+				if src.Flags.Has(jsonflags.ByteLimit) {
 					dst.ByteLimit = src.ByteLimit
 				}
-				if srcFlags.Has(jsonflags.DepthLimit) {
+				if src.Flags.Has(jsonflags.DepthLimit) {
 					dst.DepthLimit = src.DepthLimit
 				}
-				if srcFlags.Has(jsonflags.Marshalers) {
+				if src.Flags.Has(jsonflags.Marshalers) {
 					dst.Marshalers = src.Marshalers
 				}
-				if srcFlags.Has(jsonflags.Unmarshalers) {
+				if src.Flags.Has(jsonflags.Unmarshalers) {
 					dst.Unmarshalers = src.Unmarshalers
 				}
 			}
@@ -187,6 +160,28 @@ func (dst *Struct) join(excludeCoderOptions bool, srcs ...Options) {
 	}
 }
 
+// InitializeMultiline sets default options implied by Multiline.
+func (s *Struct) InitializeMultiline() {
+	if !s.Flags.Has(jsonflags.SpaceAfterColon) {
+		s.Flags.Set(jsonflags.SpaceAfterColon | 1)
+	}
+	if !s.Flags.Has(jsonflags.SpaceAfterComma) {
+		s.Flags.Set(jsonflags.SpaceAfterComma | 0)
+	}
+	if !s.Flags.Has(jsonflags.Indent) {
+		s.Flags.Set(jsonflags.Indent | 1)
+		s.Indent = "\t"
+	}
+}
+
+// ChangedWhitespace reports whether whitespace values have changed.
+func ChangedWhitespace(s1, s2 Struct) bool {
+	return s1.Flags.Get(jsonflags.Multiline) != s2.Flags.Get(jsonflags.Multiline) ||
+		s1.Flags.Get(jsonflags.SpaceAfterColon) != s2.Flags.Get(jsonflags.SpaceAfterColon) ||
+		s1.Flags.Get(jsonflags.SpaceAfterComma) != s2.Flags.Get(jsonflags.SpaceAfterComma) ||
+		(s2.Flags.Get(jsonflags.Multiline) && (s1.Indent != s2.Indent || s1.IndentPrefix != s2.IndentPrefix))
+}
+
 type (
 	Indent       string // jsontext.WithIndent
 	IndentPrefix string // jsontext.WithIndentPrefix

src/encoding/json/internal/jsonopts/options_test.go

@@ -25,9 +25,8 @@ func makeFlags(f ...jsonflags.Bools) (fs jsonflags.Flags) {
 
 func TestJoin(t *testing.T) {
 	tests := []struct {
-		in            Options
-		excludeCoders bool
-		want          *Struct
+		in   Options
+		want *Struct
 	}{{
 		in:   jsonflags.AllowInvalidUTF8 | 1,
 		want: &Struct{Flags: makeFlags(jsonflags.AllowInvalidUTF8 | 1)},
@@ -68,46 +67,7 @@ func TestJoin(t *testing.T) {
 			return &v2
 		}(), // v2 fully replaces before (except for whitespace related flags)
 	}, {
-		in: jsonflags.Deterministic | jsonflags.AllowInvalidUTF8 | 1, excludeCoders: true,
-		want: func() *Struct {
-			v2 := DefaultOptionsV2
-			v2.Flags.Set(jsonflags.Deterministic | 1)
-			v2.Flags.Set(jsonflags.Indent | 1)
-			v2.Flags.Set(jsonflags.Multiline | 0)
-			v2.Indent = "\t"
-			return &v2
-		}(),
-	}, {
-		in: jsontext.WithIndentPrefix("    "), excludeCoders: true,
-		want: func() *Struct {
-			v2 := DefaultOptionsV2
-			v2.Flags.Set(jsonflags.Deterministic | 1)
-			v2.Flags.Set(jsonflags.Indent | 1)
-			v2.Flags.Set(jsonflags.Multiline | 0)
-			v2.Indent = "\t"
-			return &v2
-		}(),
-	}, {
-		in: jsontext.WithIndentPrefix("    "), excludeCoders: false,
-		want: func() *Struct {
-			v2 := DefaultOptionsV2
-			v2.Flags.Set(jsonflags.Deterministic | 1)
-			v2.Flags.Set(jsonflags.Indent | 1)
-			v2.Flags.Set(jsonflags.IndentPrefix | 1)
-			v2.Flags.Set(jsonflags.Multiline | 1)
-			v2.Indent = "\t"
-			v2.IndentPrefix = "    "
-			return &v2
-		}(),
-	}, {
-		in: &Struct{
-			Flags: jsonflags.Flags{
-				Presence: uint64(jsonflags.Deterministic | jsonflags.Indent | jsonflags.IndentPrefix),
-				Values:   uint64(jsonflags.Indent | jsonflags.IndentPrefix),
-			},
-			CoderValues: CoderValues{Indent: "  ", IndentPrefix: "  "},
-		},
-		excludeCoders: true,
+		in: jsontext.WithIndentPrefix("    "),
 		want: func() *Struct {
 			v2 := DefaultOptionsV2
 			v2.Flags.Set(jsonflags.Indent | 1)
@@ -125,7 +85,6 @@ func TestJoin(t *testing.T) {
 			},
 			CoderValues: CoderValues{Indent: "  ", IndentPrefix: "  "},
 		},
-		excludeCoders: false,
 		want: func() *Struct {
 			v2 := DefaultOptionsV2
 			v2.Flags.Set(jsonflags.Indent | 1)
@@ -138,11 +97,7 @@ func TestJoin(t *testing.T) {
 	}}
 	got := new(Struct)
 	for i, tt := range tests {
-		if tt.excludeCoders {
-			got.JoinWithoutCoderOptions(tt.in)
-		} else {
-			got.Join(tt.in)
-		}
+		got.Join(tt.in)
 		if !reflect.DeepEqual(got, tt.want) {
 			t.Fatalf("%d: Join:\n\tgot:  %+v\n\twant: %+v", i, got, tt.want)
 		}

src/encoding/json/jsontext/encode.go

@@ -124,17 +124,8 @@ func (e *encoderState) reset(b []byte, w io.Writer, opts ...Options) {
 	opts2 := jsonopts.Struct{} // avoid mutating e.Struct in case it is part of opts
 	opts2.Join(opts...)
 	e.Struct = opts2
-	if e.Flags.Get(jsonflags.Multiline) {
-		if !e.Flags.Has(jsonflags.SpaceAfterColon) {
-			e.Flags.Set(jsonflags.SpaceAfterColon | 1)
-		}
-		if !e.Flags.Has(jsonflags.SpaceAfterComma) {
-			e.Flags.Set(jsonflags.SpaceAfterComma | 0)
-		}
-		if !e.Flags.Has(jsonflags.Indent) {
-			e.Flags.Set(jsonflags.Indent | 1)
-			e.Indent = "\t"
-		}
+	if e.Struct.Flags.Get(jsonflags.Multiline) {
+		e.Struct.InitializeMultiline()
 	}
 }
 

src/encoding/json/v2/arshal.go

@@ -9,6 +9,7 @@ package json
 import (
 	"bytes"
 	"encoding"
+	"errors"
 	"io"
 	"reflect"
 	"sync"
@@ -30,6 +31,36 @@ var (
 	_ time.Duration
 )
 
+var (
+	// Once a JSON object has begun processing without duplicate name verification,
+	// it does not track the history of names that have been seen so far.
+	// Reject changing the setting for the current JSON object namespace,
+	// otherwise we would be operating with inconsistent state.
+	// Note that you can change the setting before processing the start
+	// of a different JSON object.
+	//
+	// TODO: We could loosen this restriction in certain conditions.
+	// If we are already checking for duplicate names,
+	// we can momentarily disable it for the next JSON object member name.
+	// However, if we are already NOT checking for duplicate names,
+	// we cannot momentarily enable it for the next JSON object member name
+	// since we already lack prior history of JSON object names.
+	errChangingDuplicateNames = errors.New("cannot change duplicate name checks after a JSON object has already begun processing")
+
+	// The presence of invalid UTF-8 has an interesting intersection
+	// with checking for duplicate names. Due to the semantic of mangling
+	// invalid UTF-8 as the Unicode replacement character,
+	// two string keys in a Go map (both with invalid UTF-8)
+	// may encode as the same JSON string. Thus, we forbid changing of
+	// invalid UTF-8 checks in the current JSON object namespace.
+	errChangingInvalidUTF8 = errors.New("cannot change UTF-8 checks after a JSON object has already begun processing")
+
+	// TODO(https://go.dev/issue/79559): Changing whitespace currently
+	// leads to strange effects and will need more careful adjustment.
+	// For now, we just report an error.
+	errChangingWhitespace = errors.New("cannot change whitespace formatting within a MarshalEncode call")
+)
+
 // export exposes internal functionality of the "jsontext" package.
 var export = jsontext.Internal.Export(&internal.AllowInternalUse)
 
@@ -158,19 +189,33 @@ func MarshalWrite(out io.Writer, in any, opts ...Options) (err error) {
 }
 
 // MarshalEncode serializes a Go value into an [jsontext.Encoder] according to
-// the provided marshal options (while ignoring unmarshal, encode, or decode options).
-// Any marshal-relevant options already specified on the [jsontext.Encoder]
-// take lower precedence than the set of options provided by the caller.
-// Unlike [Marshal] and [MarshalWrite], encode options are ignored because
-// they must have already been specified on the provided [jsontext.Encoder].
+// the provided marshal or encode options (while ignoring unmarshal or decode options).
+// The options provided take precedence over options already applied on
+// the [jsontext.Encoder] and only apply for the duration of the marshal call.
 //
 // See [Marshal] for details about the conversion of a Go value into JSON.
 func MarshalEncode(out *jsontext.Encoder, in any, opts ...Options) (err error) {
 	xe := export.Encoder(out)
 	if len(opts) > 0 {
 		optsOriginal := xe.Struct
 		defer func() { xe.Struct = optsOriginal }()
-		xe.Struct.JoinWithoutCoderOptions(opts...)
+		xe.Struct.Join(opts...)
+		if xe.Tokens.Last.NeedObjectName() {
+			if optsOriginal.Flags.Get(jsonflags.AllowDuplicateNames) != xe.Struct.Flags.Get(jsonflags.AllowDuplicateNames) {
+				return newMarshalErrorBefore(out, reflect.TypeOf(in), errChangingDuplicateNames)
+			}
+			if optsOriginal.Flags.Get(jsonflags.AllowInvalidUTF8) != xe.Struct.Flags.Get(jsonflags.AllowInvalidUTF8) {
+				return newMarshalErrorBefore(out, reflect.TypeOf(in), errChangingInvalidUTF8)
+			}
+		}
+		if xe.Struct.Flags.Has(jsonflags.AnyWhitespace) {
+			if xe.Struct.Flags.Get(jsonflags.Multiline) {
+				xe.Struct.InitializeMultiline()
+			}
+			if jsonopts.ChangedWhitespace(optsOriginal, xe.Struct) {
+				return newMarshalErrorBefore(out, reflect.TypeOf(in), errChangingWhitespace)
+			}
+		}
 	}
 	err = marshalEncode(out, in, &xe.Struct)
 	if err != nil && xe.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {
@@ -361,11 +406,9 @@ func UnmarshalRead(in io.Reader, out any, opts ...Options) (err error) {
 }
 
 // UnmarshalDecode deserializes a Go value from a [jsontext.Decoder] according to
-// the provided unmarshal options (while ignoring marshal, encode, or decode options).
-// Any unmarshal options already specified on the [jsontext.Decoder]
-// take lower precedence than the set of options provided by the caller.
-// Unlike [Unmarshal] and [UnmarshalRead], decode options are ignored because
-// they must have already been specified on the provided [jsontext.Decoder].
+// the provided unmarshal or decode options (while ignoring marshal or encode options).
+// The options provided take precedence over options already applied on
+// the [jsontext.Decoder] and only apply for the duration of the unmarshal call.
 //
 // The input may be a stream of zero or more JSON values,
 // where this only unmarshals the next JSON value in the stream.
@@ -377,7 +420,15 @@ func UnmarshalDecode(in *jsontext.Decoder, out any, opts ...Options) (err error)
 	if len(opts) > 0 {
 		optsOriginal := xd.Struct
 		defer func() { xd.Struct = optsOriginal }()
-		xd.Struct.JoinWithoutCoderOptions(opts...)
+		xd.Struct.Join(opts...)
+		if xd.Tokens.Last.NeedObjectName() {
+			if optsOriginal.Flags.Get(jsonflags.AllowDuplicateNames) != xd.Struct.Flags.Get(jsonflags.AllowDuplicateNames) {
+				return newUnmarshalErrorBefore(in, reflect.TypeOf(out), errChangingDuplicateNames)
+			}
+			if optsOriginal.Flags.Get(jsonflags.AllowInvalidUTF8) != xd.Struct.Flags.Get(jsonflags.AllowInvalidUTF8) {
+				return newUnmarshalErrorBefore(in, reflect.TypeOf(out), errChangingInvalidUTF8)
+			}
+		}
 	}
 	err = unmarshalDecode(in, out, &xd.Struct, false)
 	if err != nil && xd.Flags.Get(jsonflags.ReportErrorsWithLegacySemantics) {