Struct rustc_query_system::query::plumbing::JobOwner

pub(in query::plumbing) struct JobOwner<'tcx, D, Q, C> where
    D: Copy + Clone + Eq + Hash,
    Q: Clone,
    C: QueryCache,  {
    state: &'tcx QueryState<D, Q, C>,
    key: C::Key,
    id: QueryJobId<D>,
}

A type representing the responsibility to execute the job in the job field. This will poison the relevant query if dropped.

Fields

state: &'tcx QueryState<D, Q, C>

key: C::Key

id: QueryJobId<D>

Implementations

impl<'tcx, D, Q, C> JobOwner<'tcx, D, Q, C> where
    D: Copy + Clone + Eq + Hash,
    Q: Clone,
    C: QueryCache, 

pub(in query::plumbing) fn try_start<'a, 'b, CTX>(
    tcx: CTX,
    state: &'b QueryState<CTX::DepKind, CTX::Query, C>,
    span: Span,
    key: &C::Key,
    lookup: QueryLookup<'a, CTX::DepKind, CTX::Query, C::Key, C::Sharded>,
    query: &QueryVtable<CTX, C::Key, C::Value>
) -> TryGetJob<'b, CTX::DepKind, CTX::Query, C> where
    CTX: QueryContext, 

Either gets a JobOwner corresponding the query, allowing us to start executing the query, or returns with the result of the query. This function assumes that try_get_cached is already called and returned lookup. If the query is executing elsewhere, this will wait for it and return the result. If the query panicked, this will silently panic.

This function is inlined because that results in a noticeable speed-up for some compile-time benchmarks.

pub(in query::plumbing) fn complete(
    self,
    result: C::Value,
    dep_node_index: DepNodeIndex
) -> C::Stored

Completes the query by updating the query cache with the result, signals the waiter and forgets the JobOwner, so it won't poison the query

Trait Implementations

impl<'tcx, D, Q, C> Drop for JobOwner<'tcx, D, Q, C> where
    D: Copy + Clone + Eq + Hash,
    Q: Clone,
    C: QueryCache, 

pub fn drop(&mut self)

Executes the destructor for this type.