Enum CcBypassReason 

#[non_exhaustive]
pub enum CcBypassReason {
    NonUtf8Argument {
        index: usize,
    },
    ResponseFile(String),
    UnknownFlag(String),
    MissingValue(String),
    CompilerQuery,
    NotACompile,
    NonObjectOutput(String),
    StandardInput,
    MissingInput,
    MultipleInputs,
    MissingOutput,
    UnsupportedLanguage(String),
    CallerDependencyFlags(String),
    PrecompiledHeader(String),
    CoverageInstrumentation(String),
    SplitDebugOutput(String),
    SaveTemps(String),
    ToolPassthrough(String),
    Plugin(String),
    SearchPathModifiedDuringCompilation(PathBuf),
    UnportableOutput(PathBuf),
    LocalCpuTarget(String),
    UnsupportedCompilerDriver(String),
    CompilerIdentityUnavailable(String),
    UnsupportedEnvironment(String),
    RealCompilerUnpinned,
    EmbeddedTimestampMacro(PathBuf),
    MalformedDepfile(String),
    DepfileRead {
        path: PathBuf,
        message: String,
    },
    TooManyInputs,
    UnmappedAbsolutePath(PathBuf),
    NonUtf8Path(PathBuf),
    RelativeWorkingDirectory(PathBuf),
    RelativePathMapping(PathBuf),
    InvalidPathPlaceholder(String),
    MissingRequiredInput(String),
    InvalidInputDigest(String),
    ConflictingInput(String),
    InputRead {
        path: PathBuf,
        message: String,
    },
    InputChanged(PathBuf),
    InputModifiedDuringCompilation(PathBuf),
    DiscoveryWorkingDirectory,
    UnsupportedPrediction,
    InvalidPredictedInput(String),
    Serialization(String),
}

Reason a C or C++ invocation cannot safely use the action cache.

A bypass is an expected conservative outcome, not a compiler error. Match on CcBypassReason::kind for aggregation rather than on the variants.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

NonUtf8Argument

An argument cannot be represented in the canonical UTF-8 key.

Fields

index: usize

Zero-based index in the argument slice.

ResponseFile(String)

The driver was handed an argument file.

UnknownFlag(String)

A compiler flag is not modeled by this adapter version.

MissingValue(String)

A recognized flag was given without its value.

CompilerQuery

The invocation asks the driver about itself rather than compiling.

NotACompile

The invocation is not a single-object compile.

NonObjectOutput(String)

The invocation emits preprocessed source or assembly.

StandardInput

The source arrives on standard input and cannot be rediscovered.

MissingInput

No source file was given.

MultipleInputs

More than one source file was given.

MissingOutput

No -o was given, so the object name follows driver defaults.

UnsupportedLanguage(String)

The source language is outside the modeled set.

CallerDependencyFlags(String)

The caller asked for its own dependency output.

PrecompiledHeader(String)

Precompiled headers are not byte-hermetic key material.

CoverageInstrumentation(String)

Coverage instrumentation writes outputs beside the object.

SplitDebugOutput(String)

Split debug info writes a .dwo beside the object.

SaveTemps(String)

Temporary files are preserved beside the object.

ToolPassthrough(String)

An option is smuggled to a sub-tool the adapter cannot model.

Plugin(String)

A compiler plugin makes the output depend on unmodeled code.

SearchPathModifiedDuringCompilation(PathBuf)

An include search directory gained or lost a header while the compiler ran, so the manifest recorded after it is not what the compilation saw.

UnportableOutput(PathBuf)

The object kept a path the key normalized away.

Remapping covers what the compiler records itself; a path the source keeps as a string survives it, and publishing such an object would share this checkout’s directory under a key that says it does not matter.

LocalCpuTarget(String)

The object depends on the machine’s own CPU rather than on named inputs.

UnsupportedCompilerDriver(String)

The driver is not a gcc-style or clang-style compiler.

CompilerIdentityUnavailable(String)

The identity probe could not be run or parsed.

UnsupportedEnvironment(String)

An environment variable outside the modeled set is set.

RealCompilerUnpinned

The shim could not be told which real compiler to run.

EmbeddedTimestampMacro(PathBuf)

A read file expands a timestamp macro, so the object is not a function of its inputs.

MalformedDepfile(String)

The injected depfile could not be parsed exactly.

DepfileRead

The injected depfile could not be read.

Fields

path: PathBuf

Depfile that could not be read.

message: String

Underlying error text.

TooManyInputs

The action exceeds an input, byte, or manifest bound.

UnmappedAbsolutePath(PathBuf)

An absolute path lies outside every mapped and system root.

NonUtf8Path(PathBuf)

A path cannot be represented in the canonical UTF-8 key.

RelativeWorkingDirectory(PathBuf)

The compiler working directory is not absolute.

RelativePathMapping(PathBuf)

A configured path mapping root is not absolute.

InvalidPathPlaceholder(String)

A configured placeholder is empty, duplicated, or not a bare name.

MissingRequiredInput(String)

A required input never appeared among the discovered inputs.

InvalidInputDigest(String)

An input digest is malformed.

ConflictingInput(String)

One normalized path carries two different digests.

InputRead

An input could not be read.

Fields

path: PathBuf

Input that could not be read.

message: String

Underlying error text.

InputChanged(PathBuf)

An input changed between discovery and publication.

InputModifiedDuringCompilation(PathBuf)

An input was written while the compiler ran.

DiscoveryWorkingDirectory

Discovery and the action disagree about the working directory.

UnsupportedPrediction

A prediction uses a schema this adapter version does not model.

InvalidPredictedInput(String)

A predicted input name cannot be resolved back to a host path.

Serialization(String)

Canonical serialization failed.

Implementations

impl CcBypassReason

pub fn kind(&self) -> &'static str

A stable, low-cardinality name for this reason.

Many variants carry a path or a flag, so Display text cannot be aggregated; statistics group by this instead.

pub fn remediation(&self) -> Option<&'static str>

A concrete change that can make this invocation cacheable, when one is available.

Expected compiler probes and failures that require adapter support return None; callers can still explain those from CcBypassReason::kind.

Trait Implementations

impl Clone for CcBypassReason

fn clone(&self) -> CcBypassReason

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CcBypassReason

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

Formats the value using the given formatter.

impl Display for CcBypassReason

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

Formats the value using the given formatter.

impl Eq for CcBypassReason

impl Error for CcBypassReason

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<'_derivative_strum> From<&'_derivative_strum CcBypassReason> for &'static str

fn from(x: &'_derivative_strum CcBypassReason) -> &'static str

Converts to this type from the input type.

impl From<CcBypassReason> for &'static str

fn from(x: CcBypassReason) -> &'static str

Converts to this type from the input type.

impl From<PathNormalizationError> for CcBypassReason

fn from(reason: PathNormalizationError) -> Self

Converts to this type from the input type.

impl PartialEq for CcBypassReason

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CcBypassReason