resolve

type CompositeEntry ¶

type CompositeEntry struct {
	Kind       string
	Name       string
	SyntaxBody syntax.FactoryBody
}

type ContextResolver ¶

type ContextResolver interface {
	ResolveFrom(ref ImportRef, parent *Source) (*Source, error)
}

ContextResolver resolves an import from the package source that declared it.

type ImportRef ¶

type ImportRef interface {
	// contains filtered or unexported methods
}

ImportRef is a parsed value from an `imports:` block.

func ParseImportRef(raw string) (ImportRef, error)

type LocalImport ¶

type LocalImport struct {
	Path string
}

LocalImport names a sibling on the operator's filesystem. Local imports do not have pinned versions; their content is whatever the developer has at the path now. Compile from a clean checkout to make the result reproducible.

type LocalResolver ¶

type LocalResolver struct {
	Root string
}

LocalResolver resolves *LocalImport refs against a working directory root. Relative paths in the import are joined to Root.

func NewLocalResolver(root string) *LocalResolver

func (r *LocalResolver) Resolve(ref ImportRef) (*Source, error)

func (r *LocalResolver) ResolveFrom(ref ImportRef, parent *Source) (*Source, error)

type RemoteImport ¶

type RemoteImport struct {
	URL           string
	Subdir        string
	ProjectSubdir string
	PackageSubdir string
	Version       string
}

RemoteImport names an importable repo by host + owner/name and an optional package subdir within the repo. The import string has no version; Version is filled in from lock.ub as the walk descends. ProjectSubdir and PackageSubdir are set after manifest or lock lookup when the owning project differs from the imported package.

type RemoteResolver ¶

type RemoteResolver struct {
	CacheRoot string
}

RemoteResolver resolves *RemoteImport refs by fetching the named git repo at the requested constraint, caching the working tree under CacheRoot, and exposing the requested subdir as a Source.

CacheRoot is the directory holding `imports/<host>/<path>/<commit>/`. `NewRemoteResolver` defaults it to `<user-cache-dir>/unobin`.

func NewRemoteResolver() (*RemoteResolver, error)

func (r *RemoteResolver) CleanImports() (string, error)

func (r *RemoteResolver) ImportsDir() string

func (r *RemoteResolver) Resolve(ref ImportRef) (*Source, error)

type Resolution ¶

type Resolution struct {
	Kind         ResolutionKind
	LocalAlias   string
	Ref          ImportRef
	Path         string
	Version      string
	CanonicalKey string
	SourcePath   string

	ModulePath     string
	ModuleRootPath string
	GoImportPath   string
}

Resolution describes one import after the walker reaches it. For Go imports, Path is the canonical Go-import path (URL plus subdir when present) and Version is the pinned version. For UB imports, CanonicalKey is the dedup key (see UBKey) and visitors look up their per-library state by that key. SourcePath is the on-disk directory where the resolver fetched the import, useful for compile-time inspection.

func WalkUB(
	refs map[string]ImportRef, resolver Resolver, v UBVisitor, versions map[string]string,
) ([]Resolution, error)

func WalkUBFrom(
	refs map[string]ImportRef,
	resolver Resolver,
	v UBVisitor,
	versions map[string]string,
	source *Source,
) ([]Resolution, error)

type ResolutionKind ¶

type ResolutionKind int

ResolutionKind tags how an import was resolved.

const (
	// ResolutionGo names a Go-library import: a remote ref whose resolved
	// source is not a UB library.
	ResolutionGo ResolutionKind = iota + 1
	// ResolutionUB names a UB-library import: a ref whose resolved source
	// has importable UB files at its root.
	ResolutionUB
)

type Resolver ¶

type Resolver interface {
	Resolve(ref ImportRef) (*Source, error)
}

Resolver turns an ImportRef into a Source. Implementations cover one kind of import each (local filesystem, remote git, etc.); callers dispatch by type-switching on the ref.

type Source ¶

type Source struct {
	FS     fs.FS
	Path   string
	Commit string

	ProjectFS     fs.FS
	ProjectPath   string
	ProjectSubdir string
	PackageSubdir string

	ModuleRootPath string
	ModulePath     string
	GoImportPath   string
}

Source is the file tree of a resolved import, rooted at the imported package directory. For remote imports, Commit records the resolved git commit. Path is the on-disk package directory the dev CLI uses for compile-time inspection of Go-library source.

func ResolveLocalSource(li *LocalImport, parent *Source) (*Source, error)

type SyntaxImport ¶

type SyntaxImport struct {
	Scope string
	Alias string
	Ref   ImportRef
}

SyntaxImport is one parsed import from a typed syntax file.

func ExtractSyntaxImports(f *syntax.File) ([]SyntaxImport, []error)

type UBLibrary ¶

type UBLibrary struct {
	SyntaxBodies map[string]map[string]syntax.FactoryBody
	BodyImports  map[string]map[string][]Resolution
}

UBLibrary has everything the visitor needs about a UB library the first time the walker reaches it. SyntaxBodies maps node kind and composite name to typed source declarations. BodyImports maps the same kind and name to the resolved imports declared by that body, in alias-sorted order so callers see a stable view across runs.

func (l *UBLibrary) CompositeEntries() []CompositeEntry

type UBVisitor ¶

type UBVisitor interface {
	// OnGoImport is called for every site whose import resolves to a
	// Go library. May fire multiple times with the same path when the
	// same library is imported from several sites; visitors that need
	// uniqueness dedup themselves.
	OnGoImport(alias, path, modulePath, version string) error
	// OnUBLibrary is called once per canonical key. alias is the local
	// alias of whichever site first reached the library (which matters
	// when the visitor names a directory or package after it).
	OnUBLibrary(alias, canonicalKey string, ref ImportRef, lib *UBLibrary) error
}

UBVisitor is implemented by callers that want to consume the walked import graph. The walker invokes its methods as it descends.