Enum PredicateNode 

pub enum PredicateNode<'db> {
    Expression(Expression<'db>),
    ContextManagerSuppresses {
        expression: Expression<'db>,
        is_async: bool,
    },
    FinallyNormalPathImpossible {
        scope: ScopeId<'db>,
        continuation: ScopedReachabilityConstraintId,
    },
    IsNonTerminalCall(CallableAndCallExpr<'db>),
    IsNonEmptyIterable(Expression<'db>),
    Pattern(PatternPredicate<'db>),
    OrPatternAlternative(ScopeId<'db>),
    SubjectElementPattern(SubjectElementPatternPredicate<'db>),
    StarImportPlaceholder(StarImportPlaceholderPredicate<'db>),
}

Variants

Expression(Expression<'db>)

ContextManagerSuppresses

Whether a context manager’s exit return type allows an exception to be suppressed.

Resolved during type inference because the context manager’s type is unavailable during semantic indexing.

Fields

expression: Expression<'db>

is_async: bool

FinallyNormalPathImpossible

Whether semantic evaluation rules out every normal entry into a finally suite.

The continuation is captured before constructing this predicate, so its constraint cannot depend on the predicate itself. Deferring evaluation preserves terminal cleanup paths when a context manager’s suppression behavior is unavailable during semantic indexing.

Fields

scope: ScopeId<'db>

continuation: ScopedReachabilityConstraintId

IsNonTerminalCall(CallableAndCallExpr<'db>)

These predicates are recorded for statements with call expressions. As part of reachability constraints, they are used to determine whether control flow can continue past this statement or not.

The predicate evaluates to crate::Truthiness::AlwaysTrue in the common case where a call is inferred as returning an inhabited type: in these situations, we will infer control flow as flowing through the call expression without terminating. If it can be statically guaranteed that a call always returns Never/NoReturn, however, the predicate evaluates to crate::Truthiness::AlwaysFalse, signaling that control flow ends as a result of the call: these call expressions are terminal.

These predicates never evaluate to crate::Truthiness::Ambiguous, even if the return type of the call is Unknown/Any, because that would result in too many false positives.

IsNonEmptyIterable(Expression<'db>)

Whether an iterable is statically known to yield at least one item.

Currently, this predicate is only emitted for direct range(...) calls. It is resolved semantically during type checking, so calls to a shadowed range remain ambiguous.

Pattern(PatternPredicate<'db>)

OrPatternAlternative(ScopeId<'db>)

Whether control flow takes one branch of an OR pattern instead of its remaining alternatives. The selected branch is unknown, but recording a predicate and its negation preserves the fact that exactly one branch is taken.

SubjectElementPattern(SubjectElementPatternPredicate<'db>)

StarImportPlaceholder(StarImportPlaceholderPredicate<'db>)

Trait Implementations

impl<'db> Clone for PredicateNode<'db>

fn clone(&self) -> PredicateNode<'db>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'db> Copy for PredicateNode<'db>

impl<'db> Debug for PredicateNode<'db>

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

Formats the value using the given formatter.

impl<'db> Eq for PredicateNode<'db>

impl<'db> GetSize for PredicateNode<'db>

fn get_heap_size(&self) -> usize

Determines how many bytes this object occupies inside the heap.

fn get_heap_size_with_tracker<TRACKER: GetSizeTracker>( &self, tracker: TRACKER, ) -> (usize, TRACKER)

Determines how many bytes this object occupies inside the heap while using a tracker.

fn get_stack_size() -> usize

Determines how may bytes this object occupies inside the stack.

fn get_size(&self) -> usize

Determines the total size of the object.

fn get_size_with_tracker<T>(&self, tracker: T) -> (usize, T)

where T: GetSizeTracker,

Determines the total size of the object while using a tracker.

impl<'db> Hash for PredicateNode<'db>

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<'db> PartialEq for PredicateNode<'db>

fn eq(&self, other: &PredicateNode<'db>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'db> SalsaValue for PredicateNode<'db>

impl<'db> StructuralPartialEq for PredicateNode<'db>