Go types.Selection.Kind 怎样区分方法值和方法表达式

在源码分析器里，p.Run 和 Worker.Run 看起来都像“取一个方法”，但它们并不是同一种选择：前者已经绑定了接收者，是方法值；后者把接收者留在函数参数中，是方法表达式。最直接的判断方式是读取 types.Info.Selections 中的 *types.Selection，再调用 Kind()。

官方文档：https://pkg.go.dev/go/types#Selection

Selection.Kind() 返回 FieldVal、MethodVal 或 MethodExpr。判断方法值和方法表达式时，不要只看 Obj() 是否为函数，还要结合 Recv() 与 Type()：方法值的函数类型已经去掉接收者参数，方法表达式的函数类型仍然包含接收者参数。

先用三个常量固定判断口径

SelectionKind 描述选择表达式 x.f 最后一次显式选择的类型。结构体嵌套带来的前置字段访问仍属于隐式字段选择，最终结果由下面三个常量表示：

这里的“值”不是指最终调用结果，而是指选择表达式本身的函数形态。例如 p.Run 的类型可能是 func()，而 Worker.Run 的类型可能是 func(Worker)。

为什么 p.Run 和 Worker.Run 不是同一种选择

假设有一个值接收者方法：

type Worker struct{}

func (Worker) Run() {}

func use(p *Worker) {
	_ = p.Run       // 方法值：接收者 p 已经绑定
	_ = Worker.Run  // 方法表达式：Worker 作为第一个参数
}

对 p.Run，调用方只需要继续传递方法自己的参数；对 Worker.Run，调用方还需要传入一个 Worker 接收者。因此 Selection.Kind() 是静态分析时最稳的分支依据，而不是通过字符串猜测表达式形状。

从零创建一个 Selection 检查器

下面的小项目只做一件事：把内嵌的 Go 源码交给解析器和类型检查器，然后打印每个选择表达式的 Kind、接收者、对象、函数类型、指针间接访问标记和嵌入索引。它适合作为 lint 规则或源码索引器的最小骨架。

准备项目目录

mkdir selection-inspector
cd selection-inspector
go mod init example.com/selection-inspector

这个示例只使用标准库，不需要额外下载依赖。把下面文件保存为 main.go：

package main

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

const source = `package demo

type Worker struct{}

func (Worker) Run() {}

func inspect(p *Worker) {
	_ = p.Run
	_ = Worker.Run
}`

// kindName 把 SelectionKind 转成文章和日志中更容易阅读的名称。
func kindName(kind types.SelectionKind) string {
	switch kind {
	case types.FieldVal:
		return "FieldVal"
	case types.MethodVal:
		return "MethodVal"
	case types.MethodExpr:
		return "MethodExpr"
	default:
		return "Unknown"
	}
}

func main() {
	fset := token.NewFileSet()
	file, err := parser.ParseFile(fset, "demo.go", source, 0)
	if err != nil {
		panic(fmt.Errorf("解析源码失败: %w", err))
	}

	// Selections 只记录字段选择、方法值和方法表达式等选择信息。
	info := &types.Info{
		Selections: make(map[*ast.SelectorExpr]*types.Selection),
	}
	conf := types.Config{Importer: importer.Default()}
	if _, err := conf.Check("example.com/demo", fset, []*ast.File{file}, info); err != nil {
		panic(fmt.Errorf("类型检查失败: %w", err))
	}

	for expr, selection := range info.Selections {
		// Type 可能和被选择对象自身的类型不同，方法表达式会保留接收者参数。
		fmt.Printf("%s => kind=%s recv=%s obj=%s type=%s indirect=%t index=%v\\n",
			types.ExprString(expr),
			kindName(selection.Kind()),
			selection.Recv(),
			selection.Obj(),
			selection.Type(),
			selection.Indirect(),
			selection.Index(),
		)
	}
}

关键点有三个：

• types.Info.Selections 必须初始化为 map，否则类型检查器没有位置保存选择信息。
• types.Config.Check 负责把 AST 与类型信息连起来；importer.Default() 用于解析标准库依赖。
• Kind() 只告诉你选择类别；需要展示调用形态时，再读取 Recv() 和 Type()。

用 Kind 分支处理两种方法形态

如果工具只是统计“出现了哪些方法”，读取 Obj() 可能就够了；如果工具要生成调用摘要、计算参数数量或做重构，就必须区分 MethodVal 和 MethodExpr。可以把处理逻辑收敛在一个函数里：

func describe(selection *types.Selection) string {
	switch selection.Kind() {
	case types.MethodVal:
		// 方法值已经绑定接收者，Type 通常不再把接收者列为参数。
		return fmt.Sprintf("方法值: recv=%s type=%s", selection.Recv(), selection.Type())
	case types.MethodExpr:
		// 方法表达式保留接收者参数，调用摘要不能把第一个参数漏掉。
		return fmt.Sprintf("方法表达式: recv=%s type=%s", selection.Recv(), selection.Type())
	case types.FieldVal:
		// 字段选择没有方法调用签名，交给字段处理分支。
		return fmt.Sprintf("字段: recv=%s type=%s", selection.Recv(), selection.Type())
	default:
		return "未知选择"
	}
}

这里不要用 selection.Obj().Type() 代替 selection.Type()。官方文档明确区分了两者：Obj() 是被指向的字段或方法对象，而 Type() 是表达式 x.f 的类型；方法值和方法表达式正是因为表达式接收者是否已经绑定，导致两者可能不同。

运行与读取结果

启动小项目：

go run .

输出顺序不应作为工具协议，因为 map 的遍历顺序不固定；判断内容时关注每一行的 kind 和 type：

p.Run => kind=MethodVal recv=*demo.Worker obj=func (demo.Worker).Run() type=func() indirect=true index=[]
Worker.Run => kind=MethodExpr recv=demo.Worker obj=func (demo.Worker).Run() type=func(demo.Worker) indirect=false index=[]

具体字符串可能因包名限定方式和 Go 版本而略有差异，但语义应保持一致：p.Run 的类型不再包含接收者，Worker.Run 的类型包含接收者。对于嵌入字段，Index() 还会给出从外层对象走到最终字段或方法的索引路径。

接入真实源码工具时的三个边界

1. 不要把限定标识符当作 Selection。像 http.Get 这样的包限定标识符不属于 types.Info.Selections 的选择记录，应结合 Info.Uses 处理。
2. 不要把 Indirect 当成方法值判断。Indirect() 只说明访问路径上是否发生指针间接访问，和 MethodVal、MethodExpr 是不同维度。
3. 不要依赖字符串格式做分类。Selection.String() 更适合调试；稳定的业务分支应使用 Kind()，参数和接收者信息再从类型对象读取。

总结

区分 Go 方法值和方法表达式时，核心不是比较文本，而是让类型检查器产生 types.Selection：p.Run 对应 MethodVal，Worker.Run 对应 MethodExpr。在工具中用 Kind() 选分支，用 Recv() 说明接收者，用 Type() 判断最终调用签名，用 Index() 还原嵌入路径，就能得到可持续扩展的选择分析结果。

常见问题

为什么 types.Info.Selections 里找不到普通函数调用？

它只记录选择表达式相关信息。普通函数标识符和包限定标识符应从 Info.Uses 等类型信息中查找。

MethodVal 一定代表指针接收者吗？

不一定。MethodVal 描述的是接收者已经绑定的选择类别，接收者可以是值或指针；是否发生指针间接访问要单独查看 Indirect()。

为什么输出里的 Index 不是方法名？

Index() 是从选择对象走到最终字段或方法的整数索引路径，适合处理嵌入字段。最终对象名称仍应从 Obj() 读取。