Enum Predicate 

pub enum Predicate {
    HasCaller,
    HasCallee,
    IsUnused,
    Callers(PredicateValue),
    Callees(PredicateValue),
    Imports(PredicateValue),
    Exports(PredicateValue),
    References(PredicateValue),
    Implements(PredicateValue),
    InFile(PathPattern),
    InScope(ScopeKind),
    MatchesName(StringPattern),
    Returns(String),
    And(Vec<Predicate>),
    Or(Vec<Predicate>),
    Not(Box<Predicate>),
}

Filter condition applied to a node-set.

Predicates fall into four groups:

1. Existence checks: Predicate::HasCaller, Predicate::HasCallee, Predicate::IsUnused. Cheap — no value or subquery traversal needed.
2. Value-bearing relation predicates: Predicate::Callers through Predicate::Implements. These accept a PredicateValue on the right-hand side — a literal pattern, a regex, or a nested subquery. They map 1:1 to the six relation handlers in sqry-core::query::executor::graph_eval (match_callers, match_callees, match_imports, match_exports, match_references, match_implements) and their _subquery variants.
3. Attribute filters: Predicate::InFile, Predicate::InScope, Predicate::MatchesName.
4. Boolean combinators: Predicate::And, Predicate::Or, Predicate::Not.

Semantic alignment with graph_eval

The six relation variants exactly mirror the value-bearing operators in sqry-core::query::types::Value:

This IR	graph_eval handler	Text syntax
Callers(v)	match_callers / match_callers_subquery	callers:v
Callees(v)	match_callees / match_callees_subquery	callees:v
Imports(v)	match_imports / match_imports_subquery	imports:v
Exports(v)	match_exports / match_exports_subquery	exports:v
References(v)	match_references / match_references_subquery	references:v (supports ~= regex)
Implements(v)	match_implements / match_implements_subquery	impl:v / implements:v

The text frontend in DB13 must accept both impl: and implements: aliases for Predicate::Implements (spec §M8).

Variants

HasCaller

True iff the node has at least one incoming Calls edge.

HasCallee

True iff the node has at least one outgoing Calls edge.

IsUnused

True iff the node is not reachable from any entry point.

Callers(PredicateValue)

callers:<value>: node’s callers match the pattern / subquery.

Callees(PredicateValue)

callees:<value>: node’s callees match the pattern / subquery.

Imports(PredicateValue)

imports:<value>: node’s imports match the pattern / subquery.

Exports(PredicateValue)

exports:<value>: node’s exports match the pattern / subquery.

References(PredicateValue)

references:<value> (also supports ~= regex via PredicateValue::Regex).

Implements(PredicateValue)

impl:<value> / implements:<value>: matches nodes implementing the referenced trait / interface.

InFile(PathPattern)

in:<path-glob>: true iff the node’s file path matches the glob.

InScope(ScopeKind)

scope:<kind>: true iff the node’s enclosing scope kind matches.

MatchesName(StringPattern)

name:<pattern>: true iff the node’s name matches the pattern.

Returns(String)

returns:<TypeName>: true iff the node (a function or method) has at least one outgoing EdgeKind::TypeOf { context: Some(TypeOfContext::Return), .. } edge whose target node’s interned name matches TypeName exactly.

Semantics

The match is evaluated edge-based, not signature-text-based: the executor walks TypeOf edges with TypeOfContext::Return from the candidate node, resolves the target node’s primary name through the snapshot string interner, and compares with byte-exact equality (case-sensitive). Substring, glob, and regex variants are deliberately out of scope for this predicate; a future returns~: token (regex form) will lower to a separate IR variant rather than overload this one — the same shape used today for Predicate::References vs the references ~= /…/ regex form.

Why a bare String instead of StringPattern?

StringPattern auto-detects glob meta-characters and promotes to MatchMode::Glob; modelling the predicate value with String keeps the contract narrow — returns:Foo* is a parse error in users’ minds, not a hidden glob expansion. The single-mode shape also keeps cache keys monomorphic which simplifies any future derived-query backing for this predicate.

And(Vec<Predicate>)

Logical AND over a list of predicates. Empty list is vacuously true.

Or(Vec<Predicate>)

Logical OR over a list of predicates. Empty list is vacuously false.

Not(Box<Predicate>)

Logical NOT of a single predicate.

Implementations

impl Predicate

pub fn has_subquery(&self) -> bool

Returns true if this predicate (or any nested predicate through boolean combinators) references a PredicateValue::Subquery.

The executor uses this hint to decide whether to allocate subquery evaluation scratch space up front.

Trait Implementations

impl Clone for Predicate

fn clone(&self) -> Predicate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Predicate

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Predicate

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Predicate

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 PartialEq for Predicate

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Predicate

impl StructuralPartialEq for Predicate