type ImportMissingError … func (e *ImportMissingError) Error() string { … } func (e *ImportMissingError) Unwrap() error { … } func (e *ImportMissingError) ImportPath() string { … } type AmbiguousImportError … func (e *AmbiguousImportError) ImportPath() string { … } func (e *AmbiguousImportError) Error() string { … } type DirectImportFromImplicitDependencyError … func (e *DirectImportFromImplicitDependencyError) Error() string { … } func (e *DirectImportFromImplicitDependencyError) ImportPath() string { … } type ImportMissingSumError … func (e *ImportMissingSumError) Error() string { … } func (e *ImportMissingSumError) ImportPath() string { … } type invalidImportError … func (e *invalidImportError) ImportPath() string { … } func (e *invalidImportError) Error() string { … } func (e *invalidImportError) Unwrap() error { … } // importFromModules finds the module and directory in the dependency graph of // rs containing the package with the given import path. If mg is nil, // importFromModules attempts to locate the module using only the main module // and the roots of rs before it loads the full graph. // // The answer must be unique: importFromModules returns an error if multiple // modules are observed to provide the same package. // // importFromModules can return a module with an empty m.Path, for packages in // the standard library. // // importFromModules can return an empty directory string, for fake packages // like "C" and "unsafe". // // If the package is not present in any module selected from the requirement // graph, importFromModules returns an *ImportMissingError. // // If the package is present in exactly one module, importFromModules will // return the module, its root directory, and a list of other modules that // lexically could have provided the package but did not. // // If skipModFile is true, the go.mod file for the package is not loaded. This // allows 'go mod tidy' to preserve a minor checksum-preservation bug // (https://go.dev/issue/56222) for modules with 'go' versions between 1.17 and // 1.20, preventing unnecessary go.sum churn and network access in those // modules. func importFromModules(ctx context.Context, path string, rs *Requirements, mg *ModuleGraph, skipModFile bool) (m module.Version, modroot, dir string, altMods []module.Version, err error) { … } // queryImport attempts to locate a module that can be added to the current // build list to provide the package with the given import path. // // Unlike QueryPattern, queryImport prefers to add a replaced version of a // module *before* checking the proxies for a version to add. func queryImport(ctx context.Context, path string, rs *Requirements) (module.Version, error) { … } // maybeInModule reports whether, syntactically, // a package with the given import path could be supplied // by a module with the given module path (mpath). func maybeInModule(path, mpath string) bool { … } var haveGoModCache … var haveGoFilesCache … // dirInModule locates the directory that would hold the package named by the given path, // if it were in the module with module path mpath and root mdir. // If path is syntactically not within mpath, // or if mdir is a local file tree (isLocal == true) and the directory // that would hold path is in a sub-module (covered by a go.mod below mdir), // dirInModule returns "", false, nil. // // Otherwise, dirInModule returns the name of the directory where // Go source files would be expected, along with a boolean indicating // whether there are in fact Go source files in that directory. // A non-nil error indicates that the existence of the directory and/or // source files could not be determined, for example due to a permission error. func dirInModule(path, mpath, mdir string, isLocal bool) (dir string, haveGoFiles bool, err error) { … } // fetch downloads the given module (or its replacement) // and returns its location. // // The isLocal return value reports whether the replacement, // if any, is local to the filesystem. func fetch(ctx context.Context, mod module.Version) (dir string, isLocal bool, err error) { … } // mustHaveSums reports whether we require that all checksums // needed to load or build packages are already present in the go.sum file. func mustHaveSums() bool { … } type sumMissingError … func (e *sumMissingError) Error() string { … }
Codebase Browser
go