Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit 130b7e7

Browse files
gavinleroygavinleroy
committed
Add trait obligation tracking to FulfillCtxt and expose FnCtxt in rustc_infer using callback.
Pass each obligation to an fn callback with its respective inference context. This avoids needing to keep around copies of obligations or inference contexts. Specify usability of inspect_typeck in comment.
1 parent 2457c02 commit 130b7e7

File tree

5 files changed

+121
-64
lines changed

5 files changed

+121
-64
lines changed

‎compiler/rustc_hir_typeck/src/lib.rs‎

Lines changed: 21 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -60,6 +60,7 @@ use rustc_hir::{HirIdMap, Node};
6060
use rustc_hir_analysis::astconv::AstConv;
6161
use rustc_hir_analysis::check::check_abi;
6262
use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
63+
use rustc_infer::traits::ObligationInspector;
6364
use rustc_middle::query::Providers;
6465
use rustc_middle::traits;
6566
use rustc_middle::ty::{self, Ty, TyCtxt};
@@ -139,7 +140,7 @@ fn used_trait_imports(tcx: TyCtxt<'_>, def_id: LocalDefId) -> &UnordSet<LocalDef
139140

140141
fn typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::TypeckResults<'tcx> {
141142
let fallback = move || tcx.type_of(def_id.to_def_id()).instantiate_identity();
142-
typeck_with_fallback(tcx, def_id, fallback)
143+
typeck_with_fallback(tcx, def_id, fallback, None)
143144
}
144145

145146
/// Used only to get `TypeckResults` for type inference during error recovery.
@@ -149,14 +150,28 @@ fn diagnostic_only_typeck<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> &ty::T
149150
let span = tcx.hir().span(tcx.local_def_id_to_hir_id(def_id));
150151
Ty::new_error_with_message(tcx, span, "diagnostic only typeck table used")
151152
};
152-
typeck_with_fallback(tcx, def_id, fallback)
153+
typeck_with_fallback(tcx, def_id, fallback, None)
153154
}
154155

155-
#[instrument(level = "debug", skip(tcx, fallback), ret)]
156+
/// Same as `typeck` but `inspect` is invoked on evaluation of each root obligation.
157+
/// Inspecting obligations only works with the new trait solver.
158+
/// This function is *only to be used* by external tools, it should not be
159+
/// called from within rustc. Note, this is not a query, and thus is not cached.
160+
pub fn inspect_typeck<'tcx>(
161+
tcx: TyCtxt<'tcx>,
162+
def_id: LocalDefId,
163+
inspect: ObligationInspector<'tcx>,
164+
) -> &'tcx ty::TypeckResults<'tcx> {
165+
let fallback = move || tcx.type_of(def_id.to_def_id()).instantiate_identity();
166+
typeck_with_fallback(tcx, def_id, fallback, Some(inspect))
167+
}
168+
169+
#[instrument(level = "debug", skip(tcx, fallback, inspector), ret)]
156170
fn typeck_with_fallback<'tcx>(
157171
tcx: TyCtxt<'tcx>,
158172
def_id: LocalDefId,
159173
fallback: impl Fn() -> Ty<'tcx> + 'tcx,
174+
inspector: Option<ObligationInspector<'tcx>>,
160175
) -> &'tcx ty::TypeckResults<'tcx> {
161176
// Closures' typeck results come from their outermost function,
162177
// as they are part of the same "inference environment".
@@ -178,6 +193,9 @@ fn typeck_with_fallback<'tcx>(
178193
let param_env = tcx.param_env(def_id);
179194

180195
let inh = Inherited::new(tcx, def_id);
196+
if let Some(inspector) = inspector {
197+
inh.infcx.attach_obligation_inspector(inspector);
198+
}
181199
let mut fcx = FnCtxt::new(&inh, param_env, def_id);
182200

183201
if let Some(hir::FnSig { header, decl, .. }) = fn_sig {

‎compiler/rustc_infer/src/infer/at.rs‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -90,6 +90,7 @@ impl<'tcx> InferCtxt<'tcx> {
9090
universe: self.universe.clone(),
9191
intercrate,
9292
next_trait_solver: self.next_trait_solver,
93+
obligation_inspector: self.obligation_inspector.clone(),
9394
}
9495
}
9596
}

‎compiler/rustc_infer/src/infer/mod.rs‎

Lines changed: 15 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,9 @@ use rustc_middle::infer::unify_key::{ConstVidKey, EffectVidKey};
1313
use self::opaque_types::OpaqueTypeStorage;
1414
pub(crate) use self::undo_log::{InferCtxtUndoLogs, Snapshot, UndoLog};
1515

16-
use crate::traits::{self, ObligationCause, PredicateObligations, TraitEngine, TraitEngineExt};
16+
use crate::traits::{
17+
self, ObligationCause, ObligationInspector, PredicateObligations, TraitEngine, TraitEngineExt,
18+
};
1719

1820
use rustc_data_structures::fx::FxIndexMap;
1921
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
@@ -334,6 +336,8 @@ pub struct InferCtxt<'tcx> {
334336
pub intercrate: bool,
335337

336338
next_trait_solver: bool,
339+
340+
pub obligation_inspector: Cell<Option<ObligationInspector<'tcx>>>,
337341
}
338342

339343
impl<'tcx> ty::InferCtxtLike for InferCtxt<'tcx> {
@@ -708,6 +712,7 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
708712
universe: Cell::new(ty::UniverseIndex::ROOT),
709713
intercrate,
710714
next_trait_solver,
715+
obligation_inspector: Cell::new(None),
711716
}
712717
}
713718
}
@@ -1724,6 +1729,15 @@ impl<'tcx> InferCtxt<'tcx> {
17241729
}
17251730
}
17261731
}
1732+
1733+
/// Attach a callback to be invoked on each root obligation evaluated in the new trait solver.
1734+
pub fn attach_obligation_inspector(&self, inspector: ObligationInspector<'tcx>) {
1735+
debug_assert!(
1736+
self.obligation_inspector.get().is_none(),
1737+
"shouldn't override a set obligation inspector"
1738+
);
1739+
self.obligation_inspector.set(Some(inspector));
1740+
}
17271741
}
17281742

17291743
impl<'tcx> TypeErrCtxt<'_, 'tcx> {

‎compiler/rustc_infer/src/traits/mod.rs‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,12 +13,15 @@ use std::hash::{Hash, Hasher};
1313

1414
use hir::def_id::LocalDefId;
1515
use rustc_hir as hir;
16+
use rustc_middle::traits::query::NoSolution;
17+
use rustc_middle::traits::solve::Certainty;
1618
use rustc_middle::ty::error::{ExpectedFound, TypeError};
1719
use rustc_middle::ty::{self, Const, ToPredicate, Ty, TyCtxt};
1820
use rustc_span::Span;
1921

2022
pub use self::ImplSource::*;
2123
pub use self::SelectionError::*;
24+
use crate::infer::InferCtxt;
2225

2326
pub use self::engine::{TraitEngine, TraitEngineExt};
2427
pub use self::project::MismatchedProjectionTypes;
@@ -116,6 +119,11 @@ pub type PredicateObligations<'tcx> = Vec<PredicateObligation<'tcx>>;
116119

117120
pub type Selection<'tcx> = ImplSource<'tcx, PredicateObligation<'tcx>>;
118121

122+
/// A callback that can be provided to `inspect_typeck`. Invoked on evaluation
123+
/// of root obligations.
124+
pub type ObligationInspector<'tcx> =
125+
fn(&InferCtxt<'tcx>, &PredicateObligation<'tcx>, Result<Certainty, NoSolution>);
126+
119127
pub struct FulfillmentError<'tcx> {
120128
pub obligation: PredicateObligation<'tcx>,
121129
pub code: FulfillmentErrorCode<'tcx>,

‎compiler/rustc_trait_selection/src/solve/fulfill.rs‎

Lines changed: 76 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ use rustc_middle::ty;
1111
use rustc_middle::ty::error::{ExpectedFound, TypeError};
1212

1313
use super::eval_ctxt::GenerateProofTree;
14-
use super::{Certainty, InferCtxtEvalExt};
14+
use super::{Certainty, Goal, InferCtxtEvalExt};
1515

1616
/// A trait engine using the new trait solver.
1717
///
@@ -43,6 +43,21 @@ impl<'tcx> FulfillmentCtxt<'tcx> {
4343
);
4444
FulfillmentCtxt { obligations: Vec::new(), usable_in_snapshot: infcx.num_open_snapshots() }
4545
}
46+
47+
fn inspect_evaluated_obligation(
48+
&self,
49+
infcx: &InferCtxt<'tcx>,
50+
obligation: &PredicateObligation<'tcx>,
51+
result: &Result<(bool, Certainty, Vec<Goal<'tcx, ty::Predicate<'tcx>>>), NoSolution>,
52+
) {
53+
if let Some(inspector) = infcx.obligation_inspector.get() {
54+
let result = match result {
55+
Ok((_, c, _)) => Ok(*c),
56+
Err(NoSolution) => Err(NoSolution),
57+
};
58+
(inspector)(infcx, &obligation, result);
59+
}
60+
}
4661
}
4762

4863
impl<'tcx> TraitEngine<'tcx> for FulfillmentCtxt<'tcx> {
@@ -100,65 +115,66 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentCtxt<'tcx> {
100115
let mut has_changed = false;
101116
for obligation in mem::take(&mut self.obligations) {
102117
let goal = obligation.clone().into();
103-
let (changed, certainty, nested_goals) =
104-
match infcx.evaluate_root_goal(goal, GenerateProofTree::IfEnabled).0 {
105-
Ok(result) => result,
106-
Err(NoSolution) => {
107-
errors.push(FulfillmentError {
108-
obligation: obligation.clone(),
109-
code: match goal.predicate.kind().skip_binder() {
110-
ty::PredicateKind::Clause(ty::ClauseKind::Projection(_)) => {
111-
FulfillmentErrorCode::ProjectionError(
112-
// FIXME: This could be a `Sorts` if the term is a type
113-
MismatchedProjectionTypes { err: TypeError::Mismatch },
114-
)
115-
}
116-
ty::PredicateKind::NormalizesTo(..) => {
117-
FulfillmentErrorCode::ProjectionError(
118-
MismatchedProjectionTypes { err: TypeError::Mismatch },
119-
)
120-
}
121-
ty::PredicateKind::AliasRelate(_, _, _) => {
122-
FulfillmentErrorCode::ProjectionError(
123-
MismatchedProjectionTypes { err: TypeError::Mismatch },
124-
)
125-
}
126-
ty::PredicateKind::Subtype(pred) => {
127-
let (a, b) = infcx.instantiate_binder_with_placeholders(
128-
goal.predicate.kind().rebind((pred.a, pred.b)),
129-
);
130-
let expected_found = ExpectedFound::new(true, a, b);
131-
FulfillmentErrorCode::SubtypeError(
132-
expected_found,
133-
TypeError::Sorts(expected_found),
134-
)
135-
}
136-
ty::PredicateKind::Coerce(pred) => {
137-
let (a, b) = infcx.instantiate_binder_with_placeholders(
138-
goal.predicate.kind().rebind((pred.a, pred.b)),
139-
);
140-
let expected_found = ExpectedFound::new(false, a, b);
141-
FulfillmentErrorCode::SubtypeError(
142-
expected_found,
143-
TypeError::Sorts(expected_found),
144-
)
145-
}
146-
ty::PredicateKind::Clause(_)
147-
| ty::PredicateKind::ObjectSafe(_)
148-
| ty::PredicateKind::Ambiguous => {
149-
FulfillmentErrorCode::SelectionError(
150-
SelectionError::Unimplemented,
151-
)
152-
}
153-
ty::PredicateKind::ConstEquate(..) => {
154-
bug!("unexpected goal: {goal:?}")
155-
}
156-
},
157-
root_obligation: obligation,
158-
});
159-
continue;
160-
}
161-
};
118+
let result = infcx.evaluate_root_goal(goal, GenerateProofTree::IfEnabled).0;
119+
self.inspect_evaluated_obligation(infcx, &obligation, &result);
120+
let (changed, certainty, nested_goals) = match result {
121+
Ok(result) => result,
122+
Err(NoSolution) => {
123+
errors.push(FulfillmentError {
124+
obligation: obligation.clone(),
125+
code: match goal.predicate.kind().skip_binder() {
126+
ty::PredicateKind::Clause(ty::ClauseKind::Projection(_)) => {
127+
FulfillmentErrorCode::ProjectionError(
128+
// FIXME: This could be a `Sorts` if the term is a type
129+
MismatchedProjectionTypes { err: TypeError::Mismatch },
130+
)
131+
}
132+
ty::PredicateKind::NormalizesTo(..) => {
133+
FulfillmentErrorCode::ProjectionError(
134+
MismatchedProjectionTypes { err: TypeError::Mismatch },
135+
)
136+
}
137+
ty::PredicateKind::AliasRelate(_, _, _) => {
138+
FulfillmentErrorCode::ProjectionError(
139+
MismatchedProjectionTypes { err: TypeError::Mismatch },
140+
)
141+
}
142+
ty::PredicateKind::Subtype(pred) => {
143+
let (a, b) = infcx.instantiate_binder_with_placeholders(
144+
goal.predicate.kind().rebind((pred.a, pred.b)),
145+
);
146+
let expected_found = ExpectedFound::new(true, a, b);
147+
FulfillmentErrorCode::SubtypeError(
148+
expected_found,
149+
TypeError::Sorts(expected_found),
150+
)
151+
}
152+
ty::PredicateKind::Coerce(pred) => {
153+
let (a, b) = infcx.instantiate_binder_with_placeholders(
154+
goal.predicate.kind().rebind((pred.a, pred.b)),
155+
);
156+
let expected_found = ExpectedFound::new(false, a, b);
157+
FulfillmentErrorCode::SubtypeError(
158+
expected_found,
159+
TypeError::Sorts(expected_found),
160+
)
161+
}
162+
ty::PredicateKind::Clause(_)
163+
| ty::PredicateKind::ObjectSafe(_)
164+
| ty::PredicateKind::Ambiguous => {
165+
FulfillmentErrorCode::SelectionError(
166+
SelectionError::Unimplemented,
167+
)
168+
}
169+
ty::PredicateKind::ConstEquate(..) => {
170+
bug!("unexpected goal: {goal:?}")
171+
}
172+
},
173+
root_obligation: obligation,
174+
});
175+
continue;
176+
}
177+
};
162178
// Push any nested goals that we get from unifying our canonical response
163179
// with our obligation onto the fulfillment context.
164180
self.obligations.extend(nested_goals.into_iter().map(|goal| {

0 commit comments

Comments
 (0)