Comparer doesn't run when type is wrapped in empty interface

[danielchatfield]

Consider the following example:

type I interface {
     V() string
}

type foo struct{
    v string
}

func(f foo) V() string {
     return f.v
}

type bar struct{
    v string
}

func(b bar) V() string {
     return b.v
}

var a,b I
a = foo{"test"}
b = bar{"test"}

cmp.Equal(a,b, cmp.Comparer(func(a, b I) {
     return a.V() == b.V()
})

Expectation: the comparer will be used to determine equality.

Reality: because a and b are different types they get wrapped in an empty interface which then fails the "can it be assigned to this interface" test and the comparer never gets invoked.

[danielchatfield]

The documentation makes it clear this should work:

If T is an interface, it is possible that f is called with two values of different concrete types that both implement T.

[dsnet]

This is an unfortunate quirk of Go. The problem here is similar to how:

var a I
reflect.TypeOf(a) // reports `nil` rather than `I`

Go generics somewhat fixes this since you can now do:

reflect.TypeFor[I]() // properly reports `I`

However, the cmp package has not been updated to use generics.

As a work around you can do:

cmp.Equal(&a, &b, ...)

where you pass in pointers to the interface, which will ensure that the interface wrapping at the top-level does not get lost.

[dsnet]

Closing as inactionable. This is a quirk of the Go language.