从你的描述来看，主要问题在于编译的并行性和文件系统操作的时机。以下是针对你问题的具体分析：

1. 代码插入位置问题

你的插入位置不正确。b.Do(ctx, a) 是异步执行的，它会启动编译任务但不会等待所有任务完成。你需要等待所有编译任务完成后再进行收集操作。

正确的做法是在 runBuild 函数的末尾，所有编译任务完成后进行收集。查看源码，你应该在 build 函数返回前处理：

// 在 runBuild 函数末尾，build 函数调用后添加
func runBuild(ctx context.Context, cmd *base.Command, args []string) {
    // ... 原有代码 ...
    
    // 等待所有编译任务完成
    b.Wait()
    
    // 现在所有包都已编译完成，可以安全收集信息
    var mainPath string
    for _, p := range pkgs {
        if p.Name == "main" {
            mainPath = p.Dir
            break
        }
    }
    
    if mainPath != "" {
        collect(pkgs, mainPath)
    }
}

2. p.Dir 字段的正确性

p.Dir 字段是正确的，它表示包的源代码目录。但需要注意，对于标准库包和第三方依赖，它们的 Dir 路径可能不在当前项目目录下。

3. 编译并行性问题

是的，Go 编译过程是高度并行的。这是导致你收集失败的主要原因。多个包同时编译，你的收集操作可能在部分包还未完成编译时就执行了。

解决方案示例

以下是修改后的 collect 函数实现，需要考虑并发安全和文件锁定：

func collect(pkgs []*load.Package, mainPath string) error {
    // 创建主信息文件
    mainInfoFile := filepath.Join(mainPath, "compilation_info.txt")
    mainFile, err := os.OpenFile(mainInfoFile, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        return err
    }
    defer mainFile.Close()
    
    // 使用互斥锁确保线程安全
    var mu sync.Mutex
    
    // 为每个包启动goroutine收集信息
    var wg sync.WaitGroup
    errors := make(chan error, len(pkgs))
    
    for _, pkg := range pkgs {
        wg.Add(1)
        go func(p *load.Package) {
            defer wg.Done()
            
            // 检查信息文件是否存在
            infoFile := filepath.Join(p.Dir, "info.txt")
            if _, err := os.Stat(infoFile); os.IsNotExist(err) {
                return // 该包没有生成信息文件
            }
            
            // 读取包的信息文件
            content, err := os.ReadFile(infoFile)
            if err != nil {
                errors <- fmt.Errorf("读取 %s 失败: %v", infoFile, err)
                return
            }
            
            // 写入主信息文件（需要加锁）
            mu.Lock()
            _, err = mainFile.WriteString(fmt.Sprintf("=== Package: %s ===\n", p.ImportPath))
            if err == nil {
                _, err = mainFile.Write(content)
                if err == nil {
                    _, err = mainFile.WriteString("\n\n")
                }
            }
            mu.Unlock()
            
            if err != nil {
                errors <- fmt.Errorf("写入主文件失败: %v", err)
            }
        }(pkg)
    }
    
    wg.Wait()
    close(errors)
    
    // 检查是否有错误
    for err := range errors {
        if err != nil {
            return err
        }
    }
    
    return nil
}

在编译器中的正确插入点

在 src/cmd/go/internal/work/build.go 中，找到 runBuild 函数，在函数返回前添加：

// 在 runBuild 函数中，build 调用之后
func runBuild(ctx context.Context, cmd *base.Command, args []string) {
    // ... 原有代码 ...
    
    // 执行构建
    b := work.NewBuilder(work.BuilderModeTool)
    defer func() {
        if err := b.Close(); err != nil && cfg.BuildN {
            base.Error(err)
        }
    }()
    
    // 原有的构建逻辑...
    
    // 等待所有任务完成
    b.Wait()
    
    // 收集编译信息
    if err := collectCompilationInfo(pkgs); err != nil {
        base.Fatalf("收集编译信息失败: %v", err)
    }
}

func collectCompilationInfo(pkgs []*load.Package) error {
    // 找到主包
    var mainPkg *load.Package
    for _, p := range pkgs {
        if p.Name == "main" && !strings.Contains(p.ImportPath, "/internal/") {
            mainPkg = p
            break
        }
    }
    
    if mainPkg == nil {
        return nil // 没有主包，不收集
    }
    
    return collect(pkgs, mainPkg.Dir)
}

关键修改点总结

1. 等待机制：在 b.Do() 后添加 b.Wait() 确保所有编译任务完成
2. 并发安全：使用 sync.Mutex 保护文件写入操作
3. 错误处理：正确处理文件不存在的情况
4. 时机正确：在所有编译任务完成后进行文件操作

这些修改能确保在所有包编译完成且信息文件生成后，安全地将信息收集到主包目录中。