package cli

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

Dependency Relation
	imports 11 packages, and imported by one package

Involved Source Files

	  d cli.go
		Package cli is the command-line boundary for plumb: it parses flags, drives
		the loader, resolves the destination, runs the pure core, and writes output.
		All diagnostics flow through the streams passed to Run so the behavior is
		testable.
Package-Level Functions (total 6, in which 1 is exported)

	 func Run(args []string, stdout, stderr, report io.Writer) int
		Run executes plumb with the given arguments and streams, returning the process
		exit code. It never calls os.Exit itself. Output is split across three writers:
		stdout carries the generated source (when -output is unset), stderr carries
		diagnostics and the tolerated-error notes, and report carries the -v
		discovery-and-inference report. That report is the deterministic,
		plumb-controlled stream, kept separate from the variable diagnostics so it can
		be consumed on its own.
		The command wires report to the same destination as stderr.

	/* 5 unexporteds ... *//* 5 unexporteds: */
	 func baseName(path string) string
	 func fail(stderr io.Writer, msg string)
	 func noteToleratedErrors(stderr io.Writer, typeErrors []error)
		noteToleratedErrors prints the load-time type errors plumb tolerated, under a
		single stderr note header with one indented line per error. They are surfaced
		on failure (a tolerated error may be the real cause) and under -v on success
		(so a not-fully-type-correct load is visible).
		
		The errors print in the order the loader encountered them, which is not stable
		across package load orders. That is deliberate: unlike the generated source
		and the -v report (which plumb guarantees byte-identical across read orders),
		these notes are a diagnostic aid, and showing the errors in the order they
		actually occurred is more useful than imposing an artificial, stable sort.

	 func resolveDestination(pkgs []*discover.Package, importPathFlag, packageNameFlag string) (importPath, packageName string, err error)
		resolveDestination determines the destination import path and emitted package
		name from the flags and scanned packages, inferring each when its flag is
		omitted and rejecting the ambiguous or contradictory combinations.

	 func writeOutput(path, src string, stdout io.Writer) error
Package-Level Variables (total 7, none are exported)

	/* 7 unexporteds ... *//* 7 unexporteds: */
	  var errAmbiguousDestination error
		Sentinel errors for destination resolution, so its failures are classified in
		tests with errors.Is rather than by matching message text.

	  var errInvalidImportPath error
		Sentinel errors for destination resolution, so its failures are classified in
		tests with errors.Is rather than by matching message text.

	  var errInvalidPackageName error
		Sentinel errors for destination resolution, so its failures are classified in
		tests with errors.Is rather than by matching message text.

	  var errNoPackages error
		Sentinel errors for destination resolution, so its failures are classified in
		tests with errors.Is rather than by matching message text.

	  var errPackageNameMismatch error
		Sentinel errors for destination resolution, so its failures are classified in
		tests with errors.Is rather than by matching message text.

	  var errPackageNameRequired error
		Sentinel errors for destination resolution, so its failures are classified in
		tests with errors.Is rather than by matching message text.

	  var errSyntheticImportPath error
		Sentinel errors for destination resolution, so its failures are classified in
		tests with errors.Is rather than by matching message text.


Package-Level Constants (total 3, none are exported)

	/* 3 unexporteds ... *//* 3 unexporteds: */
	const noteHeader = "plumb: note: tolerated load errors:"
		noteHeader is the fixed line noteToleratedErrors prints above the tolerated
		go/types errors. It is deterministic (unlike the error bodies below it), so
		tests key on it to confirm the note surfaced.

	const syntheticImportPath = "command-line-arguments"
		syntheticImportPath is the placeholder import path the go/packages loader
		assigns to a package it synthesizes from file arguments (e.g. `plumb a.go`)
		rather than resolving from an import-path pattern. It is syntactically a valid
		path, so it passes module.CheckImportPath; plumb must reject it separately
		because it is not a real, importable destination to qualify against.

	const usage = "plumb is a demand-based compile-time dependency injection generator....

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