fix(gen): encode discriminator field only once

gen/_template/json/encoders_struct.tmpl

@@ -1,11 +1,31 @@
 {{- define "json/encode_struct_fields" }}
-{{- /*gotype: github.com/ogen-go/ogen/gen/ir.JSONFields*/ -}}
-	{{- range $i, $f := $ }}
+{{- /*gotype: github.com/ogen-go/ogen/gen/ir.JSON*/ -}}
+	{{- $fields := $.Fields }}
+	{{- $additional := $.AdditionalProps }}
+	{{- $pattern := $.PatternProps }}
+	{{- $sum := $.SumProps }}
+
+	{{- range $i, $f := $fields }}
 		{
 		{{- $elem := field_elem $f }}
 		{{- template "json/enc" $elem }}
 		}
 	{{- end }}
+	{{- if $additional }}
+	for k, elem := range s.{{ $additional.Name }} {
+		e.FieldStart(k)
+    	{{ template "json/enc" map_elem $additional.Type.Item }}
+	}
+	{{- end }}
+	{{- range $p := $pattern }}
+	for k, elem := range s.{{ $p.Name }} {
+		e.FieldStart(k)
+    	{{ template "json/enc" map_elem $p.Type.Item }}
+	}
+	{{- end }}
+	{{- range $s := $sum }}
+	s.{{ $s.Name }}.encodeFields(e)
+	{{- end }}
 {{- end }}
 
 {{- define "json/encoders_struct" }}
@@ -67,22 +87,7 @@ func (s *{{ $.Name }}) Decode(d *jx.Decoder) error {
 {{- else }}
 // encodeFields encodes fields.
 func (s {{ $.ReadOnlyReceiver }}) encodeFields(e *jx.Encoder) {
-	{{- template "json/encode_struct_fields" $fields }}
-	{{- if $additional }}
-	for k, elem := range s.{{ $additional.Name }} {
-		e.FieldStart(k)
-    	{{ template "json/enc" map_elem $additional.Type.Item }}
-	}
-	{{- end }}
-	{{- range $p := $pattern }}
-	for k, elem := range s.{{ $p.Name }} {
-		e.FieldStart(k)
-    	{{ template "json/enc" map_elem $p.Type.Item }}
-	}
-	{{- end }}
-	{{- range $s := $sum }}
-	s.{{ $s.Name }}.encodeFields(e)
-	{{- end }}
+	{{- template "json/encode_struct_fields" $.JSON }}
 }
 
 var jsonFieldsNameOf{{ $.Name }} = [{{ len $fields }}]string{

gen/_template/json/encoders_sum.tmpl

@@ -24,7 +24,13 @@ func (s {{ $.ReadOnlyReceiver }}) encodeFields(e *jx.Encoder) {
 		case {{ $m.Type.Name }}{{ $.Name }}:
 			e.FieldStart({{ quote $.SumSpec.Discriminator }})
 			e.Str({{ quote $m.Key }})
-			s.{{ $m.Type.Name }}.encodeFields(e)
+			{{- $j := $m.Type.JSON.Except $.SumSpec.Discriminator }}
+			{{- if $j.AnyFields }}
+			{
+				s := s.{{ $m.Type.Name }}
+				{{- template "json/encode_struct_fields" $j }}
+			}
+			{{- end }}
 		{{- end }}
 		}
 	{{- else if $d.Fields }}

gen/ir/json.go

@@ -20,16 +20,35 @@ func (t *Type) JSON() JSON {
 
 // JSON specifies json encoding and decoding for Type.
 type JSON struct {
-	t *Type
+	t      *Type
+	except []string
 }
 
-type JSONFields []*Field
+// AnyFields whether if type has any fields to encode.
+func (j JSON) AnyFields() bool {
+	for _, f := range j.t.Fields {
+		if f.Inline != InlineNone {
+			return true
+		}
 
-// NotEmpty whether field slice is not empty.
-func (j JSONFields) NotEmpty() bool {
-	return len(j) != 0
+		t := f.Tag.JSON
+		if t != "" && !slices.Contains(j.except, t) {
+			return true
+		}
+	}
+	return false
 }
 
+// Except return JSON with filter by given properties.
+func (j JSON) Except(set ...string) JSON {
+	return JSON{
+		t:      j.t,
+		except: set,
+	}
+}
+
+type JSONFields []*Field
+
 // FirstRequiredIndex returns first required field index.
 //
 // Or -1 if there is no required fields.
@@ -70,7 +89,7 @@ func (j JSONFields) RequiredMask() []uint8 {
 // Fields return all fields of Type that should be encoded via json.
 func (j JSON) Fields() (fields JSONFields) {
 	for _, f := range j.t.Fields {
-		if f.Tag.JSON == "" {
+		if t := f.Tag.JSON; t == "" || slices.Contains(j.except, t) {
 			continue
 		}
 		fields = append(fields, f)

internal/integration/json_test.go

@@ -4,6 +4,7 @@ import (
 	std "encoding/json"
 	"fmt"
 	"strconv"
+	"strings"
 	"testing"
 
 	"github.com/go-faster/jx"
@@ -49,6 +50,31 @@ func testEncode(t *testing.T, encoder json.Marshaler, expected string) {
 	}
 	require.True(t, std.Valid(e.Bytes()), string(e.Bytes()))
 	require.JSONEq(t, expected, string(e.Bytes()), "encoding result mismatch")
+	require.NoError(t, validProperties(jx.DecodeBytes(e.Bytes()), []string{"$"}))
+}
+
+func validProperties(d *jx.Decoder, path []string) error {
+	if tt := d.Next(); tt != jx.Object {
+		return d.Skip()
+	}
+
+	m := map[string]struct{}{}
+	return d.Obj(func(d *jx.Decoder, key string) error {
+		path = append(path, key)
+		defer func() {
+			path = path[:len(path)-1]
+		}()
+
+		if _, ok := m[key]; ok {
+			return fmt.Errorf("duplicate field %q (at %q)", key, strings.Join(path, "."))
+		}
+		m[key] = struct{}{}
+
+		if err := validProperties(d, path); err != nil {
+			return err
+		}
+		return nil
+	})
 }
 
 func TestJSONGenerics(t *testing.T) {