如何解析指定版本Go标准库常量并解决依赖导入问题？

我想要提取并打印特定版本Go标准库中定义的所有常量变量，操作步骤如下：

• 下载Go标准库源码（例如go1.22.1版本）
• 将src目录复制到/foo/bar路径
• 排除/foo/bar/src/cmd目录
• 使用go/parser、go/types和go/ast遍历并打印每个常量定义

以下是我使用的代码片段：

package main

import (
    "cmp"
    "fmt"
    "go/ast"
    "go/build"
    "go/importer"
    "go/parser"
    "go/token"
    "go/types"
    "os"
    "path/filepath"
    "sort"
    "strings"
)

type PackageInfo struct {
    DirPath        string
    Name           string
    Files          map[string]*ast.File
    Fileset        *token.FileSet
    CheckedPackage *types.Package
}

func MapToSortedKeys[K cmp.Ordered, V any](m map[K]V) []K {
    keys := make([]K, len(m))
    i := 0
    for k := range m {
        keys[i] = k
        i++
    }
    sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
    return keys
}

func MapToValues[M ~map[K]V, K comparable, V any](m M) []V {
    r := make([]V, 0, len(m))
    for _, v := range m {
        r = append(r, v)
    }
    return r
}

func main() {
    errorsAll := []error{}

    rootSourceDirectory := "/Users/shu/Downloads/asdasd/src"
    dir2Files := map[string][]string{}
    filepath.Walk(rootSourceDirectory, func(path string, d os.FileInfo, err error) error {
        // Exclude non-go files and tests
        if strings.HasSuffix(path, ".go") && !strings.HasSuffix(path, "_test.go") {
            fileDir := filepath.Dir(path)

            // Exclude testdatas
            if !strings.Contains(fileDir, "/testdata/") {
                if _, ok := dir2Files[fileDir]; !ok {
                    dir2Files[fileDir] = []string{}
                }
                dir2Files[fileDir] = append(dir2Files[fileDir], path)
            }
        }
        return nil
    })

    buildContext := build.Default
    fset := token.NewFileSet()
    pkgDirPathToInfo := map[string]PackageInfo{}
    for _, fileDir := range MapToSortedKeys(dir2Files) {
        sourceFiles := dir2Files[fileDir]
        for _, sourceFile := range sourceFiles {
            if ok, err := buildContext.MatchFile(fileDir, filepath.Base(sourceFile)); err == nil && ok {
                fileDir := filepath.Dir(sourceFile)
                currFileSet := token.NewFileSet()
                file, err := parser.ParseFile(currFileSet, sourceFile, nil, parser.ParseComments)
                if err == nil {
                    if packageInfo, exists := pkgDirPathToInfo[fileDir]; exists {
                        packageInfo.Files[sourceFile] = file
                        currFileSet.Iterate(func(f *token.File) bool {
                            packageInfo.Fileset.AddFile(f.Name(), -1, f.Size())
                            fset.AddFile(f.Name(), -1, f.Size())
                            return true
                        })
                    } else {
                        pkgDirPathToInfo[fileDir] = PackageInfo{
                            DirPath:        fileDir,
                            Name:           file.Name.Name,
                            Files:          map[string]*ast.File{sourceFile: file},
                            Fileset:        currFileSet,
                            CheckedPackage: nil,
                        }
                    }
                } else {
                    fmt.Printf("file parsing failed for %s: %s\n", sourceFile, err)
                }
            }
        }
    }

    conf := types.Config{
        Importer:                 importer.ForCompiler(token.NewFileSet(), "source", nil),
        IgnoreFuncBodies:         true,
        FakeImportC:              true,
        DisableUnusedImportCheck: true,
        GoVersion:                "go1.22.1",
    }

    info := &types.Info{
        Types: make(map[ast.Expr]types.TypeAndValue),
    }
    for _, fileDir := range MapToSortedKeys(pkgDirPathToInfo) {
        pkgInfo := pkgDirPathToInfo[fileDir]
        checkedPackage, err := conf.Check(pkgInfo.Name, pkgInfo.Fileset, MapToValues(pkgInfo.Files), info)
        if err == nil {
            pkgInfo.CheckedPackage = checkedPackage
            pkgDirPathToInfo[fileDir] = pkgInfo
        } else {
            errorsAll = append(errorsAll, fmt.Errorf("%s: %s", pkgInfo.Name, err))
        }
    }

    fmt.Printf("Errors (%v):\n", len(errorsAll))
    for _, err := range errorsAll {
        fmt.Println(err)
    }

    fmt.Println()
    fmt.Printf("Constants (%v):\n", len(info.Types))
    for _, tv := range info.Types {
        if tv.Value != nil {
            fmt.Printf("%s: %s\n", tv.Type.String(), tv.Value.ExactString())
        }
    }
}

代码大体可用，但遇到了依赖相关错误，例如：

• could not import golang.org/x/crypto/cryptobyte (no required module provides package golang.org/x/crypto/cryptobyte; to add it: go get golang.org/x/crypto/cryptobyte)
• could not import github.com/mmcloughlin/avo/build (no required module provides package github.com/mmcloughlin/avo/build; to add it: go get github.com/mmcloughlin/avo/build)

手动安装依赖后代码可运行，但需要重复处理所有嵌套依赖，且不确定如何获取这些依赖。另外，类型检查必须解析这些依赖，因为部分常量可能依赖于依赖包中的常量，所以解析依赖对准确获取常量值至关重要。

请问如何获取所有依赖并配置脚本从指定文件路径（如/foo/bar/src/vendor）导入，而非依赖系统安装的包？

一、获取Go标准库的完整依赖（含vendor目录） #

Go官方发布版的源码已经包含所有依赖的外部包，存放在vendor目录中，无需手动go get：

1. 从Go官方下载对应版本的源码压缩包（比如go1.22.1），解压后直接将根目录下的src和vendor文件夹复制到你的目标路径（如/foo/bar）
2. 若使用GitHub仓库，需拉取完整子模块：

git clone https://github.com/golang/go.git
cd go
git checkout go1.22.1
git submodule update --init --recursive

执行后仓库会包含所有依赖的外部包。

二、实现自定义导入器，指定从vendor目录加载依赖 #

默认导入器会使用系统Go模块环境，我们需要自定义types.Importer，让它优先从指定的vendor目录查找包：

1. 定义自定义导入器结构体 #

type VendorImporter struct {
    vendorDir string
    cache     map[string]*types.Package
    fset      *token.FileSet
    conf      *types.Config
}

func NewVendorImporter(vendorDir string, conf *types.Config) *VendorImporter {
    return &VendorImporter{
        vendorDir: vendorDir,
        cache:     make(map[string]*types.Package),
        fset:      token.NewFileSet(),
        conf:      conf,
    }
}

2. 实现Import方法 #

func (vi *VendorImporter) Import(path string) (*types.Package, error) {
    // 缓存命中直接返回
    if pkg, ok := vi.cache[path]; ok {
        return pkg, nil
    }

    // 先从vendor目录查找包路径
    vendorPkgPath := filepath.Join(vi.vendorDir, path)
    if _, err := os.Stat(vendorPkgPath); os.IsNotExist(err) {
        // vendor目录没有则尝试标准库src目录
        stdPkgPath := filepath.Join(filepath.Dir(vi.vendorDir), path)
        if _, err := os.Stat(stdPkgPath); os.IsNotExist(err) {
            return nil, fmt.Errorf("package %s not found in vendor or std src", path)
        }
        vendorPkgPath = stdPkgPath
    }

    // 遍历包目录下的非测试Go文件
    var files []*ast.File
    err := filepath.Walk(vendorPkgPath, func(p string, d os.FileInfo, err error) error {
        if d.IsDir() && strings.HasSuffix(p, "testdata") {
            return filepath.SkipDir
        }
        if strings.HasSuffix(p, ".go") && !strings.HasSuffix(p, "_test.go") {
            f, err := parser.ParseFile(vi.fset, p, nil, parser.ParseComments)
            if err != nil {
                return err
            }
            files = append(files, f)
        }
        return nil
    })
    if err != nil {
        return nil, err
    }

    // 类型检查并缓存包
    pkg, err := vi.conf.Check(path, vi.fset, files, nil)
    if err != nil {
        return nil, err
    }
    vi.cache[path] = pkg
    return pkg, nil
}

3. 替换默认导入器 #

在主函数中修改types.Config的Importer字段：

// 指定vendor目录路径
vendorDir := "/foo/bar/src/vendor"

conf := types.Config{
    Importer:                 NewVendorImporter(vendorDir, &conf),
    IgnoreFuncBodies:         true,
    FakeImportC:              true,
    DisableUnusedImportCheck: true,
    GoVersion:                "go1.22.1",
}

三、调整路径与遍历逻辑 #

• 确保rootSourceDirectory指向完整的标准库src目录，且同级存在vendor目录
• 若只需提取标准库自身的常量，可在遍历文件时排除vendor目录；若需要依赖包中的常量，则保留遍历

四、额外注意事项 #

• 确保本地Go版本与下载的标准库版本一致，避免语法或类型检查错误
• 自定义导入器的缓存机制可避免重复解析同一包，提升效率

内容的提问来源于stack exchange，提问作者VanDir