Enum CompileOutcome 

pub enum CompileOutcome {
    Compiled(CompiledId),
    CompiledWithWarnings(CompiledId, Vec<String>),
    Rejected(String),
}

What Evaluator::compile decided about one predicate document.

Three outcomes, not two, because a working compile and a working compile with something the operator should see are different enough to need different handling downstream (an operator-facing report, never a blocked policy) and collapsing them would either bury the warning or promote it to a rejection it never earned.

Variants

Compiled(CompiledId)

predicate compiled cleanly. evaluate/observe/policy_lifecycle calls for this policy should name this CompiledId from now on.

CompiledWithWarnings(CompiledId, Vec<String>)

predicate compiled, but the evaluator has something to say about it that does not block it from being used – e.g. “this pattern is vulnerable to homoglyphs, normalize first.” Reaches the operator; never the caller’s decision to invent on the evaluator’s behalf, since only the evaluator knows what is actually wrong with its own compiled form.

Rejected(String)

predicate could not be compiled at all: bad syntax, an unsupported combination, whatever this evaluator wants to say. The caller treats this exactly like an unrecognised language – crate::policy::Predicate::Unusable, scoped to this policy’s own applicability – except that didbot-pds’s loader additionally checks whether an earlier revision of the same policy last compiled successfully, and if so keeps enforcing that one instead. See plan/policy.md’s last-good-revision behaviour for why a rejection here must never by itself widen or produce a blanket denial.

Trait Implementations

impl Clone for CompileOutcome

fn clone(&self) -> CompileOutcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompileOutcome

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

Formats the value using the given formatter.

impl PartialEq for CompileOutcome

fn eq(&self, other: &CompileOutcome) -> 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 Eq for CompileOutcome

impl StructuralPartialEq for CompileOutcome