Go types.Selection.Index 怎样还原提升字段的访问路径

用 go/types 做静态分析时，x.ID 看起来只有一个选择器，但字段可能藏在多层匿名嵌入结构中。还原这条路径不需要重新扫描字段名：对 FieldVal 选择器，Selection.Index() 的前置项是逐层嵌入字段的下标，最后一项是声明目标字段在所属结构体中的下标。

Go 官方地址：https://go.dev/

先看懂 Index 的每一项对应什么

官方文档把索引链分成两部分：前面的索引表示从接收值开始，按嵌入深度穿过的 struct 字段；最后一项表示最终字段在声明它的 struct 字段列表中的位置。假设有 Item { Meta }、Meta { Base }、Base { ID int }，那么 item.ID 的索引链可表示为 [0,0,0]，对应路径 Item.Meta.Base.ID。

这里的数字是位置，不是字段名，也不是字节偏移。字段顺序变化后索引可能变化，因此生成诊断信息时最好同时保存字段名和所属类型，不要把索引链单独当作稳定 ID。

用 types.Info 找到 FieldVal 选择器

Selection 不是通过字符串猜出来的，而是在类型检查阶段写入 types.Info.Selections。下面的实验代码构造一个两层嵌入结构，找到 item.ID，再打印它的索引链。代码中的输出是示例结果，表示静态分析器应关注的字段。

// 文件：main.go；通过类型检查收集选择器信息。
package main

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

const src = `package demo
type Base struct { ID int }
type Meta struct { Base }
type Item struct { Meta }
func use(item Item) int { return item.ID }`

func main() {
	// 解析源码并让 go/types 记录每个选择器的 Selection。
	fset := token.NewFileSet()
	file, err := parser.ParseFile(fset, "demo.go", src, 0)
	if err != nil { panic(err) }
	info := &types.Info{Selections: map[*ast.SelectorExpr]*types.Selection{}}
	conf := types.Config{Importer: importer.Default()}
	if _, err = conf.Check("demo", fset, []*ast.File{file}, info); err != nil { panic(err) }

	// 只处理字段选择器；item.ID 在这里是 FieldVal。
	ast.Inspect(file, func(n ast.Node) bool {
		selExpr, ok := n.(*ast.SelectorExpr)
		if !ok { return true }
		sel := info.Selections[selExpr]
		if sel != nil && sel.Kind() == types.FieldVal {
			fmt.Printf("obj=%s index=%v indirect=%v\n", sel.Obj().Name(), sel.Index(), sel.Indirect())
		}
		return true
	})
}

示例中最终会关注到类似 obj=ID index=[0 0 0] 的记录。真正的路径文字还要按照接收类型逐层读取字段，不能把 Index() 直接格式化成名字。

按索引链逐层还原字段名

还原函数的核心只有一个循环：当前类型先去掉指针，再把命名类型落到其底层类型；当前值必须是 struct，索引才有“字段位置”的含义。读出字段后，把字段类型交给下一轮，最后得到从外层到目标字段的名字列表。

// fieldPath 把 Selection.Index 还原成结构体字段名路径。
func fieldPath(start types.Type, index []int) ([]string, error) {
	if start == nil { return nil, fmt.Errorf("接收类型为空") }
	path := make([]string, 0, len(index))
	current := start
	for depth, fieldIndex := range index {
		// 选择器可能经过指针；字段下标要在元素类型的 struct 上读取。
		for {
			if p, ok := current.(*types.Pointer); ok {
				current = p.Elem()
				continue
			}
			break
		}
		if named, ok := current.(*types.Named); ok {
			current = named.Underlying()
		}
		st, ok := current.(*types.Struct)
		if !ok { return nil, fmt.Errorf("第%d层不是 struct: %T", depth, current) }
		if fieldIndex = st.NumFields() {
			return nil, fmt.Errorf("第%d层字段下标越界: %d", depth, fieldIndex)
		}
		field := st.Field(fieldIndex)
		path = append(path, field.Name())
		current = field.Type()
	}
	return path, nil
}

// 选中的 sel 来自 types.Info.Selections。
names, err := fieldPath(sel.Recv(), sel.Index())
if err != nil { panic(err) }
fmt.Println(strings.Join(names, ".")) // Meta.Base.ID

需要补上 strings 导入，并把函数放到示例的包级作用域。sel.Recv() 是选择器的有效接收类型；对文档中的 *T 字段选择，go/types 会把隐式解引用的语义反映在选择信息里。路径恢复关注字段结构，是否发生过指针间接则单独查看 sel.Indirect()。

Obj、Kind 和 Indirect 要怎样一起判断

Index 只回答“沿哪几个字段位置走”，实际工具还应把它和选择对象放在一起记录：

如果分析目标是生成显式访问式，可以把名字路径和间接信息分开输出，例如记录 path=Meta.Base.ID、indirect=true。不要为了得到路径而把指针类型永久改写成值类型，因为后续诊断可能还需要知道 nil 指针会不会影响选择。

常见边界与排查方式

为什么索引不能跨文章或跨类型复用

索引只对对应的接收类型和字段声明顺序有意义。另一个 struct 即使也有三个字段，[0,0,0] 也不代表同一条路径。缓存时至少绑定接收类型的对象身份或包路径。

为什么拿到 nil Selection

types.Info.Selections 只记录需要选择语义的表达式；包限定标识符、普通标识符或类型检查失败的源码不应按 FieldVal 处理。先判断 map 查询结果，再检查 Kind。

字段冲突时能不能自己选一条更深路径

不能。Go 选择器必须满足语言的提升和深度规则；名称冲突或同层多个候选会使选择非法。静态分析器应保留类型检查错误，不要自行猜测一个“最接近”的字段。

把这项工作压缩成一句话就是：先用 Selection.Kind 确认对象，再从 Selection.Recv 出发逐项读取 Selection.Index，最后用 Obj 和 Indirect 补齐语义。这样得到的 Meta.Base.ID 才是可解释、可诊断的提升字段访问路径。

参考：go/types.Selection.Index、go/types.Selection、Go 语言规范：Selectors。