encoding/gob: use reflect.Value.IsZero

The reflect method was added in Go 1.13, in 2019.
gob's own version dates all the way back to 2011.

The behavior appears to be the same, and all tests still pass.
gob does have special cases like always encoding arrays even when they
are the zero value, but that is done via the sendZero boolean field.

Change-Id: I9057b7436963e231fdbf2f6c4b1edb58a2b13305
Reviewed-on: https://go-review.googlesource.com/c/go/+/479397
Reviewed-by: Ian Lance Taylor <iant@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Rob Pike <r@golang.org>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Gopher Robot <gobot@golang.org>

diff --git a/src/encoding/gob/encode.go b/src/encoding/gob/encode.go
index abc76701cacbe93e6bc9e896378a9b61b56fe2b8..5f4d2539faafe3c783ac1102e3546cc45064ee71 100644 (file)
--- a/src/encoding/gob/encode.go
+++ b/src/encoding/gob/encode.go
@@ -430,41 +430,6 @@ func (enc *Encoder) encodeInterface(b *encBuffer, iv reflect.Value) {
        enc.freeEncoderState(state)
 }
 
-// isZero reports whether the value is the zero of its type.
-func isZero(val reflect.Value) bool {
-       switch val.Kind() {
-       case reflect.Array:
-               for i := 0; i < val.Len(); i++ {
-                       if !isZero(val.Index(i)) {
-                               return false
-                       }
-               }
-               return true
-       case reflect.Map, reflect.Slice, reflect.String:
-               return val.Len() == 0
-       case reflect.Bool:
-               return !val.Bool()
-       case reflect.Complex64, reflect.Complex128:
-               return val.Complex() == 0
-       case reflect.Chan, reflect.Func, reflect.Interface, reflect.Pointer:
-               return val.IsNil()
-       case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-               return val.Int() == 0
-       case reflect.Float32, reflect.Float64:
-               return val.Float() == 0
-       case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-               return val.Uint() == 0
-       case reflect.Struct:
-               for i := 0; i < val.NumField(); i++ {
-                       if !isZero(val.Field(i)) {
-                               return false
-                       }
-               }
-               return true
-       }
-       panic("unknown type in isZero " + val.Type().String())
-}
-
 // encodeGobEncoder encodes a value that implements the GobEncoder interface.
 // The data is sent as a byte array.
 func (enc *Encoder) encodeGobEncoder(b *encBuffer, ut *userTypeInfo, v reflect.Value) {
@@ -615,7 +580,7 @@ func gobEncodeOpFor(ut *userTypeInfo) (*encOp, int) {
                        }
                        v = v.Addr()
                }
-               if !state.sendZero && isZero(v) {
+               if !state.sendZero && v.IsZero() {
                        return
                }
                state.update(i)