package packagestest

Import Path
	go.pact.im/x/plumb/internal/packagestest (on go.dev)

Dependency Relation
	imports 10 packages, and imported by 0 packages

Involved Source Files

	  d packagestest.go
		Package packagestest is an in-memory Go package loader for tests. It type-checks
		source provided as a map of path → content, resolving imports against the
		in-memory module and a small synthetic subset of the standard library (see
		fakeStd), never GOROOT, a subprocess, or the disk. That keeps the fast unit
		tests (table-driven, golden, compile-check, fuzz, determinism) hermetic: they
		pass even when the test binary is built with -trimpath, which strips the
		baked-in GOROOT that the default disk-backed importer would otherwise need.
		
		File paths encode the package: a file at "example.com/app/x.go" belongs to
		the package whose import path is "example.com/app". The package name is taken
		from the package clause.
Package-Level Type Names (total 3, in which 2 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Loaded (struct)
		Loaded is the result of loading an in-memory module.

		Fields (total 2, both are exported)
			Packages []*discover.Package
			TypeErrors []error
				TypeErrors are non-fatal type-checking errors (e.g. a stale generated
				file). Parse errors are returned as the error result instead.

		As Outputs Of (at least 2, both are exported)
			func Load(files map[string]string) (*Loaded, error)
			func LoadShuffled(files map[string]string, shuffle ShuffleFunc) (*Loaded, error)

	 type ShuffleFunc (func)
		ShuffleFunc reorders a sequence of n elements by swapping pairs. It has the
		signature of math/rand/v2's (*Rand).Shuffle, so a *Rand's Shuffle method can
		be passed directly.

		As Inputs Of (at least 2, in which 1 is exported)
			func LoadShuffled(files map[string]string, shuffle ShuffleFunc) (*Loaded, error)
			/* at least one unexported ... *//* at least one unexported: */
			func applyShuffle[S, E](s S, shuffle ShuffleFunc)

	/* one unexported ... *//* one unexported: */
	 type recChecker (struct)
		recChecker type-checks the in-memory packages, resolving imports (both
		intra-module packages and the synthetic standard library) recursively from
		its parsed set. An import outside that set is an unknown package.

		Fields (total 8, none are exported)
			/* 8 unexporteds ... *//* 8 unexporteds: */
			cache map[string]*types.Package
			cycleErr error
				// first import cycle seen, wrapping ErrImportCycle

			fset *token.FileSet
			inProg map[string]bool
			infos map[string]*types.Info
			names map[string]string
			parsed map[string][]*ast.File
			typeErr *[]error
		Methods (total 3, in which 1 is exported)
			(*recChecker) Import(path string) (*types.Package, error)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			(*recChecker) appendError(err error)
			(*recChecker) check(ip string) (*types.Package, *types.Info, error)
		Implements (at least one exported)
			*recChecker : go/types.Importer


Package-Level Functions (total 3, in which 2 are exported)

	 func Load(files map[string]string) (*Loaded, error)
		Load parses and type-checks the given files, grouped into packages by their
		directory. The companion LoadShuffled additionally reorders the files, the
		load order, and the returned package slice to exercise determinism.

	 func LoadShuffled(files map[string]string, shuffle ShuffleFunc) (*Loaded, error)
		LoadShuffled is Load with an optional reordering of files within packages and
		of the packages themselves, used by the determinism test. When shuffle is nil
		the deterministic sorted order is used as-is.

	/* one unexported ... *//* one unexported: */
	 func applyShuffle[S, E](s S, shuffle ShuffleFunc)

		Type Parameters:
			S: ~[]E
			E: any

		applyShuffle reorders s in place using the given shuffle function. A nil
		shuffle leaves s untouched.


Package-Level Variables (total 2, in which 1 is exported)

	  var ErrImportCycle error
		ErrImportCycle is returned by Load when type-checking hits an import cycle. It
		is a sentinel so callers classify the failure with errors.Is rather than
		matching message text. (The type-checker also reports the cycle as a per-import
		type error, but that loses the error chain.)

	/* one unexported ... *//* one unexported: */
	  var fakeStd map[string]string
		fakeStd is the standard-library subset the corpus and plumb's generated output
		import, given as synthetic source. Resolving stdlib here rather than through
		go/importer keeps loads self-contained (no GOROOT, no disk), so the tests
		type-check under -trimpath. The declared surface is exactly what the fixtures
		and generated code reference: a wider import fails to resolve like any missing
		package, which points at the fixture that needs a new entry added here.

The pages are generated with Golds v0.8.4. (GOOS=linux GOARCH=amd64)