Go语言技巧 - 6.【深入Go Module】探索最小版本选择的机制

var cmdTidy = &base.Command{
 UsageLine: "go mod tidy [-v]",
 Short:     "add missing and remove unused modules",
 Long: `
Tidy makes sure go.mod matches the source code in the module.
It adds any missing modules necessary to build the current module's
packages and dependencies, and it removes unused modules that
don't provide any relevant packages. It also adds any missing entries
to go.sum and removes any unnecessary ones.

The -v flag causes tidy to print information about removed modules
to standard error.
 `,
}

type Version struct {
 Path string
 Version string `json:",omitempty"`
}

// cmd/go/internal/mvs
mvs.Req(Target, direct, &mvsReqs{buildList: keep})

func Req(target module.Version, base []string, reqs Reqs) ([]module.Version, error) {
  // 保存模块与其依赖module的map，用map是为了防止依赖库重复
 reqCache := map[module.Version][]module.Version{}
 reqCache[target] = nil
  
  // 第一次遍历：walk函数，用于遍历整个依赖
 var walk func(module.Version) error
 walk = func(m module.Version) error {
  // 获取m的依赖库required，保存到map中
  required, err := reqs.Required(m)
  if err != nil {
   return err
  }
  reqCache[m] = required
    // 继续遍历依赖的依赖，保证不缺失
  for _, m1 := range required {
   if err := walk(m1); err != nil {
    return err
   }
  }
  postorder = append(postorder, m)
  return nil
 }
  
  // 真正运行第一次walk的地方
 for _, m := range list {
  if err := walk(m); err != nil {
   return nil, err
  }
 }

  // 第二次遍历：再次定义一个walk函数，取最大的版本号
 have := map[module.Version]bool{}
 walk = func(m module.Version) error {
  if have[m] {
   return nil
  }
  have[m] = true
  for _, m1 := range reqCache[m] {
   walk(m1)
  }
  return nil
 }
 max := map[string]string{}
 for _, m := range list {
  if v, ok := max[m.Path]; ok {
      // 只保存较大的版本号
      // 而v1与v2的问题也是在这里解决的：两者的Path路径不同
   max[m.Path] = reqs.Max(m.Version, v)
  } else {
   max[m.Path] = m.Version
  }
 }
 
  // 真正运行第二次walk的地方
 var min []module.Version
 for _, path := range base {
  m := module.Version{Path: path, Version: max[path]}
  min = append(min, m)
  walk(m)
 }
 
  // 根据名称排序
 sort.Slice(min, func(i, j int) bool {
  return min[i].Path < min[j].Path
 })
 return min, nil