Go types.Scope.Names 怎样生成稳定排序的符号清单

用 go/types 做静态分析时，如果直接遍历 map 来输出声明，结果顺序就不适合日志比较、快照测试或增量索引。更稳妥的做法是先从 types.Info.Scopes 找到目标函数对应的 *types.Scope，再调用 Scope.Names()。官方 API 已明确说明，这个方法返回当前作用域元素名称的排序结果，因此通常不需要再调用一次 sort.Strings。

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

稳定排序的关键不是自己猜作用域内部的数据结构，而是使用类型检查结果中的正确 Scope，并把“当前作用域”“外层作用域”“嵌套块作用域”分开处理。

先弄清 Names 返回的范围

Scope.Names() 返回的是当前 Scope 中的元素名称，而且结果已经排序。它不会把父作用域的变量自动合并进来，也不会把所有子块的声明扁平化。因此，函数作用域里能看到参数、命名返回值以及函数范围内的局部声明；if、for 或 switch 内部新建的声明仍属于对应的子作用域。

从 types.Info.Scopes 找到函数 Scope

类型检查前要初始化 Info.Scopes。函数作用域关联的是 *ast.FuncType，不是函数体 *ast.BlockStmt；这个细节能避免查表时拿错节点。下面的示例只解析内存中的源文本，重点是把目标函数与 Names 的输出连接起来。

package main

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

func scopeNames(src string, wanted string) ([]string, error) {
    fset := token.NewFileSet()
    file, err := parser.ParseFile(fset, "sample.go", src, 0)
    if err != nil {
        return nil, fmt.Errorf("解析源码失败: %w", err)
    }

    // 先记住目标声明；类型检查完成后用它的 FuncType 查作用域。
    var target *ast.FuncDecl
    ast.Inspect(file, func(node ast.Node) bool {
        fn, ok := node.(*ast.FuncDecl)
        if ok && fn.Name.Name == wanted {
            target = fn
            return false
        }
        return true
    })
    if target == nil {
        return nil, fmt.Errorf("找不到函数 %q", wanted)
    }

    // Scopes 由 Check 填充；只收集本示例真正需要的作用域信息。
    info := &types.Info{Scopes: make(map[ast.Node]*types.Scope)}
    if _, err := (&types.Config{}).Check("sample", fset, []*ast.File{file}, info); err != nil {
        return nil, fmt.Errorf("类型检查失败: %w", err)
    }
    functionScope := info.Scopes[target.Type]
    if functionScope == nil {
        return nil, fmt.Errorf("函数 %q 没有对应的 Scope", wanted)
    }

    // Names 已按排序顺序返回；复制一份便于后续过滤或序列化。
    names := append([]string(nil), functionScope.Names()...)
    return names, nil
}

这里的 append([]string(nil), ...) 不是为了重新排序，而是把 API 返回的切片复制到调用方自己的结果里。后续若要删除内部名称、转换成 JSON 或交给缓存层，就不会把“查询 Scope”和“加工输出”混在一起。

为什么不应该看到名称后再次排序

如果代码只是要输出 Scope.Names() 的结果，再调用 sort.Strings 只是重复工作，也让读者误以为 Names 返回的是无序 map 键。正确的排错方式是先打印作用域来源和名称数量：若数量不对，问题通常出在拿错 Scope；若名称重复或排序异常，则应检查输入是否已经完成类型检查，而不是盲目增加排序。

func describeScope(scope *types.Scope) string {
    if scope == nil {
        return ""
    }

    // 名称顺序由 Scope.Names 保证，Len 用来核对当前层元素数量。
    names := scope.Names()
    return fmt.Sprintf("len=%d names=%v", scope.Len(), names)
}

要做大小写不敏感排序、按声明位置排序或按对象类型分组时，才需要把名称和 types.Object 一起复制到自定义结构中，再自行定义比较规则。那已经是业务输出规则，不应与 Names() 的默认契约混为一谈。

当前层、父层和子层要分开排查

“为什么清单里没有外层变量”通常不是排序问题。Names 只列当前层；如果要解析名称在当前位置可见的对象，应使用 LookupParent，并传入可靠的 token.Pos。如果要覆盖嵌套块，则从对应 Scope 的 Children 继续遍历，把每一层的名称保留在自己的记录中，避免不同层级同名时互相覆盖。

func lookupVisible(scope *types.Scope, name string, pos token.Pos) types.Object {
    if scope == nil {
        return nil
    }

    // 有源码位置时沿父作用域查询，结果能说明声明来自哪一层。
    _, object := scope.LookupParent(name, pos)
    return object
}

一个实用的调试记录可以包含：作用域的 Pos/End、Names() 的结果、查询名称、命中的对象类型。这样当快照发生变化时，能区分“当前层确实少了声明”和“查询本来就应该沿父链进行”。

稳定清单的落地检查

• 先完成 AST 解析和类型检查，再读取 Info.Scopes。
• 函数作用域使用 FuncDecl.Type 作为键，不用函数体节点替代。
• 当前层清单直接使用 Names()；过滤后再复制，不重复排序。
• 需要外层可见性时使用 LookupParent，需要嵌套块时记录子 Scope。
• 快照或索引同时保存 Scope 的来源和名称数量，方便定位语义错误。

常见问题

Names() 会返回父作用域名称吗？

不会。它只返回接收者 Scope 的元素名称；父作用域需要显式调用 Parent 或使用 LookupParent。

拿到排序结果后还要调用 sort.Strings 吗？

只为保持默认名称顺序时不需要。只有当你要按源码位置、大小写规则或对象类别输出时，才应建立独立的自定义排序键。