Skip to content

Commit dde3f2b

Browse files
rust-timerrust-timer
authored
Unrolled build for rust-lang#119613
Rollup merge of rust-lang#119613 - gavinleroy:expose-obligations, r=lcnr Expose Obligations created during type inference. This PR is a first pass at exposing the trait obligations generated and solved for during the type-check progress. Exposing these obligations allows for rustc plugins to use the public interface for proof trees (provided by the next gen trait solver). The changes proposed track *all* obligations during the type-check process, this is desirable to not only look at the trees of failed obligations, but also those of successfully proved obligations. This feature is placed behind an unstable compiler option `track-trait-obligations` which should be used together with the `next-solver` option. I should note that the main interface is the function `inspect_typeck` made public in `rustc_hir_typeck/src/lib.rs` which allows the caller to provide a callback granting access to the `FnCtxt`. r? `@lcnr`
2 parents 5378c1c + 130b7e7 commit dde3f2b

File tree

5 files changed

+121
-64
lines changed

5 files changed

+121
-64
lines changed

‎compiler/rustc_hir_typeck/src/lib.rs

+21-3
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

+1
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

+15-1
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
}
@@ -1718,6 +1723,15 @@ impl<'tcx> InferCtxt<'tcx> {
17181723
}
17191724
}
17201725
}
1726+
1727+
/// Attach a callback to be invoked on each root obligation evaluated in the new trait solver.
1728+
pub fn attach_obligation_inspector(&self, inspector: ObligationInspector<'tcx>) {
1729+
debug_assert!(
1730+
self.obligation_inspector.get().is_none(),
1731+
"shouldn't override a set obligation inspector"
1732+
);
1733+
self.obligation_inspector.set(Some(inspector));
1734+
}
17211735
}
17221736

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

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

+8
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

+76-60
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)