1use std::cell::{Cell, RefCell};
2use std::fmt;
3
4pub use BoundRegionConversionTime::*;
5pub use RegionVariableOrigin::*;
6pub use SubregionOrigin::*;
7pub use at::DefineOpaqueTypes;
8use free_regions::RegionRelations;
9pub use freshen::TypeFreshener;
10use lexical_region_resolve::LexicalRegionResolutions;
11pub use lexical_region_resolve::RegionResolutionError;
12pub use opaque_types::{OpaqueTypeStorage, OpaqueTypeStorageEntries, OpaqueTypeTable};
13use region_constraints::{
14 GenericKind, RegionConstraintCollector, RegionConstraintStorage, VarInfos, VerifyBound,
15};
16pub use relate::StructurallyRelateAliases;
17pub use relate::combine::PredicateEmittingRelation;
18use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
19use rustc_data_structures::undo_log::{Rollback, UndoLogs};
20use rustc_data_structures::unify as ut;
21use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed};
22use rustc_hir as hir;
23use rustc_hir::def_id::{DefId, LocalDefId};
24use rustc_macros::extension;
25pub use rustc_macros::{TypeFoldable, TypeVisitable};
26use rustc_middle::bug;
27use rustc_middle::infer::canonical::{CanonicalQueryInput, CanonicalVarValues};
28use rustc_middle::mir::ConstraintCategory;
29use rustc_middle::traits::select;
30use rustc_middle::traits::solve::Goal;
31use rustc_middle::ty::error::{ExpectedFound, TypeError};
32use rustc_middle::ty::{
33 self, BoundVarReplacerDelegate, ConstVid, FloatVid, GenericArg, GenericArgKind, GenericArgs,
34 GenericArgsRef, GenericParamDefKind, InferConst, IntVid, OpaqueHiddenType, OpaqueTypeKey,
35 PseudoCanonicalInput, Term, TermKind, Ty, TyCtxt, TyVid, TypeFoldable, TypeFolder,
36 TypeSuperFoldable, TypeVisitable, TypeVisitableExt, TypingEnv, TypingMode, fold_regions,
37};
38use rustc_span::{Span, Symbol};
39use snapshot::undo_log::InferCtxtUndoLogs;
40use tracing::{debug, instrument};
41use type_variable::TypeVariableOrigin;
42
43use crate::infer::region_constraints::UndoLog;
44use crate::infer::unify_key::{ConstVariableOrigin, ConstVariableValue, ConstVidKey};
45use crate::traits::{
46 self, ObligationCause, ObligationInspector, PredicateObligations, TraitEngine,
47};
48
49pub mod at;
50pub mod canonical;
51mod context;
52mod free_regions;
53mod freshen;
54mod lexical_region_resolve;
55mod opaque_types;
56pub mod outlives;
57mod projection;
58pub mod region_constraints;
59pub mod relate;
60pub mod resolve;
61pub(crate) mod snapshot;
62mod type_variable;
63mod unify_key;
64
65#[must_use]
73#[derive(Debug)]
74pub struct InferOk<'tcx, T> {
75 pub value: T,
76 pub obligations: PredicateObligations<'tcx>,
77}
78pub type InferResult<'tcx, T> = Result<InferOk<'tcx, T>, TypeError<'tcx>>;
79
80pub(crate) type FixupResult<T> = Result<T, FixupError>; pub(crate) type UnificationTable<'a, 'tcx, T> = ut::UnificationTable<
83 ut::InPlace<T, &'a mut ut::UnificationStorage<T>, &'a mut InferCtxtUndoLogs<'tcx>>,
84>;
85
86#[derive(Clone)]
91pub struct InferCtxtInner<'tcx> {
92 undo_log: InferCtxtUndoLogs<'tcx>,
93
94 projection_cache: traits::ProjectionCacheStorage<'tcx>,
98
99 type_variable_storage: type_variable::TypeVariableStorage<'tcx>,
103
104 const_unification_storage: ut::UnificationTableStorage<ConstVidKey<'tcx>>,
106
107 int_unification_storage: ut::UnificationTableStorage<ty::IntVid>,
109
110 float_unification_storage: ut::UnificationTableStorage<ty::FloatVid>,
112
113 region_constraint_storage: Option<RegionConstraintStorage<'tcx>>,
120
121 region_obligations: Vec<TypeOutlivesConstraint<'tcx>>,
154
155 opaque_type_storage: OpaqueTypeStorage<'tcx>,
157}
158
159impl<'tcx> InferCtxtInner<'tcx> {
160 fn new() -> InferCtxtInner<'tcx> {
161 InferCtxtInner {
162 undo_log: InferCtxtUndoLogs::default(),
163
164 projection_cache: Default::default(),
165 type_variable_storage: Default::default(),
166 const_unification_storage: Default::default(),
167 int_unification_storage: Default::default(),
168 float_unification_storage: Default::default(),
169 region_constraint_storage: Some(Default::default()),
170 region_obligations: vec![],
171 opaque_type_storage: Default::default(),
172 }
173 }
174
175 #[inline]
176 pub fn region_obligations(&self) -> &[TypeOutlivesConstraint<'tcx>] {
177 &self.region_obligations
178 }
179
180 #[inline]
181 pub fn projection_cache(&mut self) -> traits::ProjectionCache<'_, 'tcx> {
182 self.projection_cache.with_log(&mut self.undo_log)
183 }
184
185 #[inline]
186 fn try_type_variables_probe_ref(
187 &self,
188 vid: ty::TyVid,
189 ) -> Option<&type_variable::TypeVariableValue<'tcx>> {
190 self.type_variable_storage.eq_relations_ref().try_probe_value(vid)
193 }
194
195 #[inline]
196 fn type_variables(&mut self) -> type_variable::TypeVariableTable<'_, 'tcx> {
197 self.type_variable_storage.with_log(&mut self.undo_log)
198 }
199
200 #[inline]
201 pub fn opaque_types(&mut self) -> opaque_types::OpaqueTypeTable<'_, 'tcx> {
202 self.opaque_type_storage.with_log(&mut self.undo_log)
203 }
204
205 #[inline]
206 fn int_unification_table(&mut self) -> UnificationTable<'_, 'tcx, ty::IntVid> {
207 self.int_unification_storage.with_log(&mut self.undo_log)
208 }
209
210 #[inline]
211 fn float_unification_table(&mut self) -> UnificationTable<'_, 'tcx, ty::FloatVid> {
212 self.float_unification_storage.with_log(&mut self.undo_log)
213 }
214
215 #[inline]
216 fn const_unification_table(&mut self) -> UnificationTable<'_, 'tcx, ConstVidKey<'tcx>> {
217 self.const_unification_storage.with_log(&mut self.undo_log)
218 }
219
220 #[inline]
221 pub fn unwrap_region_constraints(&mut self) -> RegionConstraintCollector<'_, 'tcx> {
222 self.region_constraint_storage
223 .as_mut()
224 .expect("region constraints already solved")
225 .with_log(&mut self.undo_log)
226 }
227}
228
229pub struct InferCtxt<'tcx> {
230 pub tcx: TyCtxt<'tcx>,
231
232 typing_mode: TypingMode<'tcx>,
235
236 pub considering_regions: bool,
240
241 skip_leak_check: bool,
246
247 pub inner: RefCell<InferCtxtInner<'tcx>>,
248
249 lexical_region_resolutions: RefCell<Option<LexicalRegionResolutions<'tcx>>>,
251
252 pub selection_cache: select::SelectionCache<'tcx, ty::ParamEnv<'tcx>>,
255
256 pub evaluation_cache: select::EvaluationCache<'tcx, ty::ParamEnv<'tcx>>,
259
260 pub reported_trait_errors:
263 RefCell<FxIndexMap<Span, (Vec<Goal<'tcx, ty::Predicate<'tcx>>>, ErrorGuaranteed)>>,
264
265 pub reported_signature_mismatch: RefCell<FxHashSet<(Span, Option<Span>)>>,
266
267 tainted_by_errors: Cell<Option<ErrorGuaranteed>>,
275
276 universe: Cell<ty::UniverseIndex>,
286
287 next_trait_solver: bool,
288
289 pub obligation_inspector: Cell<Option<ObligationInspector<'tcx>>>,
290}
291
292#[derive(Clone, Copy, Debug, PartialEq, Eq, TypeFoldable, TypeVisitable)]
294pub enum ValuePairs<'tcx> {
295 Regions(ExpectedFound<ty::Region<'tcx>>),
296 Terms(ExpectedFound<ty::Term<'tcx>>),
297 Aliases(ExpectedFound<ty::AliasTerm<'tcx>>),
298 TraitRefs(ExpectedFound<ty::TraitRef<'tcx>>),
299 PolySigs(ExpectedFound<ty::PolyFnSig<'tcx>>),
300 ExistentialTraitRef(ExpectedFound<ty::PolyExistentialTraitRef<'tcx>>),
301 ExistentialProjection(ExpectedFound<ty::PolyExistentialProjection<'tcx>>),
302}
303
304impl<'tcx> ValuePairs<'tcx> {
305 pub fn ty(&self) -> Option<(Ty<'tcx>, Ty<'tcx>)> {
306 if let ValuePairs::Terms(ExpectedFound { expected, found }) = self
307 && let Some(expected) = expected.as_type()
308 && let Some(found) = found.as_type()
309 {
310 Some((expected, found))
311 } else {
312 None
313 }
314 }
315}
316
317#[derive(Clone, Debug)]
322pub struct TypeTrace<'tcx> {
323 pub cause: ObligationCause<'tcx>,
324 pub values: ValuePairs<'tcx>,
325}
326
327#[derive(Clone, Debug)]
331pub enum SubregionOrigin<'tcx> {
332 Subtype(Box<TypeTrace<'tcx>>),
334
335 RelateObjectBound(Span),
338
339 RelateParamBound(Span, Ty<'tcx>, Option<Span>),
342
343 RelateRegionParamBound(Span, Option<Ty<'tcx>>),
346
347 Reborrow(Span),
349
350 ReferenceOutlivesReferent(Ty<'tcx>, Span),
352
353 CompareImplItemObligation {
356 span: Span,
357 impl_item_def_id: LocalDefId,
358 trait_item_def_id: DefId,
359 },
360
361 CheckAssociatedTypeBounds {
363 parent: Box<SubregionOrigin<'tcx>>,
364 impl_item_def_id: LocalDefId,
365 trait_item_def_id: DefId,
366 },
367
368 AscribeUserTypeProvePredicate(Span),
369}
370
371#[cfg(target_pointer_width = "64")]
373rustc_data_structures::static_assert_size!(SubregionOrigin<'_>, 32);
374
375impl<'tcx> SubregionOrigin<'tcx> {
376 pub fn to_constraint_category(&self) -> ConstraintCategory<'tcx> {
377 match self {
378 Self::Subtype(type_trace) => type_trace.cause.to_constraint_category(),
379 Self::AscribeUserTypeProvePredicate(span) => ConstraintCategory::Predicate(*span),
380 _ => ConstraintCategory::BoringNoLocation,
381 }
382 }
383}
384
385#[derive(Clone, Copy, Debug)]
387pub enum BoundRegionConversionTime {
388 FnCall,
390
391 HigherRankedType,
393
394 AssocTypeProjection(DefId),
396}
397
398#[derive(Copy, Clone, Debug)]
402pub enum RegionVariableOrigin {
403 MiscVariable(Span),
407
408 PatternRegion(Span),
410
411 BorrowRegion(Span),
413
414 Autoref(Span),
416
417 Coercion(Span),
419
420 RegionParameterDefinition(Span, Symbol),
425
426 BoundRegion(Span, ty::BoundRegionKind, BoundRegionConversionTime),
429
430 UpvarRegion(ty::UpvarId, Span),
431
432 Nll(NllRegionVariableOrigin),
435}
436
437#[derive(Copy, Clone, Debug)]
438pub enum NllRegionVariableOrigin {
439 FreeRegion,
443
444 Placeholder(ty::PlaceholderRegion),
447
448 Existential {
449 from_forall: bool,
460 },
461}
462
463#[derive(Copy, Clone, Debug)]
464pub struct FixupError {
465 unresolved: TyOrConstInferVar,
466}
467
468impl fmt::Display for FixupError {
469 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
470 use TyOrConstInferVar::*;
471
472 match self.unresolved {
473 TyInt(_) => write!(
474 f,
475 "cannot determine the type of this integer; \
476 add a suffix to specify the type explicitly"
477 ),
478 TyFloat(_) => write!(
479 f,
480 "cannot determine the type of this number; \
481 add a suffix to specify the type explicitly"
482 ),
483 Ty(_) => write!(f, "unconstrained type"),
484 Const(_) => write!(f, "unconstrained const value"),
485 }
486 }
487}
488
489#[derive(Clone, Debug)]
491pub struct TypeOutlivesConstraint<'tcx> {
492 pub sub_region: ty::Region<'tcx>,
493 pub sup_type: Ty<'tcx>,
494 pub origin: SubregionOrigin<'tcx>,
495}
496
497pub struct InferCtxtBuilder<'tcx> {
499 tcx: TyCtxt<'tcx>,
500 considering_regions: bool,
501 skip_leak_check: bool,
502 next_trait_solver: bool,
505}
506
507#[extension(pub trait TyCtxtInferExt<'tcx>)]
508impl<'tcx> TyCtxt<'tcx> {
509 fn infer_ctxt(self) -> InferCtxtBuilder<'tcx> {
510 InferCtxtBuilder {
511 tcx: self,
512 considering_regions: true,
513 skip_leak_check: false,
514 next_trait_solver: self.next_trait_solver_globally(),
515 }
516 }
517}
518
519impl<'tcx> InferCtxtBuilder<'tcx> {
520 pub fn with_next_trait_solver(mut self, next_trait_solver: bool) -> Self {
521 self.next_trait_solver = next_trait_solver;
522 self
523 }
524
525 pub fn ignoring_regions(mut self) -> Self {
526 self.considering_regions = false;
527 self
528 }
529
530 pub fn skip_leak_check(mut self, skip_leak_check: bool) -> Self {
531 self.skip_leak_check = skip_leak_check;
532 self
533 }
534
535 pub fn build_with_canonical<T>(
543 mut self,
544 span: Span,
545 input: &CanonicalQueryInput<'tcx, T>,
546 ) -> (InferCtxt<'tcx>, T, CanonicalVarValues<'tcx>)
547 where
548 T: TypeFoldable<TyCtxt<'tcx>>,
549 {
550 let infcx = self.build(input.typing_mode);
551 let (value, args) = infcx.instantiate_canonical(span, &input.canonical);
552 (infcx, value, args)
553 }
554
555 pub fn build_with_typing_env(
556 mut self,
557 TypingEnv { typing_mode, param_env }: TypingEnv<'tcx>,
558 ) -> (InferCtxt<'tcx>, ty::ParamEnv<'tcx>) {
559 (self.build(typing_mode), param_env)
560 }
561
562 pub fn build(&mut self, typing_mode: TypingMode<'tcx>) -> InferCtxt<'tcx> {
563 let InferCtxtBuilder { tcx, considering_regions, skip_leak_check, next_trait_solver } =
564 *self;
565 InferCtxt {
566 tcx,
567 typing_mode,
568 considering_regions,
569 skip_leak_check,
570 inner: RefCell::new(InferCtxtInner::new()),
571 lexical_region_resolutions: RefCell::new(None),
572 selection_cache: Default::default(),
573 evaluation_cache: Default::default(),
574 reported_trait_errors: Default::default(),
575 reported_signature_mismatch: Default::default(),
576 tainted_by_errors: Cell::new(None),
577 universe: Cell::new(ty::UniverseIndex::ROOT),
578 next_trait_solver,
579 obligation_inspector: Cell::new(None),
580 }
581 }
582}
583
584impl<'tcx, T> InferOk<'tcx, T> {
585 pub fn into_value_registering_obligations<E: 'tcx>(
587 self,
588 infcx: &InferCtxt<'tcx>,
589 fulfill_cx: &mut dyn TraitEngine<'tcx, E>,
590 ) -> T {
591 let InferOk { value, obligations } = self;
592 fulfill_cx.register_predicate_obligations(infcx, obligations);
593 value
594 }
595}
596
597impl<'tcx> InferOk<'tcx, ()> {
598 pub fn into_obligations(self) -> PredicateObligations<'tcx> {
599 self.obligations
600 }
601}
602
603impl<'tcx> InferCtxt<'tcx> {
604 pub fn dcx(&self) -> DiagCtxtHandle<'_> {
605 self.tcx.dcx().taintable_handle(&self.tainted_by_errors)
606 }
607
608 pub fn next_trait_solver(&self) -> bool {
609 self.next_trait_solver
610 }
611
612 #[inline(always)]
613 pub fn typing_mode(&self) -> TypingMode<'tcx> {
614 self.typing_mode
615 }
616
617 pub fn freshen<T: TypeFoldable<TyCtxt<'tcx>>>(&self, t: T) -> T {
618 t.fold_with(&mut self.freshener())
619 }
620
621 pub fn type_var_origin(&self, vid: TyVid) -> TypeVariableOrigin {
625 self.inner.borrow_mut().type_variables().var_origin(vid)
626 }
627
628 pub fn const_var_origin(&self, vid: ConstVid) -> Option<ConstVariableOrigin> {
632 match self.inner.borrow_mut().const_unification_table().probe_value(vid) {
633 ConstVariableValue::Known { .. } => None,
634 ConstVariableValue::Unknown { origin, .. } => Some(origin),
635 }
636 }
637
638 pub fn freshener<'b>(&'b self) -> TypeFreshener<'b, 'tcx> {
639 freshen::TypeFreshener::new(self)
640 }
641
642 pub fn unresolved_variables(&self) -> Vec<Ty<'tcx>> {
643 let mut inner = self.inner.borrow_mut();
644 let mut vars: Vec<Ty<'_>> = inner
645 .type_variables()
646 .unresolved_variables()
647 .into_iter()
648 .map(|t| Ty::new_var(self.tcx, t))
649 .collect();
650 vars.extend(
651 (0..inner.int_unification_table().len())
652 .map(|i| ty::IntVid::from_usize(i))
653 .filter(|&vid| inner.int_unification_table().probe_value(vid).is_unknown())
654 .map(|v| Ty::new_int_var(self.tcx, v)),
655 );
656 vars.extend(
657 (0..inner.float_unification_table().len())
658 .map(|i| ty::FloatVid::from_usize(i))
659 .filter(|&vid| inner.float_unification_table().probe_value(vid).is_unknown())
660 .map(|v| Ty::new_float_var(self.tcx, v)),
661 );
662 vars
663 }
664
665 #[instrument(skip(self), level = "debug")]
666 pub fn sub_regions(
667 &self,
668 origin: SubregionOrigin<'tcx>,
669 a: ty::Region<'tcx>,
670 b: ty::Region<'tcx>,
671 ) {
672 self.inner.borrow_mut().unwrap_region_constraints().make_subregion(origin, a, b);
673 }
674
675 pub fn coerce_predicate(
691 &self,
692 cause: &ObligationCause<'tcx>,
693 param_env: ty::ParamEnv<'tcx>,
694 predicate: ty::PolyCoercePredicate<'tcx>,
695 ) -> Result<InferResult<'tcx, ()>, (TyVid, TyVid)> {
696 let subtype_predicate = predicate.map_bound(|p| ty::SubtypePredicate {
697 a_is_expected: false, a: p.a,
699 b: p.b,
700 });
701 self.subtype_predicate(cause, param_env, subtype_predicate)
702 }
703
704 pub fn subtype_predicate(
705 &self,
706 cause: &ObligationCause<'tcx>,
707 param_env: ty::ParamEnv<'tcx>,
708 predicate: ty::PolySubtypePredicate<'tcx>,
709 ) -> Result<InferResult<'tcx, ()>, (TyVid, TyVid)> {
710 let r_a = self.shallow_resolve(predicate.skip_binder().a);
724 let r_b = self.shallow_resolve(predicate.skip_binder().b);
725 match (r_a.kind(), r_b.kind()) {
726 (&ty::Infer(ty::TyVar(a_vid)), &ty::Infer(ty::TyVar(b_vid))) => {
727 return Err((a_vid, b_vid));
728 }
729 _ => {}
730 }
731
732 self.enter_forall(predicate, |ty::SubtypePredicate { a_is_expected, a, b }| {
733 if a_is_expected {
734 Ok(self.at(cause, param_env).sub(DefineOpaqueTypes::Yes, a, b))
735 } else {
736 Ok(self.at(cause, param_env).sup(DefineOpaqueTypes::Yes, b, a))
737 }
738 })
739 }
740
741 pub fn num_ty_vars(&self) -> usize {
743 self.inner.borrow_mut().type_variables().num_vars()
744 }
745
746 pub fn next_ty_var(&self, span: Span) -> Ty<'tcx> {
747 self.next_ty_var_with_origin(TypeVariableOrigin { span, param_def_id: None })
748 }
749
750 pub fn next_ty_var_with_origin(&self, origin: TypeVariableOrigin) -> Ty<'tcx> {
751 let vid = self.inner.borrow_mut().type_variables().new_var(self.universe(), origin);
752 Ty::new_var(self.tcx, vid)
753 }
754
755 pub fn next_ty_var_id_in_universe(&self, span: Span, universe: ty::UniverseIndex) -> TyVid {
756 let origin = TypeVariableOrigin { span, param_def_id: None };
757 self.inner.borrow_mut().type_variables().new_var(universe, origin)
758 }
759
760 pub fn next_ty_var_in_universe(&self, span: Span, universe: ty::UniverseIndex) -> Ty<'tcx> {
761 let vid = self.next_ty_var_id_in_universe(span, universe);
762 Ty::new_var(self.tcx, vid)
763 }
764
765 pub fn next_const_var(&self, span: Span) -> ty::Const<'tcx> {
766 self.next_const_var_with_origin(ConstVariableOrigin { span, param_def_id: None })
767 }
768
769 pub fn next_const_var_with_origin(&self, origin: ConstVariableOrigin) -> ty::Const<'tcx> {
770 let vid = self
771 .inner
772 .borrow_mut()
773 .const_unification_table()
774 .new_key(ConstVariableValue::Unknown { origin, universe: self.universe() })
775 .vid;
776 ty::Const::new_var(self.tcx, vid)
777 }
778
779 pub fn next_const_var_in_universe(
780 &self,
781 span: Span,
782 universe: ty::UniverseIndex,
783 ) -> ty::Const<'tcx> {
784 let origin = ConstVariableOrigin { span, param_def_id: None };
785 let vid = self
786 .inner
787 .borrow_mut()
788 .const_unification_table()
789 .new_key(ConstVariableValue::Unknown { origin, universe })
790 .vid;
791 ty::Const::new_var(self.tcx, vid)
792 }
793
794 pub fn next_int_var(&self) -> Ty<'tcx> {
795 let next_int_var_id =
796 self.inner.borrow_mut().int_unification_table().new_key(ty::IntVarValue::Unknown);
797 Ty::new_int_var(self.tcx, next_int_var_id)
798 }
799
800 pub fn next_float_var(&self) -> Ty<'tcx> {
801 let next_float_var_id =
802 self.inner.borrow_mut().float_unification_table().new_key(ty::FloatVarValue::Unknown);
803 Ty::new_float_var(self.tcx, next_float_var_id)
804 }
805
806 pub fn next_region_var(&self, origin: RegionVariableOrigin) -> ty::Region<'tcx> {
810 self.next_region_var_in_universe(origin, self.universe())
811 }
812
813 pub fn next_region_var_in_universe(
817 &self,
818 origin: RegionVariableOrigin,
819 universe: ty::UniverseIndex,
820 ) -> ty::Region<'tcx> {
821 let region_var =
822 self.inner.borrow_mut().unwrap_region_constraints().new_region_var(universe, origin);
823 ty::Region::new_var(self.tcx, region_var)
824 }
825
826 pub fn universe_of_region(&self, r: ty::Region<'tcx>) -> ty::UniverseIndex {
832 self.inner.borrow_mut().unwrap_region_constraints().universe(r)
833 }
834
835 pub fn num_region_vars(&self) -> usize {
837 self.inner.borrow_mut().unwrap_region_constraints().num_region_vars()
838 }
839
840 #[instrument(skip(self), level = "debug")]
842 pub fn next_nll_region_var(&self, origin: NllRegionVariableOrigin) -> ty::Region<'tcx> {
843 self.next_region_var(RegionVariableOrigin::Nll(origin))
844 }
845
846 #[instrument(skip(self), level = "debug")]
848 pub fn next_nll_region_var_in_universe(
849 &self,
850 origin: NllRegionVariableOrigin,
851 universe: ty::UniverseIndex,
852 ) -> ty::Region<'tcx> {
853 self.next_region_var_in_universe(RegionVariableOrigin::Nll(origin), universe)
854 }
855
856 pub fn var_for_def(&self, span: Span, param: &ty::GenericParamDef) -> GenericArg<'tcx> {
857 match param.kind {
858 GenericParamDefKind::Lifetime => {
859 self.next_region_var(RegionParameterDefinition(span, param.name)).into()
862 }
863 GenericParamDefKind::Type { .. } => {
864 let ty_var_id = self.inner.borrow_mut().type_variables().new_var(
873 self.universe(),
874 TypeVariableOrigin { param_def_id: Some(param.def_id), span },
875 );
876
877 Ty::new_var(self.tcx, ty_var_id).into()
878 }
879 GenericParamDefKind::Const { .. } => {
880 let origin = ConstVariableOrigin { param_def_id: Some(param.def_id), span };
881 let const_var_id = self
882 .inner
883 .borrow_mut()
884 .const_unification_table()
885 .new_key(ConstVariableValue::Unknown { origin, universe: self.universe() })
886 .vid;
887 ty::Const::new_var(self.tcx, const_var_id).into()
888 }
889 }
890 }
891
892 pub fn fresh_args_for_item(&self, span: Span, def_id: DefId) -> GenericArgsRef<'tcx> {
895 GenericArgs::for_item(self.tcx, def_id, |param, _| self.var_for_def(span, param))
896 }
897
898 #[must_use = "this method does not have any side effects"]
904 pub fn tainted_by_errors(&self) -> Option<ErrorGuaranteed> {
905 self.tainted_by_errors.get()
906 }
907
908 pub fn set_tainted_by_errors(&self, e: ErrorGuaranteed) {
911 debug!("set_tainted_by_errors(ErrorGuaranteed)");
912 self.tainted_by_errors.set(Some(e));
913 }
914
915 pub fn region_var_origin(&self, vid: ty::RegionVid) -> RegionVariableOrigin {
916 let mut inner = self.inner.borrow_mut();
917 let inner = &mut *inner;
918 inner.unwrap_region_constraints().var_origin(vid)
919 }
920
921 pub fn get_region_var_infos(&self) -> VarInfos {
924 let inner = self.inner.borrow();
925 assert!(!UndoLogs::<UndoLog<'_>>::in_snapshot(&inner.undo_log));
926 let storage = inner.region_constraint_storage.as_ref().expect("regions already resolved");
927 assert!(storage.data.is_empty(), "{:#?}", storage.data);
928 storage.var_infos.clone()
932 }
933
934 #[instrument(level = "debug", skip(self), ret)]
935 pub fn take_opaque_types(&self) -> Vec<(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)> {
936 self.inner.borrow_mut().opaque_type_storage.take_opaque_types().collect()
937 }
938
939 #[instrument(level = "debug", skip(self), ret)]
940 pub fn clone_opaque_types(&self) -> Vec<(OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>)> {
941 self.inner.borrow_mut().opaque_type_storage.iter_opaque_types().collect()
942 }
943
944 #[inline(always)]
945 pub fn can_define_opaque_ty(&self, id: impl Into<DefId>) -> bool {
946 debug_assert!(!self.next_trait_solver());
947 match self.typing_mode() {
948 TypingMode::Analysis {
949 defining_opaque_types_and_generators: defining_opaque_types,
950 }
951 | TypingMode::Borrowck { defining_opaque_types } => {
952 id.into().as_local().is_some_and(|def_id| defining_opaque_types.contains(&def_id))
953 }
954 TypingMode::Coherence
958 | TypingMode::PostBorrowckAnalysis { .. }
959 | TypingMode::PostAnalysis => false,
960 }
961 }
962
963 pub fn ty_to_string(&self, t: Ty<'tcx>) -> String {
964 self.resolve_vars_if_possible(t).to_string()
965 }
966
967 pub fn probe_ty_var(&self, vid: TyVid) -> Result<Ty<'tcx>, ty::UniverseIndex> {
970 use self::type_variable::TypeVariableValue;
971
972 match self.inner.borrow_mut().type_variables().probe(vid) {
973 TypeVariableValue::Known { value } => Ok(value),
974 TypeVariableValue::Unknown { universe } => Err(universe),
975 }
976 }
977
978 pub fn shallow_resolve(&self, ty: Ty<'tcx>) -> Ty<'tcx> {
979 if let ty::Infer(v) = *ty.kind() {
980 match v {
981 ty::TyVar(v) => {
982 let known = self.inner.borrow_mut().type_variables().probe(v).known();
995 known.map_or(ty, |t| self.shallow_resolve(t))
996 }
997
998 ty::IntVar(v) => {
999 match self.inner.borrow_mut().int_unification_table().probe_value(v) {
1000 ty::IntVarValue::IntType(ty) => Ty::new_int(self.tcx, ty),
1001 ty::IntVarValue::UintType(ty) => Ty::new_uint(self.tcx, ty),
1002 ty::IntVarValue::Unknown => ty,
1003 }
1004 }
1005
1006 ty::FloatVar(v) => {
1007 match self.inner.borrow_mut().float_unification_table().probe_value(v) {
1008 ty::FloatVarValue::Known(ty) => Ty::new_float(self.tcx, ty),
1009 ty::FloatVarValue::Unknown => ty,
1010 }
1011 }
1012
1013 ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => ty,
1014 }
1015 } else {
1016 ty
1017 }
1018 }
1019
1020 pub fn shallow_resolve_const(&self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
1021 match ct.kind() {
1022 ty::ConstKind::Infer(infer_ct) => match infer_ct {
1023 InferConst::Var(vid) => self
1024 .inner
1025 .borrow_mut()
1026 .const_unification_table()
1027 .probe_value(vid)
1028 .known()
1029 .unwrap_or(ct),
1030 InferConst::Fresh(_) => ct,
1031 },
1032 ty::ConstKind::Param(_)
1033 | ty::ConstKind::Bound(_, _)
1034 | ty::ConstKind::Placeholder(_)
1035 | ty::ConstKind::Unevaluated(_)
1036 | ty::ConstKind::Value(_)
1037 | ty::ConstKind::Error(_)
1038 | ty::ConstKind::Expr(_) => ct,
1039 }
1040 }
1041
1042 pub fn root_var(&self, var: ty::TyVid) -> ty::TyVid {
1043 self.inner.borrow_mut().type_variables().root_var(var)
1044 }
1045
1046 pub fn root_const_var(&self, var: ty::ConstVid) -> ty::ConstVid {
1047 self.inner.borrow_mut().const_unification_table().find(var).vid
1048 }
1049
1050 pub fn opportunistic_resolve_int_var(&self, vid: ty::IntVid) -> Ty<'tcx> {
1053 let mut inner = self.inner.borrow_mut();
1054 let value = inner.int_unification_table().probe_value(vid);
1055 match value {
1056 ty::IntVarValue::IntType(ty) => Ty::new_int(self.tcx, ty),
1057 ty::IntVarValue::UintType(ty) => Ty::new_uint(self.tcx, ty),
1058 ty::IntVarValue::Unknown => {
1059 Ty::new_int_var(self.tcx, inner.int_unification_table().find(vid))
1060 }
1061 }
1062 }
1063
1064 pub fn opportunistic_resolve_float_var(&self, vid: ty::FloatVid) -> Ty<'tcx> {
1067 let mut inner = self.inner.borrow_mut();
1068 let value = inner.float_unification_table().probe_value(vid);
1069 match value {
1070 ty::FloatVarValue::Known(ty) => Ty::new_float(self.tcx, ty),
1071 ty::FloatVarValue::Unknown => {
1072 Ty::new_float_var(self.tcx, inner.float_unification_table().find(vid))
1073 }
1074 }
1075 }
1076
1077 pub fn resolve_vars_if_possible<T>(&self, value: T) -> T
1084 where
1085 T: TypeFoldable<TyCtxt<'tcx>>,
1086 {
1087 if let Err(guar) = value.error_reported() {
1088 self.set_tainted_by_errors(guar);
1089 }
1090 if !value.has_non_region_infer() {
1091 return value;
1092 }
1093 let mut r = resolve::OpportunisticVarResolver::new(self);
1094 value.fold_with(&mut r)
1095 }
1096
1097 pub fn resolve_numeric_literals_with_default<T>(&self, value: T) -> T
1098 where
1099 T: TypeFoldable<TyCtxt<'tcx>>,
1100 {
1101 if !value.has_infer() {
1102 return value; }
1104 let mut r = InferenceLiteralEraser { tcx: self.tcx };
1105 value.fold_with(&mut r)
1106 }
1107
1108 pub fn probe_const_var(&self, vid: ty::ConstVid) -> Result<ty::Const<'tcx>, ty::UniverseIndex> {
1109 match self.inner.borrow_mut().const_unification_table().probe_value(vid) {
1110 ConstVariableValue::Known { value } => Ok(value),
1111 ConstVariableValue::Unknown { origin: _, universe } => Err(universe),
1112 }
1113 }
1114
1115 pub fn fully_resolve<T: TypeFoldable<TyCtxt<'tcx>>>(&self, value: T) -> FixupResult<T> {
1123 match resolve::fully_resolve(self, value) {
1124 Ok(value) => {
1125 if value.has_non_region_infer() {
1126 bug!("`{value:?}` is not fully resolved");
1127 }
1128 if value.has_infer_regions() {
1129 let guar = self.dcx().delayed_bug(format!("`{value:?}` is not fully resolved"));
1130 Ok(fold_regions(self.tcx, value, |re, _| {
1131 if re.is_var() { ty::Region::new_error(self.tcx, guar) } else { re }
1132 }))
1133 } else {
1134 Ok(value)
1135 }
1136 }
1137 Err(e) => Err(e),
1138 }
1139 }
1140
1141 pub fn instantiate_binder_with_fresh_vars<T>(
1149 &self,
1150 span: Span,
1151 lbrct: BoundRegionConversionTime,
1152 value: ty::Binder<'tcx, T>,
1153 ) -> T
1154 where
1155 T: TypeFoldable<TyCtxt<'tcx>> + Copy,
1156 {
1157 if let Some(inner) = value.no_bound_vars() {
1158 return inner;
1159 }
1160
1161 let bound_vars = value.bound_vars();
1162 let mut args = Vec::with_capacity(bound_vars.len());
1163
1164 for bound_var_kind in bound_vars {
1165 let arg: ty::GenericArg<'_> = match bound_var_kind {
1166 ty::BoundVariableKind::Ty(_) => self.next_ty_var(span).into(),
1167 ty::BoundVariableKind::Region(br) => {
1168 self.next_region_var(BoundRegion(span, br, lbrct)).into()
1169 }
1170 ty::BoundVariableKind::Const => self.next_const_var(span).into(),
1171 };
1172 args.push(arg);
1173 }
1174
1175 struct ToFreshVars<'tcx> {
1176 args: Vec<ty::GenericArg<'tcx>>,
1177 }
1178
1179 impl<'tcx> BoundVarReplacerDelegate<'tcx> for ToFreshVars<'tcx> {
1180 fn replace_region(&mut self, br: ty::BoundRegion) -> ty::Region<'tcx> {
1181 self.args[br.var.index()].expect_region()
1182 }
1183 fn replace_ty(&mut self, bt: ty::BoundTy) -> Ty<'tcx> {
1184 self.args[bt.var.index()].expect_ty()
1185 }
1186 fn replace_const(&mut self, bv: ty::BoundVar) -> ty::Const<'tcx> {
1187 self.args[bv.index()].expect_const()
1188 }
1189 }
1190 let delegate = ToFreshVars { args };
1191 self.tcx.replace_bound_vars_uncached(value, delegate)
1192 }
1193
1194 pub(crate) fn verify_generic_bound(
1196 &self,
1197 origin: SubregionOrigin<'tcx>,
1198 kind: GenericKind<'tcx>,
1199 a: ty::Region<'tcx>,
1200 bound: VerifyBound<'tcx>,
1201 ) {
1202 debug!("verify_generic_bound({:?}, {:?} <: {:?})", kind, a, bound);
1203
1204 self.inner
1205 .borrow_mut()
1206 .unwrap_region_constraints()
1207 .verify_generic_bound(origin, kind, a, bound);
1208 }
1209
1210 pub fn closure_kind(&self, closure_ty: Ty<'tcx>) -> Option<ty::ClosureKind> {
1214 let unresolved_kind_ty = match *closure_ty.kind() {
1215 ty::Closure(_, args) => args.as_closure().kind_ty(),
1216 ty::CoroutineClosure(_, args) => args.as_coroutine_closure().kind_ty(),
1217 _ => bug!("unexpected type {closure_ty}"),
1218 };
1219 let closure_kind_ty = self.shallow_resolve(unresolved_kind_ty);
1220 closure_kind_ty.to_opt_closure_kind()
1221 }
1222
1223 pub fn universe(&self) -> ty::UniverseIndex {
1224 self.universe.get()
1225 }
1226
1227 pub fn create_next_universe(&self) -> ty::UniverseIndex {
1230 let u = self.universe.get().next_universe();
1231 debug!("create_next_universe {u:?}");
1232 self.universe.set(u);
1233 u
1234 }
1235
1236 pub fn typing_env(&self, param_env: ty::ParamEnv<'tcx>) -> ty::TypingEnv<'tcx> {
1240 let typing_mode = match self.typing_mode() {
1241 ty::TypingMode::Analysis { defining_opaque_types_and_generators: _ }
1246 | ty::TypingMode::Borrowck { defining_opaque_types: _ } => {
1247 TypingMode::non_body_analysis()
1248 }
1249 mode @ (ty::TypingMode::Coherence
1250 | ty::TypingMode::PostBorrowckAnalysis { .. }
1251 | ty::TypingMode::PostAnalysis) => mode,
1252 };
1253 ty::TypingEnv { typing_mode, param_env }
1254 }
1255
1256 pub fn pseudo_canonicalize_query<V>(
1260 &self,
1261 param_env: ty::ParamEnv<'tcx>,
1262 value: V,
1263 ) -> PseudoCanonicalInput<'tcx, V>
1264 where
1265 V: TypeVisitable<TyCtxt<'tcx>>,
1266 {
1267 debug_assert!(!value.has_infer());
1268 debug_assert!(!value.has_placeholders());
1269 debug_assert!(!param_env.has_infer());
1270 debug_assert!(!param_env.has_placeholders());
1271 self.typing_env(param_env).as_query_input(value)
1272 }
1273
1274 #[inline]
1277 pub fn is_ty_infer_var_definitely_unchanged(&self) -> impl Fn(TyOrConstInferVar) -> bool {
1278 let inner = self.inner.try_borrow();
1280
1281 move |infer_var: TyOrConstInferVar| match (infer_var, &inner) {
1282 (TyOrConstInferVar::Ty(ty_var), Ok(inner)) => {
1283 use self::type_variable::TypeVariableValue;
1284
1285 matches!(
1286 inner.try_type_variables_probe_ref(ty_var),
1287 Some(TypeVariableValue::Unknown { .. })
1288 )
1289 }
1290 _ => false,
1291 }
1292 }
1293
1294 #[inline(always)]
1304 pub fn ty_or_const_infer_var_changed(&self, infer_var: TyOrConstInferVar) -> bool {
1305 match infer_var {
1306 TyOrConstInferVar::Ty(v) => {
1307 use self::type_variable::TypeVariableValue;
1308
1309 match self.inner.borrow_mut().type_variables().inlined_probe(v) {
1312 TypeVariableValue::Unknown { .. } => false,
1313 TypeVariableValue::Known { .. } => true,
1314 }
1315 }
1316
1317 TyOrConstInferVar::TyInt(v) => {
1318 self.inner.borrow_mut().int_unification_table().inlined_probe_value(v).is_known()
1322 }
1323
1324 TyOrConstInferVar::TyFloat(v) => {
1325 self.inner.borrow_mut().float_unification_table().probe_value(v).is_known()
1330 }
1331
1332 TyOrConstInferVar::Const(v) => {
1333 match self.inner.borrow_mut().const_unification_table().probe_value(v) {
1338 ConstVariableValue::Unknown { .. } => false,
1339 ConstVariableValue::Known { .. } => true,
1340 }
1341 }
1342 }
1343 }
1344
1345 pub fn attach_obligation_inspector(&self, inspector: ObligationInspector<'tcx>) {
1347 debug_assert!(
1348 self.obligation_inspector.get().is_none(),
1349 "shouldn't override a set obligation inspector"
1350 );
1351 self.obligation_inspector.set(Some(inspector));
1352 }
1353}
1354
1355#[derive(Copy, Clone, Debug)]
1358pub enum TyOrConstInferVar {
1359 Ty(TyVid),
1361 TyInt(IntVid),
1363 TyFloat(FloatVid),
1365
1366 Const(ConstVid),
1368}
1369
1370impl<'tcx> TyOrConstInferVar {
1371 pub fn maybe_from_generic_arg(arg: GenericArg<'tcx>) -> Option<Self> {
1375 match arg.kind() {
1376 GenericArgKind::Type(ty) => Self::maybe_from_ty(ty),
1377 GenericArgKind::Const(ct) => Self::maybe_from_const(ct),
1378 GenericArgKind::Lifetime(_) => None,
1379 }
1380 }
1381
1382 pub fn maybe_from_term(term: Term<'tcx>) -> Option<Self> {
1386 match term.kind() {
1387 TermKind::Ty(ty) => Self::maybe_from_ty(ty),
1388 TermKind::Const(ct) => Self::maybe_from_const(ct),
1389 }
1390 }
1391
1392 fn maybe_from_ty(ty: Ty<'tcx>) -> Option<Self> {
1395 match *ty.kind() {
1396 ty::Infer(ty::TyVar(v)) => Some(TyOrConstInferVar::Ty(v)),
1397 ty::Infer(ty::IntVar(v)) => Some(TyOrConstInferVar::TyInt(v)),
1398 ty::Infer(ty::FloatVar(v)) => Some(TyOrConstInferVar::TyFloat(v)),
1399 _ => None,
1400 }
1401 }
1402
1403 fn maybe_from_const(ct: ty::Const<'tcx>) -> Option<Self> {
1406 match ct.kind() {
1407 ty::ConstKind::Infer(InferConst::Var(v)) => Some(TyOrConstInferVar::Const(v)),
1408 _ => None,
1409 }
1410 }
1411}
1412
1413struct InferenceLiteralEraser<'tcx> {
1416 tcx: TyCtxt<'tcx>,
1417}
1418
1419impl<'tcx> TypeFolder<TyCtxt<'tcx>> for InferenceLiteralEraser<'tcx> {
1420 fn cx(&self) -> TyCtxt<'tcx> {
1421 self.tcx
1422 }
1423
1424 fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
1425 match ty.kind() {
1426 ty::Infer(ty::IntVar(_) | ty::FreshIntTy(_)) => self.tcx.types.i32,
1427 ty::Infer(ty::FloatVar(_) | ty::FreshFloatTy(_)) => self.tcx.types.f64,
1428 _ => ty.super_fold_with(self),
1429 }
1430 }
1431}
1432
1433impl<'tcx> TypeTrace<'tcx> {
1434 pub fn span(&self) -> Span {
1435 self.cause.span
1436 }
1437
1438 pub fn types(cause: &ObligationCause<'tcx>, a: Ty<'tcx>, b: Ty<'tcx>) -> TypeTrace<'tcx> {
1439 TypeTrace {
1440 cause: cause.clone(),
1441 values: ValuePairs::Terms(ExpectedFound::new(a.into(), b.into())),
1442 }
1443 }
1444
1445 pub fn trait_refs(
1446 cause: &ObligationCause<'tcx>,
1447 a: ty::TraitRef<'tcx>,
1448 b: ty::TraitRef<'tcx>,
1449 ) -> TypeTrace<'tcx> {
1450 TypeTrace { cause: cause.clone(), values: ValuePairs::TraitRefs(ExpectedFound::new(a, b)) }
1451 }
1452
1453 pub fn consts(
1454 cause: &ObligationCause<'tcx>,
1455 a: ty::Const<'tcx>,
1456 b: ty::Const<'tcx>,
1457 ) -> TypeTrace<'tcx> {
1458 TypeTrace {
1459 cause: cause.clone(),
1460 values: ValuePairs::Terms(ExpectedFound::new(a.into(), b.into())),
1461 }
1462 }
1463}
1464
1465impl<'tcx> SubregionOrigin<'tcx> {
1466 pub fn span(&self) -> Span {
1467 match *self {
1468 Subtype(ref a) => a.span(),
1469 RelateObjectBound(a) => a,
1470 RelateParamBound(a, ..) => a,
1471 RelateRegionParamBound(a, _) => a,
1472 Reborrow(a) => a,
1473 ReferenceOutlivesReferent(_, a) => a,
1474 CompareImplItemObligation { span, .. } => span,
1475 AscribeUserTypeProvePredicate(span) => span,
1476 CheckAssociatedTypeBounds { ref parent, .. } => parent.span(),
1477 }
1478 }
1479
1480 pub fn from_obligation_cause<F>(cause: &traits::ObligationCause<'tcx>, default: F) -> Self
1481 where
1482 F: FnOnce() -> Self,
1483 {
1484 match *cause.code() {
1485 traits::ObligationCauseCode::ReferenceOutlivesReferent(ref_type) => {
1486 SubregionOrigin::ReferenceOutlivesReferent(ref_type, cause.span)
1487 }
1488
1489 traits::ObligationCauseCode::CompareImplItem {
1490 impl_item_def_id,
1491 trait_item_def_id,
1492 kind: _,
1493 } => SubregionOrigin::CompareImplItemObligation {
1494 span: cause.span,
1495 impl_item_def_id,
1496 trait_item_def_id,
1497 },
1498
1499 traits::ObligationCauseCode::CheckAssociatedTypeBounds {
1500 impl_item_def_id,
1501 trait_item_def_id,
1502 } => SubregionOrigin::CheckAssociatedTypeBounds {
1503 impl_item_def_id,
1504 trait_item_def_id,
1505 parent: Box::new(default()),
1506 },
1507
1508 traits::ObligationCauseCode::AscribeUserTypeProvePredicate(span) => {
1509 SubregionOrigin::AscribeUserTypeProvePredicate(span)
1510 }
1511
1512 traits::ObligationCauseCode::ObjectTypeBound(ty, _reg) => {
1513 SubregionOrigin::RelateRegionParamBound(cause.span, Some(ty))
1514 }
1515
1516 _ => default(),
1517 }
1518 }
1519}
1520
1521impl RegionVariableOrigin {
1522 pub fn span(&self) -> Span {
1523 match *self {
1524 MiscVariable(a)
1525 | PatternRegion(a)
1526 | BorrowRegion(a)
1527 | Autoref(a)
1528 | Coercion(a)
1529 | RegionParameterDefinition(a, ..)
1530 | BoundRegion(a, ..)
1531 | UpvarRegion(_, a) => a,
1532 Nll(..) => bug!("NLL variable used with `span`"),
1533 }
1534 }
1535}
1536
1537impl<'tcx> InferCtxt<'tcx> {
1538 pub fn find_block_span(&self, block: &'tcx hir::Block<'tcx>) -> Span {
1541 let block = block.innermost_block();
1542 if let Some(expr) = &block.expr {
1543 expr.span
1544 } else if let Some(stmt) = block.stmts.last() {
1545 stmt.span
1547 } else {
1548 block.span
1550 }
1551 }
1552
1553 pub fn find_block_span_from_hir_id(&self, hir_id: hir::HirId) -> Span {
1556 match self.tcx.hir_node(hir_id) {
1557 hir::Node::Block(blk) => self.find_block_span(blk),
1558 hir::Node::Expr(e) => e.span,
1561 _ => rustc_span::DUMMY_SP,
1562 }
1563 }
1564}