RecursiveEmptyCheck is not honoured by codecgen

[bboreham]

I noticed it wasn't implemented and you asked for a repro at #163 (comment)

I had to create two files to test: I called them omit.go:

package codec

type TestSliceInt struct {
    I []int `json:",omitempty"`
}

type TestInnerSliceInt struct {
    T TestSliceInt `json:",omitempty"`
}

omit_test.go:

package codec

import (
    "testing"
)

func TestJsonEncodeOmitempty(t *testing.T) {
    var v TestInnerSliceInt
    jsonH := &JsonHandle{}
    jsonH.RecursiveEmptyCheck = true
    var bs []byte
    NewEncoderBytes(&bs, jsonH).MustEncode(&v)
    txt := string(bs)

    goldenResult := `{}`

    if txt != goldenResult {
	logT(t, "encoded != expected: \nexpected: %s\nencoded: %s", goldenResult, txt)
	failT(t)
    }
}

Run without code generation:

$ go test -v -tags netgo -run Omit
=== RUN   TestJsonEncodeOmitempty
--- PASS: TestJsonEncodeOmitempty (0.00s)
PASS
ok  	github.com/ugorji/go/codec	0.008s

Now with generation:

$ ./codecgen/codecgen -o omit_generated_test.go omit.go
$ go test -run Omit
--- FAIL: TestJsonEncodeOmitempty (0.00s)
	shared_test.go:277: encoded != expected: 
		expected: {}
		encoded: {"T":{}}
FAIL
exit status 1
FAIL	github.com/ugorji/go/codec	0.009s

(Note I probably wouldn't use this if it involved a lot of reflection; maybe if it worked via an interface like Selfer which allowed testing IsEmpty)

[ugorji]

Got it. Seen.

Yes, RecursiveEmptyCheck is not supported in codecgen. And it CANNOT be supported in codecgen.

Codecgen doesn't use reflection - as that gives up the performance it's after. RecursiveEmptyCheck uses reflection to introspect a struct and determine if empty.

For omitempty, we strive to statically determine whether a value is empty. Structs cannot be compared if non-pointer reference types exist (slices, maps, funcs, chans). We can't even compare them to the zero value (which should be ok, as it should be a comparison to nil values). So - the only recourse will be to enumerate the fields transitively, which is ... insane.

I remember trying it before, and punting as it was just ugly. E.g. for a struct like:

type T struct {
  I int 
  S []uint64
}

type T2 struct {
  F1 bool
  F2 map[int]float64
  F3 *T
  F4 T
}

var v T2 
v.F1 = &T{I: 10, S: []uint64{1,2,3}}

// the omitempty line for v would be:
var omit = v.F1 != false && v.F2 != nil && v.F3 != nil && v.F4.I != 0 && v.F4.S != nil

Let me think some more, and see if I can push this in. Writing it out, it doesn't seem as onerous anymore. But I reserve the right to still punt ;(

[bboreham]

In my case I'm implementing Selfer for custom containers, so an extra interface to test emptiness will be easy.

I.e. you would generate

var omit = v.IsEmpty()

[ugorji]

I had gone back and forth regarding supporting an IsZero(), and decided not to do anything until the go community decides what they want to do about it.

See
golang/go#7501
https://go-review.googlesource.com/c/go/+/23064
golang/go#11939

So - we won't support IsEmpty or IsZero at this time. I don't want to do something unique for codec.

[ugorji]

I'm not too happy with this solution, as it ignores unexported fields, which many times are the real place where state is stored.

So - i am still considering using this as a forcing function to add "IsZero" support across the board for isEmpty.

[ugorji]

@bboreham

See updates via 8badb25 and then ae82d72 and then d36cb94 . These should solve your concerns completely i.e. the IsZero() support and comparable to efficiently compare to a zero value (if possible).

Let me know how it works.