src/cmd/go/internal/modload/search.go

   1 // Copyright 2018 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package modload
   6
   7 import (
   8         "context"
   9         "errors"
  10         "fmt"
  11         "io/fs"
  12         "os"
  13         "path"
  14         "path/filepath"
  15         "runtime"
  16         "sort"
  17         "strings"
  18         "sync"
  19
  20         "cmd/go/internal/cfg"
  21         "cmd/go/internal/fsys"
  22         "cmd/go/internal/gover"
  23         "cmd/go/internal/imports"
  24         "cmd/go/internal/modindex"
  25         "cmd/go/internal/par"
  26         "cmd/go/internal/search"
  27         "cmd/go/internal/str"
  28         "cmd/go/internal/trace"
  29         "cmd/internal/pkgpattern"
  30
  31         "golang.org/x/mod/module"
  32 )
  33
  34 type stdFilter int8
  35
  36 const (
  37         omitStd = stdFilter(iota)
  38         includeStd
  39 )
  40
  41 // matchPackages is like m.MatchPackages, but uses a local variable (rather than
  42 // a global) for tags, can include or exclude packages in the standard library,
  43 // and is restricted to the given list of modules.
  44 func matchPackages(ctx context.Context, m *search.Match, tags map[string]bool, filter stdFilter, modules []module.Version) {
  45         ctx, span := trace.StartSpan(ctx, "modload.matchPackages")
  46         defer span.Done()
  47
  48         m.Pkgs = []string{}
  49
  50         isMatch := func(string) bool { return true }
  51         treeCanMatch := func(string) bool { return true }
  52         if !m.IsMeta() {
  53                 isMatch = pkgpattern.MatchPattern(m.Pattern())
  54                 treeCanMatch = pkgpattern.TreeCanMatchPattern(m.Pattern())
  55         }
  56
  57         var mu sync.Mutex
  58         have := map[string]bool{
  59                 "builtin": true, // ignore pseudo-package that exists only for documentation
  60         }
  61         addPkg := func(p string) {
  62                 mu.Lock()
  63                 m.Pkgs = append(m.Pkgs, p)
  64                 mu.Unlock()
  65         }
  66         if !cfg.BuildContext.CgoEnabled {
  67                 have["runtime/cgo"] = true // ignore during walk
  68         }
  69
  70         type pruning int8
  71         const (
  72                 pruneVendor = pruning(1 << iota)
  73                 pruneGoMod
  74         )
  75
  76         q := par.NewQueue(runtime.GOMAXPROCS(0))
  77
  78         walkPkgs := func(root, importPathRoot string, prune pruning) {
  79                 _, span := trace.StartSpan(ctx, "walkPkgs "+root)
  80                 defer span.Done()
  81
  82                 // If the root itself is a symlink to a directory,
  83                 // we want to follow it (see https://go.dev/issue/50807).
  84                 // Add a trailing separator to force that to happen.
  85                 root = str.WithFilePathSeparator(filepath.Clean(root))
  86                 err := fsys.Walk(root, func(pkgDir string, fi fs.FileInfo, err error) error {
  87                         if err != nil {
  88                                 m.AddError(err)
  89                                 return nil
  90                         }
  91
  92                         want := true
  93                         elem := ""
  94
  95                         // Don't use GOROOT/src but do walk down into it.
  96                         if pkgDir == root {
  97                                 if importPathRoot == "" {
  98                                         return nil
  99                                 }
 100                         } else {
 101                                 // Avoid .foo, _foo, and testdata subdirectory trees.
 102                                 _, elem = filepath.Split(pkgDir)
 103                                 if strings.HasPrefix(elem, ".") || strings.HasPrefix(elem, "_") || elem == "testdata" {
 104                                         want = false
 105                                 }
 106                         }
 107
 108                         name := path.Join(importPathRoot, filepath.ToSlash(pkgDir[len(root):]))
 109                         if !treeCanMatch(name) {
 110                                 want = false
 111                         }
 112
 113                         if !fi.IsDir() {
 114                                 if fi.Mode()&fs.ModeSymlink != 0 && want && strings.Contains(m.Pattern(), "...") {
 115                                         if target, err := fsys.Stat(pkgDir); err == nil && target.IsDir() {
 116                                                 fmt.Fprintf(os.Stderr, "warning: ignoring symlink %s\n", pkgDir)
 117                                         }
 118                                 }
 119                                 return nil
 120                         }
 121
 122                         if !want {
 123                                 return filepath.SkipDir
 124                         }
 125                         // Stop at module boundaries.
 126                         if (prune&pruneGoMod != 0) && pkgDir != root {
 127                                 if fi, err := os.Stat(filepath.Join(pkgDir, "go.mod")); err == nil && !fi.IsDir() {
 128                                         return filepath.SkipDir
 129                                 }
 130                         }
 131
 132                         if !have[name] {
 133                                 have[name] = true
 134                                 if isMatch(name) {
 135                                         q.Add(func() {
 136                                                 if _, _, err := scanDir(root, pkgDir, tags); err != imports.ErrNoGo {
 137                                                         addPkg(name)
 138                                                 }
 139                                         })
 140                                 }
 141                         }
 142
 143                         if elem == "vendor" && (prune&pruneVendor != 0) {
 144                                 return filepath.SkipDir
 145                         }
 146                         return nil
 147                 })
 148                 if err != nil {
 149                         m.AddError(err)
 150                 }
 151         }
 152
 153         // Wait for all in-flight operations to complete before returning.
 154         defer func() {
 155                 <-q.Idle()
 156                 sort.Strings(m.Pkgs) // sort everything we added for determinism
 157         }()
 158
 159         if filter == includeStd {
 160                 walkPkgs(cfg.GOROOTsrc, "", pruneGoMod)
 161                 if treeCanMatch("cmd") {
 162                         walkPkgs(filepath.Join(cfg.GOROOTsrc, "cmd"), "cmd", pruneGoMod)
 163                 }
 164         }
 165
 166         if cfg.BuildMod == "vendor" {
 167                 for _, mod := range MainModules.Versions() {
 168                         if modRoot := MainModules.ModRoot(mod); modRoot != "" {
 169                                 walkPkgs(modRoot, MainModules.PathPrefix(mod), pruneGoMod|pruneVendor)
 170                         }
 171                 }
 172                 if HasModRoot() {
 173                         walkPkgs(VendorDir(), "", pruneVendor)
 174                 }
 175                 return
 176         }
 177
 178         for _, mod := range modules {
 179                 if gover.IsToolchain(mod.Path) || !treeCanMatch(mod.Path) {
 180                         continue
 181                 }
 182
 183                 var (
 184                         root, modPrefix string
 185                         isLocal         bool
 186                 )
 187                 if MainModules.Contains(mod.Path) {
 188                         if MainModules.ModRoot(mod) == "" {
 189                                 continue // If there is no main module, we can't search in it.
 190                         }
 191                         root = MainModules.ModRoot(mod)
 192                         modPrefix = MainModules.PathPrefix(mod)
 193                         isLocal = true
 194                 } else {
 195                         var err error
 196                         root, isLocal, err = fetch(ctx, mod)
 197                         if err != nil {
 198                                 m.AddError(err)
 199                                 continue
 200                         }
 201                         modPrefix = mod.Path
 202                 }
 203                 if mi, err := modindex.GetModule(root); err == nil {
 204                         walkFromIndex(mi, modPrefix, isMatch, treeCanMatch, tags, have, addPkg)
 205                         continue
 206                 } else if !errors.Is(err, modindex.ErrNotIndexed) {
 207                         m.AddError(err)
 208                 }
 209
 210                 prune := pruneVendor
 211                 if isLocal {
 212                         prune |= pruneGoMod
 213                 }
 214                 walkPkgs(root, modPrefix, prune)
 215         }
 216 }
 217
 218 // walkFromIndex matches packages in a module using the module index. modroot
 219 // is the module's root directory on disk, index is the modindex.Module for the
 220 // module, and importPathRoot is the module's path prefix.
 221 func walkFromIndex(index *modindex.Module, importPathRoot string, isMatch, treeCanMatch func(string) bool, tags, have map[string]bool, addPkg func(string)) {
 222         index.Walk(func(reldir string) {
 223                 // Avoid .foo, _foo, and testdata subdirectory trees.
 224                 p := reldir
 225                 for {
 226                         elem, rest, found := strings.Cut(p, string(filepath.Separator))
 227                         if strings.HasPrefix(elem, ".") || strings.HasPrefix(elem, "_") || elem == "testdata" {
 228                                 return
 229                         }
 230                         if found && elem == "vendor" {
 231                                 // Ignore this path if it contains the element "vendor" anywhere
 232                                 // except for the last element (packages named vendor are allowed
 233                                 // for historical reasons). Note that found is true when this
 234                                 // isn't the last path element.
 235                                 return
 236                         }
 237                         if !found {
 238                                 // Didn't find the separator, so we're considering the last element.
 239                                 break
 240                         }
 241                         p = rest
 242                 }
 243
 244                 // Don't use GOROOT/src.
 245                 if reldir == "" && importPathRoot == "" {
 246                         return
 247                 }
 248
 249                 name := path.Join(importPathRoot, filepath.ToSlash(reldir))
 250                 if !treeCanMatch(name) {
 251                         return
 252                 }
 253
 254                 if !have[name] {
 255                         have[name] = true
 256                         if isMatch(name) {
 257                                 if _, _, err := index.Package(reldir).ScanDir(tags); err != imports.ErrNoGo {
 258                                         addPkg(name)
 259                                 }
 260                         }
 261                 }
 262         })
 263 }
 264
 265 // MatchInModule identifies the packages matching the given pattern within the
 266 // given module version, which does not need to be in the build list or module
 267 // requirement graph.
 268 //
 269 // If m is the zero module.Version, MatchInModule matches the pattern
 270 // against the standard library (std and cmd) in GOROOT/src.
 271 func MatchInModule(ctx context.Context, pattern string, m module.Version, tags map[string]bool) *search.Match {
 272         match := search.NewMatch(pattern)
 273         if m == (module.Version{}) {
 274                 matchPackages(ctx, match, tags, includeStd, nil)
 275         }
 276
 277         LoadModFile(ctx) // Sets Target, needed by fetch and matchPackages.
 278
 279         if !match.IsLiteral() {
 280                 matchPackages(ctx, match, tags, omitStd, []module.Version{m})
 281                 return match
 282         }
 283
 284         root, isLocal, err := fetch(ctx, m)
 285         if err != nil {
 286                 match.Errs = []error{err}
 287                 return match
 288         }
 289
 290         dir, haveGoFiles, err := dirInModule(pattern, m.Path, root, isLocal)
 291         if err != nil {
 292                 match.Errs = []error{err}
 293                 return match
 294         }
 295         if haveGoFiles {
 296                 if _, _, err := scanDir(root, dir, tags); err != imports.ErrNoGo {
 297                         // ErrNoGo indicates that the directory is not actually a Go package,
 298                         // perhaps due to the tags in use. Any other non-nil error indicates a
 299                         // problem with one or more of the Go source files, but such an error does
 300                         // not stop the package from existing, so it has no impact on matching.
 301                         match.Pkgs = []string{pattern}
 302                 }
 303         }
 304         return match
 305 }