func printGoEnv(loaderstate *modload.State, w io.Writer) {
env := envcmd.MkEnv()
env = append(env, envcmd.ExtraEnvVars(loaderstate)...)
- env = append(env, envcmd.ExtraEnvVarsCostly()...)
+ env = append(env, envcmd.ExtraEnvVarsCostly(loaderstate)...)
envcmd.PrintEnv(w, env, false)
}
// ExtraEnvVarsCostly returns environment variables that should not leak into child processes
// but are costly to evaluate.
-func ExtraEnvVarsCostly() []cfg.EnvVar {
- b := work.NewBuilder("")
+func ExtraEnvVarsCostly(loaderstate *modload.State) []cfg.EnvVar {
+ b := work.NewBuilder("", loaderstate.VendorDirOrEmpty)
defer func() {
if err := b.Close(); err != nil {
base.Fatal(err)
}
if needCostly {
work.BuildInit(modload.LoaderState)
- env = append(env, ExtraEnvVarsCostly()...)
+ env = append(env, ExtraEnvVarsCostly(modload.LoaderState)...)
}
if len(args) > 0 {
// Do we need to run a build to gather information?
needStale := (listJson && listJsonFields.needAny("Stale", "StaleReason")) || strings.Contains(*listFmt, ".Stale")
if needStale || *listExport || *listCompiled {
- b := work.NewBuilder("")
+ b := work.NewBuilder("", modload.LoaderState.VendorDirOrEmpty)
if *listE {
b.AllowErrors = true
}
}
func (mms *MainModuleSet) mustGetSingleMainModule(loaderstate *State) module.Version {
+ mm, err := mms.getSingleMainModule(loaderstate)
+ if err != nil {
+ panic(err)
+ }
+ return mm
+}
+
+func (mms *MainModuleSet) getSingleMainModule(loaderstate *State) (module.Version, error) {
if mms == nil || len(mms.versions) == 0 {
- panic("internal error: mustGetSingleMainModule called in context with no main modules")
+ return module.Version{}, errors.New("internal error: mustGetSingleMainModule called in context with no main modules")
}
if len(mms.versions) != 1 {
if inWorkspaceMode(loaderstate) {
- panic("internal error: mustGetSingleMainModule called in workspace mode")
+ return module.Version{}, errors.New("internal error: mustGetSingleMainModule called in workspace mode")
} else {
- panic("internal error: multiple main modules present outside of workspace mode")
+ return module.Version{}, errors.New("internal error: multiple main modules present outside of workspace mode")
}
}
- return mms.versions[0]
+ return mms.versions[0], nil
}
func (mms *MainModuleSet) GetSingleIndexOrNil(loaderstate *State) *modFileIndex {
return loaderstate.modRoots != nil || cfg.ModulesEnabled
}
-func VendorDir(loaderstate *State) string {
- if inWorkspaceMode(loaderstate) {
- return filepath.Join(filepath.Dir(WorkFilePath(loaderstate)), "vendor")
+func (s *State) vendorDir() (string, error) {
+ if inWorkspaceMode(s) {
+ return filepath.Join(filepath.Dir(WorkFilePath(s)), "vendor"), nil
+ }
+ mainModule, err := s.MainModules.getSingleMainModule(s)
+ if err != nil {
+ return "", err
}
// 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(loaderstate))
+ modRoot := s.MainModules.ModRoot(mainModule)
if modRoot == "" {
- panic("vendor directory does not exist when in single module mode outside of a module")
+ return "", errors.New("vendor directory does not exist when in single module mode outside of a module")
+ }
+ return filepath.Join(modRoot, "vendor"), nil
+}
+
+func (s *State) VendorDirOrEmpty() string {
+ dir, err := s.vendorDir()
+ if err != nil {
+ return ""
+ }
+ return dir
+}
+
+func VendorDir(loaderstate *State) string {
+ dir, err := loaderstate.vendorDir()
+ if err != nil {
+ panic(err)
}
- return filepath.Join(modRoot, "vendor")
+ return dir
}
func inWorkspaceMode(loaderstate *State) bool {
}
work.BuildInit(modload.LoaderState)
- b := work.NewBuilder("")
+ b := work.NewBuilder("", modload.LoaderState.VendorDirOrEmpty)
defer func() {
if err := b.Close(); err != nil {
base.Fatal(err)
}
}
- b := work.NewBuilder("")
+ b := work.NewBuilder("", modload.LoaderState.VendorDirOrEmpty)
defer func() {
if err := b.Close(); err != nil {
base.Fatal(err)
func buildAndRunTool(loaderstate *modload.State, ctx context.Context, tool string, args []string, runTool work.ActorFunc) {
work.BuildInit(loaderstate)
- b := work.NewBuilder("")
+ b := work.NewBuilder("", loaderstate.VendorDirOrEmpty)
defer func() {
if err := b.Close(); err != nil {
base.Fatal(err)
base.Fatalf("no packages to %s", cmd.Name())
}
- b := work.NewBuilder("")
+ b := work.NewBuilder("", modload.LoaderState.VendorDirOrEmpty)
defer func() {
if err := b.Close(); err != nil {
base.Fatal(err)
// build packages in parallel, and the builder is shared.
type Builder struct {
WorkDir string // the temporary work directory (ends in filepath.Separator)
+ getVendorDir func() string // TODO(jitsu): remove this after we eliminate global module state
actionCache map[cacheKey]*Action // a cache of already-constructed actions
flagCache map[[2]string]bool // a cache of supported compiler flags
gccCompilerIDCache map[string]cache.ActionID // cache for gccCompilerID
// and arranges for it to be removed in case of an unclean exit.
// The caller must Close the builder explicitly to clean up the WorkDir
// before a clean exit.
-func NewBuilder(workDir string) *Builder {
+func NewBuilder(workDir string, getVendorDir func() string) *Builder {
b := new(Builder)
+ b.getVendorDir = getVendorDir
b.actionCache = make(map[cacheKey]*Action)
b.gccToolIDCache = make(map[string]string)
func runBuild(ctx context.Context, cmd *base.Command, args []string) {
modload.InitWorkfile(modload.LoaderState)
BuildInit(modload.LoaderState)
- b := NewBuilder("")
+ b := NewBuilder("", modload.LoaderState.VendorDirOrEmpty)
defer func() {
if err := b.Close(); err != nil {
base.Fatal(err)
}
base.ExitIfErrors()
- b := NewBuilder("")
+ b := NewBuilder("", loaderstate.VendorDirOrEmpty)
defer func() {
if err := b.Close(); err != nil {
base.Fatal(err)
} 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(loaderstate)
+ from = b.getVendorDir()
toPath = "vendor"
} else {
from = m.Dir
}
srcs := []string{src}
- p := load.GoFilesPackage(modload.LoaderState, context.TODO(), load.PackageOpts{}, srcs)
+ p := load.GoFilesPackage(modload.NewState(), 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
Args: "args...",
},
func(s *script.State, args ...string) (script.WaitFunc, error) {
- b := work.NewBuilder(s.Getwd())
+ fakeVendorDirProvider := func() string { return "" }
+ b := work.NewBuilder(s.Getwd(), fakeVendorDirProvider)
wait, err := cmdExec.Run(s, append(b.GccCmd(".", ""), args...)...)
if err != nil {
return wait, err