go/types finding if struct implements interface

OK so looking at using go/types, go/parser... an so forth to generate some code; but need to identify all structs that implement a specific interface which I have figured out, however, if the struct definition on the struct function it does not match using types.Implements.

OK the code examples:

Getting the interface

package ifacepkg

const interfacePkg = `package ifacepkg

type MyInterface interface {
	MyFunction() error
}
`

func getIface() *types.Interface {

fset := token.NewFileSet()

f, err := parser.ParseFile(fset, "iface.go", interfacePkg, 0)
if err != nil {
	panic(err)
}

config := &types.Config{
	Error: func(e error) {
		fmt.Println(e)
	},
	Importer: importer.Default(),
}

info := types.Info{
	Types: make(map[ast.Expr]types.TypeAndValue),
	Defs:  make(map[*ast.Ident]types.Object),
	Uses:  make(map[*ast.Ident]types.Object),
}

pkg, e := config.Check("genval", fset, []*ast.File{f}, &info)
if e != nil {
	fmt.Println(e)
}

return pkg.Scope().Lookup("MyInterface").Type().Underlying().(*types.Interface)
}

Test File

package test

import "ifacepkg"

// User struct
type User struct {
	FirstName string
	LastName  string
}

func (u User) MyFunction() error {
	return nil
}

var _ ifacepkg.MyInterface = &User{}

Loading Test File & trying to see if User implements MyInterface

fset := token.NewFileSet()

pkgs, e := parser.ParseDir(fset, "./test", nil, 0)
if e != nil {
	log.Fatal(e)
	// return
}

var astf []*ast.File

for _, pkg := range pkgs {
	fmt.Printf("package %v\n", pkg.Name)
	for fn, f := range pkg.Files {
		fmt.Printf("file %v\n", fn)
		astf = append(astf, f)
	}
}

config := &types.Config{
	Error: func(e error) {
		fmt.Println(e)
	},
	Importer: importer.Default(),
}

info := types.Info{
	Types: make(map[ast.Expr]types.TypeAndValue),
	Defs:  make(map[*ast.Ident]types.Object),
	Uses:  make(map[*ast.Ident]types.Object),
}

pkg, e := config.Check(path, fset, astf, &info)
if e != nil {
	fmt.Println(e)
}

vIface := getIface()
fmt.Println(vIface)

scope := pkg.Scope()

	for _, name := range scope.Names() {

		obj := scope.Lookup(name)

		_, ok := obj.Type().Underlying().(*types.Struct)
		imp := types.Implements(obj.Type(), vIface)

		fmt.Println(obj.Name(), ok, imp)
	}

OK so fmt.Println(obj.Name(), ok, imp) prints User true true all good! however if I change the source file function from

func (u User) MyFunction() error {

to

func (u *User) MyFunction() error {

it now prints User true false

so the function types.Implements is reporting that User does not implement MyInterface, which is not true.

So my question is: Is there an issue with the type.Implements method or is there something I have to do to my object prior to calling that function.

Answer

ok to solve my own issue changing final portion of code to

scope := pkg.Scope()

for _, name := range scope.Names() {

    obj := scope.Lookup(name)

    _, ok := obj.Type().Underlying().(*types.Struct)
    ptr := types.NewPointer(obj.Type())
    imp := types.Implements(ptr.Underlying(), vIface)

    fmt.Println(obj.Name(), ok, imp)
}

which works with both Pointer and non-pointer recievers

What your compiler is telling you is true. *Type != Type in Go. If you want *User to implement your interface then the methods receiver has to be *User and if you want it to be User then it needs to be User. I don't really know how else to explain it... Go's type system is strict and those aren't the same. You can see this more practically if you have (u *User) MyFunction() defined for the pointer type do ptr := &MyUser then check if MyUser and ptr implement the interface, ptr will, MyUser will not.