package modpkgload

import "cuelang.org/go/internal/mod/modpkgload"

Index ¶

• func IsStdlibPackage(pkgPath string) bool
• type AmbiguousImportError
• func (e *AmbiguousImportError) Error() string
• type Flags
• func (f Flags) String() string
• type ImportMissingError
• func (e *ImportMissingError) Error() string
• type Package
• func (pkg *Package) Error() error
• func (pkg *Package) Flags() Flags
• func (pkg *Package) FromExternalModule() bool
• func (pkg *Package) HasFlags(flags Flags) bool
• func (pkg *Package) ImportPath() string
• func (pkg *Package) Imports() []*Package
• func (pkg *Package) Locations() []module.SourceLoc
• func (pkg *Package) Mod() module.Version
• func (pkg *Package) SetError(err error)
• type Packages
• func LoadPackages( ctx context.Context, mainModulePath string, mainModuleLoc module.SourceLoc, rs *modrequirements.Requirements, reg Registry, rootPkgPaths []string, shouldIncludePkgFile func(pkgPath string, mod module.Version, fsys fs.FS, mf modimports.ModuleFile) bool, ) *Packages
• func (pkgs *Packages) All() []*Package
• func (pkgs *Packages) Pkg(canonicalPkgPath string) *Package
• func (pkgs *Packages) Roots() []*Package
• type Registry

Functions ¶

func IsStdlibPackage ¶

func IsStdlibPackage(pkgPath string) bool

Types ¶

type AmbiguousImportError ¶

type AmbiguousImportError struct {
	ImportPath string
	Locations  [][]module.SourceLoc
	Modules    []module.Version // Either empty or 1:1 with Dirs.
}

An AmbiguousImportError indicates an import of a package found in multiple modules in the build list, or found in both the main module and its vendor directory.

func (*AmbiguousImportError) Error ¶

func (e *AmbiguousImportError) Error() string

type Flags ¶

type Flags int8

Flags is a set of flags tracking metadata about a package.

const (
	// PkgInAll indicates that the package is in the "all" package pattern,
	// regardless of whether we are loading the "all" package pattern.
	//
	// When the PkgInAll flag and PkgImportsLoaded flags are both set, the caller
	// who set the last of those flags must propagate the PkgInAll marking to all
	// of the imports of the marked package.
	PkgInAll Flags = 1 << iota

	// PkgIsRoot indicates that the package matches one of the root package
	// patterns requested by the caller.
	PkgIsRoot

	// PkgFromRoot indicates that the package is in the transitive closure of
	// imports starting at the roots. (Note that every package marked as PkgIsRoot
	// is also trivially marked PkgFromRoot.)
	PkgFromRoot

	// PkgImportsLoaded indicates that the Imports field of a
	// Pkg have been populated.
	PkgImportsLoaded
)

func (Flags) String ¶

func (f Flags) String() string

type ImportMissingError ¶

type ImportMissingError struct {
	Path string
}

ImportMissingError is used for errors where an imported package cannot be found.

func (*ImportMissingError) Error ¶

func (e *ImportMissingError) Error() string

type Package ¶

type Package struct {
	// contains filtered or unexported fields
}

func (*Package) Error ¶

func (pkg *Package) Error() error

func (*Package) Flags ¶

func (pkg *Package) Flags() Flags

func (*Package) FromExternalModule ¶

func (pkg *Package) FromExternalModule() bool

func (*Package) HasFlags ¶

func (pkg *Package) HasFlags(flags Flags) bool

func (*Package) ImportPath ¶

func (pkg *Package) ImportPath() string

func (*Package) Imports ¶

func (pkg *Package) Imports() []*Package

func (*Package) Locations ¶

func (pkg *Package) Locations() []module.SourceLoc

func (*Package) Mod ¶

func (pkg *Package) Mod() module.Version

func (*Package) SetError ¶

func (pkg *Package) SetError(err error)

type Packages ¶

type Packages struct {
	// contains filtered or unexported fields
}

func LoadPackages ¶

func LoadPackages(
	ctx context.Context,
	mainModulePath string,
	mainModuleLoc module.SourceLoc,
	rs *modrequirements.Requirements,
	reg Registry,
	rootPkgPaths []string,
	shouldIncludePkgFile func(pkgPath string, mod module.Version, fsys fs.FS, mf modimports.ModuleFile) bool,
) *Packages

LoadPackages loads information about all the given packages and the packages they import, recursively, using modules from the given requirements to determine which modules they might be obtained from, and reg to download module contents.

rootPkgPaths should only contain canonical import paths.

The shouldIncludePkgFile function is used to determine whether a given file in a package should be considered to be part of the build. If it returns true for a package, the file's imports will be followed. A nil value corresponds to a function that always returns true. It may be called concurrently.

func (*Packages) All ¶

func (pkgs *Packages) All() []*Package

func (*Packages) Pkg ¶

func (pkgs *Packages) Pkg(canonicalPkgPath string) *Package

Pkg obtains a given package given its canonical import path.

func (*Packages) Roots ¶

func (pkgs *Packages) Roots() []*Package

type Registry ¶

type Registry interface {
	// Fetch returns the location of the contents for the given module
	// version, downloading it if necessary.
	Fetch(ctx context.Context, m module.Version) (module.SourceLoc, error)
}

Registry represents a module registry, or at least this package's view of it.

Source Files ¶

import.go pkgload.go