Use reflect.Value.IsZero (#297)

Now that Go 1.13 is the minimum version, we can use the reflect.Value.IsZero
method instead of our own internal/value.IsZero function.
Interestingly, our IsZero function pre-dates the IsZero method,
but fortunately has the exact same semantics, since both are targetting
semantics defined by the Go language specification.

4 files changed, 4 insertions, 106 deletions

diff --git a/cmp/internal/value/zero.go b/cmp/internal/value/zero.go
deleted file mode 100644
index 9147a29..0000000
--- a/cmp/internal/value/zero.go
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2017, The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package value
-
-import (
-	"math"
-	"reflect"
-)
-
-// IsZero reports whether v is the zero value.
-// This does not rely on Interface and so can be used on unexported fields.
-func IsZero(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.Bool:
-		return v.Bool() == false
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return v.Int() == 0
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		return v.Uint() == 0
-	case reflect.Float32, reflect.Float64:
-		return math.Float64bits(v.Float()) == 0
-	case reflect.Complex64, reflect.Complex128:
-		return math.Float64bits(real(v.Complex())) == 0 && math.Float64bits(imag(v.Complex())) == 0
-	case reflect.String:
-		return v.String() == ""
-	case reflect.UnsafePointer:
-		return v.Pointer() == 0
-	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Ptr, reflect.Map, reflect.Slice:
-		return v.IsNil()
-	case reflect.Array:
-		for i := 0; i < v.Len(); i++ {
-			if !IsZero(v.Index(i)) {
-				return false
-			}
-		}
-		return true
-	case reflect.Struct:
-		for i := 0; i < v.NumField(); i++ {
-			if !IsZero(v.Field(i)) {
-				return false
-			}
-		}
-		return true
-	}
-	return false
-}
diff --git a/cmp/internal/value/zero_test.go b/cmp/internal/value/zero_test.go
deleted file mode 100644
index ddaa337..0000000
--- a/cmp/internal/value/zero_test.go
+++ /dev/null
@@ -1,52 +0,0 @@
-// Copyright 2019, The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package value
-
-import (
-	"archive/tar"
-	"math"
-	"reflect"
-	"testing"
-)
-
-func TestIsZero(t *testing.T) {
-	tests := []struct {
-		in   interface{}
-		want bool
-	}{
-		{0, true},
-		{1, false},
-		{"", true},
-		{"foo", false},
-		{[]byte(nil), true},
-		{[]byte{}, false},
-		{map[string]bool(nil), true},
-		{map[string]bool{}, false},
-		{tar.Header{}, true},
-		{&tar.Header{}, false},
-		{tar.Header{Name: "foo"}, false},
-		{(chan bool)(nil), true},
-		{make(chan bool), false},
-		{(func(*testing.T))(nil), true},
-		{TestIsZero, false},
-		{[...]int{0, 0, 0}, true},
-		{[...]int{0, 1, 0}, false},
-		{math.Copysign(0, +1), true},
-		{math.Copysign(0, -1), false},
-		{complex(math.Copysign(0, +1), math.Copysign(0, +1)), true},
-		{complex(math.Copysign(0, -1), math.Copysign(0, +1)), false},
-		{complex(math.Copysign(0, +1), math.Copysign(0, -1)), false},
-		{complex(math.Copysign(0, -1), math.Copysign(0, -1)), false},
-	}
-
-	for _, tt := range tests {
-		t.Run("", func(t *testing.T) {
-			got := IsZero(reflect.ValueOf(tt.in))
-			if got != tt.want {
-				t.Errorf("IsZero(%v) = %v, want %v", tt.in, got, tt.want)
-			}
-		})
-	}
-}
diff --git a/cmp/report_compare.go b/cmp/report_compare.go
index 1ef65ac..498c57a 100644
--- a/cmp/report_compare.go
+++ b/cmp/report_compare.go
@@ -7,8 +7,6 @@ package cmp
 import (
 	"fmt"
 	"reflect"
-
-	"github.com/google/go-cmp/cmp/internal/value"
 )
 
 // numContextRecords is the number of surrounding equal records to print.
@@ -248,11 +246,11 @@ func (opts formatOptions) formatDiffList(recs []reportRecord, k reflect.Kind, pt
 				var isZero bool
 				switch opts.DiffMode {
 				case diffIdentical:
-					isZero = value.IsZero(r.Value.ValueX) || value.IsZero(r.Value.ValueY)
+					isZero = r.Value.ValueX.IsZero() || r.Value.ValueY.IsZero()
 				case diffRemoved:
-					isZero = value.IsZero(r.Value.ValueX)
+					isZero = r.Value.ValueX.IsZero()
 				case diffInserted:
-					isZero = value.IsZero(r.Value.ValueY)
+					isZero = r.Value.ValueY.IsZero()
 				}
 				if isZero {
 					continue
diff --git a/cmp/report_reflect.go b/cmp/report_reflect.go
index 287b893..381fd31 100644
--- a/cmp/report_reflect.go
+++ b/cmp/report_reflect.go
@@ -184,7 +184,7 @@ func (opts formatOptions) FormatValue(v reflect.Value, parentKind reflect.Kind,
 		}
 		for i := 0; i < v.NumField(); i++ {
 			vv := v.Field(i)
-			if value.IsZero(vv) {
+			if vv.IsZero() {
 				continue // Elide fields with zero values
 			}
 			if len(list) == maxLen {