1
2
3
4
5
6 package list
7
8 import (
9 "bufio"
10 "bytes"
11 "context"
12 "encoding/json"
13 "errors"
14 "fmt"
15 "io"
16 "os"
17 "reflect"
18 "runtime"
19 "sort"
20 "strconv"
21 "strings"
22 "sync"
23 "text/template"
24
25 "golang.org/x/sync/semaphore"
26
27 "cmd/go/internal/base"
28 "cmd/go/internal/cache"
29 "cmd/go/internal/cfg"
30 "cmd/go/internal/load"
31 "cmd/go/internal/modinfo"
32 "cmd/go/internal/modload"
33 "cmd/go/internal/str"
34 "cmd/go/internal/work"
35 )
36
37 var CmdList = &base.Command{
38
39
40 UsageLine: "go list [-f format] [-json] [-m] [list flags] [build flags] [packages]",
41 Short: "list packages or modules",
42 Long: `
43 List lists the named packages, one per line.
44 The most commonly-used flags are -f and -json, which control the form
45 of the output printed for each package. Other list flags, documented below,
46 control more specific details.
47
48 The default output shows the package import path:
49
50 bytes
51 encoding/json
52 github.com/gorilla/mux
53 golang.org/x/net/html
54
55 The -f flag specifies an alternate format for the list, using the
56 syntax of package template. The default output is equivalent
57 to -f '{{.ImportPath}}'. The struct being passed to the template is:
58
59 type Package struct {
60 Dir string // directory containing package sources
61 ImportPath string // import path of package in dir
62 ImportComment string // path in import comment on package statement
63 Name string // package name
64 Doc string // package documentation string
65 Target string // install path
66 Shlib string // the shared library that contains this package (only set when -linkshared)
67 Goroot bool // is this package in the Go root?
68 Standard bool // is this package part of the standard Go library?
69 Stale bool // would 'go install' do anything for this package?
70 StaleReason string // explanation for Stale==true
71 Root string // Go root or Go path dir containing this package
72 ConflictDir string // this directory shadows Dir in $GOPATH
73 BinaryOnly bool // binary-only package (no longer supported)
74 ForTest string // package is only for use in named test
75 Export string // file containing export data (when using -export)
76 BuildID string // build ID of the compiled package (when using -export)
77 Module *Module // info about package's containing module, if any (can be nil)
78 Match []string // command-line patterns matching this package
79 DepOnly bool // package is only a dependency, not explicitly listed
80 DefaultGODEBUG string // default GODEBUG setting, for main packages
81
82 // Source files
83 GoFiles []string // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles)
84 CgoFiles []string // .go source files that import "C"
85 CompiledGoFiles []string // .go files presented to compiler (when using -compiled)
86 IgnoredGoFiles []string // .go source files ignored due to build constraints
87 IgnoredOtherFiles []string // non-.go source files ignored due to build constraints
88 CFiles []string // .c source files
89 CXXFiles []string // .cc, .cxx and .cpp source files
90 MFiles []string // .m source files
91 HFiles []string // .h, .hh, .hpp and .hxx source files
92 FFiles []string // .f, .F, .for and .f90 Fortran source files
93 SFiles []string // .s source files
94 SwigFiles []string // .swig files
95 SwigCXXFiles []string // .swigcxx files
96 SysoFiles []string // .syso object files to add to archive
97 TestGoFiles []string // _test.go files in package
98 XTestGoFiles []string // _test.go files outside package
99
100 // Embedded files
101 EmbedPatterns []string // //go:embed patterns
102 EmbedFiles []string // files matched by EmbedPatterns
103 TestEmbedPatterns []string // //go:embed patterns in TestGoFiles
104 TestEmbedFiles []string // files matched by TestEmbedPatterns
105 XTestEmbedPatterns []string // //go:embed patterns in XTestGoFiles
106 XTestEmbedFiles []string // files matched by XTestEmbedPatterns
107
108 // Cgo directives
109 CgoCFLAGS []string // cgo: flags for C compiler
110 CgoCPPFLAGS []string // cgo: flags for C preprocessor
111 CgoCXXFLAGS []string // cgo: flags for C++ compiler
112 CgoFFLAGS []string // cgo: flags for Fortran compiler
113 CgoLDFLAGS []string // cgo: flags for linker
114 CgoPkgConfig []string // cgo: pkg-config names
115
116 // Dependency information
117 Imports []string // import paths used by this package
118 ImportMap map[string]string // map from source import to ImportPath (identity entries omitted)
119 Deps []string // all (recursively) imported dependencies
120 TestImports []string // imports from TestGoFiles
121 XTestImports []string // imports from XTestGoFiles
122
123 // Error information
124 Incomplete bool // this package or a dependency has an error
125 Error *PackageError // error loading package
126 DepsErrors []*PackageError // errors loading dependencies
127 }
128
129 Packages stored in vendor directories report an ImportPath that includes the
130 path to the vendor directory (for example, "d/vendor/p" instead of "p"),
131 so that the ImportPath uniquely identifies a given copy of a package.
132 The Imports, Deps, TestImports, and XTestImports lists also contain these
133 expanded import paths. See golang.org/s/go15vendor for more about vendoring.
134
135 The error information, if any, is
136
137 type PackageError struct {
138 ImportStack []string // shortest path from package named on command line to this one
139 Pos string // position of error (if present, file:line:col)
140 Err string // the error itself
141 }
142
143 The module information is a Module struct, defined in the discussion
144 of list -m below.
145
146 The template function "join" calls strings.Join.
147
148 The template function "context" returns the build context, defined as:
149
150 type Context struct {
151 GOARCH string // target architecture
152 GOOS string // target operating system
153 GOROOT string // Go root
154 GOPATH string // Go path
155 CgoEnabled bool // whether cgo can be used
156 UseAllFiles bool // use files regardless of //go:build lines, file names
157 Compiler string // compiler to assume when computing target paths
158 BuildTags []string // build constraints to match in //go:build lines
159 ToolTags []string // toolchain-specific build constraints
160 ReleaseTags []string // releases the current release is compatible with
161 InstallSuffix string // suffix to use in the name of the install dir
162 }
163
164 For more information about the meaning of these fields see the documentation
165 for the go/build package's Context type.
166
167 The -json flag causes the package data to be printed in JSON format
168 instead of using the template format. The JSON flag can optionally be
169 provided with a set of comma-separated required field names to be output.
170 If so, those required fields will always appear in JSON output, but
171 others may be omitted to save work in computing the JSON struct.
172
173 The -compiled flag causes list to set CompiledGoFiles to the Go source
174 files presented to the compiler. Typically this means that it repeats
175 the files listed in GoFiles and then also adds the Go code generated
176 by processing CgoFiles and SwigFiles. The Imports list contains the
177 union of all imports from both GoFiles and CompiledGoFiles.
178
179 The -deps flag causes list to iterate over not just the named packages
180 but also all their dependencies. It visits them in a depth-first post-order
181 traversal, so that a package is listed only after all its dependencies.
182 Packages not explicitly listed on the command line will have the DepOnly
183 field set to true.
184
185 The -e flag changes the handling of erroneous packages, those that
186 cannot be found or are malformed. By default, the list command
187 prints an error to standard error for each erroneous package and
188 omits the packages from consideration during the usual printing.
189 With the -e flag, the list command never prints errors to standard
190 error and instead processes the erroneous packages with the usual
191 printing. Erroneous packages will have a non-empty ImportPath and
192 a non-nil Error field; other information may or may not be missing
193 (zeroed).
194
195 The -export flag causes list to set the Export field to the name of a
196 file containing up-to-date export information for the given package,
197 and the BuildID field to the build ID of the compiled package.
198
199 The -find flag causes list to identify the named packages but not
200 resolve their dependencies: the Imports and Deps lists will be empty.
201 With the -find flag, the -deps, -test and -export commands cannot be
202 used.
203
204 The -test flag causes list to report not only the named packages
205 but also their test binaries (for packages with tests), to convey to
206 source code analysis tools exactly how test binaries are constructed.
207 The reported import path for a test binary is the import path of
208 the package followed by a ".test" suffix, as in "math/rand.test".
209 When building a test, it is sometimes necessary to rebuild certain
210 dependencies specially for that test (most commonly the tested
211 package itself). The reported import path of a package recompiled
212 for a particular test binary is followed by a space and the name of
213 the test binary in brackets, as in "math/rand [math/rand.test]"
214 or "regexp [sort.test]". The ForTest field is also set to the name
215 of the package being tested ("math/rand" or "sort" in the previous
216 examples).
217
218 The Dir, Target, Shlib, Root, ConflictDir, and Export file paths
219 are all absolute paths.
220
221 By default, the lists GoFiles, CgoFiles, and so on hold names of files in Dir
222 (that is, paths relative to Dir, not absolute paths).
223 The generated files added when using the -compiled and -test flags
224 are absolute paths referring to cached copies of generated Go source files.
225 Although they are Go source files, the paths may not end in ".go".
226
227 The -m flag causes list to list modules instead of packages.
228
229 When listing modules, the -f flag still specifies a format template
230 applied to a Go struct, but now a Module struct:
231
232 type Module struct {
233 Path string // module path
234 Query string // version query corresponding to this version
235 Version string // module version
236 Versions []string // available module versions
237 Replace *Module // replaced by this module
238 Time *time.Time // time version was created
239 Update *Module // available update (with -u)
240 Main bool // is this the main module?
241 Indirect bool // module is only indirectly needed by main module
242 Dir string // directory holding local copy of files, if any
243 GoMod string // path to go.mod file describing module, if any
244 GoVersion string // go version used in module
245 Retracted []string // retraction information, if any (with -retracted or -u)
246 Deprecated string // deprecation message, if any (with -u)
247 Error *ModuleError // error loading module
248 Sum string // checksum for path, version (as in go.sum)
249 GoModSum string // checksum for go.mod (as in go.sum)
250 Origin any // provenance of module
251 Reuse bool // reuse of old module info is safe
252 }
253
254 type ModuleError struct {
255 Err string // the error itself
256 }
257
258 The file GoMod refers to may be outside the module directory if the
259 module is in the module cache or if the -modfile flag is used.
260
261 The default output is to print the module path and then
262 information about the version and replacement if any.
263 For example, 'go list -m all' might print:
264
265 my/main/module
266 golang.org/x/text v0.3.0 => /tmp/text
267 rsc.io/pdf v0.1.1
268
269 The Module struct has a String method that formats this
270 line of output, so that the default format is equivalent
271 to -f '{{.String}}'.
272
273 Note that when a module has been replaced, its Replace field
274 describes the replacement module, and its Dir field is set to
275 the replacement's source code, if present. (That is, if Replace
276 is non-nil, then Dir is set to Replace.Dir, with no access to
277 the replaced source code.)
278
279 The -u flag adds information about available upgrades.
280 When the latest version of a given module is newer than
281 the current one, list -u sets the Module's Update field
282 to information about the newer module. list -u will also set
283 the module's Retracted field if the current version is retracted.
284 The Module's String method indicates an available upgrade by
285 formatting the newer version in brackets after the current version.
286 If a version is retracted, the string "(retracted)" will follow it.
287 For example, 'go list -m -u all' might print:
288
289 my/main/module
290 golang.org/x/text v0.3.0 [v0.4.0] => /tmp/text
291 rsc.io/pdf v0.1.1 (retracted) [v0.1.2]
292
293 (For tools, 'go list -m -u -json all' may be more convenient to parse.)
294
295 The -versions flag causes list to set the Module's Versions field
296 to a list of all known versions of that module, ordered according
297 to semantic versioning, earliest to latest. The flag also changes
298 the default output format to display the module path followed by the
299 space-separated version list.
300
301 The -retracted flag causes list to report information about retracted
302 module versions. When -retracted is used with -f or -json, the Retracted
303 field will be set to a string explaining why the version was retracted.
304 The string is taken from comments on the retract directive in the
305 module's go.mod file. When -retracted is used with -versions, retracted
306 versions are listed together with unretracted versions. The -retracted
307 flag may be used with or without -m.
308
309 The arguments to list -m are interpreted as a list of modules, not packages.
310 The main module is the module containing the current directory.
311 The active modules are the main module and its dependencies.
312 With no arguments, list -m shows the main module.
313 With arguments, list -m shows the modules specified by the arguments.
314 Any of the active modules can be specified by its module path.
315 The special pattern "all" specifies all the active modules, first the main
316 module and then dependencies sorted by module path.
317 A pattern containing "..." specifies the active modules whose
318 module paths match the pattern.
319 A query of the form path@version specifies the result of that query,
320 which is not limited to active modules.
321 See 'go help modules' for more about module queries.
322
323 The template function "module" takes a single string argument
324 that must be a module path or query and returns the specified
325 module as a Module struct. If an error occurs, the result will
326 be a Module struct with a non-nil Error field.
327
328 When using -m, the -reuse=old.json flag accepts the name of file containing
329 the JSON output of a previous 'go list -m -json' invocation with the
330 same set of modifier flags (such as -u, -retracted, and -versions).
331 The go command may use this file to determine that a module is unchanged
332 since the previous invocation and avoid redownloading information about it.
333 Modules that are not redownloaded will be marked in the new output by
334 setting the Reuse field to true. Normally the module cache provides this
335 kind of reuse automatically; the -reuse flag can be useful on systems that
336 do not preserve the module cache.
337
338 For more about build flags, see 'go help build'.
339
340 For more about specifying packages, see 'go help packages'.
341
342 For more about modules, see https://golang.org/ref/mod.
343 `,
344 }
345
346 func init() {
347 CmdList.Run = runList
348
349 work.AddBuildFlags(CmdList, work.OmitJSONFlag)
350 if cfg.Experiment != nil && cfg.Experiment.CoverageRedesign {
351 work.AddCoverFlags(CmdList, nil)
352 }
353 CmdList.Flag.Var(&listJsonFields, "json", "")
354 }
355
356 var (
357 listCompiled = CmdList.Flag.Bool("compiled", false, "")
358 listDeps = CmdList.Flag.Bool("deps", false, "")
359 listE = CmdList.Flag.Bool("e", false, "")
360 listExport = CmdList.Flag.Bool("export", false, "")
361 listFmt = CmdList.Flag.String("f", "", "")
362 listFind = CmdList.Flag.Bool("find", false, "")
363 listJson bool
364 listJsonFields jsonFlag
365 listM = CmdList.Flag.Bool("m", false, "")
366 listRetracted = CmdList.Flag.Bool("retracted", false, "")
367 listReuse = CmdList.Flag.String("reuse", "", "")
368 listTest = CmdList.Flag.Bool("test", false, "")
369 listU = CmdList.Flag.Bool("u", false, "")
370 listVersions = CmdList.Flag.Bool("versions", false, "")
371 )
372
373
374
375 type jsonFlag map[string]bool
376
377 func (v *jsonFlag) Set(s string) error {
378 if v, err := strconv.ParseBool(s); err == nil {
379 listJson = v
380 return nil
381 }
382 listJson = true
383 if *v == nil {
384 *v = make(map[string]bool)
385 }
386 for _, f := range strings.Split(s, ",") {
387 (*v)[f] = true
388 }
389 return nil
390 }
391
392 func (v *jsonFlag) String() string {
393 fields := make([]string, 0, len(*v))
394 for f := range *v {
395 fields = append(fields, f)
396 }
397 sort.Strings(fields)
398 return strings.Join(fields, ",")
399 }
400
401 func (v *jsonFlag) IsBoolFlag() bool {
402 return true
403 }
404
405 func (v *jsonFlag) needAll() bool {
406 return len(*v) == 0
407 }
408
409 func (v *jsonFlag) needAny(fields ...string) bool {
410 if v.needAll() {
411 return true
412 }
413 for _, f := range fields {
414 if (*v)[f] {
415 return true
416 }
417 }
418 return false
419 }
420
421 var nl = []byte{'\n'}
422
423 func runList(ctx context.Context, cmd *base.Command, args []string) {
424 modload.InitWorkfile()
425
426 if *listFmt != "" && listJson {
427 base.Fatalf("go list -f cannot be used with -json")
428 }
429 if *listReuse != "" && !*listM {
430 base.Fatalf("go list -reuse cannot be used without -m")
431 }
432 if *listReuse != "" && modload.HasModRoot() {
433 base.Fatalf("go list -reuse cannot be used inside a module")
434 }
435
436 work.BuildInit()
437 out := newTrackingWriter(os.Stdout)
438 defer out.w.Flush()
439
440 if *listFmt == "" {
441 if *listM {
442 *listFmt = "{{.String}}"
443 if *listVersions {
444 *listFmt = `{{.Path}}{{range .Versions}} {{.}}{{end}}{{if .Deprecated}} (deprecated){{end}}`
445 }
446 } else {
447 *listFmt = "{{.ImportPath}}"
448 }
449 }
450
451 var do func(x any)
452 if listJson {
453 do = func(x any) {
454 if !listJsonFields.needAll() {
455
456 v := reflect.New(reflect.TypeOf(x).Elem()).Elem()
457 v.Set(reflect.ValueOf(x).Elem())
458 for i := 0; i < v.NumField(); i++ {
459 if !listJsonFields.needAny(v.Type().Field(i).Name) {
460 v.Field(i).SetZero()
461 }
462 }
463 x = v.Interface()
464 }
465 b, err := json.MarshalIndent(x, "", "\t")
466 if err != nil {
467 out.Flush()
468 base.Fatalf("%s", err)
469 }
470 out.Write(b)
471 out.Write(nl)
472 }
473 } else {
474 var cachedCtxt *Context
475 context := func() *Context {
476 if cachedCtxt == nil {
477 cachedCtxt = newContext(&cfg.BuildContext)
478 }
479 return cachedCtxt
480 }
481 fm := template.FuncMap{
482 "join": strings.Join,
483 "context": context,
484 "module": func(path string) *modinfo.ModulePublic { return modload.ModuleInfo(ctx, path) },
485 }
486 tmpl, err := template.New("main").Funcs(fm).Parse(*listFmt)
487 if err != nil {
488 base.Fatalf("%s", err)
489 }
490 do = func(x any) {
491 if err := tmpl.Execute(out, x); err != nil {
492 out.Flush()
493 base.Fatalf("%s", err)
494 }
495 if out.NeedNL() {
496 out.Write(nl)
497 }
498 }
499 }
500
501 modload.Init()
502 if *listRetracted {
503 if cfg.BuildMod == "vendor" {
504 base.Fatalf("go list -retracted cannot be used when vendoring is enabled")
505 }
506 if !modload.Enabled() {
507 base.Fatalf("go list -retracted can only be used in module-aware mode")
508 }
509 }
510
511 if *listM {
512
513 if *listCompiled {
514 base.Fatalf("go list -compiled cannot be used with -m")
515 }
516 if *listDeps {
517
518 base.Fatalf("go list -deps cannot be used with -m")
519 }
520 if *listExport {
521 base.Fatalf("go list -export cannot be used with -m")
522 }
523 if *listFind {
524 base.Fatalf("go list -find cannot be used with -m")
525 }
526 if *listTest {
527 base.Fatalf("go list -test cannot be used with -m")
528 }
529
530 if modload.Init(); !modload.Enabled() {
531 base.Fatalf("go: list -m cannot be used with GO111MODULE=off")
532 }
533
534 modload.LoadModFile(ctx)
535 if cfg.BuildMod == "vendor" {
536 const actionDisabledFormat = "go: can't %s using the vendor directory\n\t(Use -mod=mod or -mod=readonly to bypass.)"
537
538 if *listVersions {
539 base.Fatalf(actionDisabledFormat, "determine available versions")
540 }
541 if *listU {
542 base.Fatalf(actionDisabledFormat, "determine available upgrades")
543 }
544
545 for _, arg := range args {
546
547
548
549 if arg == "all" {
550 base.Fatalf(actionDisabledFormat, "compute 'all'")
551 }
552 if strings.Contains(arg, "...") {
553 base.Fatalf(actionDisabledFormat, "match module patterns")
554 }
555 }
556 }
557
558 var mode modload.ListMode
559 if *listU {
560 mode |= modload.ListU | modload.ListRetracted | modload.ListDeprecated
561 }
562 if *listRetracted {
563 mode |= modload.ListRetracted
564 }
565 if *listVersions {
566 mode |= modload.ListVersions
567 if *listRetracted {
568 mode |= modload.ListRetractedVersions
569 }
570 }
571 if *listReuse != "" && len(args) == 0 {
572 base.Fatalf("go: list -m -reuse only has an effect with module@version arguments")
573 }
574 mods, err := modload.ListModules(ctx, args, mode, *listReuse)
575 if !*listE {
576 for _, m := range mods {
577 if m.Error != nil {
578 base.Error(errors.New(m.Error.Err))
579 }
580 }
581 if err != nil {
582 base.Error(err)
583 }
584 base.ExitIfErrors()
585 }
586 for _, m := range mods {
587 do(m)
588 }
589 return
590 }
591
592
593 if *listU {
594 base.Fatalf("go list -u can only be used with -m")
595 }
596 if *listVersions {
597 base.Fatalf("go list -versions can only be used with -m")
598 }
599
600
601 if *listFind && *listDeps {
602 base.Fatalf("go list -deps cannot be used with -find")
603 }
604 if *listFind && *listTest {
605 base.Fatalf("go list -test cannot be used with -find")
606 }
607 if *listFind && *listExport {
608 base.Fatalf("go list -export cannot be used with -find")
609 }
610
611 pkgOpts := load.PackageOpts{
612 IgnoreImports: *listFind,
613 ModResolveTests: *listTest,
614 AutoVCS: true,
615 SuppressBuildInfo: !*listExport && !listJsonFields.needAny("Stale", "StaleReason"),
616 SuppressEmbedFiles: !*listExport && !listJsonFields.needAny("EmbedFiles", "TestEmbedFiles", "XTestEmbedFiles"),
617 }
618 pkgs := load.PackagesAndErrors(ctx, pkgOpts, args)
619 if !*listE {
620 w := 0
621 for _, pkg := range pkgs {
622 if pkg.Error != nil {
623 base.Errorf("%v", pkg.Error)
624 continue
625 }
626 pkgs[w] = pkg
627 w++
628 }
629 pkgs = pkgs[:w]
630 base.ExitIfErrors()
631 }
632
633 if *listTest {
634 c := cache.Default()
635
636
637 var wg sync.WaitGroup
638 sema := semaphore.NewWeighted(int64(runtime.GOMAXPROCS(0)))
639 type testPackageSet struct {
640 p, pmain, ptest, pxtest *load.Package
641 }
642 var testPackages []testPackageSet
643 for _, p := range pkgs {
644 if len(p.TestGoFiles)+len(p.XTestGoFiles) > 0 {
645 var pmain, ptest, pxtest *load.Package
646 if *listE {
647 sema.Acquire(ctx, 1)
648 wg.Add(1)
649 done := func() {
650 sema.Release(1)
651 wg.Done()
652 }
653 pmain, ptest, pxtest = load.TestPackagesAndErrors(ctx, done, pkgOpts, p, nil)
654 } else {
655 var perr *load.Package
656 pmain, ptest, pxtest, perr = load.TestPackagesFor(ctx, pkgOpts, p, nil)
657 if perr != nil {
658 base.Fatalf("go: can't load test package: %s", perr.Error)
659 }
660 }
661 testPackages = append(testPackages, testPackageSet{p, pmain, ptest, pxtest})
662 }
663 }
664 wg.Wait()
665 for _, pkgset := range testPackages {
666 p, pmain, ptest, pxtest := pkgset.p, pkgset.pmain, pkgset.ptest, pkgset.pxtest
667 if pmain != nil {
668 pkgs = append(pkgs, pmain)
669 data := *pmain.Internal.TestmainGo
670 sema.Acquire(ctx, 1)
671 wg.Add(1)
672 go func() {
673 h := cache.NewHash("testmain")
674 h.Write([]byte("testmain\n"))
675 h.Write(data)
676 out, _, err := c.Put(h.Sum(), bytes.NewReader(data))
677 if err != nil {
678 base.Fatalf("%s", err)
679 }
680 pmain.GoFiles[0] = c.OutputFile(out)
681 sema.Release(1)
682 wg.Done()
683 }()
684
685 }
686 if ptest != nil && ptest != p {
687 pkgs = append(pkgs, ptest)
688 }
689 if pxtest != nil {
690 pkgs = append(pkgs, pxtest)
691 }
692 }
693
694 wg.Wait()
695 }
696
697
698 cmdline := make(map[*load.Package]bool)
699 for _, p := range pkgs {
700 cmdline[p] = true
701 }
702
703 if *listDeps {
704
705
706
707
708
709
710
711
712 pkgs = loadPackageList(pkgs)
713 }
714
715
716 needStale := (listJson && listJsonFields.needAny("Stale", "StaleReason")) || strings.Contains(*listFmt, ".Stale")
717 if needStale || *listExport || *listCompiled {
718 b := work.NewBuilder("")
719 if *listE {
720 b.AllowErrors = true
721 }
722 defer func() {
723 if err := b.Close(); err != nil {
724 base.Fatal(err)
725 }
726 }()
727
728 b.IsCmdList = true
729 b.NeedExport = *listExport
730 b.NeedCompiledGoFiles = *listCompiled
731 if cfg.Experiment.CoverageRedesign && cfg.BuildCover {
732 load.PrepareForCoverageBuild(pkgs)
733 }
734 a := &work.Action{}
735
736 for _, p := range pkgs {
737 if len(p.GoFiles)+len(p.CgoFiles) > 0 {
738 a.Deps = append(a.Deps, b.AutoAction(work.ModeInstall, work.ModeInstall, p))
739 }
740 }
741 b.Do(ctx, a)
742 }
743
744 for _, p := range pkgs {
745
746 p.TestImports = p.Resolve(p.TestImports)
747 p.XTestImports = p.Resolve(p.XTestImports)
748 p.DepOnly = !cmdline[p]
749
750 if *listCompiled {
751 p.Imports = str.StringList(p.Imports, p.Internal.CompiledImports)
752 }
753 }
754
755 if *listTest || (cfg.BuildPGO == "auto" && len(cmdline) > 1) {
756 all := pkgs
757 if !*listDeps {
758 all = loadPackageList(pkgs)
759 }
760
761
762
763
764
765
766 old := make(map[string]string)
767 for _, p := range all {
768 if p.ForTest != "" || p.Internal.ForMain != "" {
769 new := p.Desc()
770 old[new] = p.ImportPath
771 p.ImportPath = new
772 }
773 p.DepOnly = !cmdline[p]
774 }
775
776 m := make(map[string]string)
777 for _, p := range all {
778 for _, p1 := range p.Internal.Imports {
779 if p1.ForTest != "" || p1.Internal.ForMain != "" {
780 m[old[p1.ImportPath]] = p1.ImportPath
781 }
782 }
783 for i, old := range p.Imports {
784 if new := m[old]; new != "" {
785 p.Imports[i] = new
786 }
787 }
788 clear(m)
789 }
790 }
791
792 if listJsonFields.needAny("Deps", "DepsErrors") {
793 all := pkgs
794
795
796
797
798
799
800
801
802 if !*listDeps {
803 all = load.PackageList(pkgs)
804 }
805 if listJsonFields.needAny("Deps") {
806 for _, p := range all {
807 collectDeps(p)
808 }
809 }
810 if listJsonFields.needAny("DepsErrors") {
811 for _, p := range all {
812 collectDepsErrors(p)
813 }
814 }
815 }
816
817
818
819 if *listRetracted {
820
821
822
823
824
825
826 modToArg := make(map[*modinfo.ModulePublic]string)
827 argToMods := make(map[string][]*modinfo.ModulePublic)
828 var args []string
829 addModule := func(mod *modinfo.ModulePublic) {
830 if mod.Version == "" {
831 return
832 }
833 arg := fmt.Sprintf("%s@%s", mod.Path, mod.Version)
834 if argToMods[arg] == nil {
835 args = append(args, arg)
836 }
837 argToMods[arg] = append(argToMods[arg], mod)
838 modToArg[mod] = arg
839 }
840 for _, p := range pkgs {
841 if p.Module == nil {
842 continue
843 }
844 addModule(p.Module)
845 if p.Module.Replace != nil {
846 addModule(p.Module.Replace)
847 }
848 }
849
850 if len(args) > 0 {
851 var mode modload.ListMode
852 if *listRetracted {
853 mode |= modload.ListRetracted
854 }
855 rmods, err := modload.ListModules(ctx, args, mode, *listReuse)
856 if err != nil && !*listE {
857 base.Error(err)
858 }
859 for i, arg := range args {
860 rmod := rmods[i]
861 for _, mod := range argToMods[arg] {
862 mod.Retracted = rmod.Retracted
863 if rmod.Error != nil && mod.Error == nil {
864 mod.Error = rmod.Error
865 }
866 }
867 }
868 }
869 }
870
871
872 for _, p := range pkgs {
873 nRaw := len(p.Internal.RawImports)
874 for i, path := range p.Imports {
875 var srcPath string
876 if i < nRaw {
877 srcPath = p.Internal.RawImports[i]
878 } else {
879
880
881
882 srcPath = p.Internal.CompiledImports[i-nRaw]
883 }
884
885 if path != srcPath {
886 if p.ImportMap == nil {
887 p.ImportMap = make(map[string]string)
888 }
889 p.ImportMap[srcPath] = path
890 }
891 }
892 }
893
894 for _, p := range pkgs {
895 do(&p.PackagePublic)
896 }
897 }
898
899
900
901
902 func loadPackageList(roots []*load.Package) []*load.Package {
903 pkgs := load.PackageList(roots)
904
905 if !*listE {
906 for _, pkg := range pkgs {
907 if pkg.Error != nil {
908 base.Errorf("%v", pkg.Error)
909 }
910 }
911 }
912
913 return pkgs
914 }
915
916
917
918 func collectDeps(p *load.Package) {
919 deps := make(map[string]bool)
920
921 for _, p := range p.Internal.Imports {
922 deps[p.ImportPath] = true
923 for _, q := range p.Deps {
924 deps[q] = true
925 }
926 }
927
928 p.Deps = make([]string, 0, len(deps))
929 for dep := range deps {
930 p.Deps = append(p.Deps, dep)
931 }
932 sort.Strings(p.Deps)
933 }
934
935
936
937 func collectDepsErrors(p *load.Package) {
938 depsErrors := make(map[*load.PackageError]bool)
939
940 for _, p := range p.Internal.Imports {
941 if p.Error != nil {
942 depsErrors[p.Error] = true
943 }
944 for _, q := range p.DepsErrors {
945 depsErrors[q] = true
946 }
947 }
948
949 p.DepsErrors = make([]*load.PackageError, 0, len(depsErrors))
950 for deperr := range depsErrors {
951 p.DepsErrors = append(p.DepsErrors, deperr)
952 }
953
954
955
956 sort.Slice(p.DepsErrors, func(i, j int) bool {
957 stki, stkj := p.DepsErrors[i].ImportStack, p.DepsErrors[j].ImportStack
958
959
960
961 if len(stki) == 0 {
962 if len(stkj) != 0 {
963 return true
964 }
965
966 return p.DepsErrors[i].Err.Error() < p.DepsErrors[j].Err.Error()
967 } else if len(stkj) == 0 {
968 return false
969 }
970 pathi, pathj := stki[len(stki)-1], stkj[len(stkj)-1]
971 return pathi.Pkg < pathj.Pkg
972 })
973 }
974
975
976
977
978 type TrackingWriter struct {
979 w *bufio.Writer
980 last byte
981 }
982
983 func newTrackingWriter(w io.Writer) *TrackingWriter {
984 return &TrackingWriter{
985 w: bufio.NewWriter(w),
986 last: '\n',
987 }
988 }
989
990 func (t *TrackingWriter) Write(p []byte) (n int, err error) {
991 n, err = t.w.Write(p)
992 if n > 0 {
993 t.last = p[n-1]
994 }
995 return
996 }
997
998 func (t *TrackingWriter) Flush() {
999 t.w.Flush()
1000 }
1001
1002 func (t *TrackingWriter) NeedNL() bool {
1003 return t.last != '\n'
1004 }
1005
View as plain text