pub dep_kind: CTX::DepKind,
pub eval_always: bool,
- // Don't use this method to compute query results, instead use the methods on TyCtxt
- pub compute: fn(CTX, K) -> V,
-
pub hash_result: fn(&mut CTX::StableHashingContext, &V) -> Option<Fingerprint>,
pub handle_cycle_error: fn(CTX, DiagnosticBuilder<'_>) -> V,
pub cache_on_disk: fn(CTX, &K, Option<&V>) -> bool,
DepNode::construct(tcx, self.dep_kind, key)
}
- pub(crate) fn compute(&self, tcx: CTX, key: K) -> V {
- (self.compute)(tcx, key)
- }
-
pub(crate) fn hash_result(
&self,
hcx: &mut CTX::StableHashingContext,
CTX: 'a;
// Don't use this method to compute query results, instead use the methods on TyCtxt
- fn compute(tcx: CTX, key: Self::Key) -> Self::Value;
+ fn compute_fn(tcx: CTX, key: &Self::Key) -> fn(CTX::DepContext, Self::Key) -> Self::Value;
fn hash_result(
hcx: &mut CTX::StableHashingContext,
anon: Q::ANON,
dep_kind: Q::DEP_KIND,
eval_always: Q::EVAL_ALWAYS,
- compute: Q::compute,
hash_result: Q::hash_result,
handle_cycle_error: Q::handle_cycle_error,
cache_on_disk: Q::cache_on_disk,
key: C::Key,
lookup: QueryLookup,
query: &QueryVtable<CTX, C::Key, C::Value>,
+ compute: fn(CTX::DepContext, C::Key) -> C::Value,
) -> C::Stored
where
C: QueryCache,
// Fast path for when incr. comp. is off.
if !dep_graph.is_fully_enabled() {
let prof_timer = tcx.dep_context().profiler().query_provider();
- let result = tcx.start_query(job.id, None, || query.compute(tcx, key));
+ let result = tcx.start_query(job.id, None, || compute(*tcx.dep_context(), key));
let dep_node_index = dep_graph.next_virtual_depnode_index();
prof_timer.finish_with_query_invocation_id(dep_node_index.into());
return job.complete(result, dep_node_index);
let ((result, dep_node_index), diagnostics) = with_diagnostics(|diagnostics| {
tcx.start_query(job.id, diagnostics, || {
- dep_graph
- .with_anon_task(*tcx.dep_context(), query.dep_kind, || query.compute(tcx, key))
+ dep_graph.with_anon_task(*tcx.dep_context(), query.dep_kind, || {
+ compute(*tcx.dep_context(), key)
+ })
})
});
dep_node_index,
&dep_node,
query,
+ compute,
),
dep_node_index,
)
}
}
- let (result, dep_node_index) = force_query_with_job(tcx, key, job, dep_node, query);
+ let (result, dep_node_index) = force_query_with_job(tcx, key, job, dep_node, query, compute);
dep_graph.read_index(dep_node_index);
result
}
dep_node_index: DepNodeIndex,
dep_node: &DepNode<CTX::DepKind>,
query: &QueryVtable<CTX, K, V>,
+ compute: fn(CTX::DepContext, K) -> V,
) -> V
where
CTX: QueryContext,
let prof_timer = tcx.dep_context().profiler().query_provider();
// The dep-graph for this computation is already in-place.
- let result = tcx.dep_context().dep_graph().with_ignore(|| query.compute(tcx, key));
+ let result = tcx.dep_context().dep_graph().with_ignore(|| compute(*tcx.dep_context(), key));
prof_timer.finish_with_query_invocation_id(dep_node_index.into());
job: JobOwner<'_, CTX::DepKind, C>,
dep_node: DepNode<CTX::DepKind>,
query: &QueryVtable<CTX, C::Key, C::Value>,
+ compute: fn(CTX::DepContext, C::Key) -> C::Value,
) -> (C::Stored, DepNodeIndex)
where
C: QueryCache,
if query.eval_always {
tcx.dep_context().dep_graph().with_eval_always_task(
dep_node,
- tcx,
+ *tcx.dep_context(),
key,
- query.compute,
+ compute,
query.hash_result,
)
} else {
tcx.dep_context().dep_graph().with_task(
dep_node,
- tcx,
+ *tcx.dep_context(),
key,
- query.compute,
+ compute,
query.hash_result,
)
}
key: C::Key,
lookup: QueryLookup,
query: &QueryVtable<CTX, C::Key, C::Value>,
+ compute: fn(CTX::DepContext, C::Key) -> C::Value,
) -> C::Stored
where
CTX: QueryContext,
C: QueryCache,
C::Key: DepNodeParams<CTX::DepContext>,
{
- try_execute_query(tcx, state, cache, span, key, lookup, query)
+ try_execute_query(tcx, state, cache, span, key, lookup, query, compute)
}
/// Ensure that either this query has all green inputs or been executed.
tcx: CTX,
state: &QueryState<CTX::DepKind, C::Key>,
cache: &QueryCacheStore<C>,
+ key: C::Key,
dep_node: DepNode<CTX::DepKind>,
query: &QueryVtable<CTX, C::Key, C::Value>,
+ compute: fn(CTX::DepContext, C::Key) -> C::Value,
) -> bool
where
C: QueryCache,
{
debug_assert!(!query.anon);
- if !<C::Key as DepNodeParams<CTX::DepContext>>::can_reconstruct_query_key() {
- return false;
- }
-
- let key = if let Some(key) =
- <C::Key as DepNodeParams<CTX::DepContext>>::recover(*tcx.dep_context(), &dep_node)
- {
- key
- } else {
- return false;
- };
-
// We may be concurrently trying both execute and force a query.
// Ensure that only one of them runs the query.
let cached = cache.cache.lookup(cache, &key, |_, index| {
TryGetJob::JobCompleted(_) => return true,
};
- force_query_with_job(tcx, key, job, dep_node, query);
+ force_query_with_job(tcx, key, job, dep_node, query, compute);
true
}
}
debug!("ty::query::get_query<{}>(key={:?}, span={:?})", Q::NAME, key, span);
- let value =
- get_query_impl(tcx, Q::query_state(tcx), Q::query_cache(tcx), span, key, lookup, query);
+ let compute = Q::compute_fn(tcx, &key);
+ let value = get_query_impl(
+ tcx,
+ Q::query_state(tcx),
+ Q::query_cache(tcx),
+ span,
+ key,
+ lookup,
+ query,
+ compute,
+ );
Some(value)
}
return false;
}
- force_query_impl(tcx, Q::query_state(tcx), Q::query_cache(tcx), *dep_node, &Q::VTABLE)
+ if !<Q::Key as DepNodeParams<CTX::DepContext>>::can_reconstruct_query_key() {
+ return false;
+ }
+
+ let key = if let Some(key) =
+ <Q::Key as DepNodeParams<CTX::DepContext>>::recover(*tcx.dep_context(), &dep_node)
+ {
+ key
+ } else {
+ return false;
+ };
+
+ let compute = Q::compute_fn(tcx, &key);
+ force_query_impl(
+ tcx,
+ Q::query_state(tcx),
+ Q::query_cache(tcx),
+ key,
+ *dep_node,
+ &Q::VTABLE,
+ compute,
+ )
}