详解Go 依赖管理 go mod tidy

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.

{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "GO debug",
            "type": "go",
            "request": "attach",
            "mode": "remote",
            "host": "127.0.0.1",
            "port": 2345,
        }
    ]
}

func runTidy(ctx context.Context, cmd *base.Command, args []string) {
        ...
	modload.LoadPackages(ctx, modload.PackageOpts{
		GoVersion:                tidyGo.String(),
		Tags:                     imports.AnyTags(),
		Tidy:                     true,
		TidyCompatibleVersion:    tidyCompat.String(),
		VendorModulesInGOROOTSrc: true,
		ResolveMissingImports:    true,
		LoadTests:                true,
		AllowErrors:              tidyE,
		SilenceMissingStdImports: true,
	}, "all")
}

// {GOROOT}/src/cmd/go/internal/modload/load.go
func LoadPackages(参数省略)(参数省略) {
	...
        //  加载项目go.mod的文件内容
	initialRS := LoadModFile(ctx)
	...
}

// ${GOROOT}/src/cmd/go/internal/modload/init.go
func LoadModFile(ctx context.Context) *Requirements {
	...
	// 做一些初始化的设置，获取当前项目的go.mod路径
	// 执行go mod tidy 是的工作路径往上一层层寻找，找到的第一个路径即为目标路径
        // 查找路径的调用栈`Init() => findModuleRoot(base.Cwd())`
	Init()
	...
	// 读取go.mod文件并解析该文件内容;modRoots的长度为1，大于1的情况我没有遇到过
	for _, modroot := range modRoots {
		gomod := modFilePath(modroot)
		data, f, err := ReadModFile(gomod, fixVersion(ctx, &fixed))
	}
	...
	// 只获取go.mod文件中的require列表，并记录每个依赖的最高版本号
	rs := requirementsFromModFiles(ctx, modFiles)
	...
	// 如果发现当前的go.mod文件有重复的依赖路径
        // 这里会先对当前项目的go.mod文件进行一次依赖项的计算
	if rs.hasRedundantRoot() {
        // If any module path appears more than once in the roots, we know that the
        // go.mod file needs to be updated even though we have not yet loaded any
        // transitive dependencies.
		...
	}
	...
}

// {GOROOT}/src/cmd/go/internal/modload/load.go
func LoadPackages(...) (...) {
    // 找出项目的所有依赖,有个全局变量负责最后的存储的
    ld := loadFromRoots(ctx, loaderParams{
        PackageOpts:  opts,
        requirements: initialRS,
        allPatternIsRoot: allPatternIsRoot,
        listRoots: func(rs *Requirements) (roots []string) {
            // 实际上调用的是 matchPackages() 方法
            updateMatches(rs, nil)
            // 这里的matches长度也是1个
            for _, m := range matches {
                roots = append(roots, m.Pkgs...)
            }
            return roots
        },
    })
}

// ${GOROOT}/src/cmd/go/internal/modload/search.go
func matchPackages(...) {
    // 遍历项目根路径
    walkPkgs := func(root, importPathRoot string, prune pruning) {
        ...
        // 这里的root为go.mod所在的目录，importPathRoot为go.mod定义的module
        err := fsys.Walk(root, func(path string, fi fs.FileInfo, err error) error {
            // 一大堆判断过滤
            ...
            // 包名 = moduleName + 相对路径
            name := importPathRoot + filepath.ToSlash(path[len(root):])
            if _, _, err := scanDir(path, tags); err != imports.ErrNoGo {
                m.Pkgs = append(m.Pkgs, name)
            }
            return nil
        })
    }
    // 同样的这里modules也只有1个，多个的没遇到过
    for _, mod := range modules {
        walkPkgs(root, modPrefix, prune)
    }
    return
}

// {GOROOT}/src/cmd/go/internal/modload/load.go
func loadFromRoots(ctx context.Context, params loaderParams) *loader {
    ...
    // 注这里是多次循环的过程
    // a=>b,只有当b加载后才能知道是否有b=>c,b=>d。
    // 所以这里会不断的重复这个过程，直至所有的依赖关系构建完毕
    for {
        ld.reset()
        ...
        // 找出项目下的文件夹路径，这里的rootPkgs每次循环都是一样的
        rootPkgs := ld.listRoots(ld.requirements)
        ...
        // 从根路径出发，遍历全部的文件，获取依赖关系
        // 在加载依赖A的同时，会根据依赖A里面的go.mod继续去找依赖B
        // 如果发现项目中有直接引用依赖A,但是当前项目的go.mod没有(前面加载过，存放在ld.requirements),
        // 则会给该pkg一个err(这里不是module,是module里面的某个包，例如 A/xxxx,A/yyy),
        // 这里会交由ld.resolveMissingImports去处理
        for _, path := range rootPkgs {
            // 这里是并发加载，速度还是比较快的
            // 主要的逻辑在在ld.load方法上
            root := ld.pkg(ctx, path, pkgIsRoot)
            if !inRoots[root] {
                ld.roots = append(ld.roots, root)
                inRoots[root] = true
            }
        }
        // 这个只是将依赖树给平铺了存放在 ld.pkgs
        ld.buildStacks()
        ...
        // 某种程度上, 可以认为这里下载的是缺失的直接依赖，即go.mod里面没声明，但是项目却使用到了的
        // 如果发现没有缺失的直接依赖了，即可认为依赖关系已经构建完毕。
        // 因为上述过程会自动构建依赖关系，这里只是添加缺失的直接依赖，然后由上面的循环来构建依赖关系
        modAddedBy := ld.resolveMissingImports(ctx)
        if len(modAddedBy) == 0 {
            break
        }
    }
    ...
}
// 因为构建的是整个依赖关系，所以上述过程完成后，项目中不需要的依赖也已经自动剔除了

// {GOROOT}/src/cmd/go/internal/modload/load.go
func (ld *loader) load(ctx context.Context, pkg *loadPkg) {
	... 
	// 找出pkg的module及其所在目录
	pkg.mod, pkg.dir, pkg.altMods, pkg.err = importFromModules(ctx, pkg.path, ld.requirements, mg)
	if pkg.dir == "" {
		return
	}
	...
	// 扫描文件获取所有的import
	// 这里是一个pkg的所有import
	/* 
	例如: 
		A/B/xxx.go 
			import "11111"
		A/B/yyy.go
			import "22222"
	则 pkg
		import "1111"
		import "2222"
	*/ 
	imports, testImports, err = scanDir(pkg.dir, ld.Tags)
	...
	// 递归执行 ld.pkg 组装下数据结构，又回来继续调用 ld.load
	for _, path := range imports {
		pkg.imports = append(pkg.imports, ld.pkg(ctx, path, importFlags))
	}
}

func LoadPackages(...) (...) {
	...
	if err := commitRequirements(ctx); err != nil {
		base.Fatalf("go: %v", err)
	}
	...
}