Enum Condition 

pub enum Condition {
    KeyValue {
        key: ConditionKey,
        value: String,
    },
    Feature(String),
    All(Vec<Condition>),
    Any(Vec<Condition>),
    Not(Box<Condition>),
}

Typed AST for a cfg(...) target condition.

The wire format matches the manifest text: a key/value (key = "value") leaf, or one of the all / any / not combinators. Equality and ordering are structural, so identical expressions always compare equal regardless of whitespace or quote style in the original source.

Variants

KeyValue

key = "value". The key is restricted to the ConditionKey set; the value is a free-form ASCII string interpreted by evaluate.

Fields

key: ConditionKey

value: String

Feature(String)

feature = "name". Evaluates against the enabled-feature set of the package the condition belongs to, not the platform. Feature conditions are only meaningful — and only accepted — in flag tables ([target.'cfg(...)'.profile]); the manifest layer rejects a feature-referencing cfg that gates a dependency table, because feature resolution itself runs over the dependency graph and a feature→dependency edge would be circular.

All(Vec<Condition>)

all(<conditions>). Empty all() is rejected at parse time.

Any(Vec<Condition>)

any(<conditions>). Empty any() is rejected at parse time.

Not(Box<Condition>)

not(<single condition>).

Implementations

impl Condition

pub fn parse_cfg(input: &str) -> Result<Self, ConditionParseError>

Parse a full cfg(...) expression. The wrapping cfg(...) is required so the parser is symmetric with the manifest text users write.

Errors

Returns ConditionParseError::ExpectedCfgPrefix when the input is not wrapped in cfg(, ConditionParseError::UnbalancedParens when the trailing ) is missing, and propagates any ConditionParseError from parsing the inner expression.

pub fn parse_inner(input: &str) -> Result<Self, ConditionParseError>

Parse the inner expression of a cfg(...) form (no cfg( prefix or trailing )). Useful for the metadata round-trip path, where we store the inner form.

Errors

Returns a ConditionParseError when the expression is malformed — e.g. an unsupported key, a missing = or quoted value, an empty all()/any(), a not() of wrong arity, unbalanced parentheses, or trailing input after the expression.

pub fn evaluate( &self, platform: &TargetPlatform, features: &BTreeSet<String>, ) -> bool

Evaluate this condition against platform and the set of features enabled on the owning package. The result is fully determined by those inputs and the condition’s AST — no global state, no environment lookup, no I/O.

Platform contexts that carry no feature information (every dependency-gating call) pass an empty set; this is correct-by-construction because a feature-referencing cfg is rejected on dependency tables at manifest-load time, so a Feature leaf can only be reached here through a flag table that threaded the real enabled-feature set in.

pub fn references_feature(&self) -> bool

Whether this condition references any feature = "..." leaf. Used by the manifest layer to reject feature conditions on dependency tables (where they would be circular) while allowing them on flag tables.

Trait Implementations

impl Clone for Condition

fn clone(&self) -> Condition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Condition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Condition

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for Condition

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

Canonical string form. Round-trips through Condition::parse_inner.

impl Eq for Condition

impl Hash for Condition

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Condition

fn cmp(&self, other: &Condition) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Condition

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Condition

fn partial_cmp(&self, other: &Condition) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Condition

fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Condition