Our handling of receiver type on generic methods in go/types and types2 is confusing, and arguably incorrect.
While type checking method declarations, the type checker checks the receiver expression T[P1,...PN], resulting in a receiver type that is instantiated with its receiver type parameters, and then assigns this receiver type to the signature being type-checker. This has two surprising consequences:
The receiver type of methods on a generic type is not itself generic: it is instantiated with receiver type parameters.
Because the receiver type is treated as an instance, it is recorded in the Info.Instances map, and its methods are subsequently re-substituted. This means that the defined method F (the thing in Info.Defs!) is not contained in the method set of F.Type().(*types.Signature).Recv().Type()!
Of these, I think (1) is a perhaps peculiar choice that we must stick with, and (2) is a bug -- a consequence of our choice to treat the receiver as an instance and a later decision to instantiate methods on instances. I think this is probably not that difficult to fix: we should avoid naively type checking the receiver parameter list. It is certainly a release blocker to decide what to do here.
Per virtual in-person discussion, I agree that we need to address this. The receiver type handling is a historical accident: before generics, the most expedient way to type-check a method signature was to treat the receiver parameter list just like any other parameter list.
This didn't work anymore for parameterized method receiver types because they look like an instantiated type - yet they are really declaring their own type parameters. Rather than completely changing the original code, I added some pre-amble to extract and declare those type parameters beforehand, so that the receiver type could be type-checked as an instantiated type (and the rest of the code didn't need to change). That code was pretty simple originally, but over time has become more and more complex, with unintended side effects (like what we're observing now). In retrospect, it would have been better to treat receiver parameter lists specially from the start (at least if they have a generic receiver).