.config/coc/extensions/coc-go-data/tools/pkg/mod/mvdan.cc/gofumpt@v0.1.0/gofumports/internal/imports/mod_cache.go

   1 package imports
   2
   3 import (
   4         "context"
   5         "fmt"
   6         "sync"
   7
   8         "mvdan.cc/gofumpt/gofumports/internal/gopathwalk"
   9 )
  10
  11 // To find packages to import, the resolver needs to know about all of the
  12 // the packages that could be imported. This includes packages that are
  13 // already in modules that are in (1) the current module, (2) replace targets,
  14 // and (3) packages in the module cache. Packages in (1) and (2) may change over
  15 // time, as the client may edit the current module and locally replaced modules.
  16 // The module cache (which includes all of the packages in (3)) can only
  17 // ever be added to.
  18 //
  19 // The resolver can thus save state about packages in the module cache
  20 // and guarantee that this will not change over time. To obtain information
  21 // about new modules added to the module cache, the module cache should be
  22 // rescanned.
  23 //
  24 // It is OK to serve information about modules that have been deleted,
  25 // as they do still exist.
  26 // TODO(suzmue): can we share information with the caller about
  27 // what module needs to be downloaded to import this package?
  28
  29 type directoryPackageStatus int
  30
  31 const (
  32         _ directoryPackageStatus = iota
  33         directoryScanned
  34         nameLoaded
  35         exportsLoaded
  36 )
  37
  38 type directoryPackageInfo struct {
  39         // status indicates the extent to which this struct has been filled in.
  40         status directoryPackageStatus
  41         // err is non-nil when there was an error trying to reach status.
  42         err error
  43
  44         // Set when status >= directoryScanned.
  45
  46         // dir is the absolute directory of this package.
  47         dir      string
  48         rootType gopathwalk.RootType
  49         // nonCanonicalImportPath is the package's expected import path. It may
  50         // not actually be importable at that path.
  51         nonCanonicalImportPath string
  52
  53         // Module-related information.
  54         moduleDir  string // The directory that is the module root of this dir.
  55         moduleName string // The module name that contains this dir.
  56
  57         // Set when status >= nameLoaded.
  58
  59         packageName string // the package name, as declared in the source.
  60
  61         // Set when status >= exportsLoaded.
  62
  63         exports []string
  64 }
  65
  66 // reachedStatus returns true when info has a status at least target and any error associated with
  67 // an attempt to reach target.
  68 func (info *directoryPackageInfo) reachedStatus(target directoryPackageStatus) (bool, error) {
  69         if info.err == nil {
  70                 return info.status >= target, nil
  71         }
  72         if info.status == target {
  73                 return true, info.err
  74         }
  75         return true, nil
  76 }
  77
  78 // dirInfoCache is a concurrency safe map for storing information about
  79 // directories that may contain packages.
  80 //
  81 // The information in this cache is built incrementally. Entries are initialized in scan.
  82 // No new keys should be added in any other functions, as all directories containing
  83 // packages are identified in scan.
  84 //
  85 // Other functions, including loadExports and findPackage, may update entries in this cache
  86 // as they discover new things about the directory.
  87 //
  88 // The information in the cache is not expected to change for the cache's
  89 // lifetime, so there is no protection against competing writes. Users should
  90 // take care not to hold the cache across changes to the underlying files.
  91 //
  92 // TODO(suzmue): consider other concurrency strategies and data structures (RWLocks, sync.Map, etc)
  93 type dirInfoCache struct {
  94         mu sync.Mutex
  95         // dirs stores information about packages in directories, keyed by absolute path.
  96         dirs      map[string]*directoryPackageInfo
  97         listeners map[*int]cacheListener
  98 }
  99
 100 type cacheListener func(directoryPackageInfo)
 101
 102 // ScanAndListen calls listener on all the items in the cache, and on anything
 103 // newly added. The returned stop function waits for all in-flight callbacks to
 104 // finish and blocks new ones.
 105 func (d *dirInfoCache) ScanAndListen(ctx context.Context, listener cacheListener) func() {
 106         ctx, cancel := context.WithCancel(ctx)
 107
 108         // Flushing out all the callbacks is tricky without knowing how many there
 109         // are going to be. Setting an arbitrary limit makes it much easier.
 110         const maxInFlight = 10
 111         sema := make(chan struct{}, maxInFlight)
 112         for i := 0; i < maxInFlight; i++ {
 113                 sema <- struct{}{}
 114         }
 115
 116         cookie := new(int) // A unique ID we can use for the listener.
 117
 118         // We can't hold mu while calling the listener.
 119         d.mu.Lock()
 120         var keys []string
 121         for key := range d.dirs {
 122                 keys = append(keys, key)
 123         }
 124         d.listeners[cookie] = func(info directoryPackageInfo) {
 125                 select {
 126                 case <-ctx.Done():
 127                         return
 128                 case <-sema:
 129                 }
 130                 listener(info)
 131                 sema <- struct{}{}
 132         }
 133         d.mu.Unlock()
 134
 135         stop := func() {
 136                 cancel()
 137                 d.mu.Lock()
 138                 delete(d.listeners, cookie)
 139                 d.mu.Unlock()
 140                 for i := 0; i < maxInFlight; i++ {
 141                         <-sema
 142                 }
 143         }
 144
 145         // Process the pre-existing keys.
 146         for _, k := range keys {
 147                 select {
 148                 case <-ctx.Done():
 149                         return stop
 150                 default:
 151                 }
 152                 if v, ok := d.Load(k); ok {
 153                         listener(v)
 154                 }
 155         }
 156
 157         return stop
 158 }
 159
 160 // Store stores the package info for dir.
 161 func (d *dirInfoCache) Store(dir string, info directoryPackageInfo) {
 162         d.mu.Lock()
 163         _, old := d.dirs[dir]
 164         d.dirs[dir] = &info
 165         var listeners []cacheListener
 166         for _, l := range d.listeners {
 167                 listeners = append(listeners, l)
 168         }
 169         d.mu.Unlock()
 170
 171         if !old {
 172                 for _, l := range listeners {
 173                         l(info)
 174                 }
 175         }
 176 }
 177
 178 // Load returns a copy of the directoryPackageInfo for absolute directory dir.
 179 func (d *dirInfoCache) Load(dir string) (directoryPackageInfo, bool) {
 180         d.mu.Lock()
 181         defer d.mu.Unlock()
 182         info, ok := d.dirs[dir]
 183         if !ok {
 184                 return directoryPackageInfo{}, false
 185         }
 186         return *info, true
 187 }
 188
 189 // Keys returns the keys currently present in d.
 190 func (d *dirInfoCache) Keys() (keys []string) {
 191         d.mu.Lock()
 192         defer d.mu.Unlock()
 193         for key := range d.dirs {
 194                 keys = append(keys, key)
 195         }
 196         return keys
 197 }
 198
 199 func (d *dirInfoCache) CachePackageName(info directoryPackageInfo) (string, error) {
 200         if loaded, err := info.reachedStatus(nameLoaded); loaded {
 201                 return info.packageName, err
 202         }
 203         if scanned, err := info.reachedStatus(directoryScanned); !scanned || err != nil {
 204                 return "", fmt.Errorf("cannot read package name, scan error: %v", err)
 205         }
 206         info.packageName, info.err = packageDirToName(info.dir)
 207         info.status = nameLoaded
 208         d.Store(info.dir, info)
 209         return info.packageName, info.err
 210 }
 211
 212 func (d *dirInfoCache) CacheExports(ctx context.Context, env *ProcessEnv, info directoryPackageInfo) (string, []string, error) {
 213         if reached, _ := info.reachedStatus(exportsLoaded); reached {
 214                 return info.packageName, info.exports, info.err
 215         }
 216         if reached, err := info.reachedStatus(nameLoaded); reached && err != nil {
 217                 return "", nil, err
 218         }
 219         info.packageName, info.exports, info.err = loadExportsFromFiles(ctx, env, info.dir, false)
 220         if info.err == context.Canceled || info.err == context.DeadlineExceeded {
 221                 return info.packageName, info.exports, info.err
 222         }
 223         // The cache structure wants things to proceed linearly. We can skip a
 224         // step here, but only if we succeed.
 225         if info.status == nameLoaded || info.err == nil {
 226                 info.status = exportsLoaded
 227         } else {
 228                 info.status = nameLoaded
 229         }
 230         d.Store(info.dir, info)
 231         return info.packageName, info.exports, info.err
 232 }