package imports import ( "context" "fmt" "sync" "golang.org/x/tools/internal/gopathwalk" ) // To find packages to import, the resolver needs to know about all of the // the packages that could be imported. This includes packages that are // already in modules that are in (1) the current module, (2) replace targets, // and (3) packages in the module cache. Packages in (1) and (2) may change over // time, as the client may edit the current module and locally replaced modules. // The module cache (which includes all of the packages in (3)) can only // ever be added to. // // The resolver can thus save state about packages in the module cache // and guarantee that this will not change over time. To obtain information // about new modules added to the module cache, the module cache should be // rescanned. // // It is OK to serve information about modules that have been deleted, // as they do still exist. // TODO(suzmue): can we share information with the caller about // what module needs to be downloaded to import this package? type directoryPackageStatus int const ( _ directoryPackageStatus = iota directoryScanned nameLoaded exportsLoaded ) type directoryPackageInfo struct { // status indicates the extent to which this struct has been filled in. status directoryPackageStatus // err is non-nil when there was an error trying to reach status. err error // Set when status >= directoryScanned. // dir is the absolute directory of this package. dir string rootType gopathwalk.RootType // nonCanonicalImportPath is the package's expected import path. It may // not actually be importable at that path. nonCanonicalImportPath string // needsReplace is true if the nonCanonicalImportPath does not match the // module's declared path, making it impossible to import without a // replace directive. needsReplace bool // Module-related information. moduleDir string // The directory that is the module root of this dir. moduleName string // The module name that contains this dir. // Set when status >= nameLoaded. packageName string // the package name, as declared in the source. // Set when status >= exportsLoaded. exports []string } // reachedStatus returns true when info has a status at least target and any error associated with // an attempt to reach target. func (info *directoryPackageInfo) reachedStatus(target directoryPackageStatus) (bool, error) { if info.err == nil { return info.status >= target, nil } if info.status == target { return true, info.err } return true, nil } // dirInfoCache is a concurrency safe map for storing information about // directories that may contain packages. // // The information in this cache is built incrementally. Entries are initialized in scan. // No new keys should be added in any other functions, as all directories containing // packages are identified in scan. // // Other functions, including loadExports and findPackage, may update entries in this cache // as they discover new things about the directory. // // The information in the cache is not expected to change for the cache's // lifetime, so there is no protection against competing writes. Users should // take care not to hold the cache across changes to the underlying files. // // TODO(suzmue): consider other concurrency strategies and data structures (RWLocks, sync.Map, etc) type dirInfoCache struct { mu sync.Mutex // dirs stores information about packages in directories, keyed by absolute path. dirs map[string]*directoryPackageInfo } // Store stores the package info for dir. func (d *dirInfoCache) Store(dir string, info directoryPackageInfo) { d.mu.Lock() defer d.mu.Unlock() stored := info // defensive copy d.dirs[dir] = &stored } // Load returns a copy of the directoryPackageInfo for absolute directory dir. func (d *dirInfoCache) Load(dir string) (directoryPackageInfo, bool) { d.mu.Lock() defer d.mu.Unlock() info, ok := d.dirs[dir] if !ok { return directoryPackageInfo{}, false } return *info, true } // Keys returns the keys currently present in d. func (d *dirInfoCache) Keys() (keys []string) { d.mu.Lock() defer d.mu.Unlock() for key := range d.dirs { keys = append(keys, key) } return keys } func (d *dirInfoCache) CachePackageName(info directoryPackageInfo) (directoryPackageInfo, error) { if loaded, err := info.reachedStatus(nameLoaded); loaded { return info, err } if scanned, err := info.reachedStatus(directoryScanned); !scanned || err != nil { return info, fmt.Errorf("cannot read package name, scan error: %v", err) } info.packageName, info.err = packageDirToName(info.dir) info.status = nameLoaded d.Store(info.dir, info) return info, info.err } func (d *dirInfoCache) CacheExports(ctx context.Context, env *ProcessEnv, info directoryPackageInfo) (string, []string, error) { if reached, _ := info.reachedStatus(exportsLoaded); reached { return info.packageName, info.exports, info.err } if reached, err := info.reachedStatus(nameLoaded); reached && err != nil { return "", nil, err } info.packageName, info.exports, info.err = loadExportsFromFiles(ctx, env, info.dir) if info.err == context.Canceled { return info.packageName, info.exports, info.err } // The cache structure wants things to proceed linearly. We can skip a // step here, but only if we succeed. if info.status == nameLoaded || info.err == nil { info.status = exportsLoaded } else { info.status = nameLoaded } d.Store(info.dir, info) return info.packageName, info.exports, info.err }