Broadly, this covers two cases:

 - Slice to pointer-to-array conversions.
 - Conversion between pointers to types with identical underlying types.

Arrays are a special case because pointer to array is a wrapped type,
unlike all other pointer types. Structs are a special case as well
because pointer to struct is actually represented by the same underlying
object as the struct value.

Since in Go they are passed by value, this is essentially equivalent to
copying the value. Even when the type is the same, the copy operation is
needed.

According to the Go spec, channels are equal if they have been created
by the same call to make(). Prior to this change reflect.DeepEqual()
would return false when comparing two channels, one of this is a named
type (e.g. `type ch chan string`) and was created by type conversion
from the other one.

After this change, DeepEquals behavior becomes consistent with the
== operator.

Upstream has a similar bug: golang/go#63886.

…ams.

Prior to this change expressions like `ss[T1, T2](val)` where `ss` is a
parameterized type were not recognized as type conversion expressions
due to use of the *ast.IndexListExpr node.

At this point both remaining issues seem to be related to other kinds of
issues.