Enum CompileError 

#[non_exhaustive]
pub enum CompileError {
    EnvInterpolate(InterpolateError),
    Parse(ParseError),
    Normalize(NormalizeError),
    Expand(ExpandError),
    CompileAfter(CompileAfterError),
    Prepare(PrepareError),
    GatedClauseRequiresCompiledPath {
        id: String,
        clause: &'static str,
    },
}

Errors produced by compile_scenario_file.

Each variant wraps the corresponding phase’s error so callers can programmatically discriminate where compilation failed without string matching. The #[from] conversions let each phase’s fallible call site bubble up naturally via ?.

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.

EnvInterpolate(InterpolateError)

Phase 0 (env_interpolate): ${VAR} substitution against the process environment failed (unset required variable, malformed reference, or invalid variable name).

Parse(ParseError)

Phase 1 (parse): YAML parsing or schema validation failed.

Normalize(NormalizeError)

Phase 2 (normalize): defaults resolution failed (e.g. an entry was missing a required field with no default available).

Expand(ExpandError)

Phase 3 (expand): pack expansion failed (unknown pack, unknown override key, duplicate id, or resolver I/O error).

CompileAfter(CompileAfterError)

Phase 4+5 (compile_after): after: resolution, dependency graph, or clock-group assignment failed.

Prepare(PrepareError)

Phase 6 (prepare): translation to the runtime input shape failed. Shape invariants not visible to earlier phases surface here — e.g. an unknown signal_type on a programmatically- constructed CompiledFile.

Note: the PrepareError::UnknownSignalType, PrepareError::MissingGenerator, PrepareError::MissingLogGenerator, and PrepareError::MissingDistribution cases are effectively unreachable when the input comes through compile_scenario_file — earlier phases gate those shapes at YAML-level. They remain reachable for programmatic callers that build a CompiledFile in code and feed it directly to prepare.

GatedClauseRequiresCompiledPath

The YAML uses while: or delay: clauses, which require the gated runtime. compile_scenario_file returns Vec<ScenarioEntry>, a shape that has no fields for these clauses, so silently accepting such input would drop the gate semantics and run the downstream as ungated. Call compile_scenario_file_compiled instead and feed the resulting CompiledFile to run_multi_compiled.

Fields

id: String

The id of the entry that carries the gated clause.

clause: &'static str

Which clause kind tripped the check ("while:" or "delay:").

Trait Implementations

impl Debug for CompileError

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

Formats the value using the given formatter.

impl Display for CompileError

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

Formats the value using the given formatter.

impl Error for CompileError

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 From<CompileAfterError> for CompileError

fn from(source: CompileAfterError) -> Self

Converts to this type from the input type.

impl From<ExpandError> for CompileError

fn from(source: ExpandError) -> Self

Converts to this type from the input type.

impl From<InterpolateError> for CompileError

fn from(source: InterpolateError) -> Self

Converts to this type from the input type.

impl From<NormalizeError> for CompileError

fn from(source: NormalizeError) -> Self

Converts to this type from the input type.

impl From<ParseError> for CompileError

fn from(source: ParseError) -> Self

Converts to this type from the input type.

impl From<PrepareError> for CompileError

fn from(source: PrepareError) -> Self

Converts to this type from the input type.