Go go/ast.PreorderStack 如何保留父节点：语法树遍历与嵌套作用域判断

写 Go 代码检查器时，单看当前的 *ast.Node 往往不够：遇到一个 Ident，你还得知道它是不是在函数体、复合语句块或嵌套函数里。Go 1.27 的 go/ast.PreorderStack 把“当前节点”和“沿途父节点”一起交给回调，正好解决这个上下文缺口。

PreorderStack 负责按前序访问语法树，并把当前节点的祖先路径以 stack []ast.Node 传给回调；调用方只需要在回调内按真实节点类型判断上下文，不必自己维护入栈和出栈。

为什么代码检查器需要父节点上下文

假设检查器要找出函数体里的标识符，并排除嵌套函数字面量。ast.Inspect 能告诉你“现在走到了哪个节点”，但如果回调只接收一个节点，就得额外写状态变量来模拟进入和离开。状态一旦遇到多个分支，维护成本会明显上升。

PreorderStack 的调用链很直接：parser.ParseFile 产出 *ast.File，再由 ast.PreorderStack 访问每个节点，回调接收 n 与 stack，最后把上下文交给判断函数。这里的关键不是“遍历更快”，而是父节点信息变成了回调参数。

先跑通 PreorderStack 的最小遍历

下面的示例解析一段内存中的 Go 源码，并打印每个函数声明的名称。代码里的 parser.ParseFile、ast.PreorderStack、*ast.FuncDecl 都是真实 API 或标准库节点类型。

package main

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

func main() {
    const src = `package demo
func outer() { helper() }
func helper() {}`

    fset := token.NewFileSet()
    file, err := parser.ParseFile(fset, "demo.go", src, 0)
    if err != nil {
        panic(err)
    }

    ast.PreorderStack(file, nil, func(n ast.Node, stack []ast.Node) bool {
        if fn, ok := n.(*ast.FuncDecl); ok {
            fmt.Println(fn.Name.Name, "parents=", len(stack))
        }
        return true
    })
}

运行结果会打印 outer 和 helper。这里返回 true 表示继续向下遍历；如果某个节点已经足够确定结论，可以返回 false，阻止继续访问它的子树。

用父节点栈区分函数体和嵌套函数字面量

真正有价值的地方在于上下文判断。下面的 insideFuncLit 沿着 stack 查找 *ast.FuncLit，所以外层函数体中的调用不会被误判成匿名函数内部调用。遍历节点时，n 仍然是当前节点，栈只负责补充它所处的位置。

func insideFuncLit(stack []ast.Node) bool {
    for _, parent := range stack {
        if _, ok := parent.(*ast.FuncLit); ok {
            return true
        }
    }
    return false
}

func reportCalls(file *ast.File) {
    ast.PreorderStack(file, nil, func(n ast.Node, stack []ast.Node) bool {
        call, ok := n.(*ast.CallExpr)
        if !ok || insideFuncLit(stack) {
            return true
        }
        if name, ok := call.Fun.(*ast.Ident); ok {
            fmt.Println("outer call:", name.Name)
        }
        return true
    })
}

这个判断依赖的是语法结构，而不是字符串搜索：*ast.CallExpr 表示调用表达式，*ast.FuncLit 表示匿名函数。遇到选择器调用，例如 fmt.Println，call.Fun 会是 *ast.SelectorExpr，不能强行按 *ast.Ident 解包。

三个容易踩到的边界

不要把 stack 当成可长期保存的快照

回调里可以读取 stack，但如果要在遍历结束后继续使用路径，应复制它：saved := append([]ast.Node(nil), stack...)。这样保存的是自己的切片，不会依赖遍历实现后续如何复用底层数组。

不要混淆 FuncDecl 和 FuncLit

具名函数通常是 *ast.FuncDecl，匿名函数是 *ast.FuncLit。用一个类型断言覆盖两者，容易让“统计具名函数”和“排除嵌套函数”变成同一条规则，最后结果不清晰。

不要把返回 false 当成“跳过当前节点”

回调返回 false 的效果是停止继续访问当前节点的子树；当前节点已经进入回调。需要记录当前节点时，应先完成记录，再决定是否停止向下遍历。

相关问题

PreorderStack 和 Inspect 的主要区别是什么？

Inspect 的回调只接收当前节点，而 PreorderStack 额外传入父节点栈，适合做作用域、调用位置和嵌套结构判断。

stack 为空是否代表解析失败？

不代表。根节点或没有父节点的回调可能拿到空栈，这是正常的遍历上下文，不应当当作 parser.ParseFile 错误。

Go 1.26 能直接使用这个 API 吗？

应以目标工具链的 go/ast 文档为准。本文示例按 Go 1.27 API 编写，升级前可先在 CI 中运行 go test 和最小示例确认版本边界。

把遍历上下文留给回调，把规则留给检查器

PreorderStack 的价值在于把“我现在位于哪里”变成了可直接读取的参数。解析入口、遍历函数和规则判断可以各自保持短小：parser.ParseFile 负责得到树，ast.PreorderStack 负责提供路径，检查器只关心 *ast.CallExpr、*ast.FuncLit 等真实节点。规则扩大到块作用域或声明上下文时，只需增加对应节点判断，不必再维护一套手写入栈状态。