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(參數(shù)省略)(參數(shù)省略) {
	...
        //  加載項目go.mod的文件內(nèi)容
	initialRS := LoadModFile(ctx)
	...
}

// ${GOROOT}/src/cmd/go/internal/modload/init.go
func LoadModFile(ctx context.Context) *Requirements {
	...
	// 做一些初始化的設置，獲取當前項目的go.mod路徑
	// 執(zhí)行g(shù)o mod tidy 是的工作路徑往上一層層尋找，找到的第一個路徑即為目標路徑
        // 查找路徑的調(diào)用棧`Init() => findModuleRoot(base.Cwd())`
	Init()
	...
	// 讀取go.mod文件并解析該文件內(nèi)容;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)
	...
	// 如果發(fā)現(xiàn)當前的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) {
            // 實際上調(diào)用的是 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 {
    ...
    // 注這里是多次循環(huán)的過程
    // a=>b,只有當b加載后才能知道是否有b=>c,b=>d。
    // 所以這里會不斷的重復這個過程，直至所有的依賴關(guān)系構(gòu)建完畢
    for {
        ld.reset()
        ...
        // 找出項目下的文件夾路徑，這里的rootPkgs每次循環(huán)都是一樣的
        rootPkgs := ld.listRoots(ld.requirements)
        ...
        // 從根路徑出發(fā)，遍歷全部的文件，獲取依賴關(guān)系
        // 在加載依賴A的同時，會根據(jù)依賴A里面的go.mod繼續(xù)去找依賴B
        // 如果發(fā)現(xiàn)項目中有直接引用依賴A,但是當前項目的go.mod沒有(前面加載過，存放在ld.requirements),
        // 則會給該pkg一個err(這里不是module,是module里面的某個包，例如 A/xxxx,A/yyy),
        // 這里會交由ld.resolveMissingImports去處理
        for _, path := range rootPkgs {
            // 這里是并發(fā)加載，速度還是比較快的
            // 主要的邏輯在在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里面沒聲明，但是項目卻使用到了的
        // 如果發(fā)現(xiàn)沒有缺失的直接依賴了，即可認為依賴關(guān)系已經(jīng)構(gòu)建完畢。
        // 因為上述過程會自動構(gòu)建依賴關(guān)系，這里只是添加缺失的直接依賴，然后由上面的循環(huán)來構(gòu)建依賴關(guān)系
        modAddedBy := ld.resolveMissingImports(ctx)
        if len(modAddedBy) == 0 {
            break
        }
    }
    ...
}
// 因為構(gòu)建的是整個依賴關(guān)系，所以上述過程完成后，項目中不需要的依賴也已經(jīng)自動剔除了

// {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)
	...
	// 遞歸執(zhí)行 ld.pkg 組裝下數(shù)據(jù)結(jié)構(gòu)，又回來繼續(xù)調(diào)用 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)
	}
	...
}