hoge.go

package main

import "fmt"

type Err string

func (err Err) Error() string {
	return string(err)
}

func f() Err {
	return Err("error")
}

func main() {
	fmt.Println(f())
	fmt.Println(func() Err {
		return Err("error2")
	})
	fmt.Println(func() error {
		return nil
	})
}

main.go

package main

import (
	"fmt"
	"go/ast"
	"go/importer"
	"go/parser"
	"go/token"
	"go/types"
)

func main() {
	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, "hoge.go", nil, 0)
	if err != nil {
		panic(err)
	}

	config := types.Config{
		Importer: importer.Default(),
	}
	info := &types.Info{
		Uses: map[*ast.Ident]types.Object{},
	}

	_, err = config.Check("main", fset, []*ast.File{f}, info)
	if err != nil {
		panic(err)
	}

	errTyp := types.Universe.Lookup("error").Type().Underlying().(*types.Interface)

	ast.Inspect(f, func(n ast.Node) bool {
		switch n := n.(type) {
		case *ast.FuncType:
			if n.Results == nil {
				return true
			}

			for _, r := range n.Results.List {
				ident, ok := r.Type.(*ast.Ident)
				if !ok {
					continue
				}
				o := info.Uses[ident]
				if o != nil {
					if t := o.Type(); !types.Identical(t.Underlying(), errTyp) &&
						types.Implements(t, errTyp) {
						fmt.Println(fset.Position(n.Pos()))
					}
				}
			}
		}
		return true
	})
}

result.sh

% go run main.go
hoge.go:11:1
hoge.go:17:14