如何在golang.org/x/tools中创建全局仅运行一次而非逐包运行的分析器（Analyzer）

我完全懂你的困扰——golang.org/x/tools里的analysis.Analyzer默认是逐包执行Run方法的，这对需要全局视角的分析场景（比如你要先收集全代码库的结构体声明，再统一检查它们的实例化逻辑）确实不太友好。你之前尝试用状态保存的方式，但因为包的处理顺序不确定，导致结果不稳定，这很正常，毕竟分析框架本身是并行处理包的。

其实我们可以利用框架的扩展能力，把分析拆成收集阶段和全局检查阶段两步来实现，具体做法如下：

1. 定义线程安全的全局存储 #

首先，我们需要一个线程安全的容器来保存所有包的结构体信息（以及你需要的实例化信息），避免并行处理时的竞争问题：

import (
    "sync"
    "go/ast"
    "go/token"
    "golang.org/x/tools/go/analysis"
)

// 定义你需要的结构体信息结构体
type StructDeclaration struct {
    FullName string // 用「包名.结构体名」避免同名冲突
    // 可以添加其他字段，比如字段列表、定义位置等
}

// 定义实例化信息结构体（如果需要检查实例化）
type StructInstantiation struct {
    StructFullName string
    Pos            token.Pos // 实例化的位置，用于报错
    // 其他你需要的实例化相关信息
}

// 全局存储，用互斥锁保护并发访问
var (
    allStructDecls     []StructDeclaration
    allStructInsts     []StructInstantiation
    globalStoreMu      sync.Mutex
)

2. 在Run方法中收集信息 #

修改你的run函数，不再直接做检查，而是专注于收集当前包的结构体声明和实例化信息：

func run(pass *analysis.Pass) (any, error) {
    // 遍历当前包的所有文件
    for _, file := range pass.Files {
        ast.Inspect(file, func(n ast.Node) bool {
            // 收集结构体声明
            if typeSpec, ok := n.(*ast.TypeSpec); ok {
                if _, isStruct := typeSpec.Type.(*ast.StructType); isStruct {
                    fullName := pass.Pkg.Name() + "." + typeSpec.Name.Name
                    decl := StructDeclaration{FullName: fullName}
                    
                    // 加锁写入全局存储
                    globalStoreMu.Lock()
                    allStructDecls = append(allStructDecls, decl)
                    globalStoreMu.Unlock()
                }
            }

            // 收集结构体实例化（比如ast.CompositeLit对应的结构体实例）
            if compositeLit, ok := n.(*ast.CompositeLit); ok {
                typ := pass.TypesInfo.TypeOf(compositeLit.Type)
                if typ != nil {
                    fullStructName := typ.String()
                    inst := StructInstantiation{
                        StructFullName: fullStructName,
                        Pos:            compositeLit.Pos(),
                    }

                    globalStoreMu.Lock()
                    allStructInsts = append(allStructInsts, inst)
                    globalStoreMu.Unlock()
                }
            }

            return true
        })
    }

    // 这里不需要返回结果，只做收集
    return nil, nil
}

3. 利用Driver钩子执行全局检查 #

默认的singlechecker.Main不会帮我们触发全局检查，所以我们需要自定义driver.Config，通过PostRun钩子在所有包分析完成后执行全局逻辑：

import (
    "log"
    "golang.org/x/tools/go/analysis/driver"
    "golang.org/x/tools/go/analysis/passes/inspect"
)

func main() {
    // 定义你的分析器
    myAnalyzer := &analysis.Analyzer{
        Name:     "mylinter",
        Doc:      "my documentation.",
        Run:      run,
        Requires: []*analysis.Analyzer{inspect.Analyzer},
    }

    // 配置Driver，添加前置和后置钩子
    cfg := driver.Config{
        Analyzers: []*analysis.Analyzer{myAnalyzer},
        // PreRun：每次分析前重置全局存储，避免测试或多次运行时的残留数据
        PreRun: func(pass *driver.Pass) error {
            globalStoreMu.Lock()
            allStructDecls = nil
            allStructInsts = nil
            globalStoreMu.Unlock()
            return nil
        },
        // PostRun：所有包分析完成后，执行全局检查
        PostRun: func(pass *driver.Pass) error {
            globalStoreMu.Lock()
            // 复制一份数据，避免后续锁持有时间过长
            structDecls := make([]StructDeclaration, len(allStructDecls))
            structInsts := make([]StructInstantiation, len(allStructInsts))
            copy(structDecls, allStructDecls)
            copy(structInsts, allStructInsts)
            globalStoreMu.Unlock()

            // 这里写你的全局检查逻辑
            for _, inst := range structInsts {
                // 查找对应的结构体声明
                var targetDecl *StructDeclaration
                for _, decl := range structDecls {
                    if decl.FullName == inst.StructFullName {
                        targetDecl = &decl
                        break
                    }
                }

                if targetDecl != nil {
                    // 执行你的检查规则，比如检查实例化是否符合要求
                    // 如果发现问题，用pass.Reportf报告错误
                    // pass.Reportf(inst.Pos, "结构体%s的实例化不符合规则", targetDecl.FullName)
                }
            }

            return nil
        },
    }

    // 启动Driver
    if err := driver.Run(&cfg); err != nil {
        log.Fatal(err)
    }
}

关键注意事项 #

• 并发安全：一定要用互斥锁保护全局存储，因为分析框架会并行处理多个包，直接写入会导致数据竞争。
• 数据重置：在PreRun中清空全局存储，避免多次运行（比如测试场景）时残留上一次的分析数据。
• 全限定名：收集结构体时一定要用「包名.结构体名」的全限定名，避免不同包中同名结构体的混淆。
• 跨包类型解析：收集实例化信息时，不要直接用AST中的标识符，而是通过pass.TypesInfo.TypeOf获取完整的类型信息，这样才能正确识别跨包的结构体。

内容来源于stack exchange