"cmd/go/internal/base"
"cmd/go/internal/cfg"
"cmd/go/internal/envcmd"
+ "cmd/go/internal/modload"
"cmd/go/internal/web"
"cmd/go/internal/work"
)
if len(args) > 0 {
base.Fatalf("go: bug takes no arguments")
}
- work.BuildInit()
+ work.BuildInit(modload.LoaderState)
var buf strings.Builder
buf.WriteString(bugHeader)
}
func runClean(ctx context.Context, cmd *base.Command, args []string) {
- modload.InitWorkfile()
+ modload.InitWorkfile(modload.LoaderState)
if len(args) > 0 {
cacheFlag := ""
switch {
// either the flags and arguments explicitly imply a package,
// or no other target (such as a cache) was requested to be cleaned.
cleanPkg := len(args) > 0 || cleanI || cleanR
- if (!modload.Enabled() || modload.HasModRoot()) &&
+ if (!modload.Enabled(modload.LoaderState) || modload.HasModRoot(modload.LoaderState)) &&
!cleanCache && !cleanModcache && !cleanTestcache && !cleanFuzzcache {
cleanPkg = true
}
if cleanPkg {
- for _, pkg := range load.PackagesAndErrors(ctx, load.PackageOpts{}, args) {
+ for _, pkg := range load.PackagesAndErrors(modload.LoaderState, ctx, load.PackageOpts{}, args) {
clean(pkg)
}
}
// ExtraEnvVars returns environment variables that should not leak into child processes.
func ExtraEnvVars() []cfg.EnvVar {
gomod := ""
- modload.Init()
- if modload.HasModRoot() {
+ modload.Init(modload.LoaderState)
+ if modload.HasModRoot(modload.LoaderState) {
gomod = modload.ModFilePath()
- } else if modload.Enabled() {
+ } else if modload.Enabled(modload.LoaderState) {
gomod = os.DevNull
}
- modload.InitWorkfile()
- gowork := modload.WorkFilePath()
+ modload.InitWorkfile(modload.LoaderState)
+ gowork := modload.WorkFilePath(modload.LoaderState)
// As a special case, if a user set off explicitly, report that in GOWORK.
if cfg.Getenv("GOWORK") == "off" {
gowork = "off"
}
}
if needCostly {
- work.BuildInit()
+ work.BuildInit(modload.LoaderState)
env = append(env, ExtraEnvVarsCostly()...)
}
baseGofmtArgs := len(gofmtArgs)
baseGofmtArgLen := gofmtArgLen
- for _, pkg := range load.PackagesAndErrors(ctx, load.PackageOpts{}, args) {
- if modload.Enabled() && pkg.Module != nil && !pkg.Module.Main {
+ for _, pkg := range load.PackagesAndErrors(modload.LoaderState, ctx, load.PackageOpts{}, args) {
+ if modload.Enabled(modload.LoaderState) && pkg.Module != nil && !pkg.Module.Main {
if !printed {
fmt.Fprintf(os.Stderr, "go: not formatting packages in dependency modules\n")
printed = true
if pkg.Error != nil {
if _, ok := errors.AsType[*load.NoGoError](pkg.Error); ok {
// Skip this error, as we will format all files regardless.
- } else if _, ok := errors.AsType[*load.EmbedError](pkg.Error); ok && len(pkg.InternalAllGoFiles()) > 0 {
+ } else if _, ok := errors.AsType[*load.EmbedError](pkg.Error); ok && len(pkg.InternalAllGoFiles()) > 0 {
// Skip this error, as we will format all files regardless.
} else {
base.Errorf("%v", pkg.Error)
}
func runGenerate(ctx context.Context, cmd *base.Command, args []string) {
- modload.InitWorkfile()
+ modload.InitWorkfile(modload.LoaderState)
if generateRunFlag != "" {
var err error
// Even if the arguments are .go files, this loop suffices.
printed := false
pkgOpts := load.PackageOpts{IgnoreImports: true}
- for _, pkg := range load.PackagesAndErrors(ctx, pkgOpts, args) {
- if modload.Enabled() && pkg.Module != nil && !pkg.Module.Main {
+ for _, pkg := range load.PackagesAndErrors(modload.LoaderState, ctx, pkgOpts, args) {
+ if modload.Enabled(modload.LoaderState) && pkg.Module != nil && !pkg.Module.Main {
if !printed {
fmt.Fprintf(os.Stderr, "go: not generating in packages in dependency modules\n")
printed = true
var nl = []byte{'\n'}
func runList(ctx context.Context, cmd *base.Command, args []string) {
- modload.InitWorkfile()
+ modload.InitWorkfile(modload.LoaderState)
if *listFmt != "" && listJson {
base.Fatalf("go list -f cannot be used with -json")
if *listReuse != "" && !*listM {
base.Fatalf("go list -reuse cannot be used without -m")
}
- if *listReuse != "" && modload.HasModRoot() {
+ if *listReuse != "" && modload.HasModRoot(modload.LoaderState) {
base.Fatalf("go list -reuse cannot be used inside a module")
}
- work.BuildInit()
+ work.BuildInit(modload.LoaderState)
out := newTrackingWriter(os.Stdout)
defer out.w.Flush()
}
}
- modload.Init()
+ modload.Init(modload.LoaderState)
if *listRetracted {
if cfg.BuildMod == "vendor" {
base.Fatalf("go list -retracted cannot be used when vendoring is enabled")
}
- if !modload.Enabled() {
+ if !modload.Enabled(modload.LoaderState) {
base.Fatalf("go list -retracted can only be used in module-aware mode")
}
}
base.Fatalf("go list -test cannot be used with -m")
}
- if modload.Init(); !modload.Enabled() {
+ if modload.Init(modload.LoaderState); !modload.Enabled(modload.LoaderState) {
base.Fatalf("go: list -m cannot be used with GO111MODULE=off")
}
- modload.LoadModFile(ctx) // Sets cfg.BuildMod as a side-effect.
+ modload.LoadModFile(modload.LoaderState, ctx) // Sets cfg.BuildMod as a side-effect.
if cfg.BuildMod == "vendor" {
const actionDisabledFormat = "go: can't %s using the vendor directory\n\t(Use -mod=mod or -mod=readonly to bypass.)"
SuppressBuildInfo: !*listExport && !listJsonFields.needAny("Stale", "StaleReason"),
SuppressEmbedFiles: !*listExport && !listJsonFields.needAny("EmbedFiles", "TestEmbedFiles", "XTestEmbedFiles"),
}
- pkgs := load.PackagesAndErrors(ctx, pkgOpts, args)
+ pkgs := load.PackagesAndErrors(modload.LoaderState, ctx, pkgOpts, args)
if !*listE {
w := 0
for _, pkg := range pkgs {
b.NeedExport = *listExport
b.NeedCompiledGoFiles = *listCompiled
if cfg.BuildCover {
- load.PrepareForCoverageBuild(pkgs)
+ load.PrepareForCoverageBuild(modload.LoaderState, pkgs)
}
a := &work.Action{}
// TODO: Use pkgsFilter?
import (
"cmd/go/internal/base"
+ "cmd/go/internal/modload"
"cmd/internal/quoted"
"fmt"
"strings"
return fmt.Errorf("parameter may not start with quote character %c", v[0])
}
pattern := strings.TrimSpace(v[:i])
- match = MatchPackage(pattern, cwd)
+ match = MatchPackage(modload.LoaderState, pattern, cwd)
v = v[i+1:]
}
flags, err := quoted.Split(v)
// defaultGODEBUG returns the default GODEBUG setting for the main package p.
// When building a test binary, directives, testDirectives, and xtestDirectives
// list additional directives from the package under test.
-func defaultGODEBUG(p *Package, directives, testDirectives, xtestDirectives []build.Directive) string {
+func defaultGODEBUG(loaderstate *modload.State, p *Package, directives, testDirectives, xtestDirectives []build.Directive) string {
if p.Name != "main" {
return ""
}
- goVersion := modload.LoaderState.MainModules.GoVersion()
- if modload.LoaderState.RootMode == modload.NoRoot && p.Module != nil {
+ goVersion := loaderstate.MainModules.GoVersion(loaderstate)
+ if loaderstate.RootMode == modload.NoRoot && p.Module != nil {
// This is go install pkg@version or go run pkg@version.
// Use the Go version from the package.
// If there isn't one, then assume Go 1.20,
}
// Add directives from main module go.mod.
- for _, g := range modload.LoaderState.MainModules.Godebugs() {
+ for _, g := range loaderstate.MainModules.Godebugs(loaderstate) {
if m == nil {
m = make(map[string]string)
}
)
// LoadPackage does Load import, but without a parent package load context
-func LoadPackage(ctx context.Context, opts PackageOpts, path, srcDir string, stk *ImportStack, importPos []token.Position, mode int) *Package {
- p, err := loadImport(ctx, opts, nil, path, srcDir, nil, stk, importPos, mode)
+func LoadPackage(loaderstate *modload.State, ctx context.Context, opts PackageOpts, path, srcDir string, stk *ImportStack, importPos []token.Position, mode int) *Package {
+ p, err := loadImport(loaderstate, ctx, opts, nil, path, srcDir, nil, stk, importPos, mode)
if err != nil {
base.Fatalf("internal error: loadImport of %q with nil parent returned an error", path)
}
// The returned PackageError, if any, describes why parent is not allowed
// to import the named package, with the error referring to importPos.
// The PackageError can only be non-nil when parent is not nil.
-func loadImport(ctx context.Context, opts PackageOpts, pre *preload, path, srcDir string, parent *Package, stk *ImportStack, importPos []token.Position, mode int) (*Package, *PackageError) {
+func loadImport(loaderstate *modload.State, ctx context.Context, opts PackageOpts, pre *preload, path, srcDir string, parent *Package, stk *ImportStack, importPos []token.Position, mode int) (*Package, *PackageError) {
ctx, span := trace.StartSpan(ctx, "modload.loadImport "+path)
defer span.Done()
parentRoot = parent.Root
parentIsStd = parent.Standard
}
- bp, loaded, err := loadPackageData(ctx, path, parentPath, srcDir, parentRoot, parentIsStd, mode)
+ bp, loaded, err := loadPackageData(loaderstate, ctx, path, parentPath, srcDir, parentRoot, parentIsStd, mode)
if loaded && pre != nil && !opts.IgnoreImports {
- pre.preloadImports(ctx, opts, bp.Imports, bp)
+ pre.preloadImports(loaderstate, ctx, opts, bp.Imports, bp)
}
if bp == nil {
p := &Package{
// Load package.
// loadPackageData may return bp != nil even if an error occurs,
// in order to return partial information.
- p.load(ctx, opts, path, stk, importPos, bp, err)
+ p.load(loaderstate, ctx, opts, path, stk, importPos, bp, err)
if !cfg.ModulesEnabled && path != cleanImport(path) {
p.Error = &PackageError{
}
// Checked on every import because the rules depend on the code doing the importing.
- if perr := disallowInternal(ctx, srcDir, parent, parentPath, p, stk); perr != nil {
+ if perr := disallowInternal(loaderstate, ctx, srcDir, parent, parentPath, p, stk); perr != nil {
perr.setPos(importPos)
return p, perr
}
//
// loadPackageData returns a boolean, loaded, which is true if this is the
// first time the package was loaded. Callers may preload imports in this case.
-func loadPackageData(ctx context.Context, path, parentPath, parentDir, parentRoot string, parentIsStd bool, mode int) (bp *build.Package, loaded bool, err error) {
+func loadPackageData(loaderstate *modload.State, ctx context.Context, path, parentPath, parentDir, parentRoot string, parentIsStd bool, mode int) (bp *build.Package, loaded bool, err error) {
ctx, span := trace.StartSpan(ctx, "load.loadPackageData "+path)
defer span.Done()
r.path = newPath
r.dir = dir
} else if cfg.ModulesEnabled {
- r.dir, r.path, r.err = modload.Lookup(parentPath, parentIsStd, path)
+ r.dir, r.path, r.err = modload.Lookup(loaderstate, parentPath, parentIsStd, path)
} else if build.IsLocalImport(path) {
r.dir = filepath.Join(parentDir, path)
r.path = dirToImportPath(r.dir)
// find out the key to use in packageCache without the
// overhead of repeated calls to buildContext.Import.
// The code is also needed in a few other places anyway.
- r.path = resolveImportPath(path, parentPath, parentDir, parentRoot, parentIsStd)
+ r.path = resolveImportPath(loaderstate, path, parentPath, parentDir, parentRoot, parentIsStd)
} else if mode&ResolveModule != 0 {
r.path = moduleImportPath(path, parentPath, parentDir, parentRoot)
}
} else {
buildContext.GOPATH = "" // Clear GOPATH so packages are imported as pure module packages
}
- modroot := modload.PackageModRoot(ctx, r.path)
+ modroot := modload.PackageModRoot(loaderstate, ctx, r.path)
if modroot == "" && str.HasPathPrefix(r.dir, cfg.GOROOTsrc) {
modroot = cfg.GOROOTsrc
gorootSrcCmd := filepath.Join(cfg.GOROOTsrc, "cmd")
if cfg.ModulesEnabled {
// Override data.p.Root, since ImportDir sets it to $GOPATH, if
// the module is inside $GOPATH/src.
- if info := modload.PackageModuleInfo(ctx, path); info != nil {
+ if info := modload.PackageModuleInfo(loaderstate, ctx, path); info != nil {
data.p.Root = info.Dir
}
}
if cfg.GOBIN != "" {
data.p.BinDir = cfg.GOBIN
} else if cfg.ModulesEnabled {
- data.p.BinDir = modload.BinDir()
+ data.p.BinDir = modload.BinDir(loaderstate)
}
}
// preloadMatches loads data for package paths matched by patterns.
// When preloadMatches returns, some packages may not be loaded yet, but
// loadPackageData and loadImport are always safe to call.
-func (pre *preload) preloadMatches(ctx context.Context, opts PackageOpts, matches []*search.Match) {
+func (pre *preload) preloadMatches(loaderstate *modload.State, ctx context.Context, opts PackageOpts, matches []*search.Match) {
for _, m := range matches {
for _, pkg := range m.Pkgs {
select {
case pre.sema <- struct{}{}:
go func(pkg string) {
mode := 0 // don't use vendoring or module import resolution
- bp, loaded, err := loadPackageData(ctx, pkg, "", base.Cwd(), "", false, mode)
+ bp, loaded, err := loadPackageData(loaderstate, ctx, pkg, "", base.Cwd(), "", false, mode)
<-pre.sema
if bp != nil && loaded && err == nil && !opts.IgnoreImports {
- pre.preloadImports(ctx, opts, bp.Imports, bp)
+ pre.preloadImports(loaderstate, ctx, opts, bp.Imports, bp)
}
}(pkg)
}
// preloadImports queues a list of imports for preloading.
// When preloadImports returns, some packages may not be loaded yet,
// but loadPackageData and loadImport are always safe to call.
-func (pre *preload) preloadImports(ctx context.Context, opts PackageOpts, imports []string, parent *build.Package) {
+func (pre *preload) preloadImports(loaderstate *modload.State, ctx context.Context, opts PackageOpts, imports []string, parent *build.Package) {
parentIsStd := parent.Goroot && parent.ImportPath != "" && search.IsStandardImportPath(parent.ImportPath)
for _, path := range imports {
if path == "C" || path == "unsafe" {
return
case pre.sema <- struct{}{}:
go func(path string) {
- bp, loaded, err := loadPackageData(ctx, path, parent.ImportPath, parent.Dir, parent.Root, parentIsStd, ResolveImport)
+ bp, loaded, err := loadPackageData(loaderstate, ctx, path, parent.ImportPath, parent.Dir, parent.Root, parentIsStd, ResolveImport)
<-pre.sema
if bp != nil && loaded && err == nil && !opts.IgnoreImports {
- pre.preloadImports(ctx, opts, bp.Imports, bp)
+ pre.preloadImports(loaderstate, ctx, opts, bp.Imports, bp)
}
}(path)
}
parentRoot = parent.Root
parentIsStd = parent.Standard
}
- return resolveImportPath(path, parentPath, parentDir, parentRoot, parentIsStd)
+ return resolveImportPath(modload.LoaderState, path, parentPath, parentDir, parentRoot, parentIsStd)
}
-func resolveImportPath(path, parentPath, parentDir, parentRoot string, parentIsStd bool) (found string) {
+func resolveImportPath(loaderstate *modload.State, path, parentPath, parentDir, parentRoot string, parentIsStd bool) (found string) {
if cfg.ModulesEnabled {
- if _, p, e := modload.Lookup(parentPath, parentIsStd, path); e == nil {
+ if _, p, e := modload.Lookup(loaderstate, parentPath, parentIsStd, path); e == nil {
return p
}
return path
// is allowed to import p.
// If the import is allowed, disallowInternal returns the original package p.
// If not, it returns a new package containing just an appropriate error.
-func disallowInternal(ctx context.Context, srcDir string, importer *Package, importerPath string, p *Package, stk *ImportStack) *PackageError {
+func disallowInternal(loaderstate *modload.State, ctx context.Context, srcDir string, importer *Package, importerPath string, p *Package, stk *ImportStack) *PackageError {
// golang.org/s/go14internal:
// An import of a path containing the element “internal”
// is disallowed if the importing code is outside the tree
// directory containing them.
// If the directory is outside the main modules, this will resolve to ".",
// which is not a prefix of any valid module.
- importerPath, _ = modload.LoaderState.MainModules.DirImportPath(ctx, importer.Dir)
+ importerPath, _ = loaderstate.MainModules.DirImportPath(loaderstate, ctx, importer.Dir)
}
parentOfInternal := p.ImportPath[:i]
if str.HasPathPrefix(importerPath, parentOfInternal) {
// load populates p using information from bp, err, which should
// be the result of calling build.Context.Import.
// stk contains the import stack, not including path itself.
-func (p *Package) load(ctx context.Context, opts PackageOpts, path string, stk *ImportStack, importPos []token.Position, bp *build.Package, err error) {
+func (p *Package) load(loaderstate *modload.State, ctx context.Context, opts PackageOpts, path string, stk *ImportStack, importPos []token.Position, bp *build.Package, err error) {
p.copyBuild(opts, bp)
// The localPrefix is the path we interpret ./ imports relative to,
elem = full
}
if p.Internal.Build.BinDir == "" && cfg.ModulesEnabled {
- p.Internal.Build.BinDir = modload.BinDir()
+ p.Internal.Build.BinDir = modload.BinDir(loaderstate)
}
if p.Internal.Build.BinDir != "" {
// Install to GOBIN or bin of GOPATH entry.
pkgPath = "command-line-arguments"
}
if cfg.ModulesEnabled {
- p.Module = modload.PackageModuleInfo(ctx, pkgPath)
+ p.Module = modload.PackageModuleInfo(loaderstate, ctx, pkgPath)
}
- p.DefaultGODEBUG = defaultGODEBUG(p, nil, nil, nil)
+ p.DefaultGODEBUG = defaultGODEBUG(loaderstate, p, nil, nil, nil)
if !opts.SuppressEmbedFiles {
p.EmbedFiles, p.Internal.Embed, err = resolveEmbed(p.Dir, p.EmbedPatterns)
if path == "C" {
continue
}
- p1, err := loadImport(ctx, opts, nil, path, p.Dir, p, stk, p.Internal.Build.ImportPos[path], ResolveImport)
+ p1, err := loadImport(loaderstate, ctx, opts, nil, path, p.Dir, p, stk, p.Internal.Build.ImportPos[path], ResolveImport)
if err != nil && p.Error == nil {
p.Error = err
p.Incomplete = true
}
walkTest := func(root *Package, path string) {
var stk ImportStack
- p1, err := loadImport(ctx, opts, nil, path, root.Dir, root, &stk, root.Internal.Build.TestImportPos[path], ResolveImport)
+ p1, err := loadImport(modload.LoaderState, ctx, opts, nil, path, root.Dir, root, &stk, root.Internal.Build.TestImportPos[path], ResolveImport)
if err != nil && root.Error == nil {
// Assign error importing the package to the importer.
root.Error = err
// dependencies (like sync/atomic for coverage).
// TODO(jayconrod): delete this function and set flags automatically
// in LoadImport instead.
-func LoadImportWithFlags(path, srcDir string, parent *Package, stk *ImportStack, importPos []token.Position, mode int) (*Package, *PackageError) {
- p, err := loadImport(context.TODO(), PackageOpts{}, nil, path, srcDir, parent, stk, importPos, mode)
+func LoadImportWithFlags(loaderstate *modload.State, path, srcDir string, parent *Package, stk *ImportStack, importPos []token.Position, mode int) (*Package, *PackageError) {
+ p, err := loadImport(loaderstate, context.TODO(), PackageOpts{}, nil, path, srcDir, parent, stk, importPos, mode)
setToolFlags(p)
return p, err
}
// LoadPackageWithFlags is the same as LoadImportWithFlags but without a parent.
// It's then guaranteed to not return an error
-func LoadPackageWithFlags(path, srcDir string, stk *ImportStack, importPos []token.Position, mode int) *Package {
- p := LoadPackage(context.TODO(), PackageOpts{}, path, srcDir, stk, importPos, mode)
+func LoadPackageWithFlags(loaderstate *modload.State, path, srcDir string, stk *ImportStack, importPos []token.Position, mode int) *Package {
+ p := LoadPackage(loaderstate, context.TODO(), PackageOpts{}, path, srcDir, stk, importPos, mode)
setToolFlags(p)
return p
}
//
// To obtain a flat list of packages, use PackageList.
// To report errors loading packages, use ReportPackageErrors.
-func PackagesAndErrors(ctx context.Context, opts PackageOpts, patterns []string) []*Package {
+func PackagesAndErrors(loaderstate *modload.State, ctx context.Context, opts PackageOpts, patterns []string) []*Package {
ctx, span := trace.StartSpan(ctx, "load.PackagesAndErrors")
defer span.Done()
// We need to test whether the path is an actual Go file and not a
// package path or pattern ending in '.go' (see golang.org/issue/34653).
if fi, err := fsys.Stat(p); err == nil && !fi.IsDir() {
- pkgs := []*Package{GoFilesPackage(ctx, opts, patterns)}
+ pkgs := []*Package{GoFilesPackage(loaderstate, ctx, opts, patterns)}
setPGOProfilePath(pkgs)
return pkgs
}
}
var matches []*search.Match
- if modload.Init(); cfg.ModulesEnabled {
+ if modload.Init(loaderstate); cfg.ModulesEnabled {
modOpts := modload.PackageOpts{
ResolveMissingImports: true,
LoadTests: opts.ModResolveTests,
SilencePackageErrors: true,
}
- matches, _ = modload.LoadPackages(ctx, modOpts, patterns...)
+ matches, _ = modload.LoadPackages(loaderstate, ctx, modOpts, patterns...)
} else {
matches = search.ImportPaths(patterns)
}
pre := newPreload()
defer pre.flush()
- pre.preloadMatches(ctx, opts, matches)
+ pre.preloadMatches(loaderstate, ctx, opts, matches)
for _, m := range matches {
for _, pkg := range m.Pkgs {
// a literal and also a non-literal pattern.
mode |= cmdlinePkgLiteral
}
- p, perr := loadImport(ctx, opts, pre, pkg, base.Cwd(), nil, &stk, nil, mode)
+ p, perr := loadImport(loaderstate, ctx, opts, pre, pkg, base.Cwd(), nil, &stk, nil, mode)
if perr != nil {
base.Fatalf("internal error: loadImport of %q with nil parent returned an error", pkg)
}
// GoFilesPackage creates a package for building a collection of Go files
// (typically named on the command line). The target is named p.a for
// package p or named after the first Go file for package main.
-func GoFilesPackage(ctx context.Context, opts PackageOpts, gofiles []string) *Package {
- modload.Init()
+func GoFilesPackage(loaderstate *modload.State, ctx context.Context, opts PackageOpts, gofiles []string) *Package {
+ modload.Init(loaderstate)
for _, f := range gofiles {
if !strings.HasSuffix(f, ".go") {
ctxt.ReadDir = func(string) ([]fs.FileInfo, error) { return dirent, nil }
if cfg.ModulesEnabled {
- modload.ImportFromFiles(ctx, gofiles)
+ modload.ImportFromFiles(loaderstate, ctx, gofiles)
}
var err error
pkg := new(Package)
pkg.Internal.Local = true
pkg.Internal.CmdlineFiles = true
- pkg.load(ctx, opts, "command-line-arguments", &stk, nil, bp, err)
+ pkg.load(loaderstate, ctx, opts, "command-line-arguments", &stk, nil, bp, err)
if !cfg.ModulesEnabled {
pkg.Internal.LocalPrefix = dirToImportPath(dir)
}
if cfg.GOBIN != "" {
pkg.Target = filepath.Join(cfg.GOBIN, exe)
} else if cfg.ModulesEnabled {
- pkg.Target = filepath.Join(modload.BinDir(), exe)
+ pkg.Target = filepath.Join(modload.BinDir(loaderstate), exe)
}
}
// module, but its go.mod file (if it has one) must not contain directives that
// would cause it to be interpreted differently if it were the main module
// (replace, exclude).
-func PackagesAndErrorsOutsideModule(ctx context.Context, opts PackageOpts, args []string) ([]*Package, error) {
- if !modload.LoaderState.ForceUseModules {
+func PackagesAndErrorsOutsideModule(loaderstate *modload.State, ctx context.Context, opts PackageOpts, args []string) ([]*Package, error) {
+ if !loaderstate.ForceUseModules {
panic("modload.ForceUseModules must be true")
}
- if modload.LoaderState.RootMode != modload.NoRoot {
+ if loaderstate.RootMode != modload.NoRoot {
panic("modload.RootMode must be NoRoot")
}
allowed = nil
}
noneSelected := func(path string) (version string) { return "none" }
- qrs, err := modload.QueryPackages(ctx, patterns[0], version, noneSelected, allowed)
+ qrs, err := modload.QueryPackages(loaderstate, ctx, patterns[0], version, noneSelected, allowed)
if err != nil {
return nil, fmt.Errorf("%s: %w", args[0], err)
}
rootMod := qrs[0].Mod
- deprecation, err := modload.CheckDeprecation(ctx, rootMod)
+ deprecation, err := modload.CheckDeprecation(loaderstate, ctx, rootMod)
if err != nil {
return nil, fmt.Errorf("%s: %w", args[0], err)
}
// Since we are in NoRoot mode, the build list initially contains only
// the dummy command-line-arguments module. Add a requirement on the
// module that provides the packages named on the command line.
- if _, err := modload.EditBuildList(ctx, nil, []module.Version{rootMod}); err != nil {
+ if _, err := modload.EditBuildList(loaderstate, ctx, nil, []module.Version{rootMod}); err != nil {
return nil, fmt.Errorf("%s: %w", args[0], err)
}
// Load packages for all arguments.
- pkgs := PackagesAndErrors(ctx, opts, patterns)
+ pkgs := PackagesAndErrors(loaderstate, ctx, opts, patterns)
// Check that named packages are all provided by the same module.
for _, pkg := range pkgs {
}
// EnsureImport ensures that package p imports the named package.
-func EnsureImport(p *Package, pkg string) {
+func EnsureImport(loaderstate *modload.State, p *Package, pkg string) {
for _, d := range p.Internal.Imports {
if d.Name == pkg {
return
}
}
- p1, err := LoadImportWithFlags(pkg, p.Dir, p, &ImportStack{}, nil, 0)
+ p1, err := LoadImportWithFlags(loaderstate, pkg, p.Dir, p, &ImportStack{}, nil, 0)
if err != nil {
base.Fatalf("load %s: %v", pkg, err)
}
// "go test -cover"). It walks through the packages being built (and
// dependencies) and marks them for coverage instrumentation when
// appropriate, and possibly adding additional deps where needed.
-func PrepareForCoverageBuild(pkgs []*Package) {
+func PrepareForCoverageBuild(loaderstate *modload.State, pkgs []*Package) {
var match []func(*Package) bool
matchMainModAndCommandLine := func(p *Package) bool {
// the specific packages selected by the user-specified pattern(s).
match = make([]func(*Package) bool, len(cfg.BuildCoverPkg))
for i := range cfg.BuildCoverPkg {
- match[i] = MatchPackage(cfg.BuildCoverPkg[i], base.Cwd())
+ match[i] = MatchPackage(loaderstate, cfg.BuildCoverPkg[i], base.Cwd())
}
} else {
// Without -coverpkg, instrument only packages in the main module
// Visit the packages being built or installed, along with all of
// their dependencies, and mark them to be instrumented, taking
// into account the matchers we've set up in the sequence above.
- SelectCoverPackages(PackageList(pkgs), match, "build")
+ SelectCoverPackages(loaderstate, PackageList(pkgs), match, "build")
}
-func SelectCoverPackages(roots []*Package, match []func(*Package) bool, op string) []*Package {
+func SelectCoverPackages(loaderstate *modload.State, roots []*Package, match []func(*Package) bool, op string) []*Package {
var warntag string
var includeMain bool
switch op {
// Force import of sync/atomic into package if atomic mode.
if cfg.BuildCoverMode == "atomic" {
- EnsureImport(p, "sync/atomic")
+ EnsureImport(loaderstate, p, "sync/atomic")
}
}
)
// MatchPackage(pattern, cwd)(p) reports whether package p matches pattern in the working directory cwd.
-func MatchPackage(pattern, cwd string) func(*Package) bool {
+func MatchPackage(loaderstate *modload.State, pattern, cwd string) func(*Package) bool {
switch {
case search.IsRelativePath(pattern):
// Split pattern into leading pattern-free directory path
return func(p *Package) bool { return p.Standard }
case pattern == "cmd":
return func(p *Package) bool { return p.Standard && strings.HasPrefix(p.ImportPath, "cmd/") }
- case pattern == "tool" && modload.Enabled():
+ case pattern == "tool" && modload.Enabled(loaderstate):
return func(p *Package) bool {
- return modload.LoaderState.MainModules.Tools()[p.ImportPath]
+ return loaderstate.MainModules.Tools()[p.ImportPath]
}
- case pattern == "work" && modload.Enabled():
+ case pattern == "work" && modload.Enabled(loaderstate):
return func(p *Package) bool {
- return p.Module != nil && modload.LoaderState.MainModules.Contains(p.Module.Path)
+ return p.Module != nil && loaderstate.MainModules.Contains(p.Module.Path)
}
default:
"unicode/utf8"
"cmd/go/internal/fsys"
+ "cmd/go/internal/modload"
"cmd/go/internal/str"
"cmd/go/internal/trace"
)
defer pre.flush()
allImports := append([]string{}, p.TestImports...)
allImports = append(allImports, p.XTestImports...)
- pre.preloadImports(ctx, opts, allImports, p.Internal.Build)
+ pre.preloadImports(modload.LoaderState, ctx, opts, allImports, p.Internal.Build)
var ptestErr, pxtestErr *PackageError
var imports, ximports []*Package
stk.Push(ImportInfo{Pkg: p.ImportPath + " (test)"})
rawTestImports := str.StringList(p.TestImports)
for i, path := range p.TestImports {
- p1, err := loadImport(ctx, opts, pre, path, p.Dir, p, &stk, p.Internal.Build.TestImportPos[path], ResolveImport)
+ p1, err := loadImport(modload.LoaderState, ctx, opts, pre, path, p.Dir, p, &stk, p.Internal.Build.TestImportPos[path], ResolveImport)
if err != nil && ptestErr == nil {
ptestErr = err
incomplete = true
var pxtestIncomplete bool
rawXTestImports := str.StringList(p.XTestImports)
for i, path := range p.XTestImports {
- p1, err := loadImport(ctx, opts, pre, path, p.Dir, p, &stk, p.Internal.Build.XTestImportPos[path], ResolveImport)
+ p1, err := loadImport(modload.LoaderState, ctx, opts, pre, path, p.Dir, p, &stk, p.Internal.Build.XTestImportPos[path], ResolveImport)
if err != nil && pxtestErr == nil {
pxtestErr = err
}
}
pb := p.Internal.Build
- pmain.DefaultGODEBUG = defaultGODEBUG(pmain, pb.Directives, pb.TestDirectives, pb.XTestDirectives)
+ pmain.DefaultGODEBUG = defaultGODEBUG(modload.LoaderState, pmain, pb.Directives, pb.TestDirectives, pb.XTestDirectives)
if pmain.Internal.BuildInfo == nil || pmain.DefaultGODEBUG != p.DefaultGODEBUG {
// Either we didn't generate build info for the package under test (because it wasn't package main), or
// the DefaultGODEBUG used to build the test main package is different from the DefaultGODEBUG
if dep == ptest.ImportPath {
pmain.Internal.Imports = append(pmain.Internal.Imports, ptest)
} else {
- p1, err := loadImport(ctx, opts, pre, dep, "", nil, &stk, nil, 0)
+ p1, err := loadImport(modload.LoaderState, ctx, opts, pre, dep, "", nil, &stk, nil, 0)
if err != nil && pmain.Error == nil {
pmain.Error = err
pmain.Incomplete = true
}
func runDownload(ctx context.Context, cmd *base.Command, args []string) {
- modload.InitWorkfile()
+ modload.InitWorkfile(modload.LoaderState)
// Check whether modules are enabled and whether we're in a module.
modload.LoaderState.ForceUseModules = true
modload.ExplicitWriteGoMod = true
haveExplicitArgs := len(args) > 0
- if modload.HasModRoot() || modload.WorkFilePath() != "" {
- modload.LoadModFile(ctx) // to fill MainModules
+ if modload.HasModRoot(modload.LoaderState) || modload.WorkFilePath(modload.LoaderState) != "" {
+ modload.LoadModFile(modload.LoaderState, ctx) // to fill MainModules
if haveExplicitArgs {
for _, mainModule := range modload.LoaderState.MainModules.Versions() {
}
}
}
- } else if modload.WorkFilePath() != "" {
+ } else if modload.WorkFilePath(modload.LoaderState) != "" {
// TODO(#44435): Think about what the correct query is to download the
// right set of modules. Also see code review comment at
// https://go-review.googlesource.com/c/go/+/359794/comments/ce946a80_6cf53992.
}
if len(args) == 0 {
- if modload.HasModRoot() {
+ if modload.HasModRoot(modload.LoaderState) {
os.Stderr.WriteString("go: no module dependencies to download\n")
} else {
base.Errorf("go: no modules specified (see 'go help mod download')")
base.Exit()
}
- if *downloadReuse != "" && modload.HasModRoot() {
+ if *downloadReuse != "" && modload.HasModRoot(modload.LoaderState) {
base.Fatalf("go mod download -reuse cannot be used inside a module")
}
// when we can.
}
- if !haveExplicitArgs && modload.WorkFilePath() == "" {
+ if !haveExplicitArgs && modload.WorkFilePath(modload.LoaderState) == "" {
// 'go mod download' is sometimes run without arguments to pre-populate the
// module cache. In modules that aren't at go 1.17 or higher, it may fetch
// modules that aren't needed to build packages in the main module. This is
// with no arguments we download the module pattern "all",
// which may include dependencies that are normally pruned out
// of the individual modules in the workspace.
- if haveExplicitArgs || modload.WorkFilePath() != "" {
+ if haveExplicitArgs || modload.WorkFilePath(modload.LoaderState) != "" {
var sw toolchain.Switcher
// Add errors to the Switcher in deterministic order so that they will be
// logged deterministically.
//
// Don't save sums for 'go mod download' without arguments unless we're in
// workspace mode; see comment above.
- if haveExplicitArgs || modload.WorkFilePath() != "" {
+ if haveExplicitArgs || modload.WorkFilePath(modload.LoaderState) != "" {
if err := modload.WriteGoMod(ctx, modload.WriteOpts{}); err != nil {
base.Error(err)
}
}
func runGraph(ctx context.Context, cmd *base.Command, args []string) {
- modload.InitWorkfile()
+ modload.InitWorkfile(modload.LoaderState)
if len(args) > 0 {
base.Fatalf("go: 'go mod graph' accepts no arguments")
})
}
- modload.LoadPackages(ctx, modload.PackageOpts{
+ modload.LoadPackages(modload.LoaderState, ctx, modload.PackageOpts{
TidyGoVersion: tidyGo.String(),
Tags: imports.AnyTags(),
Tidy: true,
}
func runVendor(ctx context.Context, cmd *base.Command, args []string) {
- modload.InitWorkfile()
- if modload.WorkFilePath() != "" {
+ modload.InitWorkfile(modload.LoaderState)
+ if modload.WorkFilePath(modload.LoaderState) != "" {
base.Fatalf("go: 'go mod vendor' cannot be run in workspace mode. Run 'go work vendor' to vendor the workspace or set 'GOWORK=off' to exit workspace mode.")
}
RunVendor(ctx, vendorE, vendorO, args)
AllowErrors: vendorE,
SilenceMissingStdImports: true,
}
- _, pkgs := modload.LoadPackages(ctx, loadOpts, "all")
+ _, pkgs := modload.LoadPackages(modload.LoaderState, ctx, loadOpts, "all")
var vdir string
switch {
case vendorO != "":
vdir = filepath.Join(base.Cwd(), vendorO)
default:
- vdir = filepath.Join(modload.VendorDir())
+ vdir = filepath.Join(modload.VendorDir(modload.LoaderState))
}
if err := os.RemoveAll(vdir); err != nil {
base.Fatal(err)
includeAllReplacements := false
includeGoVersions := false
isExplicit := map[module.Version]bool{}
- gv := modload.LoaderState.MainModules.GoVersion()
- if gover.Compare(gv, "1.14") >= 0 && (modload.FindGoWork(base.Cwd()) != "" || modload.ModFile().Go != nil) {
+ gv := modload.LoaderState.MainModules.GoVersion(modload.LoaderState)
+ if gover.Compare(gv, "1.14") >= 0 && (modload.FindGoWork(modload.LoaderState, base.Cwd()) != "" || modload.ModFile().Go != nil) {
// If the Go version is at least 1.14, annotate all explicit 'require' and
// 'replace' targets found in the go.mod file so that we can perform a
// stronger consistency check when -mod=vendor is set.
replacementWritten := make(map[module.Version]bool)
for _, m := range vendorMods {
- replacement := modload.Replacement(m)
+ replacement := modload.Replacement(modload.LoaderState, m)
line := moduleLine(m, replacement)
replacementWritten[m] = true
io.WriteString(w, line)
continue
}
replacementWritten[r.Old] = true
- rNew := modload.Replacement(r.Old)
+ rNew := modload.Replacement(modload.LoaderState, r.Old)
if rNew == (module.Version{}) {
// There is no replacement. Don't try to write it.
continue
}
func vendorPkg(vdir, pkg string) {
- src, realPath, _ := modload.Lookup("", false, pkg)
+ src, realPath, _ := modload.Lookup(modload.LoaderState, "", false, pkg)
if src == "" {
base.Errorf("internal error: no pkg for %s\n", pkg)
return
}
}
var embedPatterns []string
- if gover.Compare(modload.LoaderState.MainModules.GoVersion(), "1.22") >= 0 {
+ if gover.Compare(modload.LoaderState.MainModules.GoVersion(modload.LoaderState), "1.22") >= 0 {
embedPatterns = bp.EmbedPatterns
} else {
// Maintain the behavior of https://github.com/golang/go/issues/63473
return false
}
if info.Name() == "go.mod" || info.Name() == "go.sum" {
- if gv := modload.LoaderState.MainModules.GoVersion(); gover.Compare(gv, "1.17") >= 0 {
+ if gv := modload.LoaderState.MainModules.GoVersion(modload.LoaderState); gover.Compare(gv, "1.17") >= 0 {
// As of Go 1.17, we strip go.mod and go.sum files from dependency modules.
// Otherwise, 'go' commands invoked within the vendor subtree may misidentify
// an arbitrary directory within the vendor tree as a module root.
}
func runVerify(ctx context.Context, cmd *base.Command, args []string) {
- modload.InitWorkfile()
+ modload.InitWorkfile(modload.LoaderState)
if len(args) != 0 {
// NOTE(rsc): Could take a module pattern.
}
func runWhy(ctx context.Context, cmd *base.Command, args []string) {
- modload.InitWorkfile()
+ modload.InitWorkfile(modload.LoaderState)
modload.LoaderState.ForceUseModules = true
modload.LoaderState.RootMode = modload.NeedRoot
modload.ExplicitWriteGoMod = true // don't write go.mod in ListModules
}
byModule := make(map[string][]string)
- _, pkgs := modload.LoadPackages(ctx, loadOpts, "all")
+ _, pkgs := modload.LoadPackages(modload.LoaderState, ctx, loadOpts, "all")
for _, path := range pkgs {
m := modload.PackageModule(path)
if m.Path != "" {
}
} else {
// Resolve to packages.
- matches, _ := modload.LoadPackages(ctx, loadOpts, args...)
+ matches, _ := modload.LoadPackages(modload.LoaderState, ctx, loadOpts, args...)
- modload.LoadPackages(ctx, loadOpts, "all") // rebuild graph, from main module (not from named packages)
+ modload.LoadPackages(modload.LoaderState, ctx, loadOpts, "all") // rebuild graph, from main module (not from named packages)
sep := ""
for _, m := range matches {
cfg.GOPROXY = "direct"
cfg.GOSUMDB = "off"
- modload.Init()
+ modload.Init(modload.LoaderState)
// Shard tests by downloading only every nth module when shard flags are set.
// This makes it easier to test small groups of modules quickly. We avoid
// Allow looking up modules for import paths when outside of a module.
// 'go get' is expected to do this, unlike other commands.
- modload.AllowMissingModuleImports()
+ modload.AllowMissingModuleImports(modload.LoaderState)
// 'go get' no longer builds or installs packages, so there's nothing to do
// if there's no go.mod file.
// TODO(#40775): make modload.Init return ErrNoModRoot instead of exiting.
// We could handle that here by printing a different message.
- modload.Init()
- if !modload.HasModRoot() {
+ modload.Init(modload.LoaderState)
+ if !modload.HasModRoot(modload.LoaderState) {
base.Fatalf("go: go.mod file not found in current directory or any parent directory.\n" +
"\t'go get' is no longer supported outside a module.\n" +
"\tTo build and install a command, use 'go install' with a version,\n" +
newReqs := reqsFromGoMod(modload.ModFile())
r.reportChanges(oldReqs, newReqs)
- if gowork := modload.FindGoWork(base.Cwd()); gowork != "" {
+ if gowork := modload.FindGoWork(modload.LoaderState, base.Cwd()); gowork != "" {
wf, err := modload.ReadWorkFile(gowork)
- if err == nil && modload.UpdateWorkGoVersion(wf, modload.LoaderState.MainModules.GoVersion()) {
+ if err == nil && modload.UpdateWorkGoVersion(wf, modload.LoaderState.MainModules.GoVersion(modload.LoaderState)) {
modload.WriteWorkFile(gowork, wf)
}
}
patterns = append(patterns, q.pattern)
}
- matches, _ := modload.LoadPackages(ctx, pkgOpts, patterns...)
+ matches, _ := modload.LoadPackages(modload.LoaderState, ctx, pkgOpts, patterns...)
for i, m := range matches {
if queries[i].version == "none" {
opts.DropTools = append(opts.DropTools, m.Pkgs...)
buildListVersion: initialVersion,
initialVersion: initialVersion,
nonesByPath: map[string]*query{},
- workspace: loadWorkspace(modload.FindGoWork(base.Cwd())),
+ workspace: loadWorkspace(modload.FindGoWork(modload.LoaderState, base.Cwd())),
}
for _, q := range queries {
// allowed versions.
func (r *resolver) queryModule(ctx context.Context, mPath, query string, selected func(string) string) (module.Version, error) {
current := r.initialSelected(mPath)
- rev, err := modload.Query(ctx, mPath, query, current, r.checkAllowedOr(query, selected))
+ rev, err := modload.Query(modload.LoaderState, ctx, mPath, query, current, r.checkAllowedOr(query, selected))
if err != nil {
return module.Version{}, err
}
// queryPackages wraps modload.QueryPackage, substituting r.checkAllowedOr to
// decide allowed versions.
func (r *resolver) queryPackages(ctx context.Context, pattern, query string, selected func(string) string) (pkgMods []module.Version, err error) {
- results, err := modload.QueryPackages(ctx, pattern, query, selected, r.checkAllowedOr(query, selected))
+ results, err := modload.QueryPackages(modload.LoaderState, ctx, pattern, query, selected, r.checkAllowedOr(query, selected))
if len(results) > 0 {
pkgMods = make([]module.Version, 0, len(results))
for _, qr := range results {
// queryPattern wraps modload.QueryPattern, substituting r.checkAllowedOr to
// decide allowed versions.
func (r *resolver) queryPattern(ctx context.Context, pattern, query string, selected func(string) string) (pkgMods []module.Version, mod module.Version, err error) {
- results, modOnly, err := modload.QueryPattern(ctx, pattern, query, selected, r.checkAllowedOr(query, selected))
+ results, modOnly, err := modload.QueryPattern(modload.LoaderState, ctx, pattern, query, selected, r.checkAllowedOr(query, selected))
if len(results) > 0 {
pkgMods = make([]module.Version, 0, len(results))
for _, qr := range results {
if !q.isWildcard() {
q.pathOnce(q.pattern, func() pathSet {
- hasModRoot := modload.HasModRoot()
+ hasModRoot := modload.HasModRoot(modload.LoaderState)
if hasModRoot && modload.LoaderState.MainModules.Contains(q.pattern) {
v := module.Version{Path: q.pattern}
// The user has explicitly requested to downgrade their own module to
continue
}
q.pathOnce(curM.Path, func() pathSet {
- if modload.HasModRoot() && curM.Version == "" && modload.LoaderState.MainModules.Contains(curM.Path) {
+ if modload.HasModRoot(modload.LoaderState) && curM.Version == "" && modload.LoaderState.MainModules.Contains(curM.Path) {
return errSet(&modload.QueryMatchesMainModulesError{MainModules: []module.Version{curM}, Pattern: q.pattern, Query: q.version})
}
return pathSet{mod: module.Version{Path: curM.Path, Version: "none"}}
// Absolute paths like C:\foo and relative paths like ../foo... are
// restricted to matching packages in the main module.
- pkgPattern, mainModule := modload.LoaderState.MainModules.DirImportPath(ctx, q.pattern)
+ pkgPattern, mainModule := modload.LoaderState.MainModules.DirImportPath(modload.LoaderState, ctx, q.pattern)
if pkgPattern == "." {
modload.MustHaveModRoot()
versions := modload.LoaderState.MainModules.Versions()
return nil
}
- _, pkgs := modload.LoadPackages(ctx, opts, patterns...)
+ _, pkgs := modload.LoadPackages(modload.LoaderState, ctx, opts, patterns...)
for _, pkgPath := range pkgs {
const (
parentPath = ""
parentIsStd = false
)
- _, _, err := modload.Lookup(parentPath, parentIsStd, pkgPath)
+ _, _, err := modload.Lookup(modload.LoaderState, parentPath, parentIsStd, pkgPath)
if err == nil {
continue
}
AllowErrors: true,
SilenceNoGoErrors: true,
}
- matches, pkgs := modload.LoadPackages(ctx, pkgOpts, pkgPatterns...)
+ matches, pkgs := modload.LoadPackages(modload.LoaderState, ctx, pkgOpts, pkgPatterns...)
for _, m := range matches {
if len(m.Errs) > 0 {
base.SetExitStatus(1)
}
}
for _, pkg := range pkgs {
- if dir, _, err := modload.Lookup("", false, pkg); err != nil {
+ if dir, _, err := modload.Lookup(modload.LoaderState, "", false, pkg); err != nil {
if dir != "" && errors.Is(err, imports.ErrNoGo) {
// Since dir is non-empty, we must have located source files
// associated with either the package or its test — ErrNoGo must
}
}
- reqs := modload.LoadModFile(ctx)
+ reqs := modload.LoadModFile(modload.LoaderState, ctx)
for m := range relevantMods {
if reqs.IsDirect(m.Path) {
relevantMods[m] |= direct
for i := range retractions {
i := i
r.work.Add(func() {
- err := modload.CheckRetractions(ctx, retractions[i].m)
+ err := modload.CheckRetractions(modload.LoaderState, ctx, retractions[i].m)
if _, ok := errors.AsType[*modload.ModuleRetractedError](err); ok {
retractions[i].message = err.Error()
}
for i := range deprecations {
i := i
r.work.Add(func() {
- deprecation, err := modload.CheckDeprecation(ctx, deprecations[i].m)
+ deprecation, err := modload.CheckDeprecation(modload.LoaderState, ctx, deprecations[i].m)
if err != nil || deprecation == "" {
return
}
i := i
m := r.buildList[i]
mActual := m
- if mRepl := modload.Replacement(m); mRepl.Path != "" {
+ if mRepl := modload.Replacement(modload.LoaderState, m); mRepl.Path != "" {
mActual = mRepl
}
old := module.Version{Path: m.Path, Version: r.initialVersion[m.Path]}
continue
}
oldActual := old
- if oldRepl := modload.Replacement(old); oldRepl.Path != "" {
+ if oldRepl := modload.Replacement(modload.LoaderState, old); oldRepl.Path != "" {
oldActual = oldRepl
}
if mActual == oldActual || mActual.Version == "" || !modfetch.HaveSum(oldActual) {
}
}
- changed, err := modload.EditBuildList(ctx, additions, resolved)
+ changed, err := modload.EditBuildList(modload.LoaderState, ctx, additions, resolved)
if err != nil {
if errors.Is(err, gover.ErrTooNew) {
toolchain.SwitchOrFatal(ctx, err)
if q.pattern == "all" {
// If there is no main module, "all" is not meaningful.
- if !modload.HasModRoot() {
+ if !modload.HasModRoot(modload.LoaderState) {
return fmt.Errorf(`cannot match "all": %v`, modload.ErrNoModRoot)
}
if !versionOkForMainModule(q.version) {
// a given package. If modules are not enabled or if the package is in the
// standard library or if the package was not successfully loaded with
// LoadPackages or ImportFromFiles, nil is returned.
-func PackageModuleInfo(ctx context.Context, pkgpath string) *modinfo.ModulePublic {
- if isStandardImportPath(pkgpath) || !Enabled() {
+func PackageModuleInfo(loaderstate *State, ctx context.Context, pkgpath string) *modinfo.ModulePublic {
+ if isStandardImportPath(pkgpath) || !Enabled(loaderstate) {
return nil
}
m, ok := findModule(loaded, pkgpath)
return nil
}
- rs := LoadModFile(ctx)
- return moduleInfo(ctx, rs, m, 0, nil)
+ rs := LoadModFile(loaderstate, ctx)
+ return moduleInfo(loaderstate, ctx, rs, m, 0, nil)
}
// PackageModRoot returns the module root directory for the module that provides
// a given package. If modules are not enabled or if the package is in the
// standard library or if the package was not successfully loaded with
// LoadPackages or ImportFromFiles, the empty string is returned.
-func PackageModRoot(ctx context.Context, pkgpath string) string {
- if isStandardImportPath(pkgpath) || !Enabled() || cfg.BuildMod == "vendor" {
+func PackageModRoot(loaderstate *State, ctx context.Context, pkgpath string) string {
+ if isStandardImportPath(pkgpath) || !Enabled(loaderstate) || cfg.BuildMod == "vendor" {
return ""
}
m, ok := findModule(loaded, pkgpath)
if !ok {
return ""
}
- root, _, err := fetch(ctx, m)
+ root, _, err := fetch(loaderstate, ctx, m)
if err != nil {
return ""
}
}
func ModuleInfo(ctx context.Context, path string) *modinfo.ModulePublic {
- if !Enabled() {
+ if !Enabled(LoaderState) {
return nil
}
if path, vers, found := strings.Cut(path, "@"); found {
m := module.Version{Path: path, Version: vers}
- return moduleInfo(ctx, nil, m, 0, nil)
+ return moduleInfo(LoaderState, ctx, nil, m, 0, nil)
}
- rs := LoadModFile(ctx)
+ rs := LoadModFile(LoaderState, ctx)
var (
v string
ok bool
)
if rs.pruning == pruned {
- v, ok = rs.rootSelected(path)
+ v, ok = rs.rootSelected(LoaderState, path)
}
if !ok {
- mg, err := rs.Graph(ctx)
+ mg, err := rs.Graph(LoaderState, ctx)
if err != nil {
base.Fatal(err)
}
}
}
- return moduleInfo(ctx, rs, module.Version{Path: path, Version: v}, 0, nil)
+ return moduleInfo(LoaderState, ctx, rs, module.Version{Path: path, Version: v}, 0, nil)
}
// addUpdate fills in m.Update if an updated version is available.
return
}
- info, err := Query(ctx, m.Path, "upgrade", m.Version, CheckAllowed)
+ info, err := Query(LoaderState, ctx, m.Path, "upgrade", m.Version, CheckAllowed)
if _, ok := errors.AsType[*NoMatchingVersionError](err); ok ||
errors.Is(err, fs.ErrNotExist) ||
errors.Is(err, ErrDisallowed) {
if listRetracted {
allowed = CheckExclusions
}
- v, origin, err := versions(ctx, m.Path, allowed)
+ v, origin, err := versions(LoaderState, ctx, m.Path, allowed)
if err != nil && m.Error == nil {
m.Error = &modinfo.ModuleError{Err: err.Error()}
}
// addRetraction fills in m.Retracted if the module was retracted by its author.
// m.Error is set if there's an error loading retraction information.
-func addRetraction(ctx context.Context, m *modinfo.ModulePublic) {
+func addRetraction(loaderstate *State, ctx context.Context, m *modinfo.ModulePublic) {
if m.Version == "" {
return
}
- err := CheckRetractions(ctx, module.Version{Path: m.Path, Version: m.Version})
+ err := CheckRetractions(loaderstate, ctx, module.Version{Path: m.Path, Version: m.Version})
if err == nil {
return
} else if _, ok := errors.AsType[*NoMatchingVersionError](err); ok || errors.Is(err, fs.ErrNotExist) {
// addDeprecation fills in m.Deprecated if the module was deprecated by its
// author. m.Error is set if there's an error loading deprecation information.
func addDeprecation(ctx context.Context, m *modinfo.ModulePublic) {
- deprecation, err := CheckDeprecation(ctx, module.Version{Path: m.Path, Version: m.Version})
+ deprecation, err := CheckDeprecation(LoaderState, ctx, module.Version{Path: m.Path, Version: m.Version})
if _, ok := errors.AsType[*NoMatchingVersionError](err); ok || errors.Is(err, fs.ErrNotExist) {
// Ignore "no matching version" and "not found" errors.
// This means the proxy has no matching version or no versions at all.
// moduleInfo returns information about module m, loaded from the requirements
// in rs (which may be nil to indicate that m was not loaded from a requirement
// graph).
-func moduleInfo(ctx context.Context, rs *Requirements, m module.Version, mode ListMode, reuse map[module.Version]*modinfo.ModulePublic) *modinfo.ModulePublic {
- if m.Version == "" && LoaderState.MainModules.Contains(m.Path) {
+func moduleInfo(loaderstate *State, ctx context.Context, rs *Requirements, m module.Version, mode ListMode, reuse map[module.Version]*modinfo.ModulePublic) *modinfo.ModulePublic {
+ if m.Version == "" && loaderstate.MainModules.Contains(m.Path) {
info := &modinfo.ModulePublic{
Path: m.Path,
Version: m.Version,
} else {
panic("internal error: GoVersion not set for main module")
}
- if modRoot := LoaderState.MainModules.ModRoot(m); modRoot != "" {
+ if modRoot := loaderstate.MainModules.ModRoot(m); modRoot != "" {
info.Dir = modRoot
info.GoMod = modFilePath(modRoot)
}
}
checksumOk := func(suffix string) bool {
- return rs == nil || m.Version == "" || !mustHaveSums() ||
+ return rs == nil || m.Version == "" || !mustHaveSums(loaderstate) ||
modfetch.HaveSum(module.Version{Path: m.Path, Version: m.Version + suffix})
}
if m.Version != "" {
if old := reuse[mod]; old != nil {
- if err := checkReuse(ctx, mod, old.Origin); err == nil {
+ if err := checkReuse(loaderstate, ctx, mod, old.Origin); err == nil {
*m = *old
m.Query = ""
m.Dir = ""
}
}
- if q, err := Query(ctx, m.Path, m.Version, "", nil); err != nil {
+ if q, err := Query(loaderstate, ctx, m.Path, m.Version, "", nil); err != nil {
m.Error = &modinfo.ModuleError{Err: err.Error()}
} else {
m.Version = q.Version
if m.GoVersion == "" && checksumOk("/go.mod") {
// Load the go.mod file to determine the Go version, since it hasn't
// already been populated from rawGoVersion.
- if summary, err := rawGoModSummary(mod); err == nil && summary.goVersion != "" {
+ if summary, err := rawGoModSummary(loaderstate, mod); err == nil && summary.goVersion != "" {
m.GoVersion = summary.goVersion
}
}
}
if mode&ListRetracted != 0 {
- addRetraction(ctx, m)
+ addRetraction(loaderstate, ctx, m)
}
}
}
return info
}
- r := Replacement(m)
+ r := Replacement(loaderstate, m)
if r.Path == "" {
if cfg.BuildMod == "vendor" {
// It's tempting to fill in the "Dir" field to point within the vendor
if filepath.IsAbs(r.Path) {
info.Replace.Dir = r.Path
} else {
- info.Replace.Dir = filepath.Join(replaceRelativeTo(), r.Path)
+ info.Replace.Dir = filepath.Join(replaceRelativeTo(loaderstate), r.Path)
}
info.Replace.GoMod = filepath.Join(info.Replace.Dir, "go.mod")
}
//
// If vendoring is in effect, the caller must invoke initVendor on the returned
// *Requirements before any other method.
-func newRequirements(pruning modPruning, rootModules []module.Version, direct map[string]bool) *Requirements {
+func newRequirements(loaderstate *State, pruning modPruning, rootModules []module.Version, direct map[string]bool) *Requirements {
mustHaveGoRoot(rootModules)
if pruning != workspace {
- if LoaderState.workFilePath != "" {
+ if loaderstate.workFilePath != "" {
panic("in workspace mode, but pruning is not workspace in newRequirements")
}
}
if pruning != workspace {
- if LoaderState.workFilePath != "" {
+ if loaderstate.workFilePath != "" {
panic("in workspace mode, but pruning is not workspace in newRequirements")
}
for i, m := range rootModules {
- if m.Version == "" && LoaderState.MainModules.Contains(m.Path) {
+ if m.Version == "" && loaderstate.MainModules.Contains(m.Path) {
panic(fmt.Sprintf("newRequirements called with untrimmed build list: rootModules[%v] is a main module", i))
}
if m.Path == "" || m.Version == "" {
// initVendor initializes rs.graph from the given list of vendored module
// dependencies, overriding the graph that would normally be loaded from module
// requirements.
-func (rs *Requirements) initVendor(vendorList []module.Version) {
+func (rs *Requirements) initVendor(loaderstate *State, vendorList []module.Version) {
rs.graphOnce.Do(func() {
- roots := LoaderState.MainModules.Versions()
- if inWorkspaceMode() {
+ roots := loaderstate.MainModules.Versions()
+ if inWorkspaceMode(loaderstate) {
// Use rs.rootModules to pull in the go and toolchain roots
// from the go.work file and preserve the invariant that all
// of rs.rootModules are in mg.g.
}
if rs.pruning == pruned {
- mainModule := LoaderState.MainModules.mustGetSingleMainModule()
+ mainModule := loaderstate.MainModules.mustGetSingleMainModule(loaderstate)
// The roots of a single pruned module should already include every module in the
// vendor list, because the vendored modules are the same as those needed
// for graph pruning.
// Just to be sure, we'll double-check that here.
inconsistent := false
for _, m := range vendorList {
- if v, ok := rs.rootSelected(m.Path); !ok || v != m.Version {
+ if v, ok := rs.rootSelected(loaderstate, m.Path); !ok || v != m.Version {
base.Errorf("go: vendored module %v should be required explicitly in go.mod", m)
inconsistent = true
}
// graph, but still distinguishes between direct and indirect
// dependencies.
vendorMod := module.Version{Path: "vendor/modules.txt", Version: ""}
- if inWorkspaceMode() {
- for _, m := range LoaderState.MainModules.Versions() {
- reqs, _ := rootsFromModFile(m, LoaderState.MainModules.ModFile(m), omitToolchainRoot)
+ if inWorkspaceMode(loaderstate) {
+ for _, m := range loaderstate.MainModules.Versions() {
+ reqs, _ := rootsFromModFile(loaderstate, m, loaderstate.MainModules.ModFile(m), omitToolchainRoot)
mg.g.Require(m, append(reqs, vendorMod))
}
mg.g.Require(vendorMod, vendorList)
} else {
- mainModule := LoaderState.MainModules.mustGetSingleMainModule()
+ mainModule := loaderstate.MainModules.mustGetSingleMainModule(loaderstate)
mg.g.Require(mainModule, append(rs.rootModules, vendorMod))
mg.g.Require(vendorMod, vendorList)
}
}
// GoVersion returns the Go language version for the Requirements.
-func (rs *Requirements) GoVersion() string {
- v, _ := rs.rootSelected("go")
+func (rs *Requirements) GoVersion(loaderstate *State) string {
+ v, _ := rs.rootSelected(loaderstate, "go")
if v == "" {
panic("internal error: missing go version in modload.Requirements")
}
// rootSelected returns the version of the root dependency with the given module
// path, or the zero module.Version and ok=false if the module is not a root
// dependency.
-func (rs *Requirements) rootSelected(path string) (version string, ok bool) {
- if LoaderState.MainModules.Contains(path) {
+func (rs *Requirements) rootSelected(loaderstate *State, path string) (version string, ok bool) {
+ if loaderstate.MainModules.Contains(path) {
return "", true
}
if v, ok := rs.maxRootVersion[path]; ok {
// of the same module or a requirement on any version of the main module.
// Redundant requirements should be pruned, but they may influence version
// selection.
-func (rs *Requirements) hasRedundantRoot() bool {
+func (rs *Requirements) hasRedundantRoot(loaderstate *State) bool {
for i, m := range rs.rootModules {
- if LoaderState.MainModules.Contains(m.Path) || (i > 0 && m.Path == rs.rootModules[i-1].Path) {
+ if loaderstate.MainModules.Contains(m.Path) || (i > 0 && m.Path == rs.rootModules[i-1].Path) {
return true
}
}
//
// If the requirements of any relevant module fail to load, Graph also
// returns a non-nil error of type *mvs.BuildListError.
-func (rs *Requirements) Graph(ctx context.Context) (*ModuleGraph, error) {
+func (rs *Requirements) Graph(loaderstate *State, ctx context.Context) (*ModuleGraph, error) {
rs.graphOnce.Do(func() {
- mg, mgErr := readModGraph(ctx, rs.pruning, rs.rootModules, nil)
+ mg, mgErr := readModGraph(loaderstate, ctx, rs.pruning, rs.rootModules, nil)
rs.graph.Store(&cachedGraph{mg, mgErr})
})
cached := rs.graph.Load()
//
// Unlike LoadModGraph, readModGraph does not attempt to diagnose or update
// inconsistent roots.
-func readModGraph(ctx context.Context, pruning modPruning, roots []module.Version, unprune map[module.Version]bool) (*ModuleGraph, error) {
+func readModGraph(loaderstate *State, ctx context.Context, pruning modPruning, roots []module.Version, unprune map[module.Version]bool) (*ModuleGraph, error) {
mustHaveGoRoot(roots)
if pruning == pruned {
// Enable diagnostics for lazy module loading
}
var graphRoots []module.Version
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
graphRoots = roots
} else {
- graphRoots = LoaderState.MainModules.Versions()
+ graphRoots = loaderstate.MainModules.Versions()
}
var (
mu sync.Mutex // guards mg.g and hasError during loading
)
if pruning != workspace {
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
panic("pruning is not workspace in workspace mode")
}
- mg.g.Require(LoaderState.MainModules.mustGetSingleMainModule(), roots)
+ mg.g.Require(loaderstate.MainModules.mustGetSingleMainModule(loaderstate), roots)
}
type dedupKey struct {
// m's go.mod file indicates that it supports graph pruning.
loadOne := func(m module.Version) (*modFileSummary, error) {
return mg.loadCache.Do(m, func() (*modFileSummary, error) {
- summary, err := goModSummary(m)
+ summary, err := goModSummary(loaderstate, m)
mu.Lock()
if err == nil {
return nil
}
-func (mg *ModuleGraph) allRootsSelected() bool {
+func (mg *ModuleGraph) allRootsSelected(loaderstate *State) bool {
var roots []module.Version
- if inWorkspaceMode() {
- roots = LoaderState.MainModules.Versions()
+ if inWorkspaceMode(loaderstate) {
+ roots = loaderstate.MainModules.Versions()
} else {
- roots, _ = mg.g.RequiredBy(LoaderState.MainModules.mustGetSingleMainModule())
+ roots, _ = mg.g.RequiredBy(loaderstate.MainModules.mustGetSingleMainModule(loaderstate))
}
for _, m := range roots {
if mg.Selected(m.Path) != m.Version {
// LoadModGraph need only be called if LoadPackages is not,
// typically in commands that care about modules but no particular package.
func LoadModGraph(ctx context.Context, goVersion string) (*ModuleGraph, error) {
- rs, err := loadModFile(ctx, nil)
+ rs, err := loadModFile(LoaderState, ctx, nil)
if err != nil {
return nil, err
}
if goVersion != "" {
- v, _ := rs.rootSelected("go")
+ v, _ := rs.rootSelected(LoaderState, "go")
if gover.Compare(v, gover.GoStrictVersion) >= 0 && gover.Compare(goVersion, v) < 0 {
return nil, fmt.Errorf("requested Go version %s cannot load module graph (requires Go >= %s)", goVersion, v)
}
// Use newRequirements instead of convertDepth because convertDepth
// also updates roots; here, we want to report the unmodified roots
// even though they may seem inconsistent.
- rs = newRequirements(unpruned, rs.rootModules, rs.direct)
+ rs = newRequirements(LoaderState, unpruned, rs.rootModules, rs.direct)
}
- return rs.Graph(ctx)
+ return rs.Graph(LoaderState, ctx)
}
- rs, mg, err := expandGraph(ctx, rs)
+ rs, mg, err := expandGraph(LoaderState, ctx, rs)
if err != nil {
return nil, err
}
// from those roots and any error encountered while loading that graph.
// expandGraph returns non-nil requirements and a non-nil graph regardless of
// errors. On error, the roots might not be updated to be consistent.
-func expandGraph(ctx context.Context, rs *Requirements) (*Requirements, *ModuleGraph, error) {
- mg, mgErr := rs.Graph(ctx)
+func expandGraph(loaderstate *State, ctx context.Context, rs *Requirements) (*Requirements, *ModuleGraph, error) {
+ mg, mgErr := rs.Graph(loaderstate, ctx)
if mgErr != nil {
// Without the graph, we can't update the roots: we don't know which
// versions of transitive dependencies would be selected.
return rs, mg, mgErr
}
- if !mg.allRootsSelected() {
+ if !mg.allRootsSelected(loaderstate) {
// The roots of rs are not consistent with the rest of the graph. Update
// them. In an unpruned module this is a no-op for the build list as a whole —
// it just promotes what were previously transitive requirements to be
// roots — but in a pruned module it may pull in previously-irrelevant
// transitive dependencies.
- newRS, rsErr := updateRoots(ctx, rs.direct, rs, nil, nil, false)
+ newRS, rsErr := updateRoots(loaderstate, ctx, rs.direct, rs, nil, nil, false)
if rsErr != nil {
// Failed to update roots, perhaps because of an error in a transitive
// dependency needed for the update. Return the original Requirements
return rs, mg, rsErr
}
rs = newRS
- mg, mgErr = rs.Graph(ctx)
+ mg, mgErr = rs.Graph(loaderstate, ctx)
}
return rs, mg, mgErr
// On success, EditBuildList reports whether the selected version of any module
// in the build list may have been changed (possibly to or from "none") as a
// result.
-func EditBuildList(ctx context.Context, add, mustSelect []module.Version) (changed bool, err error) {
- rs, changed, err := editRequirements(ctx, LoadModFile(ctx), add, mustSelect)
+func EditBuildList(loaderstate *State, ctx context.Context, add, mustSelect []module.Version) (changed bool, err error) {
+ rs, changed, err := editRequirements(loaderstate, ctx, LoadModFile(loaderstate, ctx), add, mustSelect)
if err != nil {
return false, err
}
- LoaderState.requirements = rs
+ loaderstate.requirements = rs
return changed, nil
}
-func overrideRoots(ctx context.Context, rs *Requirements, replace []module.Version) *Requirements {
+func overrideRoots(loaderstate *State, ctx context.Context, rs *Requirements, replace []module.Version) *Requirements {
drop := make(map[string]bool)
for _, m := range replace {
drop[m.Path] = true
}
roots = append(roots, replace...)
gover.ModSort(roots)
- return newRequirements(rs.pruning, roots, rs.direct)
+ return newRequirements(loaderstate, rs.pruning, roots, rs.direct)
}
// A ConstraintError describes inconsistent constraints in EditBuildList
// tidyRoots trims the root dependencies to the minimal requirements needed to
// both retain the same versions of all packages in pkgs and satisfy the
// graph-pruning invariants (if applicable).
-func tidyRoots(ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Requirements, error) {
- mainModule := LoaderState.MainModules.mustGetSingleMainModule()
+func tidyRoots(loaderstate *State, ctx context.Context, rs *Requirements, pkgs []*loadPkg) (*Requirements, error) {
+ mainModule := loaderstate.MainModules.mustGetSingleMainModule(loaderstate)
if rs.pruning == unpruned {
- return tidyUnprunedRoots(ctx, mainModule, rs, pkgs)
+ return tidyUnprunedRoots(loaderstate, ctx, mainModule, rs, pkgs)
}
- return tidyPrunedRoots(ctx, mainModule, rs, pkgs)
+ return tidyPrunedRoots(loaderstate, ctx, mainModule, rs, pkgs)
}
-func updateRoots(ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version, rootsImported bool) (*Requirements, error) {
+func updateRoots(loaderstate *State, ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version, rootsImported bool) (*Requirements, error) {
switch rs.pruning {
case unpruned:
- return updateUnprunedRoots(ctx, direct, rs, add)
+ return updateUnprunedRoots(loaderstate, ctx, direct, rs, add)
case pruned:
- return updatePrunedRoots(ctx, direct, rs, pkgs, add, rootsImported)
+ return updatePrunedRoots(loaderstate, ctx, direct, rs, pkgs, add, rootsImported)
case workspace:
- return updateWorkspaceRoots(ctx, direct, rs, add)
+ return updateWorkspaceRoots(loaderstate, ctx, direct, rs, add)
default:
panic(fmt.Sprintf("unsupported pruning mode: %v", rs.pruning))
}
}
-func updateWorkspaceRoots(ctx context.Context, direct map[string]bool, rs *Requirements, add []module.Version) (*Requirements, error) {
+func updateWorkspaceRoots(loaderstate *State, ctx context.Context, direct map[string]bool, rs *Requirements, add []module.Version) (*Requirements, error) {
if len(add) != 0 {
// add should be empty in workspace mode because workspace mode implies
// -mod=readonly, which in turn implies no new requirements. The code path
// return an error.
panic("add is not empty")
}
- return newRequirements(workspace, rs.rootModules, direct), nil
+ return newRequirements(loaderstate, workspace, rs.rootModules, direct), nil
}
// tidyPrunedRoots returns a minimal set of root requirements that maintains the
// To ensure that the loading process eventually converges, the caller should
// add any needed roots from the tidy root set (without removing existing untidy
// roots) until the set of roots has converged.
-func tidyPrunedRoots(ctx context.Context, mainModule module.Version, old *Requirements, pkgs []*loadPkg) (*Requirements, error) {
+func tidyPrunedRoots(loaderstate *State, ctx context.Context, mainModule module.Version, old *Requirements, pkgs []*loadPkg) (*Requirements, error) {
var (
roots []module.Version
pathIsRoot = map[string]bool{mainModule.Path: true}
)
- if v, ok := old.rootSelected("go"); ok {
+ if v, ok := old.rootSelected(loaderstate, "go"); ok {
roots = append(roots, module.Version{Path: "go", Version: v})
pathIsRoot["go"] = true
}
- if v, ok := old.rootSelected("toolchain"); ok {
+ if v, ok := old.rootSelected(loaderstate, "toolchain"); ok {
roots = append(roots, module.Version{Path: "toolchain", Version: v})
pathIsRoot["toolchain"] = true
}
if !pkg.flags.has(pkgInAll) {
continue
}
- if pkg.fromExternalModule() && !pathIsRoot[pkg.mod.Path] {
+ if pkg.fromExternalModule(loaderstate) && !pathIsRoot[pkg.mod.Path] {
roots = append(roots, pkg.mod)
pathIsRoot[pkg.mod.Path] = true
}
queued[pkg] = true
}
gover.ModSort(roots)
- tidy := newRequirements(pruned, roots, old.direct)
+ tidy := newRequirements(loaderstate, pruned, roots, old.direct)
for len(queue) > 0 {
roots = tidy.rootModules
- mg, err := tidy.Graph(ctx)
+ mg, err := tidy.Graph(loaderstate, ctx)
if err != nil {
return nil, err
}
if len(roots) > len(tidy.rootModules) {
gover.ModSort(roots)
- tidy = newRequirements(pruned, roots, tidy.direct)
+ tidy = newRequirements(loaderstate, pruned, roots, tidy.direct)
}
}
roots = tidy.rootModules
- _, err := tidy.Graph(ctx)
+ _, err := tidy.Graph(loaderstate, ctx)
if err != nil {
return nil, err
}
pkg := pkg
q.Add(func() {
skipModFile := true
- _, _, _, _, err := importFromModules(ctx, pkg.path, tidy, nil, skipModFile)
+ _, _, _, _, err := importFromModules(loaderstate, ctx, pkg.path, tidy, nil, skipModFile)
if _, ok := errors.AsType[*AmbiguousImportError](err); ok {
disambiguateRoot.Store(pkg.mod, true)
}
if len(roots) > len(tidy.rootModules) {
module.Sort(roots)
- tidy = newRequirements(pruned, roots, tidy.direct)
- _, err = tidy.Graph(ctx)
+ tidy = newRequirements(loaderstate, pruned, roots, tidy.direct)
+ _, err = tidy.Graph(loaderstate, ctx)
if err != nil {
return nil, err
}
//
// (See https://golang.org/design/36460-lazy-module-loading#invariants for more
// detail.)
-func updatePrunedRoots(ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version, rootsImported bool) (*Requirements, error) {
+func updatePrunedRoots(loaderstate *State, ctx context.Context, direct map[string]bool, rs *Requirements, pkgs []*loadPkg, add []module.Version, rootsImported bool) (*Requirements, error) {
roots := rs.rootModules
rootsUpgraded := false
// either pkgInAll or pkgIsRoot is included as a root.”
needSort := false
for _, pkg := range pkgs {
- if !pkg.fromExternalModule() {
+ if !pkg.fromExternalModule(loaderstate) {
// pkg was not loaded from a module dependency, so we don't need
// to do anything special to maintain that dependency.
continue
continue
}
- if _, ok := rs.rootSelected(pkg.mod.Path); ok {
+ if _, ok := rs.rootSelected(loaderstate, pkg.mod.Path); ok {
// It is possible that the main module's go.mod file is incomplete or
// otherwise erroneous — for example, perhaps the author forgot to 'git
// add' their updated go.mod file after adding a new package import, or
}
for _, m := range add {
- if v, ok := rs.rootSelected(m.Path); !ok || gover.ModCompare(m.Path, v, m.Version) < 0 {
+ if v, ok := rs.rootSelected(loaderstate, m.Path); !ok || gover.ModCompare(m.Path, v, m.Version) < 0 {
roots = append(roots, m)
rootsUpgraded = true
needSort = true
// We've added or upgraded one or more roots, so load the full module
// graph so that we can update those roots to be consistent with other
// requirements.
- if mustHaveCompleteRequirements() {
+ if mustHaveCompleteRequirements(loaderstate) {
// Our changes to the roots may have moved dependencies into or out of
// the graph-pruning horizon, which could in turn change the selected
// versions of other modules. (For pruned modules adding or removing an
return rs, errGoModDirty
}
- rs = newRequirements(pruned, roots, direct)
+ rs = newRequirements(loaderstate, pruned, roots, direct)
var err error
- mg, err = rs.Graph(ctx)
+ mg, err = rs.Graph(loaderstate, ctx)
if err != nil {
return rs, err
}
// We've already loaded the full module graph, which includes the
// requirements of all of the root modules — even the transitive
// requirements, if they are unpruned!
- mg, _ = rs.Graph(ctx)
+ mg, _ = rs.Graph(loaderstate, ctx)
} else if cfg.BuildMod == "vendor" {
// We can't spot-check the requirements of other modules because we
// don't in general have their go.mod files available in the vendor
// directory. (Fortunately this case is impossible, because mg.graph is
// always non-nil in vendor mode!)
panic("internal error: rs.graph is unexpectedly nil with -mod=vendor")
- } else if !spotCheckRoots(ctx, rs, spotCheckRoot) {
+ } else if !spotCheckRoots(loaderstate, ctx, rs, spotCheckRoot) {
// We spot-checked the explicit requirements of the roots that are
// relevant to the packages we've loaded. Unfortunately, they're
// inconsistent in some way; we need to load the full module graph
// so that we can fix the roots properly.
var err error
- mg, err = rs.Graph(ctx)
+ mg, err = rs.Graph(loaderstate, ctx)
if err != nil {
return rs, err
}
roots = make([]module.Version, 0, len(rs.rootModules))
rootsUpgraded = false
inRootPaths := make(map[string]bool, len(rs.rootModules)+1)
- for _, mm := range LoaderState.MainModules.Versions() {
+ for _, mm := range loaderstate.MainModules.Versions() {
inRootPaths[mm.Path] = true
}
for _, m := range rs.rootModules {
var v string
if mg == nil {
- v, _ = rs.rootSelected(m.Path)
+ v, _ = rs.rootSelected(loaderstate, m.Path)
} else {
v = mg.Selected(m.Path)
}
// preserve its cached ModuleGraph (if any).
return rs, nil
}
- return newRequirements(pruned, roots, direct), nil
+ return newRequirements(loaderstate, pruned, roots, direct), nil
}
// spotCheckRoots reports whether the versions of the roots in rs satisfy the
// explicit requirements of the modules in mods.
-func spotCheckRoots(ctx context.Context, rs *Requirements, mods map[module.Version]bool) bool {
+func spotCheckRoots(loaderstate *State, ctx context.Context, rs *Requirements, mods map[module.Version]bool) bool {
ctx, cancel := context.WithCancel(ctx)
defer cancel()
return
}
- summary, err := goModSummary(m)
+ summary, err := goModSummary(loaderstate, m)
if err != nil {
cancel()
return
}
for _, r := range summary.require {
- if v, ok := rs.rootSelected(r.Path); ok && gover.ModCompare(r.Path, v, r.Version) < 0 {
+ if v, ok := rs.rootSelected(loaderstate, r.Path); ok && gover.ModCompare(r.Path, v, r.Version) < 0 {
cancel()
return
}
// the selected version of every module that provided or lexically could have
// provided a package in pkgs, and includes the selected version of every such
// module in direct as a root.
-func tidyUnprunedRoots(ctx context.Context, mainModule module.Version, old *Requirements, pkgs []*loadPkg) (*Requirements, error) {
+func tidyUnprunedRoots(loaderstate *State, ctx context.Context, mainModule module.Version, old *Requirements, pkgs []*loadPkg) (*Requirements, error) {
var (
// keep is a set of modules that provide packages or are needed to
// disambiguate imports.
// without its sum. See #47738.
altMods = map[string]string{}
)
- if v, ok := old.rootSelected("go"); ok {
+ if v, ok := old.rootSelected(loaderstate, "go"); ok {
keep = append(keep, module.Version{Path: "go", Version: v})
keptPath["go"] = true
}
- if v, ok := old.rootSelected("toolchain"); ok {
+ if v, ok := old.rootSelected(loaderstate, "toolchain"); ok {
keep = append(keep, module.Version{Path: "toolchain", Version: v})
keptPath["toolchain"] = true
}
for _, pkg := range pkgs {
- if !pkg.fromExternalModule() {
+ if !pkg.fromExternalModule(loaderstate) {
continue
}
if m := pkg.mod; !keptPath[m.Path] {
}
}
- return newRequirements(unpruned, min, old.direct), nil
+ return newRequirements(loaderstate, unpruned, min, old.direct), nil
}
// updateUnprunedRoots returns a set of root requirements that includes the selected
// by a dependency in add.
// 4. Every version in add is selected at its given version unless upgraded by
// (the dependencies of) an existing root or another module in add.
-func updateUnprunedRoots(ctx context.Context, direct map[string]bool, rs *Requirements, add []module.Version) (*Requirements, error) {
- mg, err := rs.Graph(ctx)
+func updateUnprunedRoots(loaderstate *State, ctx context.Context, direct map[string]bool, rs *Requirements, add []module.Version) (*Requirements, error) {
+ mg, err := rs.Graph(loaderstate, ctx)
if err != nil {
// We can't ignore errors in the module graph even if the user passed the -e
// flag to try to push past them. If we can't load the complete module
return rs, err
}
- if mustHaveCompleteRequirements() {
+ if mustHaveCompleteRequirements(loaderstate) {
// Instead of actually updating the requirements, just check that no updates
// are needed.
if rs == nil {
}
}
for mPath := range direct {
- if _, ok := rs.rootSelected(mPath); !ok {
+ if _, ok := rs.rootSelected(loaderstate, mPath); !ok {
// Module m is supposed to be listed explicitly, but isn't.
//
// Note that this condition is also detected (and logged with more
// This is only for convenience and clarity for end users: in an unpruned module,
// the choice of explicit vs. implicit dependency has no impact on MVS
// selection (for itself or any other module).
- keep := append(mg.BuildList()[LoaderState.MainModules.Len():], add...)
+ keep := append(mg.BuildList()[loaderstate.MainModules.Len():], add...)
for _, m := range keep {
if direct[m.Path] && !inRootPaths[m.Path] {
rootPaths = append(rootPaths, m.Path)
}
var roots []module.Version
- for _, mainModule := range LoaderState.MainModules.Versions() {
+ for _, mainModule := range loaderstate.MainModules.Versions() {
min, err := mvs.Req(mainModule, rootPaths, &mvsReqs{roots: keep})
if err != nil {
return rs, err
}
roots = append(roots, min...)
}
- if LoaderState.MainModules.Len() > 1 {
+ if loaderstate.MainModules.Len() > 1 {
gover.ModSort(roots)
}
if rs.pruning == unpruned && slices.Equal(roots, rs.rootModules) && maps.Equal(direct, rs.direct) {
return rs, nil
}
- return newRequirements(unpruned, roots, direct), nil
+ return newRequirements(loaderstate, unpruned, roots, direct), nil
}
// convertPruning returns a version of rs with the given pruning behavior.
// If rs already has the given pruning, convertPruning returns rs unmodified.
-func convertPruning(ctx context.Context, rs *Requirements, pruning modPruning) (*Requirements, error) {
+func convertPruning(loaderstate *State, ctx context.Context, rs *Requirements, pruning modPruning) (*Requirements, error) {
if rs.pruning == pruning {
return rs, nil
} else if rs.pruning == workspace || pruning == workspace {
// pruned module graph are a superset of the roots of an unpruned one, so
// we don't need to add any new roots — we just need to drop the ones that
// are redundant, which is exactly what updateUnprunedRoots does.
- return updateUnprunedRoots(ctx, rs.direct, rs, nil)
+ return updateUnprunedRoots(loaderstate, ctx, rs.direct, rs, nil)
}
// We are converting an unpruned module to a pruned one.
// root set! “Include the transitive dependencies of every module in the build
// list” is exactly what happens in a pruned module if we promote every module
// in the build list to a root.
- mg, err := rs.Graph(ctx)
+ mg, err := rs.Graph(loaderstate, ctx)
if err != nil {
return rs, err
}
- return newRequirements(pruned, mg.BuildList()[LoaderState.MainModules.Len():], rs.direct), nil
+ return newRequirements(loaderstate, pruned, mg.BuildList()[loaderstate.MainModules.Len():], rs.direct), nil
}
// If pruning is enabled, the roots of the edited requirements include an
// explicit entry for each module path in tryUpgrade, mustSelect, and the roots
// of rs, unless the selected version for the module path is "none".
-func editRequirements(ctx context.Context, rs *Requirements, tryUpgrade, mustSelect []module.Version) (edited *Requirements, changed bool, err error) {
+func editRequirements(loaderstate *State, ctx context.Context, rs *Requirements, tryUpgrade, mustSelect []module.Version) (edited *Requirements, changed bool, err error) {
if rs.pruning == workspace {
panic("editRequirements cannot edit workspace requirements")
}
}
if rootPruning != rs.pruning {
- rs, err = convertPruning(ctx, rs, rootPruning)
+ rs, err = convertPruning(loaderstate, ctx, rs, rootPruning)
if err != nil {
return orig, false, err
}
// dependencies, so we need to treat everything in the build list as
// potentially relevant — that is, as what would be a “root” in a module
// with graph pruning enabled.
- mg, err := rs.Graph(ctx)
+ mg, err := rs.Graph(loaderstate, ctx)
if err != nil {
// If we couldn't load the graph, we don't know what its requirements were
// to begin with, so we can't edit those requirements in a coherent way.
return orig, false, err
}
- bl := mg.BuildList()[LoaderState.MainModules.Len():]
+ bl := mg.BuildList()[loaderstate.MainModules.Len():]
selectedRoot = make(map[string]string, len(bl))
for _, m := range bl {
selectedRoot[m.Path] = m.Version
// of every root. The upgraded roots are in addition to the original
// roots, so we will have enough information to trace a path to each
// conflict we discover from one or more of the original roots.
- mg, upgradedRoots, err := extendGraph(ctx, rootPruning, roots, selectedRoot)
+ mg, upgradedRoots, err := extendGraph(loaderstate, ctx, rootPruning, roots, selectedRoot)
if err != nil {
if mg == nil {
return orig, false, err
// the edit. We want to make sure we consider keeping it as-is,
// even if it wouldn't normally be included. (For example, it might
// be a pseudo-version or pre-release.)
- origMG, _ := orig.Graph(ctx)
+ origMG, _ := orig.Graph(loaderstate, ctx)
origV := origMG.Selected(m.Path)
if conflict.Err != nil && origV == m.Version {
rejectedRoot[m] = true
prev := m
for {
- prev, err = previousVersion(ctx, prev)
+ prev, err = previousVersion(loaderstate, ctx, prev)
if gover.ModCompare(m.Path, m.Version, origV) > 0 && (gover.ModCompare(m.Path, prev.Version, origV) < 0 || err != nil) {
// previousVersion skipped over origV. Insert it into the order.
prev.Version = origV
// The modules in mustSelect are always promoted to be explicit.
for _, m := range mustSelect {
- if m.Version != "none" && !LoaderState.MainModules.Contains(m.Path) {
+ if m.Version != "none" && !loaderstate.MainModules.Contains(m.Path) {
rootPaths = append(rootPaths, m.Path)
}
}
for _, m := range roots {
- if v, ok := rs.rootSelected(m.Path); ok && (v == m.Version || rs.direct[m.Path]) {
+ if v, ok := rs.rootSelected(loaderstate, m.Path); ok && (v == m.Version || rs.direct[m.Path]) {
// m.Path was formerly a root, and either its version hasn't changed or
// we believe that it provides a package directly imported by a package
// or test in the main module. For now we'll assume that it is still
}
}
- roots, err = mvs.Req(LoaderState.MainModules.mustGetSingleMainModule(), rootPaths, &mvsReqs{roots: roots})
+ roots, err = mvs.Req(loaderstate.MainModules.mustGetSingleMainModule(loaderstate), rootPaths, &mvsReqs{roots: roots})
if err != nil {
return nil, false, err
}
direct[m.Path] = true
}
}
- edited = newRequirements(rootPruning, roots, direct)
+ edited = newRequirements(loaderstate, rootPruning, roots, direct)
// If we ended up adding a dependency that upgrades our go version far enough
// to activate pruning, we must convert the edited Requirements in order to
// those two modules will never be downgraded due to a conflict with any other
// constraint.
if rootPruning == unpruned {
- if v, ok := edited.rootSelected("go"); ok && pruningForGoVersion(v) == pruned {
+ if v, ok := edited.rootSelected(loaderstate, "go"); ok && pruningForGoVersion(v) == pruned {
// Since we computed the edit with the unpruned graph, and the pruned
// graph is a strict subset of the unpruned graph, this conversion
// preserves the exact (edited) build list that we already computed.
// the graph. 'go get' will check for that sort of transition and log a
// message reminding the user how to clean up this mess we're about to
// make. 😅
- edited, err = convertPruning(ctx, edited, pruned)
+ edited, err = convertPruning(loaderstate, ctx, edited, pruned)
if err != nil {
return orig, false, err
}
// The extended graph is useful for diagnosing version conflicts: for each
// selected module version, it can provide a complete path of requirements from
// some root to that version.
-func extendGraph(ctx context.Context, rootPruning modPruning, roots []module.Version, selectedRoot map[string]string) (mg *ModuleGraph, upgradedRoot map[module.Version]bool, err error) {
+func extendGraph(loaderstate *State, ctx context.Context, rootPruning modPruning, roots []module.Version, selectedRoot map[string]string) (mg *ModuleGraph, upgradedRoot map[module.Version]bool, err error) {
for {
- mg, err = readModGraph(ctx, rootPruning, roots, upgradedRoot)
+ mg, err = readModGraph(loaderstate, ctx, rootPruning, roots, upgradedRoot)
// We keep on going even if err is non-nil until we reach a steady state.
// (Note that readModGraph returns a non-nil *ModuleGraph even in case of
// errors.) The caller may be able to fix the errors by adjusting versions,
// (https://go.dev/issue/56222) for modules with 'go' versions between 1.17 and
// 1.20, preventing unnecessary go.sum churn and network access in those
// modules.
-func importFromModules(ctx context.Context, path string, rs *Requirements, mg *ModuleGraph, skipModFile bool) (m module.Version, modroot, dir string, altMods []module.Version, err error) {
+func importFromModules(loaderstate *State, ctx context.Context, path string, rs *Requirements, mg *ModuleGraph, skipModFile bool) (m module.Version, modroot, dir string, altMods []module.Version, err error) {
invalidf := func(format string, args ...interface{}) (module.Version, string, string, []module.Version, error) {
return module.Version{}, "", "", nil, &invalidImportError{
importPath: path,
// Is the package in the standard library?
pathIsStd := search.IsStandardImportPath(path)
if pathIsStd && modindex.IsStandardPackage(cfg.GOROOT, cfg.BuildContext.Compiler, path) {
- for _, mainModule := range LoaderState.MainModules.Versions() {
- if LoaderState.MainModules.InGorootSrc(mainModule) {
- if dir, ok, err := dirInModule(path, LoaderState.MainModules.PathPrefix(mainModule), LoaderState.MainModules.ModRoot(mainModule), true); err != nil {
- return module.Version{}, LoaderState.MainModules.ModRoot(mainModule), dir, nil, err
+ for _, mainModule := range loaderstate.MainModules.Versions() {
+ if loaderstate.MainModules.InGorootSrc(mainModule) {
+ if dir, ok, err := dirInModule(path, loaderstate.MainModules.PathPrefix(mainModule), loaderstate.MainModules.ModRoot(mainModule), true); err != nil {
+ return module.Version{}, loaderstate.MainModules.ModRoot(mainModule), dir, nil, err
} else if ok {
- return mainModule, LoaderState.MainModules.ModRoot(mainModule), dir, nil, nil
+ return mainModule, loaderstate.MainModules.ModRoot(mainModule), dir, nil, nil
}
}
}
// Everything must be in the main modules or the main module's or workspace's vendor directory.
if cfg.BuildMod == "vendor" {
var mainErr error
- for _, mainModule := range LoaderState.MainModules.Versions() {
- modRoot := LoaderState.MainModules.ModRoot(mainModule)
+ for _, mainModule := range loaderstate.MainModules.Versions() {
+ modRoot := loaderstate.MainModules.ModRoot(mainModule)
if modRoot != "" {
- dir, mainOK, err := dirInModule(path, LoaderState.MainModules.PathPrefix(mainModule), modRoot, true)
+ dir, mainOK, err := dirInModule(path, loaderstate.MainModules.PathPrefix(mainModule), modRoot, true)
if mainErr == nil {
mainErr = err
}
}
}
- if HasModRoot() {
- vendorDir := VendorDir()
+ if HasModRoot(loaderstate) {
+ vendorDir := VendorDir(loaderstate)
dir, inVendorDir, _ := dirInModule(path, "", vendorDir, false)
if inVendorDir {
readVendorList(vendorDir)
// vendor/modules.txt does not exist or the user manually added directories to the vendor directory.
// Go 1.23 and later require vendored packages to be present in modules.txt to be imported.
_, ok := vendorPkgModule[path]
- if ok || (gover.Compare(LoaderState.MainModules.GoVersion(), gover.ExplicitModulesTxtImportVersion) < 0) {
+ if ok || (gover.Compare(loaderstate.MainModules.GoVersion(loaderstate), gover.ExplicitModulesTxtImportVersion) < 0) {
mods = append(mods, vendorPkgModule[path])
dirs = append(dirs, dir)
roots = append(roots, vendorDir)
} else {
subCommand := "mod"
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
subCommand = "work"
}
fmt.Fprintf(os.Stderr, "go: ignoring package %s which exists in the vendor directory but is missing from vendor/modules.txt. To sync the vendor directory run go %s vendor.\n", path, subCommand)
ok bool
)
if mg == nil {
- v, ok = rs.rootSelected(prefix)
+ v, ok = rs.rootSelected(loaderstate, prefix)
} else {
v, ok = mg.Selected(prefix), true
}
}
m := module.Version{Path: prefix, Version: v}
- root, isLocal, err := fetch(ctx, m)
+ root, isLocal, err := fetch(loaderstate, ctx, m)
if err != nil {
if _, ok := errors.AsType[*sumMissingError](err); ok {
// We are missing a sum needed to fetch a module in the build list.
// If the module graph is pruned and this is a test-only dependency
// of a package in "all", we didn't necessarily load that file
// when we read the module graph, so do it now to be sure.
- if !skipModFile && cfg.BuildMod != "vendor" && mods[0].Path != "" && !LoaderState.MainModules.Contains(mods[0].Path) {
- if _, err := goModSummary(mods[0]); err != nil {
+ if !skipModFile && cfg.BuildMod != "vendor" && mods[0].Path != "" && !loaderstate.MainModules.Contains(mods[0].Path) {
+ if _, err := goModSummary(loaderstate, mods[0]); err != nil {
return module.Version{}, "", "", nil, err
}
}
// We checked the full module graph and still didn't find the
// requested package.
var queryErr error
- if !HasModRoot() {
+ if !HasModRoot(loaderstate) {
queryErr = ErrNoModRoot
}
return module.Version{}, "", "", nil, &ImportMissingError{Path: path, QueryErr: queryErr, isStd: pathIsStd}
// So far we've checked the root dependencies.
// Load the full module graph and try again.
- mg, err = rs.Graph(ctx)
+ mg, err = rs.Graph(loaderstate, ctx)
if err != nil {
// We might be missing one or more transitive (implicit) dependencies from
// the module graph, so we can't return an ImportMissingError here — one
//
// Unlike QueryPattern, queryImport prefers to add a replaced version of a
// module *before* checking the proxies for a version to add.
-func queryImport(ctx context.Context, path string, rs *Requirements) (module.Version, error) {
+func queryImport(loaderstate *State, ctx context.Context, path string, rs *Requirements) (module.Version, error) {
// To avoid spurious remote fetches, try the latest replacement for each
// module (golang.org/issue/26241).
var mods []module.Version
- if LoaderState.MainModules != nil { // TODO(#48912): Ensure MainModules exists at this point, and remove the check.
- for mp, mv := range LoaderState.MainModules.HighestReplaced() {
+ if loaderstate.MainModules != nil { // TODO(#48912): Ensure MainModules exists at this point, and remove the check.
+ for mp, mv := range loaderstate.MainModules.HighestReplaced() {
if !maybeInModule(path, mp) {
continue
}
mv = module.ZeroPseudoVersion("v0")
}
}
- mg, err := rs.Graph(ctx)
+ mg, err := rs.Graph(loaderstate, ctx)
if err != nil {
return module.Version{}, err
}
return len(mods[i].Path) > len(mods[j].Path)
})
for _, m := range mods {
- root, isLocal, err := fetch(ctx, m)
+ root, isLocal, err := fetch(loaderstate, ctx, m)
if err != nil {
if _, ok := errors.AsType[*sumMissingError](err); ok {
return module.Version{}, &ImportMissingSumError{importPath: path}
// The package path is not valid to fetch remotely,
// so it can only exist in a replaced module,
// and we know from the above loop that it is not.
- replacement := Replacement(mods[0])
+ replacement := Replacement(loaderstate, mods[0])
return module.Version{}, &PackageNotInModuleError{
Mod: mods[0],
Query: "latest",
// and return m, dir, ImportMissingError.
fmt.Fprintf(os.Stderr, "go: finding module for package %s\n", path)
- mg, err := rs.Graph(ctx)
+ mg, err := rs.Graph(loaderstate, ctx)
if err != nil {
return module.Version{}, err
}
- candidates, err := QueryPackages(ctx, path, "latest", mg.Selected, CheckAllowed)
+ candidates, err := QueryPackages(loaderstate, ctx, path, "latest", mg.Selected, CheckAllowed)
if err != nil {
if errors.Is(err, fs.ErrNotExist) {
// Return "cannot find module providing package […]" instead of whatever
//
// The isLocal return value reports whether the replacement,
// if any, is local to the filesystem.
-func fetch(ctx context.Context, mod module.Version) (dir string, isLocal bool, err error) {
- if modRoot := LoaderState.MainModules.ModRoot(mod); modRoot != "" {
+func fetch(loaderstate *State, ctx context.Context, mod module.Version) (dir string, isLocal bool, err error) {
+ if modRoot := loaderstate.MainModules.ModRoot(mod); modRoot != "" {
return modRoot, true, nil
}
- if r := Replacement(mod); r.Path != "" {
+ if r := Replacement(loaderstate, mod); r.Path != "" {
if r.Version == "" {
dir = r.Path
if !filepath.IsAbs(dir) {
- dir = filepath.Join(replaceRelativeTo(), dir)
+ dir = filepath.Join(replaceRelativeTo(loaderstate), dir)
}
// Ensure that the replacement directory actually exists:
// dirInModule does not report errors for missing modules,
mod = r
}
- if mustHaveSums() && !modfetch.HaveSum(mod) {
+ if mustHaveSums(loaderstate) && !modfetch.HaveSum(mod) {
return "", false, module.VersionError(mod, &sumMissingError{})
}
// mustHaveSums reports whether we require that all checksums
// needed to load or build packages are already present in the go.sum file.
-func mustHaveSums() bool {
- return HasModRoot() && cfg.BuildMod == "readonly" && !inWorkspaceMode()
+func mustHaveSums(loaderstate *State) bool {
+ return HasModRoot(loaderstate) && cfg.BuildMod == "readonly" && !inWorkspaceMode(loaderstate)
}
type sumMissingError struct {
LoaderState.RootMode = NoRoot
ctx := context.Background()
- rs := LoadModFile(ctx)
+ rs := LoadModFile(LoaderState, ctx)
for _, tt := range importTests {
t.Run(strings.ReplaceAll(tt.path, "/", "_"), func(t *testing.T) {
// Note that there is no build list, so Import should always fail.
- m, err := queryImport(ctx, tt.path, rs)
+ m, err := queryImport(LoaderState, ctx, tt.path, rs)
if tt.err == "" {
if err != nil {
modfetch.Reset()
LoaderState.modRoots = []string{enterModroot}
- LoadModFile(ctx)
+ LoadModFile(LoaderState, ctx)
}
// EnterWorkspace enters workspace mode from module mode, applying the updated requirements to the main
// EnterWorkspace will modify the global state they depend on in a non-thread-safe way.
func EnterWorkspace(ctx context.Context) (exit func(), err error) {
// Find the identity of the main module that will be updated before we reset modload state.
- mm := LoaderState.MainModules.mustGetSingleMainModule()
+ mm := LoaderState.MainModules.mustGetSingleMainModule(LoaderState)
// Get the updated modfile we will use for that module.
- _, _, updatedmodfile, err := UpdateGoModFromReqs(ctx, WriteOpts{})
+ _, _, updatedmodfile, err := UpdateGoModFromReqs(LoaderState, ctx, WriteOpts{})
if err != nil {
return nil, err
}
LoaderState.ForceUseModules = true
// Load in workspace mode.
- InitWorkfile()
- LoadModFile(ctx)
+ InitWorkfile(LoaderState)
+ LoadModFile(LoaderState, ctx)
// Update the content of the previous main module, and recompute the requirements.
*LoaderState.MainModules.ModFile(mm) = *updatedmodfile
- LoaderState.requirements = requirementsFromModFiles(ctx, LoaderState.MainModules.workFile, slices.Collect(maps.Values(LoaderState.MainModules.modFiles)), nil)
+ LoaderState.requirements = requirementsFromModFiles(LoaderState, ctx, LoaderState.MainModules.workFile, slices.Collect(maps.Values(LoaderState.MainModules.modFiles)), nil)
return func() {
setState(oldstate)
return mms.inGorootSrc[m]
}
-func (mms *MainModuleSet) mustGetSingleMainModule() module.Version {
+func (mms *MainModuleSet) mustGetSingleMainModule(loaderstate *State) module.Version {
if mms == nil || len(mms.versions) == 0 {
panic("internal error: mustGetSingleMainModule called in context with no main modules")
}
if len(mms.versions) != 1 {
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
panic("internal error: mustGetSingleMainModule called in workspace mode")
} else {
panic("internal error: multiple main modules present outside of workspace mode")
return mms.versions[0]
}
-func (mms *MainModuleSet) GetSingleIndexOrNil() *modFileIndex {
+func (mms *MainModuleSet) GetSingleIndexOrNil(loaderstate *State) *modFileIndex {
if mms == nil {
return nil
}
if len(mms.versions) == 0 {
return nil
}
- return mms.indices[mms.mustGetSingleMainModule()]
+ return mms.indices[mms.mustGetSingleMainModule(loaderstate)]
}
func (mms *MainModuleSet) Index(m module.Version) *modFileIndex {
// GoVersion returns the go version set on the single module, in module mode,
// or the go.work file in workspace mode.
-func (mms *MainModuleSet) GoVersion() string {
- if inWorkspaceMode() {
+func (mms *MainModuleSet) GoVersion(loaderstate *State) string {
+ if inWorkspaceMode(loaderstate) {
return gover.FromGoWork(mms.workFile)
}
if mms != nil && len(mms.versions) == 1 {
- f := mms.ModFile(mms.mustGetSingleMainModule())
+ f := mms.ModFile(mms.mustGetSingleMainModule(loaderstate))
if f == nil {
// Special case: we are outside a module, like 'go run x.go'.
// Assume the local Go version.
// Godebugs returns the godebug lines set on the single module, in module mode,
// or on the go.work file in workspace mode.
// The caller must not modify the result.
-func (mms *MainModuleSet) Godebugs() []*modfile.Godebug {
- if inWorkspaceMode() {
+func (mms *MainModuleSet) Godebugs(loaderstate *State) []*modfile.Godebug {
+ if inWorkspaceMode(loaderstate) {
if mms.workFile != nil {
return mms.workFile.Godebug
}
return nil
}
if mms != nil && len(mms.versions) == 1 {
- f := mms.ModFile(mms.mustGetSingleMainModule())
+ f := mms.ModFile(mms.mustGetSingleMainModule(loaderstate))
if f == nil {
// Special case: we are outside a module, like 'go run x.go'.
return nil
// To make permanent changes to the require statements
// in go.mod, edit it before loading.
func ModFile() *modfile.File {
- Init()
- modFile := LoaderState.MainModules.ModFile(LoaderState.MainModules.mustGetSingleMainModule())
+ Init(LoaderState)
+ modFile := LoaderState.MainModules.ModFile(LoaderState.MainModules.mustGetSingleMainModule(LoaderState))
if modFile == nil {
- die()
+ die(LoaderState)
}
return modFile
}
-func BinDir() string {
- Init()
+func BinDir(loaderstate *State) string {
+ Init(loaderstate)
if cfg.GOBIN != "" {
return cfg.GOBIN
}
// InitWorkfile initializes the workFilePath variable for commands that
// operate in workspace mode. It should not be called by other commands,
// for example 'go mod tidy', that don't operate in workspace mode.
-func InitWorkfile() {
+func InitWorkfile(loaderstate *State) {
// Initialize fsys early because we need overlay to read go.work file.
fips140.Init()
if err := fsys.Init(); err != nil {
base.Fatal(err)
}
- LoaderState.workFilePath = FindGoWork(base.Cwd())
+ loaderstate.workFilePath = FindGoWork(loaderstate, base.Cwd())
}
// FindGoWork returns the name of the go.work file for this command,
// Most code should use Init and Enabled rather than use this directly.
// It is exported mainly for Go toolchain switching, which must process
// the go.work very early at startup.
-func FindGoWork(wd string) string {
- if LoaderState.RootMode == NoRoot {
+func FindGoWork(loaderstate *State, wd string) string {
+ if loaderstate.RootMode == NoRoot {
return ""
}
// WorkFilePath returns the absolute path of the go.work file, or "" if not in
// workspace mode. WorkFilePath must be called after InitWorkfile.
-func WorkFilePath() string {
- return LoaderState.workFilePath
+func WorkFilePath(loaderstate *State) string {
+ return loaderstate.workFilePath
}
// Reset clears all the initialized, cached state about the use of modules,
// current module (if any), sets environment variables for Git subprocesses, and
// configures the cfg, codehost, load, modfetch, and search packages for use
// with modules.
-func Init() {
- if LoaderState.initialized {
+func Init(loaderstate *State) {
+ if loaderstate.initialized {
return
}
- LoaderState.initialized = true
+ loaderstate.initialized = true
fips140.Init()
default:
base.Fatalf("go: unknown environment setting GO111MODULE=%s", env)
case "auto":
- mustUseModules = LoaderState.ForceUseModules
+ mustUseModules = loaderstate.ForceUseModules
case "on", "":
mustUseModules = true
case "off":
- if LoaderState.ForceUseModules {
+ if loaderstate.ForceUseModules {
base.Fatalf("go: modules disabled by GO111MODULE=off; see 'go help modules'")
}
mustUseModules = false
if os.Getenv("GCM_INTERACTIVE") == "" {
os.Setenv("GCM_INTERACTIVE", "never")
}
- if LoaderState.modRoots != nil {
+ if loaderstate.modRoots != nil {
// modRoot set before Init was called ("go mod init" does this).
// No need to search for go.mod.
- } else if LoaderState.RootMode == NoRoot {
+ } else if loaderstate.RootMode == NoRoot {
if cfg.ModFile != "" && !base.InGOFLAGS("-modfile") {
base.Fatalf("go: -modfile cannot be used with commands that ignore the current module")
}
- LoaderState.modRoots = nil
- } else if LoaderState.workFilePath != "" {
+ loaderstate.modRoots = nil
+ } else if loaderstate.workFilePath != "" {
// We're in workspace mode, which implies module mode.
if cfg.ModFile != "" {
base.Fatalf("go: -modfile cannot be used in workspace mode")
if cfg.ModFile != "" {
base.Fatalf("go: cannot find main module, but -modfile was set.\n\t-modfile cannot be used to set the module root directory.")
}
- if LoaderState.RootMode == NeedRoot {
+ if loaderstate.RootMode == NeedRoot {
base.Fatal(ErrNoModRoot)
}
if !mustUseModules {
// It's a bit of a peculiar thing to disallow but quite mysterious
// when it happens. See golang.org/issue/26708.
fmt.Fprintf(os.Stderr, "go: warning: ignoring go.mod in system temp root %v\n", os.TempDir())
- if LoaderState.RootMode == NeedRoot {
+ if loaderstate.RootMode == NeedRoot {
base.Fatal(ErrNoModRoot)
}
if !mustUseModules {
return
}
} else {
- LoaderState.modRoots = []string{modRoot}
+ loaderstate.modRoots = []string{modRoot}
}
}
if cfg.ModFile != "" && !strings.HasSuffix(cfg.ModFile, ".mod") {
// We're in module mode. Set any global variables that need to be set.
cfg.ModulesEnabled = true
- setDefaultBuildMod()
+ setDefaultBuildMod(loaderstate)
list := filepath.SplitList(cfg.BuildContext.GOPATH)
if len(list) > 0 && list[0] != "" {
gopath = list[0]
if _, err := fsys.Stat(filepath.Join(gopath, "go.mod")); err == nil {
fmt.Fprintf(os.Stderr, "go: warning: ignoring go.mod in $GOPATH %v\n", gopath)
- if LoaderState.RootMode == NeedRoot {
+ if loaderstate.RootMode == NeedRoot {
base.Fatal(ErrNoModRoot)
}
if !mustUseModules {
// If modules are enabled but there is no main module, Enabled returns true
// and then the first use of module information will call die
// (usually through MustModRoot).
-func Enabled() bool {
- Init()
- return LoaderState.modRoots != nil || cfg.ModulesEnabled
+func Enabled(loaderstate *State) bool {
+ Init(loaderstate)
+ return loaderstate.modRoots != nil || cfg.ModulesEnabled
}
-func VendorDir() string {
- if inWorkspaceMode() {
- return filepath.Join(filepath.Dir(WorkFilePath()), "vendor")
+func VendorDir(loaderstate *State) string {
+ if inWorkspaceMode(loaderstate) {
+ return filepath.Join(filepath.Dir(WorkFilePath(loaderstate)), "vendor")
}
// Even if -mod=vendor, we could be operating with no mod root (and thus no
// vendor directory). As long as there are no dependencies that is expected
// to work. See script/vendor_outside_module.txt.
- modRoot := LoaderState.MainModules.ModRoot(LoaderState.MainModules.mustGetSingleMainModule())
+ modRoot := loaderstate.MainModules.ModRoot(loaderstate.MainModules.mustGetSingleMainModule(loaderstate))
if modRoot == "" {
panic("vendor directory does not exist when in single module mode outside of a module")
}
return filepath.Join(modRoot, "vendor")
}
-func inWorkspaceMode() bool {
- if !LoaderState.initialized {
+func inWorkspaceMode(loaderstate *State) bool {
+ if !loaderstate.initialized {
panic("inWorkspaceMode called before modload.Init called")
}
- if !Enabled() {
+ if !Enabled(loaderstate) {
return false
}
- return LoaderState.workFilePath != ""
+ return loaderstate.workFilePath != ""
}
// HasModRoot reports whether a main module or main modules are present.
// HasModRoot may return false even if Enabled returns true: for example, 'get'
// does not require a main module.
-func HasModRoot() bool {
- Init()
- return LoaderState.modRoots != nil
+func HasModRoot(loaderstate *State) bool {
+ Init(loaderstate)
+ return loaderstate.modRoots != nil
}
// MustHaveModRoot checks that a main module or main modules are present,
// and calls base.Fatalf if there are no main modules.
func MustHaveModRoot() {
- Init()
- if !HasModRoot() {
- die()
+ Init(LoaderState)
+ if !HasModRoot(LoaderState) {
+ die(LoaderState)
}
}
return filepath.Join(modRoot, "go.mod")
}
-func die() {
+func die(loaderstate *State) {
if cfg.Getenv("GO111MODULE") == "off" {
base.Fatalf("go: modules disabled by GO111MODULE=off; see 'go help modules'")
}
- if !inWorkspaceMode() {
+ if !inWorkspaceMode(loaderstate) {
if dir, name := findAltConfig(base.Cwd()); dir != "" {
rel, err := filepath.Rel(base.Cwd(), dir)
if err != nil {
type noMainModulesError struct{}
func (e noMainModulesError) Error() string {
- if inWorkspaceMode() {
+ if inWorkspaceMode(LoaderState) {
return "no modules were found in the current workspace; see 'go help work'"
}
return "go.mod file not found in current directory or any parent directory; see 'go help modules'"
// other, but unlike LoadModGraph does not load the full module graph or check
// it for global consistency. Most callers outside of the modload package should
// use LoadModGraph instead.
-func LoadModFile(ctx context.Context) *Requirements {
- rs, err := loadModFile(ctx, nil)
+func LoadModFile(loaderstate *State, ctx context.Context) *Requirements {
+ rs, err := loadModFile(loaderstate, ctx, nil)
if err != nil {
base.Fatal(err)
}
return rs
}
-func loadModFile(ctx context.Context, opts *PackageOpts) (*Requirements, error) {
- if LoaderState.requirements != nil {
- return LoaderState.requirements, nil
+func loadModFile(loaderstate *State, ctx context.Context, opts *PackageOpts) (*Requirements, error) {
+ if loaderstate.requirements != nil {
+ return loaderstate.requirements, nil
}
- Init()
+ Init(loaderstate)
var workFile *modfile.WorkFile
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
var err error
- workFile, LoaderState.modRoots, err = LoadWorkFile(LoaderState.workFilePath)
+ workFile, loaderstate.modRoots, err = LoadWorkFile(loaderstate.workFilePath)
if err != nil {
return nil, err
}
- for _, modRoot := range LoaderState.modRoots {
+ for _, modRoot := range loaderstate.modRoots {
sumFile := strings.TrimSuffix(modFilePath(modRoot), ".mod") + ".sum"
modfetch.WorkspaceGoSumFiles = append(modfetch.WorkspaceGoSumFiles, sumFile)
}
- modfetch.GoSumFile = LoaderState.workFilePath + ".sum"
- } else if len(LoaderState.modRoots) == 0 {
+ modfetch.GoSumFile = loaderstate.workFilePath + ".sum"
+ } else if len(loaderstate.modRoots) == 0 {
// We're in module mode, but not inside a module.
//
// Commands like 'go build', 'go run', 'go list' have no go.mod file to
//
// See golang.org/issue/32027.
} else {
- modfetch.GoSumFile = strings.TrimSuffix(modFilePath(LoaderState.modRoots[0]), ".mod") + ".sum"
+ modfetch.GoSumFile = strings.TrimSuffix(modFilePath(loaderstate.modRoots[0]), ".mod") + ".sum"
}
- if len(LoaderState.modRoots) == 0 {
+ if len(loaderstate.modRoots) == 0 {
// TODO(#49228): Instead of creating a fake module with an empty modroot,
// make MainModules.Len() == 0 mean that we're in module mode but not inside
// any module.
mainModule := module.Version{Path: "command-line-arguments"}
- LoaderState.MainModules = makeMainModules([]module.Version{mainModule}, []string{""}, []*modfile.File{nil}, []*modFileIndex{nil}, nil)
+ loaderstate.MainModules = makeMainModules(loaderstate, []module.Version{mainModule}, []string{""}, []*modfile.File{nil}, []*modFileIndex{nil}, nil)
var (
goVersion string
pruning modPruning
roots []module.Version
direct = map[string]bool{"go": true}
)
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
// Since we are in a workspace, the Go version for the synthetic
// "command-line-arguments" module must not exceed the Go version
// for the workspace.
- goVersion = LoaderState.MainModules.GoVersion()
+ goVersion = loaderstate.MainModules.GoVersion(loaderstate)
pruning = workspace
roots = []module.Version{
mainModule,
}
}
rawGoVersion.Store(mainModule, goVersion)
- LoaderState.requirements = newRequirements(pruning, roots, direct)
+ loaderstate.requirements = newRequirements(loaderstate, pruning, roots, direct)
if cfg.BuildMod == "vendor" {
// For issue 56536: Some users may have GOFLAGS=-mod=vendor set.
// Make sure it behaves as though the fake module is vendored
// with no dependencies.
- LoaderState.requirements.initVendor(nil)
+ loaderstate.requirements.initVendor(loaderstate, nil)
}
- return LoaderState.requirements, nil
+ return loaderstate.requirements, nil
}
var modFiles []*modfile.File
var mainModules []module.Version
var indices []*modFileIndex
var errs []error
- for _, modroot := range LoaderState.modRoots {
+ for _, modroot := range loaderstate.modRoots {
gomod := modFilePath(modroot)
var fixed bool
- data, f, err := ReadModFile(gomod, fixVersion(ctx, &fixed))
+ data, f, err := ReadModFile(gomod, fixVersion(loaderstate, ctx, &fixed))
if err != nil {
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
if tooNew, ok := err.(*gover.TooNewError); ok && !strings.HasPrefix(cfg.CmdName, "work ") {
// Switching to a newer toolchain won't help - the go.work has the wrong version.
// Report this more specific error, unless we are a command like 'go work use'
errs = append(errs, err)
continue
}
- if inWorkspaceMode() && !strings.HasPrefix(cfg.CmdName, "work ") {
+ if inWorkspaceMode(loaderstate) && !strings.HasPrefix(cfg.CmdName, "work ") {
// Refuse to use workspace if its go version is too old.
// Disable this check if we are a workspace command like work use or work sync,
// which will fix the problem.
}
}
- if !inWorkspaceMode() {
+ if !inWorkspaceMode(loaderstate) {
ok := true
for _, g := range f.Godebug {
if err := CheckGodebug("godebug", g.Key, g.Value); err != nil {
return nil, errors.Join(errs...)
}
- LoaderState.MainModules = makeMainModules(mainModules, LoaderState.modRoots, modFiles, indices, workFile)
- setDefaultBuildMod() // possibly enable automatic vendoring
- rs := requirementsFromModFiles(ctx, workFile, modFiles, opts)
+ loaderstate.MainModules = makeMainModules(loaderstate, mainModules, loaderstate.modRoots, modFiles, indices, workFile)
+ setDefaultBuildMod(loaderstate) // possibly enable automatic vendoring
+ rs := requirementsFromModFiles(loaderstate, ctx, workFile, modFiles, opts)
if cfg.BuildMod == "vendor" {
- readVendorList(VendorDir())
- versions := LoaderState.MainModules.Versions()
+ readVendorList(VendorDir(loaderstate))
+ versions := loaderstate.MainModules.Versions()
indexes := make([]*modFileIndex, 0, len(versions))
modFiles := make([]*modfile.File, 0, len(versions))
modRoots := make([]string, 0, len(versions))
for _, m := range versions {
- indexes = append(indexes, LoaderState.MainModules.Index(m))
- modFiles = append(modFiles, LoaderState.MainModules.ModFile(m))
- modRoots = append(modRoots, LoaderState.MainModules.ModRoot(m))
+ indexes = append(indexes, loaderstate.MainModules.Index(m))
+ modFiles = append(modFiles, loaderstate.MainModules.ModFile(m))
+ modRoots = append(modRoots, loaderstate.MainModules.ModRoot(m))
}
- checkVendorConsistency(indexes, modFiles, modRoots)
- rs.initVendor(vendorList)
+ checkVendorConsistency(loaderstate, indexes, modFiles, modRoots)
+ rs.initVendor(loaderstate, vendorList)
}
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
// We don't need to update the mod file so return early.
- LoaderState.requirements = rs
+ loaderstate.requirements = rs
return rs, nil
}
- mainModule := LoaderState.MainModules.mustGetSingleMainModule()
+ mainModule := loaderstate.MainModules.mustGetSingleMainModule(loaderstate)
- if rs.hasRedundantRoot() {
+ if rs.hasRedundantRoot(loaderstate) {
// 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.
var err error
- rs, err = updateRoots(ctx, rs.direct, rs, nil, nil, false)
+ rs, err = updateRoots(loaderstate, ctx, rs.direct, rs, nil, nil, false)
if err != nil {
return nil, err
}
}
- if LoaderState.MainModules.Index(mainModule).goVersion == "" && rs.pruning != workspace {
+ if loaderstate.MainModules.Index(mainModule).goVersion == "" && rs.pruning != workspace {
// TODO(#45551): Do something more principled instead of checking
// cfg.CmdName directly here.
if cfg.BuildMod == "mod" && cfg.CmdName != "mod graph" && cfg.CmdName != "mod why" {
if opts != nil && opts.TidyGoVersion != "" {
v = opts.TidyGoVersion
}
- addGoStmt(LoaderState.MainModules.ModFile(mainModule), mainModule, v)
- rs = overrideRoots(ctx, rs, []module.Version{{Path: "go", Version: v}})
+ addGoStmt(loaderstate.MainModules.ModFile(mainModule), mainModule, v)
+ rs = overrideRoots(loaderstate, ctx, rs, []module.Version{{Path: "go", Version: v}})
// We need to add a 'go' version to the go.mod file, but we must assume
// that its existing contents match something between Go 1.11 and 1.16.
// requirements to support pruning.
if gover.Compare(v, gover.ExplicitIndirectVersion) >= 0 {
var err error
- rs, err = convertPruning(ctx, rs, pruned)
+ rs, err = convertPruning(loaderstate, ctx, rs, pruned)
if err != nil {
return nil, err
}
}
}
- LoaderState.requirements = rs
- return LoaderState.requirements, nil
+ loaderstate.requirements = rs
+ return loaderstate.requirements, nil
}
func errWorkTooOld(gomod string, wf *modfile.WorkFile, goVers string) error {
func CreateModFile(ctx context.Context, modPath string) {
modRoot := base.Cwd()
LoaderState.modRoots = []string{modRoot}
- Init()
+ Init(LoaderState)
modFilePath := modFilePath(modRoot)
if _, err := fsys.Stat(modFilePath); err == nil {
base.Fatalf("go: %s already exists", modFilePath)
fmt.Fprintf(os.Stderr, "go: creating new go.mod: module %s\n", modPath)
modFile := new(modfile.File)
modFile.AddModuleStmt(modPath)
- LoaderState.MainModules = makeMainModules([]module.Version{modFile.Module.Mod}, []string{modRoot}, []*modfile.File{modFile}, []*modFileIndex{nil}, nil)
+ LoaderState.MainModules = makeMainModules(LoaderState, []module.Version{modFile.Module.Mod}, []string{modRoot}, []*modfile.File{modFile}, []*modFileIndex{nil}, nil)
addGoStmt(modFile, modFile.Module.Mod, gover.Local()) // Add the go directive before converted module requirements.
- rs := requirementsFromModFiles(ctx, nil, []*modfile.File{modFile}, nil)
- rs, err := updateRoots(ctx, rs.direct, rs, nil, nil, false)
+ rs := requirementsFromModFiles(LoaderState, ctx, nil, []*modfile.File{modFile}, nil)
+ rs, err := updateRoots(LoaderState, ctx, rs.direct, rs, nil, nil, false)
if err != nil {
base.Fatal(err)
}
LoaderState.requirements = rs
- if err := commitRequirements(ctx, WriteOpts{}); err != nil {
+ if err := commitRequirements(LoaderState, ctx, WriteOpts{}); err != nil {
base.Fatal(err)
}
// and does nothing for versions that already appear to be canonical.
//
// The VersionFixer sets 'fixed' if it ever returns a non-canonical version.
-func fixVersion(ctx context.Context, fixed *bool) modfile.VersionFixer {
+func fixVersion(loaderstate *State, ctx context.Context, fixed *bool) modfile.VersionFixer {
return func(path, vers string) (resolved string, err error) {
defer func() {
if err == nil && resolved != vers {
return vers, nil
}
- info, err := Query(ctx, path, vers, "", nil)
+ info, err := Query(loaderstate, ctx, path, vers, "", nil)
if err != nil {
return "", err
}
//
// This function affects the default cfg.BuildMod when outside of a module,
// so it can only be called prior to Init.
-func AllowMissingModuleImports() {
- if LoaderState.initialized {
+func AllowMissingModuleImports(loaderstate *State) {
+ if loaderstate.initialized {
panic("AllowMissingModuleImports after Init")
}
allowMissingModuleImports = true
// makeMainModules creates a MainModuleSet and associated variables according to
// the given main modules.
-func makeMainModules(ms []module.Version, rootDirs []string, modFiles []*modfile.File, indices []*modFileIndex, workFile *modfile.WorkFile) *MainModuleSet {
+func makeMainModules(loaderstate *State, ms []module.Version, rootDirs []string, modFiles []*modfile.File, indices []*modFileIndex, workFile *modfile.WorkFile) *MainModuleSet {
for _, m := range ms {
if m.Version != "" {
panic("mainModulesCalled with module.Version with non empty Version field: " + fmt.Sprintf("%#v", m))
continue
}
var newV module.Version = r.New
- if WorkFilePath() != "" && newV.Version == "" && !filepath.IsAbs(newV.Path) {
+ if WorkFilePath(loaderstate) != "" && newV.Version == "" && !filepath.IsAbs(newV.Path) {
// Since we are in a workspace, we may be loading replacements from
// multiple go.mod files. Relative paths in those replacement are
// relative to the go.mod file, not the workspace, so the same string
// requirementsFromModFiles returns the set of non-excluded requirements from
// the global modFile.
-func requirementsFromModFiles(ctx context.Context, workFile *modfile.WorkFile, modFiles []*modfile.File, opts *PackageOpts) *Requirements {
+func requirementsFromModFiles(loaderstate *State, ctx context.Context, workFile *modfile.WorkFile, modFiles []*modfile.File, opts *PackageOpts) *Requirements {
var roots []module.Version
direct := map[string]bool{}
var pruning modPruning
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
pruning = workspace
- roots = make([]module.Version, len(LoaderState.MainModules.Versions()), 2+len(LoaderState.MainModules.Versions()))
- copy(roots, LoaderState.MainModules.Versions())
+ roots = make([]module.Version, len(loaderstate.MainModules.Versions()), 2+len(loaderstate.MainModules.Versions()))
+ copy(roots, loaderstate.MainModules.Versions())
goVersion := gover.FromGoWork(workFile)
var toolchain string
if workFile.Toolchain != nil {
roots = appendGoAndToolchainRoots(roots, goVersion, toolchain, direct)
direct = directRequirements(modFiles)
} else {
- pruning = pruningForGoVersion(LoaderState.MainModules.GoVersion())
+ pruning = pruningForGoVersion(loaderstate.MainModules.GoVersion(loaderstate))
if len(modFiles) != 1 {
panic(fmt.Errorf("requirementsFromModFiles called with %v modfiles outside workspace mode", len(modFiles)))
}
modFile := modFiles[0]
- roots, direct = rootsFromModFile(LoaderState.MainModules.mustGetSingleMainModule(), modFile, withToolchainRoot)
+ roots, direct = rootsFromModFile(loaderstate, loaderstate.MainModules.mustGetSingleMainModule(loaderstate), modFile, withToolchainRoot)
}
gover.ModSort(roots)
- rs := newRequirements(pruning, roots, direct)
+ rs := newRequirements(loaderstate, pruning, roots, direct)
return rs
}
return direct
}
-func rootsFromModFile(m module.Version, modFile *modfile.File, addToolchainRoot addToolchainRoot) (roots []module.Version, direct map[string]bool) {
+func rootsFromModFile(loaderstate *State, m module.Version, modFile *modfile.File, addToolchainRoot addToolchainRoot) (roots []module.Version, direct map[string]bool) {
direct = make(map[string]bool)
padding := 2 // Add padding for the toolchain and go version, added upon return.
if !addToolchainRoot {
}
roots = make([]module.Version, 0, padding+len(modFile.Require))
for _, r := range modFile.Require {
- if index := LoaderState.MainModules.Index(m); index != nil && index.exclude[r.Mod] {
+ if index := loaderstate.MainModules.Index(m); index != nil && index.exclude[r.Mod] {
if cfg.BuildMod == "mod" {
fmt.Fprintf(os.Stderr, "go: dropping requirement on excluded version %s %s\n", r.Mod.Path, r.Mod.Version)
} else {
// setDefaultBuildMod sets a default value for cfg.BuildMod if the -mod flag
// wasn't provided. setDefaultBuildMod may be called multiple times.
-func setDefaultBuildMod() {
+func setDefaultBuildMod(loaderstate *State) {
if cfg.BuildModExplicit {
- if inWorkspaceMode() && cfg.BuildMod != "readonly" && cfg.BuildMod != "vendor" {
+ if inWorkspaceMode(loaderstate) && cfg.BuildMod != "readonly" && cfg.BuildMod != "vendor" {
switch cfg.CmdName {
case "work sync", "mod graph", "mod verify", "mod why":
// These commands run with BuildMod set to mod, but they don't take the
cfg.BuildMod = "readonly"
return
}
- if LoaderState.modRoots == nil {
+ if loaderstate.modRoots == nil {
if allowMissingModuleImports {
cfg.BuildMod = "mod"
} else {
return
}
- if len(LoaderState.modRoots) >= 1 {
+ if len(loaderstate.modRoots) >= 1 {
var goVersion string
var versionSource string
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
versionSource = "go.work"
- if wfg := LoaderState.MainModules.WorkFile().Go; wfg != nil {
+ if wfg := loaderstate.MainModules.WorkFile().Go; wfg != nil {
goVersion = wfg.Version
}
} else {
versionSource = "go.mod"
- index := LoaderState.MainModules.GetSingleIndexOrNil()
+ index := loaderstate.MainModules.GetSingleIndexOrNil(loaderstate)
if index != nil {
goVersion = index.goVersion
}
}
vendorDir := ""
- if LoaderState.workFilePath != "" {
- vendorDir = filepath.Join(filepath.Dir(LoaderState.workFilePath), "vendor")
+ if loaderstate.workFilePath != "" {
+ vendorDir = filepath.Join(filepath.Dir(loaderstate.workFilePath), "vendor")
} else {
- if len(LoaderState.modRoots) != 1 {
- panic(fmt.Errorf("outside workspace mode, but have %v modRoots", LoaderState.modRoots))
+ if len(loaderstate.modRoots) != 1 {
+ panic(fmt.Errorf("outside workspace mode, but have %v modRoots", loaderstate.modRoots))
}
- vendorDir = filepath.Join(LoaderState.modRoots[0], "vendor")
+ vendorDir = filepath.Join(loaderstate.modRoots[0], "vendor")
}
if fi, err := fsys.Stat(vendorDir); err == nil && fi.IsDir() {
if goVersion != "" {
return false, nil
}
-func mustHaveCompleteRequirements() bool {
- return cfg.BuildMod != "mod" && !inWorkspaceMode()
+func mustHaveCompleteRequirements(loaderstate *State) bool {
+ return cfg.BuildMod != "mod" && !inWorkspaceMode(loaderstate)
}
// addGoStmt adds a go directive to the go.mod file if it does not already
// WriteGoMod writes the current build list back to go.mod.
func WriteGoMod(ctx context.Context, opts WriteOpts) error {
- LoaderState.requirements = LoadModFile(ctx)
- return commitRequirements(ctx, opts)
+ LoaderState.requirements = LoadModFile(LoaderState, ctx)
+ return commitRequirements(LoaderState, ctx, opts)
}
var errNoChange = errors.New("no update needed")
// UpdateGoModFromReqs returns a modified go.mod file using the current
// requirements. It does not commit these changes to disk.
-func UpdateGoModFromReqs(ctx context.Context, opts WriteOpts) (before, after []byte, modFile *modfile.File, err error) {
- if LoaderState.MainModules.Len() != 1 || LoaderState.MainModules.ModRoot(LoaderState.MainModules.Versions()[0]) == "" {
+func UpdateGoModFromReqs(loaderstate *State, ctx context.Context, opts WriteOpts) (before, after []byte, modFile *modfile.File, err error) {
+ if loaderstate.MainModules.Len() != 1 || loaderstate.MainModules.ModRoot(loaderstate.MainModules.Versions()[0]) == "" {
// We aren't in a module, so we don't have anywhere to write a go.mod file.
return nil, nil, nil, errNoChange
}
- mainModule := LoaderState.MainModules.mustGetSingleMainModule()
- modFile = LoaderState.MainModules.ModFile(mainModule)
+ mainModule := loaderstate.MainModules.mustGetSingleMainModule(loaderstate)
+ modFile = loaderstate.MainModules.ModFile(mainModule)
if modFile == nil {
// command-line-arguments has no .mod file to write.
return nil, nil, nil, errNoChange
var list []*modfile.Require
toolchain := ""
goVersion := ""
- for _, m := range LoaderState.requirements.rootModules {
+ for _, m := range loaderstate.requirements.rootModules {
if m.Path == "go" {
goVersion = m.Version
continue
}
list = append(list, &modfile.Require{
Mod: m,
- Indirect: !LoaderState.requirements.direct[m.Path],
+ Indirect: !loaderstate.requirements.direct[m.Path],
})
}
// go.mod or go.sum are out of date in a semantically significant way.
//
// In workspace mode, commitRequirements only writes changes to go.work.sum.
-func commitRequirements(ctx context.Context, opts WriteOpts) (err error) {
- if inWorkspaceMode() {
+func commitRequirements(loaderstate *State, ctx context.Context, opts WriteOpts) (err error) {
+ if inWorkspaceMode(loaderstate) {
// go.mod files aren't updated in workspace mode, but we still want to
// update the go.work.sum file.
- return modfetch.WriteGoSum(ctx, keepSums(ctx, loaded, LoaderState.requirements, addBuildListZipSums), mustHaveCompleteRequirements())
+ return modfetch.WriteGoSum(ctx, keepSums(loaderstate, ctx, loaded, loaderstate.requirements, addBuildListZipSums), mustHaveCompleteRequirements(loaderstate))
}
- _, updatedGoMod, modFile, err := UpdateGoModFromReqs(ctx, opts)
+ _, updatedGoMod, modFile, err := UpdateGoModFromReqs(loaderstate, ctx, opts)
if err != nil {
if errors.Is(err, errNoChange) {
return nil
return err
}
- index := LoaderState.MainModules.GetSingleIndexOrNil()
+ index := loaderstate.MainModules.GetSingleIndexOrNil(loaderstate)
dirty := index.modFileIsDirty(modFile) || len(opts.DropTools) > 0 || len(opts.AddTools) > 0
if dirty && cfg.BuildMod != "mod" {
// If we're about to fail due to -mod=readonly,
// Don't write go.mod, but write go.sum in case we added or trimmed sums.
// 'go mod init' shouldn't write go.sum, since it will be incomplete.
if cfg.CmdName != "mod init" {
- if err := modfetch.WriteGoSum(ctx, keepSums(ctx, loaded, LoaderState.requirements, addBuildListZipSums), mustHaveCompleteRequirements()); err != nil {
+ if err := modfetch.WriteGoSum(ctx, keepSums(loaderstate, ctx, loaded, loaderstate.requirements, addBuildListZipSums), mustHaveCompleteRequirements(loaderstate)); err != nil {
return err
}
}
return nil
}
- mainModule := LoaderState.MainModules.mustGetSingleMainModule()
- modFilePath := modFilePath(LoaderState.MainModules.ModRoot(mainModule))
+ mainModule := loaderstate.MainModules.mustGetSingleMainModule(loaderstate)
+ modFilePath := modFilePath(loaderstate.MainModules.ModRoot(mainModule))
if fsys.Replaced(modFilePath) {
if dirty {
return errors.New("updates to go.mod needed, but go.mod is part of the overlay specified with -overlay")
}
defer func() {
// At this point we have determined to make the go.mod file on disk equal to new.
- LoaderState.MainModules.SetIndex(mainModule, indexModFile(updatedGoMod, modFile, mainModule, false))
+ loaderstate.MainModules.SetIndex(mainModule, indexModFile(updatedGoMod, modFile, mainModule, false))
// Update go.sum after releasing the side lock and refreshing the index.
// 'go mod init' shouldn't write go.sum, since it will be incomplete.
if cfg.CmdName != "mod init" {
if err == nil {
- err = modfetch.WriteGoSum(ctx, keepSums(ctx, loaded, LoaderState.requirements, addBuildListZipSums), mustHaveCompleteRequirements())
+ err = modfetch.WriteGoSum(ctx, keepSums(loaderstate, ctx, loaded, loaderstate.requirements, addBuildListZipSums), mustHaveCompleteRequirements(loaderstate))
}
}
}()
// including any go.mod files needed to reconstruct the MVS result
// or identify go versions,
// in addition to the checksums for every module in keepMods.
-func keepSums(ctx context.Context, ld *loader, rs *Requirements, which whichSums) map[module.Version]bool {
+func keepSums(loaderstate *State, ctx context.Context, ld *loader, rs *Requirements, which whichSums) map[module.Version]bool {
// Every module in the full module graph contributes its requirements,
// so in order to ensure that the build list itself is reproducible,
// we need sums for every go.mod in the graph (regardless of whether
// ambiguous import errors the next time we load the package.
keepModSumsForZipSums := true
if ld == nil {
- if gover.Compare(LoaderState.MainModules.GoVersion(), gover.TidyGoModSumVersion) < 0 && cfg.BuildMod != "mod" {
+ if gover.Compare(loaderstate.MainModules.GoVersion(loaderstate), gover.TidyGoModSumVersion) < 0 && cfg.BuildMod != "mod" {
keepModSumsForZipSums = false
}
} else {
keepPkgGoModSums := true
- if gover.Compare(ld.requirements.GoVersion(), gover.TidyGoModSumVersion) < 0 && (ld.Tidy || cfg.BuildMod != "mod") {
+ if gover.Compare(ld.requirements.GoVersion(loaderstate), gover.TidyGoModSumVersion) < 0 && (ld.Tidy || cfg.BuildMod != "mod") {
keepPkgGoModSums = false
keepModSumsForZipSums = false
}
// minor, so we maintain the previous (buggy) behavior in 'go mod tidy' to
// avoid introducing unnecessary churn.
if keepPkgGoModSums {
- r := resolveReplacement(pkg.mod)
+ r := resolveReplacement(loaderstate, pkg.mod)
keep[modkey(r)] = true
}
if rs.pruning == pruned && pkg.mod.Path != "" {
- if v, ok := rs.rootSelected(pkg.mod.Path); ok && v == pkg.mod.Version {
+ if v, ok := rs.rootSelected(loaderstate, pkg.mod.Path); ok && v == pkg.mod.Version {
// pkg was loaded from a root module, and because the main module has
// a pruned module graph we do not check non-root modules for
// conflicts for packages that can be found in roots. So we only need
// the checksums for the root modules that may contain pkg, not all
// possible modules.
for prefix := pkg.path; prefix != "."; prefix = path.Dir(prefix) {
- if v, ok := rs.rootSelected(prefix); ok && v != "none" {
+ if v, ok := rs.rootSelected(loaderstate, prefix); ok && v != "none" {
m := module.Version{Path: prefix, Version: v}
- r := resolveReplacement(m)
+ r := resolveReplacement(loaderstate, m)
keep[r] = true
}
}
}
}
- mg, _ := rs.Graph(ctx)
+ mg, _ := rs.Graph(loaderstate, ctx)
for prefix := pkg.path; prefix != "."; prefix = path.Dir(prefix) {
if v := mg.Selected(prefix); v != "none" {
m := module.Version{Path: prefix, Version: v}
- r := resolveReplacement(m)
+ r := resolveReplacement(loaderstate, m)
keep[r] = true
}
}
// Save sums for the root modules (or their replacements), but don't
// incur the cost of loading the graph just to find and retain the sums.
for _, m := range rs.rootModules {
- r := resolveReplacement(m)
+ r := resolveReplacement(loaderstate, m)
keep[modkey(r)] = true
if which == addBuildListZipSums {
keep[r] = true
}
}
} else {
- mg, _ := rs.Graph(ctx)
+ mg, _ := rs.Graph(loaderstate, ctx)
mg.WalkBreadthFirst(func(m module.Version) {
if _, ok := mg.RequiredBy(m); ok {
// The requirements from m's go.mod file are present in the module graph,
// so they are relevant to the MVS result regardless of whether m was
// actually selected.
- r := resolveReplacement(m)
+ r := resolveReplacement(loaderstate, m)
keep[modkey(r)] = true
}
})
if which == addBuildListZipSums {
for _, m := range mg.BuildList() {
- r := resolveReplacement(m)
+ r := resolveReplacement(loaderstate, m)
if keepModSumsForZipSums {
keep[modkey(r)] = true // we need the go version from the go.mod file to do anything useful with the zipfile
}
}
}
- rs, mods, err := listModules(ctx, LoadModFile(ctx), args, mode, reuse)
+ rs, mods, err := listModules(ctx, LoadModFile(LoaderState, ctx), args, mode, reuse)
type token struct{}
sem := make(chan token, runtime.GOMAXPROCS(0))
addVersions(ctx, m, mode&ListRetractedVersions != 0)
}
if mode&ListRetracted != 0 {
- addRetraction(ctx, m)
+ addRetraction(LoaderState, ctx, m)
}
if mode&ListDeprecated != 0 {
addDeprecation(ctx, m)
// but in general list -u is looking up other checksums in the checksum database
// that won't be necessary later, so it makes sense not to write the go.sum back out.
if !ExplicitWriteGoMod && mode&ListU == 0 {
- err = commitRequirements(ctx, WriteOpts{})
+ err = commitRequirements(LoaderState, ctx, WriteOpts{})
}
}
return mods, err
if gover.IsToolchain(m.Path) {
continue
}
- ms = append(ms, moduleInfo(ctx, rs, m, mode, reuse))
+ ms = append(ms, moduleInfo(LoaderState, ctx, rs, m, mode, reuse))
}
return rs, ms, nil
}
}
if arg == "all" || strings.Contains(arg, "...") {
needFullGraph = true
- if !HasModRoot() {
+ if !HasModRoot(LoaderState) {
base.Fatalf("go: cannot match %q: %v", arg, ErrNoModRoot)
}
continue
}
if path, vers, found := strings.Cut(arg, "@"); found {
if vers == "upgrade" || vers == "patch" {
- if _, ok := rs.rootSelected(path); !ok || rs.pruning == unpruned {
+ if _, ok := rs.rootSelected(LoaderState, path); !ok || rs.pruning == unpruned {
needFullGraph = true
- if !HasModRoot() {
+ if !HasModRoot(LoaderState) {
base.Fatalf("go: cannot match %q: %v", arg, ErrNoModRoot)
}
}
}
continue
}
- if _, ok := rs.rootSelected(arg); !ok || rs.pruning == unpruned {
+ if _, ok := rs.rootSelected(LoaderState, arg); !ok || rs.pruning == unpruned {
needFullGraph = true
- if mode&ListVersions == 0 && !HasModRoot() {
+ if mode&ListVersions == 0 && !HasModRoot(LoaderState) {
base.Fatalf("go: cannot match %q without -versions or an explicit version: %v", arg, ErrNoModRoot)
}
}
var mg *ModuleGraph
if needFullGraph {
- rs, mg, mgErr = expandGraph(ctx, rs)
+ rs, mg, mgErr = expandGraph(LoaderState, ctx, rs)
}
matchedModule := map[module.Version]bool{}
if path, vers, found := strings.Cut(arg, "@"); found {
var current string
if mg == nil {
- current, _ = rs.rootSelected(path)
+ current, _ = rs.rootSelected(LoaderState, path)
} else {
current = mg.Selected(path)
}
// specific revision or used 'go list -retracted'.
allowed = nil
}
- info, err := queryReuse(ctx, path, vers, current, allowed, reuse)
+ info, err := queryReuse(LoaderState, ctx, path, vers, current, allowed, reuse)
if err != nil {
var origin *codehost.Origin
if info != nil {
// *Requirements instead.
var noRS *Requirements
- mod := moduleInfo(ctx, noRS, module.Version{Path: path, Version: info.Version}, mode, reuse)
+ mod := moduleInfo(LoaderState, ctx, noRS, module.Version{Path: path, Version: info.Version}, mode, reuse)
if vers != mod.Version {
mod.Query = vers
}
var v string
if mg == nil {
var ok bool
- v, ok = rs.rootSelected(arg)
+ v, ok = rs.rootSelected(LoaderState, arg)
if !ok {
// We checked rootSelected(arg) in the earlier args loop, so if there
// is no such root we should have loaded a non-nil mg.
continue
}
if v != "none" {
- mods = append(mods, moduleInfo(ctx, rs, module.Version{Path: arg, Version: v}, mode, reuse))
+ mods = append(mods, moduleInfo(LoaderState, ctx, rs, module.Version{Path: arg, Version: v}, mode, reuse))
} else if cfg.BuildMod == "vendor" {
// In vendor mode, we can't determine whether a missing module is “a
// known dependency” because the module graph is incomplete.
fetchedMods := make([]*modinfo.ModulePublic, len(matches))
for i, m := range matches {
q.Add(func() {
- fetchedMods[i] = moduleInfo(ctx, rs, m, mode, reuse)
+ fetchedMods[i] = moduleInfo(LoaderState, ctx, rs, m, mode, reuse)
})
}
<-q.Idle()
// LoadPackages identifies the set of packages matching the given patterns and
// loads the packages in the import graph rooted at that set.
-func LoadPackages(ctx context.Context, opts PackageOpts, patterns ...string) (matches []*search.Match, loadedPackages []string) {
+func LoadPackages(loaderstate *State, ctx context.Context, opts PackageOpts, patterns ...string) (matches []*search.Match, loadedPackages []string) {
if opts.Tags == nil {
opts.Tags = imports.Tags()
}
case m.IsLocal():
// Evaluate list of file system directories on first iteration.
if m.Dirs == nil {
- matchModRoots := LoaderState.modRoots
+ matchModRoots := loaderstate.modRoots
if opts.MainModule != (module.Version{}) {
- matchModRoots = []string{LoaderState.MainModules.ModRoot(opts.MainModule)}
+ matchModRoots = []string{loaderstate.MainModules.ModRoot(opts.MainModule)}
}
- matchLocalDirs(ctx, matchModRoots, m, rs)
+ matchLocalDirs(loaderstate, ctx, matchModRoots, m, rs)
}
// Make a copy of the directory list and translate to import paths.
// the loader iterations.
m.Pkgs = m.Pkgs[:0]
for _, dir := range m.Dirs {
- pkg, err := resolveLocalPackage(ctx, dir, rs)
+ pkg, err := resolveLocalPackage(loaderstate, ctx, dir, rs)
if err != nil {
if !m.IsLiteral() && (err == errPkgIsBuiltin || err == errPkgIsGorootSrc) {
continue // Don't include "builtin" or GOROOT/src in wildcard patterns.
// If we're outside of a module, ensure that the failure mode
// indicates that.
- if !HasModRoot() {
- die()
+ if !HasModRoot(loaderstate) {
+ die(loaderstate)
}
if ld != nil {
case strings.Contains(m.Pattern(), "..."):
m.Errs = m.Errs[:0]
- mg, err := rs.Graph(ctx)
+ mg, err := rs.Graph(loaderstate, ctx)
if err != nil {
// The module graph is (or may be) incomplete — perhaps we failed to
// load the requirements of some module. This is an error in matching
// necessarily prevent us from loading the packages we could find.
m.Errs = append(m.Errs, err)
}
- matchPackages(ctx, m, opts.Tags, includeStd, mg.BuildList())
+ matchPackages(loaderstate, ctx, m, opts.Tags, includeStd, mg.BuildList())
case m.Pattern() == "work":
- matchModules := LoaderState.MainModules.Versions()
+ matchModules := loaderstate.MainModules.Versions()
if opts.MainModule != (module.Version{}) {
matchModules = []module.Version{opts.MainModule}
}
- matchPackages(ctx, m, opts.Tags, omitStd, matchModules)
+ matchPackages(loaderstate, ctx, m, opts.Tags, omitStd, matchModules)
case m.Pattern() == "all":
if ld == nil {
// The initial roots are the packages and tools in the main module.
// loadFromRoots will expand that to "all".
m.Errs = m.Errs[:0]
- matchModules := LoaderState.MainModules.Versions()
+ matchModules := loaderstate.MainModules.Versions()
if opts.MainModule != (module.Version{}) {
matchModules = []module.Version{opts.MainModule}
}
- matchPackages(ctx, m, opts.Tags, omitStd, matchModules)
- for tool := range LoaderState.MainModules.Tools() {
+ matchPackages(loaderstate, ctx, m, opts.Tags, omitStd, matchModules)
+ for tool := range loaderstate.MainModules.Tools() {
m.Pkgs = append(m.Pkgs, tool)
}
} else {
}
case m.Pattern() == "tool":
- for tool := range LoaderState.MainModules.Tools() {
+ for tool := range loaderstate.MainModules.Tools() {
m.Pkgs = append(m.Pkgs, tool)
}
default:
}
}
- initialRS, err := loadModFile(ctx, &opts)
+ initialRS, err := loadModFile(loaderstate, ctx, &opts)
if err != nil {
base.Fatal(err)
}
- ld := loadFromRoots(ctx, loaderParams{
+ ld := loadFromRoots(loaderstate, ctx, loaderParams{
PackageOpts: opts,
requirements: initialRS,
if opts.Tidy {
if cfg.BuildV {
- mg, _ := ld.requirements.Graph(ctx)
+ mg, _ := ld.requirements.Graph(loaderstate, ctx)
for _, m := range initialRS.rootModules {
var unused bool
if ld.requirements.pruning == unpruned {
// m is unused if it was dropped from the roots. If it is still present
// as a transitive dependency, that transitive dependency is not needed
// by any package or test in the main module.
- _, ok := ld.requirements.rootSelected(m.Path)
+ _, ok := ld.requirements.rootSelected(loaderstate, m.Path)
unused = !ok
}
if unused {
}
}
- keep := keepSums(ctx, ld, ld.requirements, loadedZipSumsOnly)
+ keep := keepSums(loaderstate, ctx, ld, ld.requirements, loadedZipSumsOnly)
compatVersion := ld.TidyCompatibleVersion
- goVersion := ld.requirements.GoVersion()
+ goVersion := ld.requirements.GoVersion(loaderstate)
if compatVersion == "" {
if gover.Compare(goVersion, gover.GoStrictVersion) < 0 {
compatVersion = gover.Prev(goVersion)
compatVersion = goVersion
}
if compatPruning := pruningForGoVersion(compatVersion); compatPruning != ld.requirements.pruning {
- compatRS := newRequirements(compatPruning, ld.requirements.rootModules, ld.requirements.direct)
- ld.checkTidyCompatibility(ctx, compatRS, compatVersion)
+ compatRS := newRequirements(loaderstate, compatPruning, ld.requirements.rootModules, ld.requirements.direct)
+ ld.checkTidyCompatibility(loaderstate, ctx, compatRS, compatVersion)
- for m := range keepSums(ctx, ld, compatRS, loadedZipSumsOnly) {
+ for m := range keepSums(loaderstate, ctx, ld, compatRS, loadedZipSumsOnly) {
keep[m] = true
}
}
if opts.TidyDiff {
cfg.BuildMod = "readonly"
loaded = ld
- LoaderState.requirements = loaded.requirements
- currentGoMod, updatedGoMod, _, err := UpdateGoModFromReqs(ctx, WriteOpts{})
+ loaderstate.requirements = loaded.requirements
+ currentGoMod, updatedGoMod, _, err := UpdateGoModFromReqs(loaderstate, ctx, WriteOpts{})
if err != nil {
base.Fatal(err)
}
// Dropping compatibility for 1.16 may result in a strictly smaller go.sum.
// Update the keep map with only the loaded.requirements.
if gover.Compare(compatVersion, "1.16") > 0 {
- keep = keepSums(ctx, loaded, LoaderState.requirements, addBuildListZipSums)
+ keep = keepSums(loaderstate, ctx, loaded, loaderstate.requirements, addBuildListZipSums)
}
currentGoSum, tidyGoSum := modfetch.TidyGoSum(keep)
goSumDiff := diff.Diff("current/go.sum", currentGoSum, "tidy/go.sum", tidyGoSum)
// loaded.requirements, but here we may have also loaded (and want to
// preserve checksums for) additional entities from compatRS, which are
// only needed for compatibility with ld.TidyCompatibleVersion.
- if err := modfetch.WriteGoSum(ctx, keep, mustHaveCompleteRequirements()); err != nil {
+ if err := modfetch.WriteGoSum(ctx, keep, mustHaveCompleteRequirements(loaderstate)); err != nil {
base.Fatal(err)
}
}
// to call WriteGoMod itself) or if ResolveMissingImports is false (the
// command wants to examine the package graph as-is).
loaded = ld
- LoaderState.requirements = loaded.requirements
+ loaderstate.requirements = loaded.requirements
for _, pkg := range ld.pkgs {
if !pkg.isTest() {
sort.Strings(loadedPackages)
if !ExplicitWriteGoMod && opts.ResolveMissingImports {
- if err := commitRequirements(ctx, WriteOpts{}); err != nil {
+ if err := commitRequirements(loaderstate, ctx, WriteOpts{}); err != nil {
base.Fatal(err)
}
}
// matchLocalDirs is like m.MatchDirs, but tries to avoid scanning directories
// outside of the standard library and active modules.
-func matchLocalDirs(ctx context.Context, modRoots []string, m *search.Match, rs *Requirements) {
+func matchLocalDirs(loaderstate *State, ctx context.Context, modRoots []string, m *search.Match, rs *Requirements) {
if !m.IsLocal() {
panic(fmt.Sprintf("internal error: resolveLocalDirs on non-local pattern %s", m.Pattern()))
}
}
modRoot := findModuleRoot(absDir)
- if !slices.Contains(modRoots, modRoot) && search.InDir(absDir, cfg.GOROOTsrc) == "" && pathInModuleCache(ctx, absDir, rs) == "" {
+ if !slices.Contains(modRoots, modRoot) && search.InDir(absDir, cfg.GOROOTsrc) == "" && pathInModuleCache(loaderstate, ctx, absDir, rs) == "" {
m.Dirs = []string{}
scope := "main module or its selected dependencies"
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
scope = "modules listed in go.work or their selected dependencies"
}
m.AddError(fmt.Errorf("directory prefix %s does not contain %s", base.ShortPath(absDir), scope))
}
// resolveLocalPackage resolves a filesystem path to a package path.
-func resolveLocalPackage(ctx context.Context, dir string, rs *Requirements) (string, error) {
+func resolveLocalPackage(loaderstate *State, ctx context.Context, dir string, rs *Requirements) (string, error) {
var absDir string
if filepath.IsAbs(dir) {
absDir = filepath.Clean(dir)
}
}
- for _, mod := range LoaderState.MainModules.Versions() {
- modRoot := LoaderState.MainModules.ModRoot(mod)
+ for _, mod := range loaderstate.MainModules.Versions() {
+ modRoot := loaderstate.MainModules.ModRoot(mod)
if modRoot != "" && absDir == modRoot {
if absDir == cfg.GOROOTsrc {
return "", errPkgIsGorootSrc
}
- return LoaderState.MainModules.PathPrefix(mod), nil
+ return loaderstate.MainModules.PathPrefix(mod), nil
}
}
// It's not strictly necessary but helpful to keep the checks.
var pkgNotFoundErr error
pkgNotFoundLongestPrefix := ""
- for _, mainModule := range LoaderState.MainModules.Versions() {
- modRoot := LoaderState.MainModules.ModRoot(mainModule)
+ for _, mainModule := range loaderstate.MainModules.Versions() {
+ modRoot := loaderstate.MainModules.ModRoot(mainModule)
if modRoot != "" && str.HasFilePathPrefix(absDir, modRoot) && !strings.Contains(absDir[len(modRoot):], "@") {
suffix := filepath.ToSlash(str.TrimFilePathPrefix(absDir, modRoot))
if pkg, found := strings.CutPrefix(suffix, "vendor/"); found {
return "", fmt.Errorf("without -mod=vendor, directory %s has no package path", absDir)
}
- readVendorList(VendorDir())
+ readVendorList(VendorDir(loaderstate))
if _, ok := vendorPkgModule[pkg]; !ok {
return "", fmt.Errorf("directory %s is not a package listed in vendor/modules.txt", absDir)
}
return pkg, nil
}
- mainModulePrefix := LoaderState.MainModules.PathPrefix(mainModule)
+ mainModulePrefix := loaderstate.MainModules.PathPrefix(mainModule)
if mainModulePrefix == "" {
pkg := suffix
if pkg == "builtin" {
return pkg, nil
}
- pkg := pathInModuleCache(ctx, absDir, rs)
+ pkg := pathInModuleCache(loaderstate, ctx, absDir, rs)
if pkg == "" {
dirstr := fmt.Sprintf("directory %s", base.ShortPath(absDir))
if dirstr == "directory ." {
dirstr = "current directory"
}
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
if mr := findModuleRoot(absDir); mr != "" {
return "", fmt.Errorf("%s is contained in a module that is not one of the workspace modules listed in go.work. You can add the module to the workspace using:\n\tgo work use %s", dirstr, base.ShortPath(mr))
}
// pathInModuleCache returns the import path of the directory dir,
// if dir is in the module cache copy of a module in our build list.
-func pathInModuleCache(ctx context.Context, dir string, rs *Requirements) string {
+func pathInModuleCache(loaderstate *State, ctx context.Context, dir string, rs *Requirements) string {
tryMod := func(m module.Version) (string, bool) {
if gover.IsToolchain(m.Path) {
return "", false
}
var root string
var err error
- if repl := Replacement(m); repl.Path != "" && repl.Version == "" {
+ if repl := Replacement(loaderstate, m); repl.Path != "" && repl.Version == "" {
root = repl.Path
if !filepath.IsAbs(root) {
- root = filepath.Join(replaceRelativeTo(), root)
+ root = filepath.Join(replaceRelativeTo(loaderstate), root)
}
} else if repl.Path != "" {
root, err = modfetch.DownloadDir(ctx, repl)
if rs.pruning == pruned {
for _, m := range rs.rootModules {
- if v, _ := rs.rootSelected(m.Path); v != m.Version {
+ if v, _ := rs.rootSelected(loaderstate, m.Path); v != m.Version {
continue // m is a root, but we have a higher root for the same path.
}
if importPath, ok := tryMod(m); ok {
// versions of root modules may differ from what we already checked above.
// Re-check those paths too.
- mg, _ := rs.Graph(ctx)
+ mg, _ := rs.Graph(loaderstate, ctx)
var importPath string
for _, m := range mg.BuildList() {
var found bool
//
// TODO(bcmills): Silencing errors seems off. Take a closer look at this and
// figure out what the error-reporting actually ought to be.
-func ImportFromFiles(ctx context.Context, gofiles []string) {
- rs := LoadModFile(ctx)
+func ImportFromFiles(loaderstate *State, ctx context.Context, gofiles []string) {
+ rs := LoadModFile(loaderstate, ctx)
tags := imports.Tags()
imports, testImports, err := imports.ScanFiles(gofiles, tags)
base.Fatal(err)
}
- loaded = loadFromRoots(ctx, loaderParams{
+ loaded = loadFromRoots(loaderstate, ctx, loaderParams{
PackageOpts: PackageOpts{
Tags: tags,
ResolveMissingImports: true,
return roots
},
})
- LoaderState.requirements = loaded.requirements
+ loaderstate.requirements = loaded.requirements
if !ExplicitWriteGoMod {
- if err := commitRequirements(ctx, WriteOpts{}); err != nil {
+ if err := commitRequirements(loaderstate, ctx, WriteOpts{}); err != nil {
base.Fatal(err)
}
}
// DirImportPath returns the effective import path for dir,
// provided it is within a main module, or else returns ".".
-func (mms *MainModuleSet) DirImportPath(ctx context.Context, dir string) (path string, m module.Version) {
- if !HasModRoot() {
+func (mms *MainModuleSet) DirImportPath(loaderstate *State, ctx context.Context, dir string) (path string, m module.Version) {
+ if !HasModRoot(loaderstate) {
return ".", module.Version{}
}
- LoadModFile(ctx) // Sets targetPrefix.
+ LoadModFile(loaderstate, ctx) // Sets targetPrefix.
if !filepath.IsAbs(dir) {
dir = filepath.Join(base.Cwd(), dir)
return mms.PathPrefix(v), v
}
if str.HasFilePathPrefix(dir, modRoot) {
- pathPrefix := LoaderState.MainModules.PathPrefix(v)
+ pathPrefix := loaderstate.MainModules.PathPrefix(v)
if pathPrefix > longestPrefix {
longestPrefix = pathPrefix
longestPrefixVersion = v
// the package at path as imported from the package in parentDir.
// Lookup requires that one of the Load functions in this package has already
// been called.
-func Lookup(parentPath string, parentIsStd bool, path string) (dir, realPath string, err error) {
+func Lookup(loaderstate *State, parentPath string, parentIsStd bool, path string) (dir, realPath string, err error) {
if path == "" {
panic("Lookup called with empty package path")
}
if parentIsStd {
- path = loaded.stdVendor(parentPath, path)
+ path = loaded.stdVendor(loaderstate, parentPath, path)
}
pkg, ok := loaded.pkgCache.Get(path)
if !ok {
// goVersion reports the Go version that should be used for the loader's
// requirements: ld.TidyGoVersion if set, or ld.requirements.GoVersion()
// otherwise.
-func (ld *loader) goVersion() string {
+func (ld *loader) goVersion(loaderstate *State) string {
if ld.TidyGoVersion != "" {
return ld.TidyGoVersion
}
- return ld.requirements.GoVersion()
+ return ld.requirements.GoVersion(loaderstate)
}
// A loadPkg records information about a single loaded package.
// fromExternalModule reports whether pkg was loaded from a module other than
// the main module.
-func (pkg *loadPkg) fromExternalModule() bool {
+func (pkg *loadPkg) fromExternalModule(loaderstate *State) bool {
if pkg.mod.Path == "" {
return false // loaded from the standard library, not a module
}
- return !LoaderState.MainModules.Contains(pkg.mod.Path)
+ return !loaderstate.MainModules.Contains(pkg.mod.Path)
}
var errMissing = errors.New("cannot find package")
// The set of root packages is returned by the params.listRoots function, and
// expanded to the full set of packages by tracing imports (and possibly tests)
// as needed.
-func loadFromRoots(ctx context.Context, params loaderParams) *loader {
+func loadFromRoots(loaderstate *State, ctx context.Context, params loaderParams) *loader {
ld := &loader{
loaderParams: params,
work: par.NewQueue(runtime.GOMAXPROCS(0)),
// spot-checks in modules that do not maintain the expanded go.mod
// requirements needed for graph pruning.
var err error
- ld.requirements, _, err = expandGraph(ctx, ld.requirements)
+ ld.requirements, _, err = expandGraph(loaderstate, ctx, ld.requirements)
if err != nil {
ld.error(err)
}
ld.exitIfErrors(ctx)
updateGoVersion := func() {
- goVersion := ld.goVersion()
+ goVersion := ld.goVersion(loaderstate)
if ld.requirements.pruning != workspace {
var err error
- ld.requirements, err = convertPruning(ctx, ld.requirements, pruningForGoVersion(goVersion))
+ ld.requirements, err = convertPruning(loaderstate, ctx, ld.requirements, pruningForGoVersion(goVersion))
if err != nil {
ld.error(err)
ld.exitIfErrors(ctx)
// set of root packages does not change then we can select the correct
// versions of all transitive imports on the first try and complete
// loading in a single iteration.
- changedBuildList := ld.preloadRootModules(ctx, rootPkgs)
+ changedBuildList := ld.preloadRootModules(loaderstate, ctx, rootPkgs)
if changedBuildList {
// The build list has changed, so the set of root packages may have also
// changed. Start over to pick up the changes. (Preloading roots is much
inRoots := map[*loadPkg]bool{}
for _, path := range rootPkgs {
- root := ld.pkg(ctx, path, pkgIsRoot)
+ root := ld.pkg(loaderstate, ctx, path, pkgIsRoot)
if !inRoots[root] {
ld.roots = append(ld.roots, root)
inRoots[root] = true
ld.buildStacks()
- changed, err := ld.updateRequirements(ctx)
+ changed, err := ld.updateRequirements(loaderstate, ctx)
if err != nil {
ld.error(err)
break
continue
}
- if !ld.ResolveMissingImports || (!HasModRoot() && !allowMissingModuleImports) {
+ if !ld.ResolveMissingImports || (!HasModRoot(loaderstate) && !allowMissingModuleImports) {
// We've loaded as much as we can without resolving missing imports.
break
}
- modAddedBy, err := ld.resolveMissingImports(ctx)
+ modAddedBy, err := ld.resolveMissingImports(loaderstate, ctx)
if err != nil {
ld.error(err)
break
// iteration so we don't need to also update it here. (That would waste time
// computing a "direct" map that we'll have to recompute later anyway.)
direct := ld.requirements.direct
- rs, err := updateRoots(ctx, direct, ld.requirements, noPkgs, toAdd, ld.AssumeRootsImported)
+ rs, err := updateRoots(loaderstate, ctx, direct, ld.requirements, noPkgs, toAdd, ld.AssumeRootsImported)
if err != nil {
// If an error was found in a newly added module, report the package
// import stack instead of the module requirement stack. Packages
// Tidy the build list, if applicable, before we report errors.
// (The process of tidying may remove errors from irrelevant dependencies.)
if ld.Tidy {
- rs, err := tidyRoots(ctx, ld.requirements, ld.pkgs)
+ rs, err := tidyRoots(loaderstate, ctx, ld.requirements, ld.pkgs)
if err != nil {
ld.error(err)
} else {
// Attempt to switch to the requested Go version. We have been using its
// pruning and semantics all along, but there may have been — and may
// still be — requirements on higher versions in the graph.
- tidy := overrideRoots(ctx, rs, []module.Version{{Path: "go", Version: ld.TidyGoVersion}})
- mg, err := tidy.Graph(ctx)
+ tidy := overrideRoots(loaderstate, ctx, rs, []module.Version{{Path: "go", Version: ld.TidyGoVersion}})
+ mg, err := tidy.Graph(loaderstate, ctx)
if err != nil {
ld.error(err)
}
if m.Path == "go" && ld.TidyGoVersion != "" {
continue
}
- if v, ok := ld.requirements.rootSelected(m.Path); !ok || v != m.Version {
+ if v, ok := ld.requirements.rootSelected(loaderstate, m.Path); !ok || v != m.Version {
ld.error(fmt.Errorf("internal error: a requirement on %v is needed but was not added during package loading (selected %s)", m, v))
}
}
ld.error(fmt.Errorf("%s: %w", pkg.stackText(), pkg.err))
}
- ld.checkMultiplePaths()
+ ld.checkMultiplePaths(loaderstate)
return ld
}
// The "changed" return value reports whether the update changed the selected
// version of any module that either provided a loaded package or may now
// provide a package that was previously unresolved.
-func (ld *loader) updateRequirements(ctx context.Context) (changed bool, err error) {
+func (ld *loader) updateRequirements(loaderstate *State, ctx context.Context) (changed bool, err error) {
rs := ld.requirements
// direct contains the set of modules believed to provide packages directly
}
}
}
- if pkg.mod.Version != "" || !LoaderState.MainModules.Contains(pkg.mod.Path) {
+ if pkg.mod.Version != "" || !loaderstate.MainModules.Contains(pkg.mod.Path) {
continue
}
for _, dep := range pkg.imports {
- if !dep.fromExternalModule() {
+ if !dep.fromExternalModule(loaderstate) {
continue
}
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
// In workspace mode / workspace pruning mode, the roots are the main modules
// rather than the main module's direct dependencies. The check below on the selected
// roots does not apply.
// of the vendor directory anyway.
continue
}
- if mg, err := rs.Graph(ctx); err != nil {
+ if mg, err := rs.Graph(loaderstate, ctx); err != nil {
return false, err
} else if _, ok := mg.RequiredBy(dep.mod); !ok {
// dep.mod is not an explicit dependency, but needs to be.
}
}
} else if pkg.err == nil && cfg.BuildMod != "mod" {
- if v, ok := rs.rootSelected(dep.mod.Path); !ok || v != dep.mod.Version {
+ if v, ok := rs.rootSelected(loaderstate, dep.mod.Path); !ok || v != dep.mod.Version {
// dep.mod is not an explicit dependency, but needs to be.
// Because we are not in "mod" mode, we will not be able to update it.
// Instead, mark the importing package with an error.
// roots can only increase and the set of roots can only expand. The set
// of extant root paths is finite and the set of versions of each path is
// finite, so the iteration *must* reach a stable fixed-point.
- tidy, err := tidyRoots(ctx, rs, ld.pkgs)
+ tidy, err := tidyRoots(loaderstate, ctx, rs, ld.pkgs)
if err != nil {
return false, err
}
addRoots = tidy.rootModules
}
- rs, err = updateRoots(ctx, direct, rs, ld.pkgs, addRoots, ld.AssumeRootsImported)
+ rs, err = updateRoots(loaderstate, ctx, direct, rs, ld.pkgs, addRoots, ld.AssumeRootsImported)
if err != nil {
// We don't actually know what even the root requirements are supposed to be,
// so we can't proceed with loading. Return the error to the caller
return false, err
}
- if rs.GoVersion() != ld.requirements.GoVersion() {
+ if rs.GoVersion(loaderstate) != ld.requirements.GoVersion(loaderstate) {
// A change in the selected Go version may or may not affect the set of
// loaded packages, but in some cases it can change the meaning of the "all"
// pattern, the level of pruning in the module graph, and even the set of
// The roots of the module graph have changed in some way (not just the
// "direct" markings). Check whether the changes affected any of the loaded
// packages.
- mg, err := rs.Graph(ctx)
+ mg, err := rs.Graph(loaderstate, ctx)
if err != nil {
return false, err
}
for _, pkg := range ld.pkgs {
- if pkg.fromExternalModule() && mg.Selected(pkg.mod.Path) != pkg.mod.Version {
+ if pkg.fromExternalModule(loaderstate) && mg.Selected(pkg.mod.Path) != pkg.mod.Version {
changed = true
break
}
//
// In some sense, we can think of this as ‘upgraded the module providing
// pkg.path from "none" to a version higher than "none"’.
- if _, _, _, _, err = importFromModules(ctx, pkg.path, rs, nil, ld.skipImportModFiles); err == nil {
+ if _, _, _, _, err = importFromModules(loaderstate, ctx, pkg.path, rs, nil, ld.skipImportModFiles); err == nil {
changed = true
break
}
// The newly-resolved packages are added to the addedModuleFor map, and
// resolveMissingImports returns a map from each new module version to
// the first missing package that module would resolve.
-func (ld *loader) resolveMissingImports(ctx context.Context) (modAddedBy map[module.Version]*loadPkg, err error) {
+func (ld *loader) resolveMissingImports(loaderstate *State, ctx context.Context) (modAddedBy map[module.Version]*loadPkg, err error) {
type pkgMod struct {
pkg *loadPkg
mod *module.Version
var mod module.Version
ld.work.Add(func() {
var err error
- mod, err = queryImport(ctx, pkg.path, ld.requirements)
+ mod, err = queryImport(loaderstate, ctx, pkg.path, ld.requirements)
if err != nil {
if ime, ok := errors.AsType[*ImportMissingError](err); ok {
for curstack := pkg.stack; curstack != nil; curstack = curstack.stack {
- if LoaderState.MainModules.Contains(curstack.mod.Path) {
+ if loaderstate.MainModules.Contains(curstack.mod.Path) {
ime.ImportingMainModule = curstack.mod
break
}
// ld.work queue, and its test (if requested) will also be populated once
// imports have been resolved. When ld.work goes idle, all transitive imports of
// the requested package (and its test, if requested) will have been loaded.
-func (ld *loader) pkg(ctx context.Context, path string, flags loadPkgFlags) *loadPkg {
+func (ld *loader) pkg(loaderstate *State, ctx context.Context, path string, flags loadPkgFlags) *loadPkg {
if flags.has(pkgImportsLoaded) {
panic("internal error: (*loader).pkg called with pkgImportsLoaded flag set")
}
pkg := &loadPkg{
path: path,
}
- ld.applyPkgFlags(ctx, pkg, flags)
+ ld.applyPkgFlags(loaderstate, ctx, pkg, flags)
- ld.work.Add(func() { ld.load(ctx, pkg) })
+ ld.work.Add(func() { ld.load(loaderstate, ctx, pkg) })
return pkg
})
- ld.applyPkgFlags(ctx, pkg, flags)
+ ld.applyPkgFlags(loaderstate, ctx, pkg, flags)
return pkg
}
// applyPkgFlags updates pkg.flags to set the given flags and propagate the
// (transitive) effects of those flags, possibly loading or enqueueing further
// packages as a result.
-func (ld *loader) applyPkgFlags(ctx context.Context, pkg *loadPkg, flags loadPkgFlags) {
+func (ld *loader) applyPkgFlags(loaderstate *State, ctx context.Context, pkg *loadPkg, flags loadPkgFlags) {
if flags == 0 {
return
}
// so it's ok if we call it more than is strictly necessary.
wantTest := false
switch {
- case ld.allPatternIsRoot && LoaderState.MainModules.Contains(pkg.mod.Path):
+ case ld.allPatternIsRoot && loaderstate.MainModules.Contains(pkg.mod.Path):
// We are loading the "all" pattern, which includes packages imported by
// tests in the main module. This package is in the main module, so we
// need to identify the imports of its test even if LoadTests is not set.
if wantTest {
var testFlags loadPkgFlags
- if LoaderState.MainModules.Contains(pkg.mod.Path) || (ld.allClosesOverTests && new.has(pkgInAll)) {
+ if loaderstate.MainModules.Contains(pkg.mod.Path) || (ld.allClosesOverTests && new.has(pkgInAll)) {
// Tests of packages in the main module are in "all", in the sense that
// they cause the packages they import to also be in "all". So are tests
// of packages in "all" if "all" closes over test dependencies.
testFlags |= pkgInAll
}
- ld.pkgTest(ctx, pkg, testFlags)
+ ld.pkgTest(loaderstate, ctx, pkg, testFlags)
}
}
// We have just marked pkg with pkgInAll, or we have just loaded its
// imports, or both. Now is the time to propagate pkgInAll to the imports.
for _, dep := range pkg.imports {
- ld.applyPkgFlags(ctx, dep, pkgInAll)
+ ld.applyPkgFlags(loaderstate, ctx, dep, pkgInAll)
}
}
if new.has(pkgFromRoot) && !old.has(pkgFromRoot|pkgImportsLoaded) {
for _, dep := range pkg.imports {
- ld.applyPkgFlags(ctx, dep, pkgFromRoot)
+ ld.applyPkgFlags(loaderstate, ctx, dep, pkgFromRoot)
}
}
}
// preloadRootModules loads the module requirements needed to identify the
// selected version of each module providing a package in rootPkgs,
// adding new root modules to the module graph if needed.
-func (ld *loader) preloadRootModules(ctx context.Context, rootPkgs []string) (changedBuildList bool) {
+func (ld *loader) preloadRootModules(loaderstate *State, ctx context.Context, rootPkgs []string) (changedBuildList bool) {
needc := make(chan map[module.Version]bool, 1)
needc <- map[module.Version]bool{}
for _, path := range rootPkgs {
// If the main module is tidy and the package is in "all" — or if we're
// lucky — we can identify all of its imports without actually loading the
// full module graph.
- m, _, _, _, err := importFromModules(ctx, path, ld.requirements, nil, ld.skipImportModFiles)
+ m, _, _, _, err := importFromModules(loaderstate, ctx, path, ld.requirements, nil, ld.skipImportModFiles)
if err != nil {
if _, ok := errors.AsType[*ImportMissingError](err); ok && ld.ResolveMissingImports {
// This package isn't provided by any selected module.
// If we can find it, it will be a new root dependency.
- m, err = queryImport(ctx, path, ld.requirements)
+ m, err = queryImport(loaderstate, ctx, path, ld.requirements)
}
if err != nil {
// We couldn't identify the root module containing this package.
return
}
- v, ok := ld.requirements.rootSelected(m.Path)
+ v, ok := ld.requirements.rootSelected(loaderstate, m.Path)
if !ok || v != m.Version {
// We found the requested package in m, but m is not a root, so
// loadModGraph will not load its requirements. We need to promote the
}
gover.ModSort(toAdd)
- rs, err := updateRoots(ctx, ld.requirements.direct, ld.requirements, nil, toAdd, ld.AssumeRootsImported)
+ rs, err := updateRoots(loaderstate, ctx, ld.requirements.direct, ld.requirements, nil, toAdd, ld.AssumeRootsImported)
if err != nil {
// We are missing some root dependency, and for some reason we can't load
// enough of the module dependency graph to add the missing root. Package
}
// load loads an individual package.
-func (ld *loader) load(ctx context.Context, pkg *loadPkg) {
+func (ld *loader) load(loaderstate *State, ctx context.Context, pkg *loadPkg) {
var mg *ModuleGraph
if ld.requirements.pruning == unpruned {
var err error
- mg, err = ld.requirements.Graph(ctx)
+ mg, err = ld.requirements.Graph(loaderstate, ctx)
if err != nil {
// We already checked the error from Graph in loadFromRoots and/or
// updateRequirements, so we ignored the error on purpose and we should
}
var modroot string
- pkg.mod, modroot, pkg.dir, pkg.altMods, pkg.err = importFromModules(ctx, pkg.path, ld.requirements, mg, ld.skipImportModFiles)
- if LoaderState.MainModules.Tools()[pkg.path] {
+ pkg.mod, modroot, pkg.dir, pkg.altMods, pkg.err = importFromModules(loaderstate, ctx, pkg.path, ld.requirements, mg, ld.skipImportModFiles)
+ if loaderstate.MainModules.Tools()[pkg.path] {
// Tools declared by main modules are always in "all".
// We apply the package flags before returning so that missing
// tool dependencies report an error https://go.dev/issue/70582
- ld.applyPkgFlags(ctx, pkg, pkgInAll)
+ ld.applyPkgFlags(loaderstate, ctx, pkg, pkgInAll)
}
if pkg.dir == "" {
return
}
- if LoaderState.MainModules.Contains(pkg.mod.Path) {
+ if loaderstate.MainModules.Contains(pkg.mod.Path) {
// Go ahead and mark pkg as in "all". This provides the invariant that a
// package that is *only* imported by other packages in "all" is always
// marked as such before loading its imports.
// about (by reducing churn on the flag bits of dependencies), and costs
// essentially nothing (these atomic flag ops are essentially free compared
// to scanning source code for imports).
- ld.applyPkgFlags(ctx, pkg, pkgInAll)
+ ld.applyPkgFlags(loaderstate, ctx, pkg, pkgInAll)
}
if ld.AllowPackage != nil {
if err := ld.AllowPackage(ctx, pkg.path, pkg.mod); err != nil {
if pkg.inStd {
// Imports from packages in "std" and "cmd" should resolve using
// GOROOT/src/vendor even when "std" is not the main module.
- path = ld.stdVendor(pkg.path, path)
+ path = ld.stdVendor(loaderstate, pkg.path, path)
}
- pkg.imports = append(pkg.imports, ld.pkg(ctx, path, importFlags))
+ pkg.imports = append(pkg.imports, ld.pkg(loaderstate, ctx, path, importFlags))
}
pkg.testImports = testImports
- ld.applyPkgFlags(ctx, pkg, pkgImportsLoaded)
+ ld.applyPkgFlags(loaderstate, ctx, pkg, pkgImportsLoaded)
}
// pkgTest locates the test of pkg, creating it if needed, and updates its state
//
// pkgTest requires that the imports of pkg have already been loaded (flagged
// with pkgImportsLoaded).
-func (ld *loader) pkgTest(ctx context.Context, pkg *loadPkg, testFlags loadPkgFlags) *loadPkg {
+func (ld *loader) pkgTest(loaderstate *State, ctx context.Context, pkg *loadPkg, testFlags loadPkgFlags) *loadPkg {
if pkg.isTest() {
panic("pkgTest called on a test package")
}
err: pkg.err,
inStd: pkg.inStd,
}
- ld.applyPkgFlags(ctx, pkg.test, testFlags)
+ ld.applyPkgFlags(loaderstate, ctx, pkg.test, testFlags)
createdTest = true
})
}
for _, path := range pkg.testImports {
if pkg.inStd {
- path = ld.stdVendor(test.path, path)
+ path = ld.stdVendor(loaderstate, test.path, path)
}
- test.imports = append(test.imports, ld.pkg(ctx, path, importFlags))
+ test.imports = append(test.imports, ld.pkg(loaderstate, ctx, path, importFlags))
}
pkg.testImports = nil
- ld.applyPkgFlags(ctx, test, pkgImportsLoaded)
+ ld.applyPkgFlags(loaderstate, ctx, test, pkgImportsLoaded)
} else {
- ld.applyPkgFlags(ctx, test, testFlags)
+ ld.applyPkgFlags(loaderstate, ctx, test, testFlags)
}
return test
// stdVendor returns the canonical import path for the package with the given
// path when imported from the standard-library package at parentPath.
-func (ld *loader) stdVendor(parentPath, path string) string {
+func (ld *loader) stdVendor(loaderstate *State, parentPath, path string) string {
if p, _, ok := fips140.ResolveImport(path); ok {
return p
}
}
if str.HasPathPrefix(parentPath, "cmd") {
- if !ld.VendorModulesInGOROOTSrc || !LoaderState.MainModules.Contains("cmd") {
+ if !ld.VendorModulesInGOROOTSrc || !loaderstate.MainModules.Contains("cmd") {
vendorPath := pathpkg.Join("cmd", "vendor", path)
if _, err := os.Stat(filepath.Join(cfg.GOROOTsrc, filepath.FromSlash(vendorPath))); err == nil {
return vendorPath
}
}
- } else if !ld.VendorModulesInGOROOTSrc || !LoaderState.MainModules.Contains("std") || str.HasPathPrefix(parentPath, "vendor") {
+ } else if !ld.VendorModulesInGOROOTSrc || !loaderstate.MainModules.Contains("std") || str.HasPathPrefix(parentPath, "vendor") {
// If we are outside of the 'std' module, resolve imports from within 'std'
// to the vendor directory.
//
// or as a replacement for another module, but not both at the same time.
//
// (See https://golang.org/issue/26607 and https://golang.org/issue/34650.)
-func (ld *loader) checkMultiplePaths() {
+func (ld *loader) checkMultiplePaths(loaderstate *State) {
mods := ld.requirements.rootModules
if cached := ld.requirements.graph.Load(); cached != nil {
if mg := cached.mg; mg != nil {
firstPath := map[module.Version]string{}
for _, mod := range mods {
- src := resolveReplacement(mod)
+ src := resolveReplacement(loaderstate, mod)
if prev, ok := firstPath[src]; !ok {
firstPath[src] = mod.Path
} else if prev != mod.Path {
// checkTidyCompatibility emits an error if any package would be loaded from a
// different module under rs than under ld.requirements.
-func (ld *loader) checkTidyCompatibility(ctx context.Context, rs *Requirements, compatVersion string) {
- goVersion := rs.GoVersion()
+func (ld *loader) checkTidyCompatibility(loaderstate *State, ctx context.Context, rs *Requirements, compatVersion string) {
+ goVersion := rs.GoVersion(loaderstate)
suggestUpgrade := false
suggestEFlag := false
suggestFixes := func() {
fmt.Fprintln(os.Stderr)
goFlag := ""
- if goVersion != LoaderState.MainModules.GoVersion() {
+ if goVersion != loaderstate.MainModules.GoVersion(loaderstate) {
goFlag = " -go=" + goVersion
}
fmt.Fprintf(os.Stderr, "For information about 'go mod tidy' compatibility, see:\n\thttps://go.dev/ref/mod#graph-pruning\n")
}
- mg, err := rs.Graph(ctx)
+ mg, err := rs.Graph(loaderstate, ctx)
if err != nil {
ld.error(fmt.Errorf("error loading go %s module graph: %w", compatVersion, err))
ld.switchIfErrors(ctx)
pkg := pkg
ld.work.Add(func() {
- mod, _, _, _, err := importFromModules(ctx, pkg.path, rs, mg, ld.skipImportModFiles)
+ mod, _, _, _, err := importFromModules(loaderstate, ctx, pkg.path, rs, mg, ld.skipImportModFiles)
if mod != pkg.mod {
mismatches := <-mismatchMu
mismatches[pkg] = mismatch{mod: mod, err: err}
if err := CheckExclusions(ctx, m); err != nil {
return err
}
- if err := CheckRetractions(ctx, m); err != nil {
+ if err := CheckRetractions(LoaderState, ctx, m); err != nil {
return err
}
return nil
// CheckRetractions returns an error if module m has been retracted by
// its author.
-func CheckRetractions(ctx context.Context, m module.Version) (err error) {
+func CheckRetractions(loaderstate *State, ctx context.Context, m module.Version) (err error) {
defer func() {
if err == nil {
return
// Cannot be retracted.
return nil
}
- if repl := Replacement(module.Version{Path: m.Path}); repl.Path != "" {
+ if repl := Replacement(loaderstate, module.Version{Path: m.Path}); repl.Path != "" {
// All versions of the module were replaced.
// Don't load retractions, since we'd just load the replacement.
return nil
// We load the raw file here: the go.mod file may have a different module
// path that we expect if the module or its repository was renamed.
// We still want to apply retractions to other aliases of the module.
- rm, err := queryLatestVersionIgnoringRetractions(ctx, m.Path)
+ rm, err := queryLatestVersionIgnoringRetractions(loaderstate, ctx, m.Path)
if err != nil {
return err
}
- summary, err := rawGoModSummary(rm)
+ summary, err := rawGoModSummary(loaderstate, rm)
if err != nil && !errors.Is(err, gover.ErrTooNew) {
return err
}
//
// CheckDeprecation returns an error if the message can't be loaded.
// CheckDeprecation returns "", nil if there is no deprecation message.
-func CheckDeprecation(ctx context.Context, m module.Version) (deprecation string, err error) {
+func CheckDeprecation(loaderstate *State, ctx context.Context, m module.Version) (deprecation string, err error) {
defer func() {
if err != nil {
err = fmt.Errorf("loading deprecation for %s: %w", m.Path, err)
// Don't look up deprecation.
return "", nil
}
- if repl := Replacement(module.Version{Path: m.Path}); repl.Path != "" {
+ if repl := Replacement(loaderstate, module.Version{Path: m.Path}); repl.Path != "" {
// All versions of the module were replaced.
// We'll look up deprecation separately for the replacement.
return "", nil
}
- latest, err := queryLatestVersionIgnoringRetractions(ctx, m.Path)
+ latest, err := queryLatestVersionIgnoringRetractions(loaderstate, ctx, m.Path)
if err != nil {
return "", err
}
- summary, err := rawGoModSummary(latest)
+ summary, err := rawGoModSummary(loaderstate, latest)
if err != nil && !errors.Is(err, gover.ErrTooNew) {
return "", err
}
// Replacement returns the replacement for mod, if any. If the path in the
// module.Version is relative it's relative to the single main module outside
// workspace mode, or the workspace's directory in workspace mode.
-func Replacement(mod module.Version) module.Version {
- r, foundModRoot, _ := replacementFrom(mod)
- return canonicalizeReplacePath(r, foundModRoot)
+func Replacement(loaderstate *State, mod module.Version) module.Version {
+ r, foundModRoot, _ := replacementFrom(loaderstate, mod)
+ return canonicalizeReplacePath(loaderstate, r, foundModRoot)
}
// replacementFrom returns the replacement for mod, if any, the modroot of the replacement if it appeared in a go.mod,
// and the source of the replacement. The replacement is relative to the go.work or go.mod file it appears in.
-func replacementFrom(mod module.Version) (r module.Version, modroot string, fromFile string) {
+func replacementFrom(loaderstate *State, mod module.Version) (r module.Version, modroot string, fromFile string) {
foundFrom, found, foundModRoot := "", module.Version{}, ""
- if LoaderState.MainModules == nil {
+ if loaderstate.MainModules == nil {
return module.Version{}, "", ""
- } else if LoaderState.MainModules.Contains(mod.Path) && mod.Version == "" {
+ } else if loaderstate.MainModules.Contains(mod.Path) && mod.Version == "" {
// Don't replace the workspace version of the main module.
return module.Version{}, "", ""
}
- if _, r, ok := replacement(mod, LoaderState.MainModules.WorkFileReplaceMap()); ok {
- return r, "", LoaderState.workFilePath
+ if _, r, ok := replacement(mod, loaderstate.MainModules.WorkFileReplaceMap()); ok {
+ return r, "", loaderstate.workFilePath
}
- for _, v := range LoaderState.MainModules.Versions() {
- if index := LoaderState.MainModules.Index(v); index != nil {
+ for _, v := range loaderstate.MainModules.Versions() {
+ if index := loaderstate.MainModules.Index(v); index != nil {
if from, r, ok := replacement(mod, index.replace); ok {
- modRoot := LoaderState.MainModules.ModRoot(v)
+ modRoot := loaderstate.MainModules.ModRoot(v)
if foundModRoot != "" && foundFrom != from && found != r {
base.Errorf("conflicting replacements found for %v in workspace modules defined by %v and %v",
mod, modFilePath(foundModRoot), modFilePath(modRoot))
return found, foundModRoot, modFilePath(foundModRoot)
}
-func replaceRelativeTo() string {
- if workFilePath := WorkFilePath(); workFilePath != "" {
+func replaceRelativeTo(loaderstate *State) string {
+ if workFilePath := WorkFilePath(loaderstate); workFilePath != "" {
return filepath.Dir(workFilePath)
}
- return LoaderState.MainModules.ModRoot(LoaderState.MainModules.mustGetSingleMainModule())
+ return loaderstate.MainModules.ModRoot(loaderstate.MainModules.mustGetSingleMainModule(loaderstate))
}
// canonicalizeReplacePath ensures that relative, on-disk, replaced module paths
// are relative to the workspace directory (in workspace mode) or to the module's
// directory (in module mode, as they already are).
-func canonicalizeReplacePath(r module.Version, modRoot string) module.Version {
+func canonicalizeReplacePath(loaderstate *State, r module.Version, modRoot string) module.Version {
if filepath.IsAbs(r.Path) || r.Version != "" || modRoot == "" {
return r
}
- workFilePath := WorkFilePath()
+ workFilePath := WorkFilePath(loaderstate)
if workFilePath == "" {
return r
}
// for m: either m itself, or the replacement for m (iff m is replaced).
// It also returns the modroot of the module providing the replacement if
// one was found.
-func resolveReplacement(m module.Version) module.Version {
- if r := Replacement(m); r.Path != "" {
+func resolveReplacement(loaderstate *State, m module.Version) module.Version {
+ if r := Replacement(loaderstate, m); r.Path != "" {
return r
}
return m
// module versions.
//
// The caller must not modify the returned summary.
-func goModSummary(m module.Version) (*modFileSummary, error) {
- if m.Version == "" && !inWorkspaceMode() && LoaderState.MainModules.Contains(m.Path) {
+func goModSummary(loaderstate *State, m module.Version) (*modFileSummary, error) {
+ if m.Version == "" && !inWorkspaceMode(loaderstate) && loaderstate.MainModules.Contains(m.Path) {
panic("internal error: goModSummary called on a main module")
}
if gover.IsToolchain(m.Path) {
- return rawGoModSummary(m)
+ return rawGoModSummary(loaderstate, m)
}
if cfg.BuildMod == "vendor" {
module: module.Version{Path: m.Path},
}
- readVendorList(VendorDir())
+ readVendorList(VendorDir(loaderstate))
if vendorVersion[m.Path] != m.Version {
// This module is not vendored, so packages cannot be loaded from it and
// it cannot be relevant to the build.
return summary, nil
}
- actual := resolveReplacement(m)
- if mustHaveSums() && actual.Version != "" {
+ actual := resolveReplacement(loaderstate, m)
+ if mustHaveSums(loaderstate) && actual.Version != "" {
key := module.Version{Path: actual.Path, Version: actual.Version + "/go.mod"}
if !modfetch.HaveSum(key) {
suggestion := fmt.Sprintf(" for go.mod file; to add it:\n\tgo mod download %s", m.Path)
return nil, module.VersionError(actual, &sumMissingError{suggestion: suggestion})
}
}
- summary, err := rawGoModSummary(actual)
+ summary, err := rawGoModSummary(loaderstate, actual)
if err != nil {
return nil, err
}
}
}
- for _, mainModule := range LoaderState.MainModules.Versions() {
- if index := LoaderState.MainModules.Index(mainModule); index != nil && len(index.exclude) > 0 {
+ for _, mainModule := range loaderstate.MainModules.Versions() {
+ if index := loaderstate.MainModules.Index(mainModule); index != nil && len(index.exclude) > 0 {
// Drop any requirements on excluded versions.
// Don't modify the cached summary though, since we might need the raw
// summary separately.
// rawGoModSummary cannot be used on the main module outside of workspace mode.
// The modFileSummary can still be used for retractions and deprecations
// even if a TooNewError is returned.
-func rawGoModSummary(m module.Version) (*modFileSummary, error) {
+func rawGoModSummary(loaderstate *State, m module.Version) (*modFileSummary, error) {
if gover.IsToolchain(m.Path) {
if m.Path == "go" && gover.Compare(m.Version, gover.GoStrictVersion) >= 0 {
// Declare that go 1.21.3 requires toolchain 1.21.3,
}
return &modFileSummary{module: m}, nil
}
- if m.Version == "" && !inWorkspaceMode() && LoaderState.MainModules.Contains(m.Path) {
+ if m.Version == "" && !inWorkspaceMode(loaderstate) && loaderstate.MainModules.Contains(m.Path) {
// Calling rawGoModSummary implies that we are treating m as a module whose
// requirements aren't the roots of the module graph and can't be modified.
//
// are the roots of the module graph and we expect them to be kept consistent.
panic("internal error: rawGoModSummary called on a main module")
}
- if m.Version == "" && inWorkspaceMode() && m.Path == "command-line-arguments" {
+ if m.Version == "" && inWorkspaceMode(loaderstate) && m.Path == "command-line-arguments" {
// "go work sync" calls LoadModGraph to make sure the module graph is valid.
// If there are no modules in the workspace, we synthesize an empty
// command-line-arguments module, which rawGoModData cannot read a go.mod for.
return &modFileSummary{module: m}, nil
- } else if m.Version == "" && inWorkspaceMode() && LoaderState.MainModules.Contains(m.Path) {
+ } else if m.Version == "" && inWorkspaceMode(loaderstate) && loaderstate.MainModules.Contains(m.Path) {
// When go get uses EnterWorkspace to check that the workspace loads properly,
// it will update the contents of the workspace module's modfile in memory. To use the updated
// contents of the modfile when doing the load, don't read from disk and instead
// recompute a summary using the updated contents of the modfile.
- if mf := LoaderState.MainModules.ModFile(m); mf != nil {
- return summaryFromModFile(m, LoaderState.MainModules.modFiles[m])
+ if mf := loaderstate.MainModules.ModFile(m); mf != nil {
+ return summaryFromModFile(m, loaderstate.MainModules.modFiles[m])
}
}
return rawGoModSummaryCache.Do(m, func() (*modFileSummary, error) {
- name, data, err := rawGoModData(m)
+ name, data, err := rawGoModData(loaderstate, m)
if err != nil {
return nil, err
}
//
// Unlike rawGoModSummary, rawGoModData does not cache its results in memory.
// Use rawGoModSummary instead unless you specifically need these bytes.
-func rawGoModData(m module.Version) (name string, data []byte, err error) {
+func rawGoModData(loaderstate *State, m module.Version) (name string, data []byte, err error) {
if m.Version == "" {
dir := m.Path
if !filepath.IsAbs(dir) {
- if inWorkspaceMode() && LoaderState.MainModules.Contains(m.Path) {
- dir = LoaderState.MainModules.ModRoot(m)
+ if inWorkspaceMode(loaderstate) && loaderstate.MainModules.Contains(m.Path) {
+ dir = loaderstate.MainModules.ModRoot(m)
} else {
// m is a replacement module with only a file path.
- dir = filepath.Join(replaceRelativeTo(), dir)
+ dir = filepath.Join(replaceRelativeTo(loaderstate), dir)
}
}
name = filepath.Join(dir, "go.mod")
//
// If the queried latest version is replaced,
// queryLatestVersionIgnoringRetractions returns the replacement.
-func queryLatestVersionIgnoringRetractions(ctx context.Context, path string) (latest module.Version, err error) {
+func queryLatestVersionIgnoringRetractions(loaderstate *State, ctx context.Context, path string) (latest module.Version, err error) {
return latestVersionIgnoringRetractionsCache.Do(path, func() (module.Version, error) {
ctx, span := trace.StartSpan(ctx, "queryLatestVersionIgnoringRetractions "+path)
defer span.Done()
- if repl := Replacement(module.Version{Path: path}); repl.Path != "" {
+ if repl := Replacement(loaderstate, module.Version{Path: path}); repl.Path != "" {
// All versions of the module were replaced.
// No need to query.
return repl, nil
// Ignore exclusions from the main module's go.mod.
const ignoreSelected = ""
var allowAll AllowedFunc
- rev, err := Query(ctx, path, "latest", ignoreSelected, allowAll)
+ rev, err := Query(loaderstate, ctx, path, "latest", ignoreSelected, allowAll)
if err != nil {
return module.Version{}, err
}
latest := module.Version{Path: path, Version: rev.Version}
- if repl := resolveReplacement(latest); repl.Path != "" {
+ if repl := resolveReplacement(loaderstate, latest); repl.Path != "" {
latest = repl
}
return latest, nil
return nil, nil
}
- summary, err := goModSummary(mod)
+ summary, err := goModSummary(LoaderState, mod)
if err != nil {
return nil, err
}
return m, nil
}
-func versions(ctx context.Context, path string, allowed AllowedFunc) (versions []string, origin *codehost.Origin, err error) {
+func versions(loaderstate *State, ctx context.Context, path string, allowed AllowedFunc) (versions []string, origin *codehost.Origin, err error) {
// Note: modfetch.Lookup and repo.Versions are cached,
// so there's no need for us to add extra caching here.
err = modfetch.TryProxies(func(proxy string) error {
- repo, err := lookupRepo(ctx, proxy, path)
+ repo, err := lookupRepo(loaderstate, ctx, proxy, path)
if err != nil {
return err
}
//
// Since the version of a main module is not found in the version list,
// it has no previous version.
-func previousVersion(ctx context.Context, m module.Version) (module.Version, error) {
- if m.Version == "" && LoaderState.MainModules.Contains(m.Path) {
+func previousVersion(loaderstate *State, ctx context.Context, m module.Version) (module.Version, error) {
+ if m.Version == "" && loaderstate.MainModules.Contains(m.Path) {
return module.Version{Path: m.Path, Version: "none"}, nil
}
- list, _, err := versions(ctx, m.Path, CheckAllowed)
+ list, _, err := versions(loaderstate, ctx, m.Path, CheckAllowed)
if err != nil {
if errors.Is(err, os.ErrNotExist) {
return module.Version{Path: m.Path, Version: "none"}, nil
func (*mvsReqs) Previous(m module.Version) (module.Version, error) {
// TODO(golang.org/issue/38714): thread tracing context through MVS.
- return previousVersion(context.TODO(), m)
+ return previousVersion(LoaderState, context.TODO(), m)
}
//
// Query often returns a non-nil *RevInfo with a non-nil error,
// to provide an info.Origin that can allow the error to be cached.
-func Query(ctx context.Context, path, query, current string, allowed AllowedFunc) (*modfetch.RevInfo, error) {
+func Query(loaderstate *State, ctx context.Context, path, query, current string, allowed AllowedFunc) (*modfetch.RevInfo, error) {
ctx, span := trace.StartSpan(ctx, "modload.Query "+path)
defer span.Done()
- return queryReuse(ctx, path, query, current, allowed, nil)
+ return queryReuse(loaderstate, ctx, path, query, current, allowed, nil)
}
// queryReuse is like Query but also takes a map of module info that can be reused
// if the validation criteria in Origin are met.
-func queryReuse(ctx context.Context, path, query, current string, allowed AllowedFunc, reuse map[module.Version]*modinfo.ModulePublic) (*modfetch.RevInfo, error) {
+func queryReuse(loaderstate *State, ctx context.Context, path, query, current string, allowed AllowedFunc, reuse map[module.Version]*modinfo.ModulePublic) (*modfetch.RevInfo, error) {
var info *modfetch.RevInfo
err := modfetch.TryProxies(func(proxy string) (err error) {
- info, err = queryProxy(ctx, proxy, path, query, current, allowed, reuse)
+ info, err = queryProxy(loaderstate, ctx, proxy, path, query, current, allowed, reuse)
return err
})
return info, err
// checkReuse checks whether a revision of a given module
// for a given module may be reused, according to the information in origin.
-func checkReuse(ctx context.Context, m module.Version, old *codehost.Origin) error {
+func checkReuse(loaderstate *State, ctx context.Context, m module.Version, old *codehost.Origin) error {
return modfetch.TryProxies(func(proxy string) error {
- repo, err := lookupRepo(ctx, proxy, m.Path)
+ repo, err := lookupRepo(loaderstate, ctx, proxy, m.Path)
if err != nil {
return err
}
return fmt.Sprintf("cannot query module due to -mod=%s\n\t(%s)", cfg.BuildMod, cfg.BuildModReason)
}
-func queryProxy(ctx context.Context, proxy, path, query, current string, allowed AllowedFunc, reuse map[module.Version]*modinfo.ModulePublic) (*modfetch.RevInfo, error) {
+func queryProxy(loaderstate *State, ctx context.Context, proxy, path, query, current string, allowed AllowedFunc, reuse map[module.Version]*modinfo.ModulePublic) (*modfetch.RevInfo, error) {
ctx, span := trace.StartSpan(ctx, "modload.queryProxy "+path+" "+query)
defer span.Done()
allowed = func(context.Context, module.Version) error { return nil }
}
- if LoaderState.MainModules.Contains(path) && (query == "upgrade" || query == "patch") {
+ if loaderstate.MainModules.Contains(path) && (query == "upgrade" || query == "patch") {
m := module.Version{Path: path}
if err := allowed(ctx, m); err != nil {
return nil, fmt.Errorf("internal error: main module version is not allowed: %w", err)
return nil, fmt.Errorf("can't query specific version (%q) of standard-library module %q", query, path)
}
- repo, err := lookupRepo(ctx, proxy, path)
+ repo, err := lookupRepo(loaderstate, ctx, proxy, path)
if err != nil {
return nil, err
}
return &clone
}
- releases, prereleases, err := qm.filterVersions(ctx, versions.List)
+ releases, prereleases, err := qm.filterVersions(loaderstate, ctx, versions.List)
if err != nil {
return revWithOrigin(nil), err
}
//
// If the allowed predicate returns an error not equivalent to ErrDisallowed,
// filterVersions returns that error.
-func (qm *queryMatcher) filterVersions(ctx context.Context, versions []string) (releases, prereleases []string, err error) {
+func (qm *queryMatcher) filterVersions(loaderstate *State, ctx context.Context, versions []string) (releases, prereleases []string, err error) {
needIncompatible := qm.preferIncompatible
var lastCompatible string
// ignore any version with a higher (+incompatible) major version. (See
// https://golang.org/issue/34165.) Note that we even prefer a
// compatible pre-release over an incompatible release.
- ok, err := versionHasGoMod(ctx, module.Version{Path: qm.path, Version: lastCompatible})
+ ok, err := versionHasGoMod(loaderstate, ctx, module.Version{Path: qm.path, Version: lastCompatible})
if err != nil {
return nil, nil, err
}
// QueryPackages is like QueryPattern, but requires that the pattern match at
// least one package and omits the non-package result (if any).
-func QueryPackages(ctx context.Context, pattern, query string, current func(string) string, allowed AllowedFunc) ([]QueryResult, error) {
- pkgMods, modOnly, err := QueryPattern(ctx, pattern, query, current, allowed)
+func QueryPackages(loaderstate *State, ctx context.Context, pattern, query string, current func(string) string, allowed AllowedFunc) ([]QueryResult, error) {
+ pkgMods, modOnly, err := QueryPattern(loaderstate, ctx, pattern, query, current, allowed)
if len(pkgMods) == 0 && err == nil {
- replacement := Replacement(modOnly.Mod)
+ replacement := Replacement(loaderstate, modOnly.Mod)
return nil, &PackageNotInModuleError{
Mod: modOnly.Mod,
Replacement: replacement,
//
// QueryPattern always returns at least one QueryResult (which may be only
// modOnly) or a non-nil error.
-func QueryPattern(ctx context.Context, pattern, query string, current func(string) string, allowed AllowedFunc) (pkgMods []QueryResult, modOnly *QueryResult, err error) {
+func QueryPattern(loaderstate *State, ctx context.Context, pattern, query string, current func(string) string, allowed AllowedFunc) (pkgMods []QueryResult, modOnly *QueryResult, err error) {
ctx, span := trace.StartSpan(ctx, "modload.QueryPattern "+pattern+" "+query)
defer span.Done()
}
match = func(mod module.Version, roots []string, isLocal bool) *search.Match {
m := search.NewMatch(pattern)
- matchPackages(ctx, m, imports.AnyTags(), omitStd, []module.Version{mod})
+ matchPackages(loaderstate, ctx, m, imports.AnyTags(), omitStd, []module.Version{mod})
return m
}
} else {
match = func(mod module.Version, roots []string, isLocal bool) *search.Match {
m := search.NewMatch(pattern)
prefix := mod.Path
- if LoaderState.MainModules.Contains(mod.Path) {
- prefix = LoaderState.MainModules.PathPrefix(module.Version{Path: mod.Path})
+ if loaderstate.MainModules.Contains(mod.Path) {
+ prefix = loaderstate.MainModules.PathPrefix(module.Version{Path: mod.Path})
}
for _, root := range roots {
if _, ok, err := dirInModule(pattern, prefix, root, isLocal); err != nil {
}
var mainModuleMatches []module.Version
- for _, mainModule := range LoaderState.MainModules.Versions() {
- m := match(mainModule, LoaderState.modRoots, true)
+ for _, mainModule := range loaderstate.MainModules.Versions() {
+ m := match(mainModule, loaderstate.modRoots, true)
if len(m.Pkgs) > 0 {
if query != "upgrade" && query != "patch" {
return nil, nil, &QueryMatchesPackagesInMainModuleError{
var (
results []QueryResult
- candidateModules = modulePrefixesExcludingTarget(base)
+ candidateModules = modulePrefixesExcludingTarget(loaderstate, base)
)
if len(candidateModules) == 0 {
if modOnly != nil {
pathCurrent := current(path)
r.Mod.Path = path
- r.Rev, err = queryProxy(ctx, proxy, path, query, pathCurrent, allowed, nil)
+ r.Rev, err = queryProxy(loaderstate, ctx, proxy, path, query, pathCurrent, allowed, nil)
if err != nil {
return r, err
}
if gover.IsToolchain(r.Mod.Path) {
return r, nil
}
- root, isLocal, err := fetch(ctx, r.Mod)
+ root, isLocal, err := fetch(loaderstate, ctx, r.Mod)
if err != nil {
return r, err
}
if err := firstError(m); err != nil {
return r, err
}
- replacement := Replacement(r.Mod)
+ replacement := Replacement(loaderstate, r.Mod)
return r, &PackageNotInModuleError{
Mod: r.Mod,
Replacement: replacement,
return r, nil
}
- allResults, err := queryPrefixModules(ctx, candidateModules, queryModule)
+ allResults, err := queryPrefixModules(loaderstate, ctx, candidateModules, queryModule)
results = allResults[:0]
for _, r := range allResults {
if len(r.Packages) == 0 {
// itself, sorted by descending length. Prefixes that are not valid module paths
// but are valid package paths (like "m" or "example.com/.gen") are included,
// since they might be replaced.
-func modulePrefixesExcludingTarget(path string) []string {
+func modulePrefixesExcludingTarget(loaderstate *State, path string) []string {
prefixes := make([]string, 0, strings.Count(path, "/")+1)
mainModulePrefixes := make(map[string]bool)
- for _, m := range LoaderState.MainModules.Versions() {
+ for _, m := range loaderstate.MainModules.Versions() {
mainModulePrefixes[m.Path] = true
}
return prefixes
}
-func queryPrefixModules(ctx context.Context, candidateModules []string, queryModule func(ctx context.Context, path string) (QueryResult, error)) (found []QueryResult, err error) {
+func queryPrefixModules(loaderstate *State, ctx context.Context, candidateModules []string, queryModule func(ctx context.Context, path string) (QueryResult, error)) (found []QueryResult, err error) {
ctx, span := trace.StartSpan(ctx, "modload.queryPrefixModules")
defer span.Done()
case *PackageNotInModuleError:
// Given the option, prefer to attribute “package not in module”
// to modules other than the main one.
- if noPackage == nil || LoaderState.MainModules.Contains(noPackage.Mod.Path) {
+ if noPackage == nil || loaderstate.MainModules.Contains(noPackage.Mod.Path) {
noPackage = rErr
}
case *NoMatchingVersionError:
// go.mod with different content. Second, if we don't fetch the .zip, then
// we don't need to verify it in go.sum. This makes 'go list -m -u' faster
// and simpler.
-func versionHasGoMod(_ context.Context, m module.Version) (bool, error) {
- _, data, err := rawGoModData(m)
+func versionHasGoMod(loaderstate *State, _ context.Context, m module.Version) (bool, error) {
+ _, data, err := rawGoModData(loaderstate, m)
if err != nil {
return false, err
}
var _ versionRepo = modfetch.Repo(nil)
-func lookupRepo(ctx context.Context, proxy, path string) (repo versionRepo, err error) {
+func lookupRepo(loaderstate *State, ctx context.Context, proxy, path string) (repo versionRepo, err error) {
if path != "go" && path != "toolchain" {
err = module.CheckPath(path)
}
repo = emptyRepo{path: path, err: err}
}
- if LoaderState.MainModules == nil {
+ if loaderstate.MainModules == nil {
return repo, err
- } else if _, ok := LoaderState.MainModules.HighestReplaced()[path]; ok {
+ } else if _, ok := loaderstate.MainModules.HighestReplaced()[path]; ok {
return &replacementRepo{repo: repo}, nil
}
}
}
- if r := Replacement(module.Version{Path: path, Version: v}); r.Path == "" {
+ if r := Replacement(LoaderState, module.Version{Path: path, Version: v}); r.Path == "" {
return info, err
}
return rr.replacementStat(v)
t.Run(strings.ReplaceAll(tt.path, "/", "_")+"/"+tt.query+"/"+tt.current+"/"+allow, func(t *testing.T) {
t.Parallel()
- info, err := Query(ctx, tt.path, tt.query, tt.current, allowed)
+ info, err := Query(LoaderState, ctx, tt.path, tt.query, tt.current, allowed)
if tt.err != "" {
if err == nil {
t.Errorf("Query(_, %q, %q, %q, %v) = %v, want error %q", tt.path, tt.query, tt.current, allow, info.Version, tt.err)
// matchPackages is like m.MatchPackages, but uses a local variable (rather than
// a global) for tags, can include or exclude packages in the standard library,
// and is restricted to the given list of modules.
-func matchPackages(ctx context.Context, m *search.Match, tags map[string]bool, filter stdFilter, modules []module.Version) {
+func matchPackages(loaderstate *State, ctx context.Context, m *search.Match, tags map[string]bool, filter stdFilter, modules []module.Version) {
ctx, span := trace.StartSpan(ctx, "modload.matchPackages")
defer span.Done()
)
q := par.NewQueue(runtime.GOMAXPROCS(0))
- ignorePatternsMap := parseIgnorePatterns(ctx, treeCanMatch, modules)
+ ignorePatternsMap := parseIgnorePatterns(loaderstate, ctx, treeCanMatch, modules)
walkPkgs := func(root, importPathRoot string, prune pruning) {
_, span := trace.StartSpan(ctx, "walkPkgs "+root)
defer span.Done()
}
if cfg.BuildMod == "vendor" {
- for _, mod := range LoaderState.MainModules.Versions() {
- if modRoot := LoaderState.MainModules.ModRoot(mod); modRoot != "" {
- walkPkgs(modRoot, LoaderState.MainModules.PathPrefix(mod), pruneGoMod|pruneVendor)
+ for _, mod := range loaderstate.MainModules.Versions() {
+ if modRoot := loaderstate.MainModules.ModRoot(mod); modRoot != "" {
+ walkPkgs(modRoot, loaderstate.MainModules.PathPrefix(mod), pruneGoMod|pruneVendor)
}
}
- if HasModRoot() {
- walkPkgs(VendorDir(), "", pruneVendor)
+ if HasModRoot(loaderstate) {
+ walkPkgs(VendorDir(loaderstate), "", pruneVendor)
}
return
}
root, modPrefix string
isLocal bool
)
- if LoaderState.MainModules.Contains(mod.Path) {
- if LoaderState.MainModules.ModRoot(mod) == "" {
+ if loaderstate.MainModules.Contains(mod.Path) {
+ if loaderstate.MainModules.ModRoot(mod) == "" {
continue // If there is no main module, we can't search in it.
}
- root = LoaderState.MainModules.ModRoot(mod)
- modPrefix = LoaderState.MainModules.PathPrefix(mod)
+ root = loaderstate.MainModules.ModRoot(mod)
+ modPrefix = loaderstate.MainModules.PathPrefix(mod)
isLocal = true
} else {
var err error
- root, isLocal, err = fetch(ctx, mod)
+ root, isLocal, err = fetch(loaderstate, ctx, mod)
if err != nil {
m.AddError(err)
continue
func MatchInModule(ctx context.Context, pattern string, m module.Version, tags map[string]bool) *search.Match {
match := search.NewMatch(pattern)
if m == (module.Version{}) {
- matchPackages(ctx, match, tags, includeStd, nil)
+ matchPackages(LoaderState, ctx, match, tags, includeStd, nil)
}
- LoadModFile(ctx) // Sets Target, needed by fetch and matchPackages.
+ LoadModFile(LoaderState, ctx) // Sets Target, needed by fetch and matchPackages.
if !match.IsLiteral() {
- matchPackages(ctx, match, tags, omitStd, []module.Version{m})
+ matchPackages(LoaderState, ctx, match, tags, omitStd, []module.Version{m})
return match
}
- root, isLocal, err := fetch(ctx, m)
+ root, isLocal, err := fetch(LoaderState, ctx, m)
if err != nil {
match.Errs = []error{err}
return match
// parseIgnorePatterns collects all ignore patterns associated with the
// provided list of modules.
// It returns a map of module root -> *search.IgnorePatterns.
-func parseIgnorePatterns(ctx context.Context, treeCanMatch func(string) bool, modules []module.Version) map[string]*search.IgnorePatterns {
+func parseIgnorePatterns(loaderstate *State, ctx context.Context, treeCanMatch func(string) bool, modules []module.Version) map[string]*search.IgnorePatterns {
ignorePatternsMap := make(map[string]*search.IgnorePatterns)
for _, mod := range modules {
if gover.IsToolchain(mod.Path) || !treeCanMatch(mod.Path) {
}
var modRoot string
var ignorePatterns []string
- if LoaderState.MainModules.Contains(mod.Path) {
- modRoot = LoaderState.MainModules.ModRoot(mod)
+ if loaderstate.MainModules.Contains(mod.Path) {
+ modRoot = loaderstate.MainModules.ModRoot(mod)
if modRoot == "" {
continue
}
- modIndex := LoaderState.MainModules.Index(mod)
+ modIndex := loaderstate.MainModules.Index(mod)
if modIndex == nil {
continue
}
// Skip getting ignore patterns for vendored modules because they
// do not have go.mod files.
var err error
- modRoot, _, err = fetch(ctx, mod)
+ modRoot, _, err = fetch(loaderstate, ctx, mod)
if err != nil {
continue
}
- summary, err := goModSummary(mod)
+ summary, err := goModSummary(loaderstate, mod)
if err != nil {
continue
}
// checkVendorConsistency verifies that the vendor/modules.txt file matches (if
// go 1.14) or at least does not contradict (go 1.13 or earlier) the
// requirements and replacements listed in the main module's go.mod file.
-func checkVendorConsistency(indexes []*modFileIndex, modFiles []*modfile.File, modRoots []string) {
+func checkVendorConsistency(loaderstate *State, indexes []*modFileIndex, modFiles []*modfile.File, modRoots []string) {
// readVendorList only needs the main module to get the directory
// the vendor directory is in.
- readVendorList(VendorDir())
+ readVendorList(VendorDir(loaderstate))
if len(modFiles) < 1 {
// We should never get here if there are zero modfiles. Either
}
pre114 := false
- if !inWorkspaceMode() { // workspace mode was added after Go 1.14
+ if !inWorkspaceMode(loaderstate) { // workspace mode was added after Go 1.14
if len(indexes) != 1 {
panic(fmt.Errorf("not in workspace mode but number of indexes is %v, not 1", len(indexes)))
}
continue // Don't print the same error more than once
}
seenrep[r.Old] = true
- rNew, modRoot, replacementSource := replacementFrom(r.Old)
- rNewCanonical := canonicalizeReplacePath(rNew, modRoot)
+ rNew, modRoot, replacementSource := replacementFrom(loaderstate, r.Old)
+ rNewCanonical := canonicalizeReplacePath(loaderstate, rNew, modRoot)
vr := vendorMeta[r.Old].Replacement
if vr == (module.Version{}) {
if rNewCanonical == (module.Version{}) {
for _, modFile := range modFiles {
checkReplace(modFile.Replace)
}
- if LoaderState.MainModules.workFile != nil {
- checkReplace(LoaderState.MainModules.workFile.Replace)
+ if loaderstate.MainModules.workFile != nil {
+ checkReplace(loaderstate.MainModules.workFile.Replace)
}
for _, mod := range vendorList {
}
if !foundRequire {
article := ""
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
article = "a "
}
vendErrorf(mod, "is marked as explicit in vendor/modules.txt, but not explicitly required in %vgo.mod", article)
}
for _, mod := range vendorReplaced {
- r := Replacement(mod)
+ r := Replacement(loaderstate, mod)
replacementSource := "go.mod"
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
replacementSource = "the workspace"
}
if r == (module.Version{}) {
if vendErrors.Len() > 0 {
subcmd := "mod"
- if inWorkspaceMode() {
+ if inWorkspaceMode(loaderstate) {
subcmd = "work"
}
- base.Fatalf("go: inconsistent vendoring in %s:%s\n\n\tTo ignore the vendor directory, use -mod=readonly or -mod=mod.\n\tTo sync the vendor directory, run:\n\t\tgo %s vendor", filepath.Dir(VendorDir()), vendErrors, subcmd)
+ base.Fatalf("go: inconsistent vendoring in %s:%s\n\n\tTo ignore the vendor directory, use -mod=readonly or -mod=mod.\n\tTo sync the vendor directory, run:\n\t\tgo %s vendor", filepath.Dir(VendorDir(loaderstate)), vendErrors, subcmd)
}
}
// for -race and -msan.
modload.LoaderState.ForceUseModules = true
modload.LoaderState.RootMode = modload.NoRoot
- modload.AllowMissingModuleImports()
- modload.Init()
+ modload.AllowMissingModuleImports(modload.LoaderState)
+ modload.Init(modload.LoaderState)
} else {
- modload.InitWorkfile()
+ modload.InitWorkfile(modload.LoaderState)
}
- work.BuildInit()
+ work.BuildInit(modload.LoaderState)
b := work.NewBuilder("")
defer func() {
if err := b.Close(); err != nil {
base.Fatalf("go: cannot run *_test.go files (%s)", file)
}
}
- p = load.GoFilesPackage(ctx, pkgOpts, files)
+ p = load.GoFilesPackage(modload.LoaderState, ctx, pkgOpts, files)
} else if len(args) > 0 && !strings.HasPrefix(args[0], "-") {
arg := args[0]
var pkgs []*load.Package
if strings.Contains(arg, "@") && !build.IsLocalImport(arg) && !filepath.IsAbs(arg) {
var err error
- pkgs, err = load.PackagesAndErrorsOutsideModule(ctx, pkgOpts, args[:1])
+ pkgs, err = load.PackagesAndErrorsOutsideModule(modload.LoaderState, ctx, pkgOpts, args[:1])
if err != nil {
base.Fatal(err)
}
} else {
- pkgs = load.PackagesAndErrors(ctx, pkgOpts, args[:1])
+ pkgs = load.PackagesAndErrors(modload.LoaderState, ctx, pkgOpts, args[:1])
}
if len(pkgs) == 0 {
load.CheckPackageErrors([]*load.Package{p})
if cfg.BuildCover {
- load.PrepareForCoverageBuild([]*load.Package{p})
+ load.PrepareForCoverageBuild(modload.LoaderState, []*load.Package{p})
}
p.Internal.OmitDebug = true
p.Internal.ExeName = p.DefaultExecName()
}
- a1 := b.LinkAction(work.ModeBuild, work.ModeBuild, p)
+ a1 := b.LinkAction(modload.LoaderState, work.ModeBuild, work.ModeBuild, p)
a1.CacheExecutable = true
a := &work.Action{Mode: "go run", Actor: work.ActorFunc(buildRunProgram), Args: cmdArgs, Deps: []*work.Action{a1}}
b.Do(ctx, a)
func incrementConfig() {
if !modload.WillBeEnabled() {
counter.Inc("go/mode:gopath")
- } else if workfile := modload.FindGoWork(base.Cwd()); workfile != "" {
+ } else if workfile := modload.FindGoWork(modload.LoaderState, base.Cwd()); workfile != "" {
counter.Inc("go/mode:workspace")
} else {
counter.Inc("go/mode:module")
func runTest(ctx context.Context, cmd *base.Command, args []string) {
pkgArgs, testArgs = testFlags(args)
- modload.InitWorkfile() // The test command does custom flag processing; initialize workspaces after that.
+ modload.InitWorkfile(modload.LoaderState) // The test command does custom flag processing; initialize workspaces after that.
if cfg.DebugTrace != "" {
var close func() error
work.FindExecCmd() // initialize cached result
- work.BuildInit()
+ work.BuildInit(modload.LoaderState)
work.VetFlags = testVet.flags
work.VetExplicit = testVet.explicit
work.VetTool = base.Tool("vet")
pkgOpts := load.PackageOpts{ModResolveTests: true}
- pkgs = load.PackagesAndErrors(ctx, pkgOpts, pkgArgs)
+ pkgs = load.PackagesAndErrors(modload.LoaderState, ctx, pkgOpts, pkgArgs)
// We *don't* call load.CheckPackageErrors here because we want to report
// loading errors as per-package test setup errors later.
if len(pkgs) == 0 {
if !mainMods.Contains(m.Path) {
base.Fatalf("cannot use -fuzz flag on package outside the main module")
}
- } else if pkgs[0].Standard && modload.Enabled() {
+ } else if pkgs[0].Standard && modload.Enabled(modload.LoaderState) {
// Because packages in 'std' and 'cmd' are part of the standard library,
// they are only treated as part of a module in 'go mod' subcommands and
// 'go get'. However, we still don't want to accidentally corrupt their
if cfg.BuildCoverPkg != nil {
match := make([]func(*load.Package) bool, len(cfg.BuildCoverPkg))
for i := range cfg.BuildCoverPkg {
- match[i] = load.MatchPackage(cfg.BuildCoverPkg[i], base.Cwd())
+ match[i] = load.MatchPackage(modload.LoaderState, cfg.BuildCoverPkg[i], base.Cwd())
}
// Select for coverage all dependencies matching the -coverpkg
// patterns.
plist := load.TestPackageList(ctx, pkgOpts, pkgs)
- testCoverPkgs = load.SelectCoverPackages(plist, match, "test")
+ testCoverPkgs = load.SelectCoverPackages(modload.LoaderState, plist, match, "test")
if len(testCoverPkgs) > 0 {
// create a new singleton action that will collect up the
// meta-data files from all of the packages mentioned in
// happens we'll wind up building the Q compile action
// before updating its deps to include sync/atomic).
if cfg.BuildCoverMode == "atomic" && p.ImportPath != "sync/atomic" {
- load.EnsureImport(p, "sync/atomic")
+ load.EnsureImport(modload.LoaderState, p, "sync/atomic")
}
// Tag the package for static meta-data generation if no
// test files (this works only with the new coverage
}
}
- a := b.LinkAction(work.ModeBuild, work.ModeBuild, pmain)
+ a := b.LinkAction(modload.LoaderState, work.ModeBuild, work.ModeBuild, pmain)
a.Target = testDir + testBinary + cfg.ExeSuffix
if cfg.Goos == "windows" {
// There are many reserved words on Windows that,
fmt.Println(name)
}
- modload.InitWorkfile()
- modload.LoadModFile(ctx)
+ modload.InitWorkfile(modload.LoaderState)
+ modload.LoadModFile(modload.LoaderState, ctx)
modTools := slices.Sorted(maps.Keys(modload.LoaderState.MainModules.Tools()))
for _, tool := range modTools {
fmt.Println(tool)
}
func loadModTool(ctx context.Context, name string) string {
- modload.InitWorkfile()
- modload.LoadModFile(ctx)
+ modload.InitWorkfile(modload.LoaderState)
+ modload.LoadModFile(modload.LoaderState, ctx)
matches := []string{}
for tool := range modload.LoaderState.MainModules.Tools() {
}
func buildAndRunTool(ctx context.Context, tool string, args []string, runTool work.ActorFunc) {
- work.BuildInit()
+ work.BuildInit(modload.LoaderState)
b := work.NewBuilder("")
defer func() {
if err := b.Close(); err != nil {
}()
pkgOpts := load.PackageOpts{MainOnly: true}
- p := load.PackagesAndErrors(ctx, pkgOpts, []string{tool})[0]
+ p := load.PackagesAndErrors(modload.LoaderState, ctx, pkgOpts, []string{tool})[0]
p.Internal.OmitDebug = true
p.Internal.ExeName = p.DefaultExecName()
- a1 := b.LinkAction(work.ModeBuild, work.ModeBuild, p)
+ a1 := b.LinkAction(modload.LoaderState, work.ModeBuild, work.ModeBuild, p)
a1.CacheExecutable = true
a := &work.Action{Mode: "go tool", Actor: runTool, Args: args, Deps: []*work.Action{a1}}
b.Do(ctx, a)
modload.Reset()
modload.LoaderState.ForceUseModules = true
modload.LoaderState.RootMode = modload.NoRoot
- modload.Init()
+ modload.Init(modload.LoaderState)
// Download and unpack toolchain module into module cache.
// Note that multiple go commands might be doing this at the same time,
// The toolchain line overrides the version line
func modGoToolchain() (file, goVers, toolchain string) {
wd := base.UncachedCwd()
- file = modload.FindGoWork(wd)
+ file = modload.FindGoWork(modload.LoaderState, wd)
// $GOWORK can be set to a file that does not yet exist, if we are running 'go work init'.
// Do not try to load the file in that case
if _, err := os.Stat(file); err != nil {
// Set up modules without an explicit go.mod, to download go.mod.
modload.LoaderState.ForceUseModules = true
modload.LoaderState.RootMode = modload.NoRoot
- modload.Init()
+ modload.Init(modload.LoaderState)
defer modload.Reset()
// See internal/load.PackagesAndErrorsOutsideModule
allowed = nil
}
noneSelected := func(path string) (version string) { return "none" }
- _, err := modload.QueryPackages(ctx, path, version, noneSelected, allowed)
+ _, err := modload.QueryPackages(modload.LoaderState, ctx, path, version, noneSelected, allowed)
if errors.Is(err, gover.ErrTooNew) {
// Run early switch, same one go install or go run would eventually do,
// if it understood all the command-line flags.
// The vet/fix commands do custom flag processing;
// initialize workspaces after that.
- modload.InitWorkfile()
+ modload.InitWorkfile(modload.LoaderState)
if cfg.DebugTrace != "" {
var close func() error
ctx, span := trace.StartSpan(ctx, fmt.Sprint("Running ", cmd.Name(), " command"))
defer span.Done()
- work.BuildInit()
+ work.BuildInit(modload.LoaderState)
// Flag theory:
//
work.VetFlags = toolFlags
pkgOpts := load.PackageOpts{ModResolveTests: true}
- pkgs := load.PackagesAndErrors(ctx, pkgOpts, pkgArgs)
+ pkgs := load.PackagesAndErrors(modload.LoaderState, ctx, pkgOpts, pkgArgs)
load.CheckPackageErrors(pkgs)
if len(pkgs) == 0 {
base.Fatalf("no packages to %s", cmd.Name())
"cmd/go/internal/cache"
"cmd/go/internal/cfg"
"cmd/go/internal/load"
+ "cmd/go/internal/modload"
"cmd/go/internal/str"
"cmd/go/internal/trace"
"cmd/internal/buildid"
// at shlibpath. For the native toolchain this list is stored, newline separated, in
// an ELF note with name "Go\x00\x00" and type 1. For GCCGO it is extracted from the
// .go_export section.
-func readpkglist(shlibpath string) (pkgs []*load.Package) {
+func readpkglist(loaderstate *modload.State, shlibpath string) (pkgs []*load.Package) {
var stk load.ImportStack
if cfg.BuildToolchainName == "gccgo" {
f, err := elf.Open(shlibpath)
for _, line := range bytes.Split(data, []byte{'\n'}) {
if path, found := bytes.CutPrefix(line, pkgpath); found {
path = bytes.TrimSuffix(path, []byte{';'})
- pkgs = append(pkgs, load.LoadPackageWithFlags(string(path), base.Cwd(), &stk, nil, 0))
+ pkgs = append(pkgs, load.LoadPackageWithFlags(loaderstate, string(path), base.Cwd(), &stk, nil, 0))
}
}
} else {
scanner := bufio.NewScanner(bytes.NewBuffer(pkglistbytes))
for scanner.Scan() {
t := scanner.Text()
- pkgs = append(pkgs, load.LoadPackageWithFlags(t, base.Cwd(), &stk, nil, 0))
+ pkgs = append(pkgs, load.LoadPackageWithFlags(loaderstate, t, base.Cwd(), &stk, nil, 0))
}
}
return
// AutoAction returns the "right" action for go build or go install of p.
func (b *Builder) AutoAction(mode, depMode BuildMode, p *load.Package) *Action {
if p.Name == "main" {
- return b.LinkAction(mode, depMode, p)
+ return b.LinkAction(modload.LoaderState, mode, depMode, p)
}
return b.CompileAction(mode, depMode, p)
}
// LinkAction returns the action for linking p into an executable
// and possibly installing the result (according to mode).
// depMode is the action (build or install) to use when compiling dependencies.
-func (b *Builder) LinkAction(mode, depMode BuildMode, p *load.Package) *Action {
+func (b *Builder) LinkAction(loaderstate *modload.State, mode, depMode BuildMode, p *load.Package) *Action {
// Construct link action.
a := b.cacheAction("link", p, func() *Action {
a := &Action{
}
a.Target = a.Objdir + filepath.Join("exe", name) + cfg.ExeSuffix
a.built = a.Target
- b.addTransitiveLinkDeps(a, a1, "")
+ b.addTransitiveLinkDeps(loaderstate, a, a1, "")
// Sequence the build of the main package (a1) strictly after the build
// of all other dependencies that go into the link. It is likely to be after
// makes sure those are present in a.Deps.
// If shlib is non-empty, then a corresponds to the build and installation of shlib,
// so any rebuild of shlib should not be added as a dependency.
-func (b *Builder) addTransitiveLinkDeps(a, a1 *Action, shlib string) {
+func (b *Builder) addTransitiveLinkDeps(loaderstate *modload.State, a, a1 *Action, shlib string) {
// Expand Deps to include all built packages, for the linker.
// Use breadth-first search to find rebuilt-for-test packages
// before the standard ones.
// we'll end up building an overall library or executable that depends at runtime
// on other libraries that are out-of-date, which is clearly not good either.
// We call it ModeBuggyInstall to make clear that this is not right.
- a.Deps = append(a.Deps, b.linkSharedAction(ModeBuggyInstall, ModeBuggyInstall, p1.Shlib, nil))
+ a.Deps = append(a.Deps, b.linkSharedAction(loaderstate, ModeBuggyInstall, ModeBuggyInstall, p1.Shlib, nil))
}
}
}
if err != nil {
base.Fatalf("%v", err)
}
- return b.linkSharedAction(mode, depMode, name, a1)
+ return b.linkSharedAction(modload.LoaderState, mode, depMode, name, a1)
}
// linkSharedAction takes a grouping action a1 corresponding to a list of built packages
// and returns an action that links them together into a shared library with the name shlib.
// If a1 is nil, shlib should be an absolute path to an existing shared library,
// and then linkSharedAction reads that library to find out the package list.
-func (b *Builder) linkSharedAction(mode, depMode BuildMode, shlib string, a1 *Action) *Action {
+func (b *Builder) linkSharedAction(loaderstate *modload.State, mode, depMode BuildMode, shlib string, a1 *Action) *Action {
fullShlib := shlib
shlib = filepath.Base(shlib)
a := b.cacheAction("build-shlib "+shlib, nil, func() *Action {
if a1 == nil {
// TODO(rsc): Need to find some other place to store config,
// not in pkg directory. See golang.org/issue/22196.
- pkgs := readpkglist(fullShlib)
+ pkgs := readpkglist(loaderstate, fullShlib)
a1 = &Action{
Mode: "shlib packages",
}
}
}
var stk load.ImportStack
- p := load.LoadPackageWithFlags(pkg, base.Cwd(), &stk, nil, 0)
+ p := load.LoadPackageWithFlags(loaderstate, pkg, base.Cwd(), &stk, nil, 0)
if p.Error != nil {
base.Fatalf("load %s: %v", pkg, p.Error)
}
add(a, dep, true)
}
}
- b.addTransitiveLinkDeps(a, a1, shlib)
+ b.addTransitiveLinkDeps(loaderstate, a, a1, shlib)
return a
})
var pkgsFilter = func(pkgs []*load.Package) []*load.Package { return pkgs }
func runBuild(ctx context.Context, cmd *base.Command, args []string) {
- modload.InitWorkfile()
- BuildInit()
+ modload.InitWorkfile(modload.LoaderState)
+ BuildInit(modload.LoaderState)
b := NewBuilder("")
defer func() {
if err := b.Close(); err != nil {
}
}()
- pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{AutoVCS: true}, args)
+ pkgs := load.PackagesAndErrors(modload.LoaderState, ctx, load.PackageOpts{AutoVCS: true}, args)
load.CheckPackageErrors(pkgs)
explicitO := len(cfg.BuildO) > 0
}
if cfg.BuildCover {
- load.PrepareForCoverageBuild(pkgs)
+ load.PrepareForCoverageBuild(modload.LoaderState, pkgs)
}
if cfg.BuildO != "" {
}
}
- modload.InitWorkfile()
- BuildInit()
- pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{AutoVCS: true}, args)
- if cfg.ModulesEnabled && !modload.HasModRoot() {
+ modload.InitWorkfile(modload.LoaderState)
+ BuildInit(modload.LoaderState)
+ pkgs := load.PackagesAndErrors(modload.LoaderState, ctx, load.PackageOpts{AutoVCS: true}, args)
+ if cfg.ModulesEnabled && !modload.HasModRoot(modload.LoaderState) {
haveErrors := false
allMissingErrors := true
for _, pkg := range pkgs {
load.CheckPackageErrors(pkgs)
if cfg.BuildCover {
- load.PrepareForCoverageBuild(pkgs)
+ load.PrepareForCoverageBuild(modload.LoaderState, pkgs)
}
InstallPackages(ctx, args, pkgs)
func installOutsideModule(ctx context.Context, args []string) {
modload.LoaderState.ForceUseModules = true
modload.LoaderState.RootMode = modload.NoRoot
- modload.AllowMissingModuleImports()
- modload.Init()
- BuildInit()
+ modload.AllowMissingModuleImports(modload.LoaderState)
+ modload.Init(modload.LoaderState)
+ BuildInit(modload.LoaderState)
// Load packages. Ignore non-main packages.
// Print a warning if an argument contains "..." and matches no main packages.
// TODO(golang.org/issue/40276): don't report errors loading non-main packages
// matched by a pattern.
pkgOpts := load.PackageOpts{MainOnly: true}
- pkgs, err := load.PackagesAndErrorsOutsideModule(ctx, pkgOpts, args)
+ pkgs, err := load.PackagesAndErrorsOutsideModule(modload.LoaderState, ctx, pkgOpts, args)
if err != nil {
base.Fatal(err)
}
// gcc runs the gcc C compiler to create an object from a single C file.
func (b *Builder) gcc(a *Action, workdir, out string, flags []string, cfile string) error {
p := a.Package
- return b.ccompile(a, out, flags, cfile, b.GccCmd(p.Dir, workdir))
+ return b.ccompile(modload.LoaderState, a, out, flags, cfile, b.GccCmd(p.Dir, workdir))
}
// gas runs the gcc c compiler to create an object file from a single C assembly file.
return fmt.Errorf("package using cgo has Go assembly file %s", sfile)
}
}
- return b.ccompile(a, out, flags, sfile, b.GccCmd(p.Dir, workdir))
+ return b.ccompile(modload.LoaderState, a, out, flags, sfile, b.GccCmd(p.Dir, workdir))
}
// gxx runs the g++ C++ compiler to create an object from a single C++ file.
func (b *Builder) gxx(a *Action, workdir, out string, flags []string, cxxfile string) error {
p := a.Package
- return b.ccompile(a, out, flags, cxxfile, b.GxxCmd(p.Dir, workdir))
+ return b.ccompile(modload.LoaderState, a, out, flags, cxxfile, b.GxxCmd(p.Dir, workdir))
}
// gfortran runs the gfortran Fortran compiler to create an object from a single Fortran file.
func (b *Builder) gfortran(a *Action, workdir, out string, flags []string, ffile string) error {
p := a.Package
- return b.ccompile(a, out, flags, ffile, b.gfortranCmd(p.Dir, workdir))
+ return b.ccompile(modload.LoaderState, a, out, flags, ffile, b.gfortranCmd(p.Dir, workdir))
}
// ccompile runs the given C or C++ compiler and creates an object from a single source file.
-func (b *Builder) ccompile(a *Action, outfile string, flags []string, file string, compiler []string) error {
+func (b *Builder) ccompile(loaderstate *modload.State, a *Action, outfile string, flags []string, file string, compiler []string) error {
p := a.Package
sh := b.Shell(a)
file = mkAbs(p.Dir, file)
} else if m.Dir == "" {
// The module is in the vendor directory. Replace the entire vendor
// directory path, because the module's Dir is not filled in.
- from = modload.VendorDir()
+ from = modload.VendorDir(loaderstate)
toPath = "vendor"
} else {
from = m.Dir
}
}
if len(newFlags) < len(flags) {
- return b.ccompile(a, outfile, newFlags, file, compiler)
+ return b.ccompile(loaderstate, a, outfile, newFlags, file, compiler)
}
}
}
srcs := []string{src}
- p := load.GoFilesPackage(context.TODO(), load.PackageOpts{}, srcs)
+ p := load.GoFilesPackage(modload.LoaderState, context.TODO(), load.PackageOpts{}, srcs)
if _, _, e := BuildToolchain.gc(b, &Action{Mode: "swigDoIntSize", Package: p, Objdir: objdir}, "", nil, nil, "", false, "", srcs); e != nil {
return "32", nil
return slices.Clip(env)
}
-func BuildInit() {
+func BuildInit(loaderstate *modload.State) {
if buildInitStarted {
base.Fatalf("go: internal error: work.BuildInit called more than once")
}
buildInitStarted = true
base.AtExit(closeBuilders)
- modload.Init()
+ modload.Init(loaderstate)
instrumentInit()
buildModeInit()
cfgChangedEnv = makeCfgChangedEnv()
if len(args) == 1 {
gowork = args[0]
} else {
- modload.InitWorkfile()
- gowork = modload.WorkFilePath()
+ modload.InitWorkfile(modload.LoaderState)
+ gowork = modload.WorkFilePath(modload.LoaderState)
}
if gowork == "" {
base.Fatalf("go: no go.work file found\n\t(run 'go work init' first or specify path using GOWORK environment variable)")
}
func runInit(ctx context.Context, cmd *base.Command, args []string) {
- modload.InitWorkfile()
+ modload.InitWorkfile(modload.LoaderState)
modload.LoaderState.ForceUseModules = true
- gowork := modload.WorkFilePath()
+ gowork := modload.WorkFilePath(modload.LoaderState)
if gowork == "" {
gowork = filepath.Join(base.Cwd(), "go.work")
}
func runSync(ctx context.Context, cmd *base.Command, args []string) {
modload.LoaderState.ForceUseModules = true
- modload.InitWorkfile()
- if modload.WorkFilePath() == "" {
+ modload.InitWorkfile(modload.LoaderState)
+ if modload.WorkFilePath(modload.LoaderState) == "" {
base.Fatalf("go: no go.work file found\n\t(run 'go work init' first or specify path using GOWORK environment variable)")
}
}
for _, m := range mms.Versions() {
opts.MainModule = m
- _, pkgs := modload.LoadPackages(ctx, opts, "all")
+ _, pkgs := modload.LoadPackages(modload.LoaderState, ctx, opts, "all")
opts.MainModule = module.Version{} // reset
var (
mustSelectFor[m] = mustSelect
}
- workFilePath := modload.WorkFilePath() // save go.work path because EnterModule clobbers it.
+ workFilePath := modload.WorkFilePath(modload.LoaderState) // save go.work path because EnterModule clobbers it.
var goV string
for _, m := range mms.Versions() {
// so we don't write some go.mods with the "before" toolchain
// and others with the "after" toolchain. If nothing else, that
// discrepancy could show up in auto-recorded toolchain lines.
- changed, err := modload.EditBuildList(ctx, nil, mustSelectFor[m])
+ changed, err := modload.EditBuildList(modload.LoaderState, ctx, nil, mustSelectFor[m])
if err != nil {
continue
}
if changed {
- modload.LoadPackages(ctx, modload.PackageOpts{
+ modload.LoadPackages(modload.LoaderState, ctx, modload.PackageOpts{
Tags: imports.AnyTags(),
Tidy: true,
VendorModulesInGOROOTSrc: true,
}, "all")
modload.WriteGoMod(ctx, modload.WriteOpts{})
}
- goV = gover.Max(goV, modload.LoaderState.MainModules.GoVersion())
+ goV = gover.Max(goV, modload.LoaderState.MainModules.GoVersion(modload.LoaderState))
}
wf, err := modload.ReadWorkFile(workFilePath)
func runUse(ctx context.Context, cmd *base.Command, args []string) {
modload.LoaderState.ForceUseModules = true
- modload.InitWorkfile()
- gowork := modload.WorkFilePath()
+ modload.InitWorkfile(modload.LoaderState)
+ gowork := modload.WorkFilePath(modload.LoaderState)
if gowork == "" {
base.Fatalf("go: no go.work file found\n\t(run 'go work init' first or specify path using GOWORK environment variable)")
}
}
func runVendor(ctx context.Context, cmd *base.Command, args []string) {
- modload.InitWorkfile()
- if modload.WorkFilePath() == "" {
+ modload.InitWorkfile(modload.LoaderState)
+ if modload.WorkFilePath(modload.LoaderState) == "" {
base.Fatalf("go: no go.work file found\n\t(run 'go work init' first or specify path using GOWORK environment variable)")
}