Struct RustcInvocation 

pub struct RustcInvocation { /* private fields */ }

Parsed, cache-safe model of one rustc command line.

Fields are intentionally private so new modeled flags can be added without exposing the adapter’s internal representation.

Implementations

impl RustcInvocation

pub fn dep_info_command( &self, output: &Path, ) -> Result<DepInfoCommand, BypassReason>

Replace the original output flags with a single explicit dep-info file.

pub fn discover_inputs( &self, dep_info: &RustcDepInfo, working_dir: &Path, ) -> Result<DiscoveredInputs, BypassReason>

Hash dep-info sources plus every direct compiler input already modeled by the invocation (--extern artifacts and custom target specs).

pub fn discover_inputs_with_mappings( &self, dep_info: &RustcDepInfo, working_dir: &Path, path_mappings: &[PathMapping], digests: &dyn FileDigestCache, ) -> Result<DiscoveredInputs, BypassReason>

Hash dep-info sources plus modeled compiler inputs, allowing native search directories beneath the working directory or a mapped root.

digests may answer for files the session already read in full; pass mbx_cache_core::NoFileDigestCache to hash everything.

pub fn discover_source_inputs( &self, dep_info: &RustcDepInfo, working_dir: &Path, digests: &dyn FileDigestCache, ) -> Result<DiscoveredInputs, BypassReason>

Hash dep-info sources and modeled compiler inputs, leaving native search directories out.

The result cannot key a shared action: the linker may read libraries it does not list. It is enough to tell whether a crate’s own sources changed, which is all that private incremental state needs, so it works for a compilation whose search paths Self::discover_inputs_with_mappings refuses.

impl RustcInvocation

pub fn parse(arguments: &[OsString]) -> Result<Self, BypassReason>

Parse rustc’s arguments, excluding the compiler executable supplied as the first argument to RUSTC_WRAPPER.

Any flag whose cache semantics are not modeled returns a bypass reason instead of guessing. A successful parse admits the rlib/rmeta tier, every compilation that links nothing at all – what cargo check and clippy run, whatever the crate type – and binaries linked by compiler-bundled WebAssembly toolchains.

pub fn expand_arguments( arguments: &[OsString], ) -> Result<Vec<OsString>, BypassReason>

The command line with @argfile response files expanded, as the parser sees it. A caller that scans the arguments before parsing, for a --target a response file may carry, reads this rather than the raw list.

pub fn parse_with( arguments: &[OsString], options: ParseOptions, ) -> Result<Self, BypassReason>

Parse as RustcInvocation::parse does, admitting what options says the caller can model.

pub fn links_natively(&self) -> bool

Whether this invocation links a native artifact, whose key must therefore describe the linker that produced it.

pub fn portable_install_name(&self, outputs: &RustcOutputs) -> Option<String>

Stable Mach-O identity for a cached macOS proc macro. The compiler loads these by filename; embedding the checkout’s output path only makes the bytes (and dependent action keys) vary between otherwise identical builds.

pub fn linker_override(&self) -> Option<&Path>

Linker selected with -C linker, if the invocation overrides rustc’s platform default.

pub fn fuse_ld(&self) -> Option<&str>

Linker selected with -C link-arg=-fuse-ld=<name>, if the invocation passes one the adapter models.

pub fn native_search_paths(&self) -> impl Iterator<Item = &Path>

Native directories explicitly searched by this invocation. Callers can map external installations so their contents participate in discovery and prediction, rather than treating their paths as immutable inputs.

pub fn source(&self) -> &Path

Return the source input passed to rustc.

pub fn required_inputs_in(&self, working_dir: &Path) -> Vec<PathBuf>

Absolute files named directly by the invocation that rustc must read.

This includes the source, explicit extern artifacts, and custom target specifications. Callers can snapshot these before rustc starts even though the complete input set is only known from dep-info afterwards.

pub fn target(&self) -> Option<&str>

Return the explicitly selected compilation target, if any.

pub fn crate_name(&self) -> &str

Return the crate name rustc will assign to this compilation.

pub fn remaps_working_directory(&self) -> bool

Whether rustc records a virtual directory in place of the working directory (-Zremap-cwd-prefix).

rustc checks incremental state against its options, the working directory included, and ignores state recorded anywhere else. Under this flag, with the paths under the working directory named relative to it, every checkout presents the same options, so one checkout’s state is as good as another’s.

pub fn source_fingerprint(&self, discovered: &DiscoveredInputs) -> CacheDigest

Digest of the inputs this compilation owns: its sources and whatever they read, but not the artifacts it merely links against.

This is what separates a crate someone is editing from one sitting above it in the graph. Rebuilding a dependency changes the action key of every crate that links it, because their keys hash its artifact; it does not change this. A caller watching for churn has to watch this instead, or a single edited crate would drag its whole dependent cone along.

Host paths enter the digest as they are. This describes one checkout to itself rather than to the cache, so there is nothing here to make portable.

pub fn outputs(&self, working_dir: &Path) -> Result<RustcOutputs, BypassReason>

Resolve the files produced by this invocation.

The initial cache tier requires one output directory so its artifact can be represented by one protocol directory and restored atomically later.

pub fn action( &self, context: ActionContext, ) -> Result<RustcAction, BypassReason>

Build canonical action bytes after precise input discovery has run.

context.inputs must contain the source, every explicit extern, and every additional source or environment-generated input discovered from dep-info.

pub fn action_linked_by( &self, context: ActionContext, linker: Option<LinkerIdentity>, ) -> Result<RustcAction, BypassReason>

Build canonical action bytes for an invocation that links a native program.

A linker is required whenever RustcInvocation::links_natively holds: the linker, its startup objects, and the platform SDK are inputs rustc dep-info does not enumerate, so a key without them would claim more than it can support. Passing one for anything else is ignored, since nothing else depends on a linker.

pub fn invocation_digest( &self, context: &ActionContext, ) -> Result<CacheDigest, BypassReason>

Fingerprint the modeled invocation before dependency contents are known.

pub fn prediction( &self, context: &ActionContext, discovered: &DiscoveredInputs, ) -> Result<RustcInputPrediction, BypassReason>

Capture normalized dependency paths for a future invocation that has no dep-info file yet.

Trait Implementations

impl Clone for RustcInvocation

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RustcInvocation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for RustcInvocation

impl PartialEq for RustcInvocation

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RustcInvocation