compiler/rustc_traits/src/type_op.rs

   1 use rustc_hir as hir;
   2 use rustc_hir::def_id::DefId;
   3 use rustc_infer::infer::at::ToTrace;
   4 use rustc_infer::infer::canonical::{Canonical, QueryResponse};
   5 use rustc_infer::infer::{DefiningAnchor, InferCtxt, TyCtxtInferExt};
   6 use rustc_infer::traits::TraitEngineExt as _;
   7 use rustc_middle::ty::query::Providers;
   8 use rustc_middle::ty::subst::{GenericArg, Subst, UserSelfTy, UserSubsts};
   9 use rustc_middle::ty::{
  10     self, EarlyBinder, FnSig, Lift, PolyFnSig, Ty, TyCtxt, TypeFoldable, Variance,
  11 };
  12 use rustc_middle::ty::{ParamEnv, ParamEnvAnd, Predicate, ToPredicate};
  13 use rustc_span::{Span, DUMMY_SP};
  14 use rustc_trait_selection::infer::InferCtxtBuilderExt;
  15 use rustc_trait_selection::infer::InferCtxtExt;
  16 use rustc_trait_selection::traits::query::normalize::AtExt;
  17 use rustc_trait_selection::traits::query::type_op::ascribe_user_type::AscribeUserType;
  18 use rustc_trait_selection::traits::query::type_op::eq::Eq;
  19 use rustc_trait_selection::traits::query::type_op::normalize::Normalize;
  20 use rustc_trait_selection::traits::query::type_op::prove_predicate::ProvePredicate;
  21 use rustc_trait_selection::traits::query::type_op::subtype::Subtype;
  22 use rustc_trait_selection::traits::query::{Fallible, NoSolution};
  23 use rustc_trait_selection::traits::{Normalized, Obligation, ObligationCause, TraitEngine};
  24 use std::fmt;
  25
  26 pub(crate) fn provide(p: &mut Providers) {
  27     *p = Providers {
  28         type_op_ascribe_user_type,
  29         type_op_eq,
  30         type_op_prove_predicate,
  31         type_op_subtype,
  32         type_op_normalize_ty,
  33         type_op_normalize_predicate,
  34         type_op_normalize_fn_sig,
  35         type_op_normalize_poly_fn_sig,
  36         ..*p
  37     };
  38 }
  39
  40 fn type_op_ascribe_user_type<'tcx>(
  41     tcx: TyCtxt<'tcx>,
  42     canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, AscribeUserType<'tcx>>>,
  43 ) -> Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution> {
  44     tcx.infer_ctxt().enter_canonical_trait_query(&canonicalized, |infcx, fulfill_cx, key| {
  45         type_op_ascribe_user_type_with_span(infcx, fulfill_cx, key, None)
  46     })
  47 }
  48
  49 /// The core of the `type_op_ascribe_user_type` query: for diagnostics purposes in NLL HRTB errors,
  50 /// this query can be re-run to better track the span of the obligation cause, and improve the error
  51 /// message. Do not call directly unless you're in that very specific context.
  52 pub fn type_op_ascribe_user_type_with_span<'a, 'tcx: 'a>(
  53     infcx: &'a InferCtxt<'a, 'tcx>,
  54     fulfill_cx: &'a mut dyn TraitEngine<'tcx>,
  55     key: ParamEnvAnd<'tcx, AscribeUserType<'tcx>>,
  56     span: Option<Span>,
  57 ) -> Result<(), NoSolution> {
  58     let (param_env, AscribeUserType { mir_ty, def_id, user_substs }) = key.into_parts();
  59     debug!(
  60         "type_op_ascribe_user_type: mir_ty={:?} def_id={:?} user_substs={:?}",
  61         mir_ty, def_id, user_substs
  62     );
  63
  64     let mut cx = AscribeUserTypeCx { infcx, param_env, fulfill_cx };
  65     cx.relate_mir_and_user_ty(mir_ty, def_id, user_substs, span)?;
  66     Ok(())
  67 }
  68
  69 struct AscribeUserTypeCx<'me, 'tcx> {
  70     infcx: &'me InferCtxt<'me, 'tcx>,
  71     param_env: ParamEnv<'tcx>,
  72     fulfill_cx: &'me mut dyn TraitEngine<'tcx>,
  73 }
  74
  75 impl<'me, 'tcx> AscribeUserTypeCx<'me, 'tcx> {
  76     fn normalize<T>(&mut self, value: T) -> T
  77     where
  78         T: TypeFoldable<'tcx>,
  79     {
  80         self.infcx
  81             .partially_normalize_associated_types_in(
  82                 ObligationCause::misc(DUMMY_SP, hir::CRATE_HIR_ID),
  83                 self.param_env,
  84                 value,
  85             )
  86             .into_value_registering_obligations(self.infcx, self.fulfill_cx)
  87     }
  88
  89     fn relate<T>(&mut self, a: T, variance: Variance, b: T) -> Result<(), NoSolution>
  90     where
  91         T: ToTrace<'tcx>,
  92     {
  93         self.infcx
  94             .at(&ObligationCause::dummy(), self.param_env)
  95             .relate(a, variance, b)?
  96             .into_value_registering_obligations(self.infcx, self.fulfill_cx);
  97         Ok(())
  98     }
  99
 100     fn prove_predicate(&mut self, predicate: Predicate<'tcx>, span: Option<Span>) {
 101         let cause = if let Some(span) = span {
 102             ObligationCause::dummy_with_span(span)
 103         } else {
 104             ObligationCause::dummy()
 105         };
 106         self.fulfill_cx.register_predicate_obligation(
 107             self.infcx,
 108             Obligation::new(cause, self.param_env, predicate),
 109         );
 110     }
 111
 112     fn tcx(&self) -> TyCtxt<'tcx> {
 113         self.infcx.tcx
 114     }
 115
 116     fn subst<T>(&self, value: T, substs: &[GenericArg<'tcx>]) -> T
 117     where
 118         T: TypeFoldable<'tcx>,
 119     {
 120         EarlyBinder(value).subst(self.tcx(), substs)
 121     }
 122
 123     #[instrument(level = "debug", skip(self))]
 124     fn relate_mir_and_user_ty(
 125         &mut self,
 126         mir_ty: Ty<'tcx>,
 127         def_id: DefId,
 128         user_substs: UserSubsts<'tcx>,
 129         span: Option<Span>,
 130     ) -> Result<(), NoSolution> {
 131         let UserSubsts { user_self_ty, substs } = user_substs;
 132         let tcx = self.tcx();
 133
 134         let ty = tcx.type_of(def_id);
 135         let ty = self.subst(ty, substs);
 136         let ty = self.normalize(ty);
 137         debug!("relate_type_and_user_type: ty of def-id is {:?}", ty);
 138
 139         self.relate(mir_ty, Variance::Invariant, ty)?;
 140
 141         // Prove the predicates coming along with `def_id`.
 142         //
 143         // Also, normalize the `instantiated_predicates`
 144         // because otherwise we wind up with duplicate "type
 145         // outlives" error messages.
 146         let instantiated_predicates =
 147             self.tcx().predicates_of(def_id).instantiate(self.tcx(), substs);
 148         debug!(?instantiated_predicates);
 149         for instantiated_predicate in instantiated_predicates.predicates {
 150             let instantiated_predicate = self.normalize(instantiated_predicate);
 151             self.prove_predicate(instantiated_predicate, span);
 152         }
 153
 154         if let Some(UserSelfTy { impl_def_id, self_ty }) = user_self_ty {
 155             let impl_self_ty = self.tcx().type_of(impl_def_id);
 156             let impl_self_ty = self.subst(impl_self_ty, &substs);
 157             let impl_self_ty = self.normalize(impl_self_ty);
 158
 159             self.relate(self_ty, Variance::Invariant, impl_self_ty)?;
 160
 161             self.prove_predicate(
 162                 ty::Binder::dummy(ty::PredicateKind::WellFormed(impl_self_ty.into()))
 163                     .to_predicate(self.tcx()),
 164                 span,
 165             );
 166         }
 167
 168         // In addition to proving the predicates, we have to
 169         // prove that `ty` is well-formed -- this is because
 170         // the WF of `ty` is predicated on the substs being
 171         // well-formed, and we haven't proven *that*. We don't
 172         // want to prove the WF of types from  `substs` directly because they
 173         // haven't been normalized.
 174         //
 175         // FIXME(nmatsakis): Well, perhaps we should normalize
 176         // them?  This would only be relevant if some input
 177         // type were ill-formed but did not appear in `ty`,
 178         // which...could happen with normalization...
 179         self.prove_predicate(
 180             ty::Binder::dummy(ty::PredicateKind::WellFormed(ty.into())).to_predicate(self.tcx()),
 181             span,
 182         );
 183         Ok(())
 184     }
 185 }
 186
 187 fn type_op_eq<'tcx>(
 188     tcx: TyCtxt<'tcx>,
 189     canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Eq<'tcx>>>,
 190 ) -> Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution> {
 191     tcx.infer_ctxt().enter_canonical_trait_query(&canonicalized, |infcx, fulfill_cx, key| {
 192         let (param_env, Eq { a, b }) = key.into_parts();
 193         infcx
 194             .at(&ObligationCause::dummy(), param_env)
 195             .eq(a, b)?
 196             .into_value_registering_obligations(infcx, fulfill_cx);
 197         Ok(())
 198     })
 199 }
 200
 201 fn type_op_normalize<'tcx, T>(
 202     infcx: &InferCtxt<'_, 'tcx>,
 203     fulfill_cx: &mut dyn TraitEngine<'tcx>,
 204     key: ParamEnvAnd<'tcx, Normalize<T>>,
 205 ) -> Fallible<T>
 206 where
 207     T: fmt::Debug + TypeFoldable<'tcx> + Lift<'tcx>,
 208 {
 209     let (param_env, Normalize { value }) = key.into_parts();
 210     let Normalized { value, obligations } =
 211         infcx.at(&ObligationCause::dummy(), param_env).normalize(value)?;
 212     fulfill_cx.register_predicate_obligations(infcx, obligations);
 213     Ok(value)
 214 }
 215
 216 fn type_op_normalize_ty<'tcx>(
 217     tcx: TyCtxt<'tcx>,
 218     canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<Ty<'tcx>>>>,
 219 ) -> Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Ty<'tcx>>>, NoSolution> {
 220     tcx.infer_ctxt().enter_canonical_trait_query(&canonicalized, type_op_normalize)
 221 }
 222
 223 fn type_op_normalize_predicate<'tcx>(
 224     tcx: TyCtxt<'tcx>,
 225     canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<Predicate<'tcx>>>>,
 226 ) -> Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, Predicate<'tcx>>>, NoSolution> {
 227     tcx.infer_ctxt().enter_canonical_trait_query(&canonicalized, type_op_normalize)
 228 }
 229
 230 fn type_op_normalize_fn_sig<'tcx>(
 231     tcx: TyCtxt<'tcx>,
 232     canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<FnSig<'tcx>>>>,
 233 ) -> Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, FnSig<'tcx>>>, NoSolution> {
 234     tcx.infer_ctxt().enter_canonical_trait_query(&canonicalized, type_op_normalize)
 235 }
 236
 237 fn type_op_normalize_poly_fn_sig<'tcx>(
 238     tcx: TyCtxt<'tcx>,
 239     canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Normalize<PolyFnSig<'tcx>>>>,
 240 ) -> Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, PolyFnSig<'tcx>>>, NoSolution> {
 241     tcx.infer_ctxt().enter_canonical_trait_query(&canonicalized, type_op_normalize)
 242 }
 243
 244 fn type_op_subtype<'tcx>(
 245     tcx: TyCtxt<'tcx>,
 246     canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Subtype<'tcx>>>,
 247 ) -> Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution> {
 248     tcx.infer_ctxt().enter_canonical_trait_query(&canonicalized, |infcx, fulfill_cx, key| {
 249         let (param_env, Subtype { sub, sup }) = key.into_parts();
 250         infcx
 251             .at(&ObligationCause::dummy(), param_env)
 252             .sup(sup, sub)?
 253             .into_value_registering_obligations(infcx, fulfill_cx);
 254         Ok(())
 255     })
 256 }
 257
 258 fn type_op_prove_predicate<'tcx>(
 259     tcx: TyCtxt<'tcx>,
 260     canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, ProvePredicate<'tcx>>>,
 261 ) -> Result<&'tcx Canonical<'tcx, QueryResponse<'tcx, ()>>, NoSolution> {
 262     // HACK This bubble is required for this test to pass:
 263     // impl-trait/issue-99642.rs
 264     tcx.infer_ctxt().with_opaque_type_inference(DefiningAnchor::Bubble).enter_canonical_trait_query(
 265         &canonicalized,
 266         |infcx, fulfill_cx, key| {
 267             type_op_prove_predicate_with_cause(infcx, fulfill_cx, key, ObligationCause::dummy());
 268             Ok(())
 269         },
 270     )
 271 }
 272
 273 /// The core of the `type_op_prove_predicate` query: for diagnostics purposes in NLL HRTB errors,
 274 /// this query can be re-run to better track the span of the obligation cause, and improve the error
 275 /// message. Do not call directly unless you're in that very specific context.
 276 pub fn type_op_prove_predicate_with_cause<'a, 'tcx: 'a>(
 277     infcx: &'a InferCtxt<'a, 'tcx>,
 278     fulfill_cx: &'a mut dyn TraitEngine<'tcx>,
 279     key: ParamEnvAnd<'tcx, ProvePredicate<'tcx>>,
 280     cause: ObligationCause<'tcx>,
 281 ) {
 282     let (param_env, ProvePredicate { predicate }) = key.into_parts();
 283     fulfill_cx.register_predicate_obligation(infcx, Obligation::new(cause, param_env, predicate));
 284 }