Unexpected diffs of nil slices

[cbandy]

For some values (types?), cmp.Diff returns no apparent difference though cmp.Equal returns false. The following program shows no -/+ for []int, []byte, and []float64 types.

Diff does produce output, so I'm not certain this is a bug. I was expecting (and would grateful) to see - nil / + {} in these cases as well.

package main

import (
	"fmt"
	"reflect"

	"github.com/google/go-cmp/cmp"
)

func main() {
	for _, tt := range []struct{ Nil, Empty interface{} }{
		{Nil: []int(nil), Empty: []int{}},
		{Nil: []byte(nil), Empty: []byte{}},
		{Nil: []string(nil), Empty: []string{}},
		{Nil: []float64(nil), Empty: []float64{}},
		{Nil: []struct{}(nil), Empty: []struct{}{}},
		{Nil: []interface{}(nil), Empty: []interface{}{}},
	} {
		fmt.Println("Type:", reflect.TypeOf(tt.Nil).String())
		fmt.Println("DeepEqual:", reflect.DeepEqual(tt.Nil, tt.Empty))
		fmt.Println("cmp.Equal:", cmp.Equal(tt.Nil, tt.Empty))
		fmt.Println("Diff:\n", cmp.Diff(tt.Nil, tt.Empty))
		fmt.Println("=====")
	}
}

Output:

Type: []int
DeepEqual: false
cmp.Equal: false
Diff:
   []int{}

=====
Type: []uint8
DeepEqual: false
cmp.Equal: false
Diff:
   bytes.Join({}, "")

=====
Type: []string
DeepEqual: false
cmp.Equal: false
Diff:
   []string(
- 	nil,
+ 	{},
  )

=====
Type: []float64
DeepEqual: false
cmp.Equal: false
Diff:
   []float64{}

=====
Type: []struct {}
DeepEqual: false
cmp.Equal: false
Diff:
   []struct{}(
- 	nil,
+ 	{},
  )

=====
Type: []interface {}
DeepEqual: false
cmp.Equal: false
Diff:
   []interface{}(
- 	nil,
+ 	{},
  )

=====

[dsnet]

This is clearly a bug in the diff output. Thank you reporting.