rustc_trait_selection/traits/query/type_op/
mod.rs1use std::fmt;
2
3use rustc_errors::ErrorGuaranteed;
4use rustc_hir::def_id::LocalDefId;
5use rustc_infer::traits::PredicateObligations;
6use rustc_middle::traits::query::NoSolution;
7use rustc_middle::ty::{ParamEnvAnd, TyCtxt, TypeFoldable};
8use rustc_span::Span;
9
10use crate::infer::canonical::{
11 CanonicalQueryInput, CanonicalQueryResponse, Certainty, OriginalQueryValues,
12 QueryRegionConstraints,
13};
14use crate::infer::{InferCtxt, InferOk};
15use crate::traits::{ObligationCause, ObligationCtxt};
16
17pub mod ascribe_user_type;
18pub mod custom;
19pub mod normalize;
20pub mod outlives;
21pub mod prove_predicate;
22
23pub use rustc_middle::traits::query::type_op::*;
24
25use self::custom::scrape_region_constraints;
26
27pub trait TypeOp<'tcx>: Sized + fmt::Debug {
31 type Output: fmt::Debug;
32 type ErrorInfo;
33
34 fn fully_perform(
38 self,
39 infcx: &InferCtxt<'tcx>,
40 root_def_id: LocalDefId,
41 span: Span,
42 ) -> Result<TypeOpOutput<'tcx, Self>, ErrorGuaranteed>;
43}
44
45pub struct TypeOpOutput<'tcx, Op: TypeOp<'tcx>> {
47 pub output: Op::Output,
49 pub constraints: Option<&'tcx QueryRegionConstraints<'tcx>>,
51 pub error_info: Option<Op::ErrorInfo>,
53}
54
55pub trait QueryTypeOp<'tcx>: fmt::Debug + Copy + TypeFoldable<TyCtxt<'tcx>> + 'tcx {
65 type QueryResponse: TypeFoldable<TyCtxt<'tcx>>;
66
67 fn try_fast_path(
71 tcx: TyCtxt<'tcx>,
72 key: &ParamEnvAnd<'tcx, Self>,
73 ) -> Option<Self::QueryResponse>;
74
75 fn perform_query(
82 tcx: TyCtxt<'tcx>,
83 canonicalized: CanonicalQueryInput<'tcx, ParamEnvAnd<'tcx, Self>>,
84 ) -> Result<CanonicalQueryResponse<'tcx, Self::QueryResponse>, NoSolution>;
85
86 fn perform_locally_with_next_solver(
93 ocx: &ObligationCtxt<'_, 'tcx>,
94 key: ParamEnvAnd<'tcx, Self>,
95 span: Span,
96 ) -> Result<Self::QueryResponse, NoSolution>;
97
98 fn fully_perform_into(
99 query_key: ParamEnvAnd<'tcx, Self>,
100 infcx: &InferCtxt<'tcx>,
101 output_query_region_constraints: &mut QueryRegionConstraints<'tcx>,
102 span: Span,
103 ) -> Result<
104 (
105 Self::QueryResponse,
106 Option<CanonicalQueryInput<'tcx, ParamEnvAnd<'tcx, Self>>>,
107 PredicateObligations<'tcx>,
108 Certainty,
109 ),
110 NoSolution,
111 > {
112 if !infcx.disable_trait_solver_fast_paths()
113 && let Some(result) = QueryTypeOp::try_fast_path(infcx.tcx, &query_key)
114 {
115 return Ok((result, None, PredicateObligations::new(), Certainty::Proven));
116 }
117
118 let mut canonical_var_values = OriginalQueryValues::default();
119 let old_param_env = query_key.param_env;
120 let canonical_self = infcx.canonicalize_query(query_key, &mut canonical_var_values);
121 let canonical_result = Self::perform_query(infcx.tcx, canonical_self)?;
122
123 let InferOk { value, obligations } = infcx
124 .instantiate_nll_query_response_and_region_obligations(
125 &ObligationCause::dummy_with_span(span),
126 old_param_env,
127 &canonical_var_values,
128 canonical_result,
129 output_query_region_constraints,
130 )?;
131
132 Ok((value, Some(canonical_self), obligations, canonical_result.value.certainty))
133 }
134}
135
136impl<'tcx, Q> TypeOp<'tcx> for ParamEnvAnd<'tcx, Q>
137where
138 Q: QueryTypeOp<'tcx>,
139{
140 type Output = Q::QueryResponse;
141 type ErrorInfo = CanonicalQueryInput<'tcx, ParamEnvAnd<'tcx, Q>>;
142
143 fn fully_perform(
144 self,
145 infcx: &InferCtxt<'tcx>,
146 root_def_id: LocalDefId,
147 span: Span,
148 ) -> Result<TypeOpOutput<'tcx, Self>, ErrorGuaranteed> {
149 let mut error_info = None;
150 let mut region_constraints = QueryRegionConstraints::default();
151
152 let (mut output, _) =
157 scrape_region_constraints(infcx, root_def_id, "fully_perform", span, |ocx| {
158 let (output, ei, obligations, _) =
159 Q::fully_perform_into(self, infcx, &mut region_constraints, span)?;
160 error_info = ei;
161
162 ocx.register_obligations(obligations);
163 Ok(output)
164 })?;
165 output.error_info = error_info;
166 if let Some(QueryRegionConstraints { constraints, assumptions }) = output.constraints {
167 region_constraints.constraints.extend(constraints.iter().cloned());
168 region_constraints.assumptions.extend(assumptions.iter().cloned());
169 }
170 output.constraints = if region_constraints.is_empty() {
171 None
172 } else {
173 Some(infcx.tcx.arena.alloc(region_constraints))
174 };
175 Ok(output)
176 }
177}