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.

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 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 linker_override(&self) -> Option<&Path>

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

pub fn source(&self) -> &Path

Return the source input passed to rustc.

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 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) -> RustcInvocation

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: &RustcInvocation) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for RustcInvocation