Skip to main content

rustc_infer/infer/outlives/
obligations.rs

1//! Code that handles "type-outlives" constraints like `T: 'a`. This
2//! is based on the `push_outlives_components` function defined in rustc_infer,
3//! but it adds a bit of heuristics on top, in particular to deal with
4//! associated types and projections.
5//!
6//! When we process a given `T: 'a` obligation, we may produce two
7//! kinds of constraints for the region inferencer:
8//!
9//! - Relationships between inference variables and other regions.
10//!   For example, if we have `&'?0 u32: 'a`, then we would produce
11//!   a constraint that `'a <= '?0`.
12//! - "Verifys" that must be checked after inferencing is done.
13//!   For example, if we know that, for some type parameter `T`,
14//!   `T: 'a + 'b`, and we have a requirement that `T: '?1`,
15//!   then we add a "verify" that checks that `'?1 <= 'a || '?1 <= 'b`.
16//!   - Note the difference with the previous case: here, the region
17//!     variable must be less than something else, so this doesn't
18//!     affect how inference works (it finds the smallest region that
19//!     will do); it's just a post-condition that we have to check.
20//!
21//! **The key point is that once this function is done, we have
22//! reduced all of our "type-region outlives" obligations into relationships
23//! between individual regions.**
24//!
25//! One key input to this function is the set of "region-bound pairs".
26//! These are basically the relationships between type parameters and
27//! regions that are in scope at the point where the outlives
28//! obligation was incurred. **When type-checking a function,
29//! particularly in the face of closures, this is not known until
30//! regionck runs!** This is because some of those bounds come
31//! from things we have yet to infer.
32//!
33//! Consider:
34//!
35//! ```
36//! fn bar<T>(a: T, b: impl for<'a> Fn(&'a T)) {}
37//! fn foo<T>(x: T) {
38//!     bar(x, |y| { /* ... */})
39//!     //      ^ closure arg
40//! }
41//! ```
42//!
43//! Here, the type of `y` may involve inference variables and the
44//! like, and it may also contain implied bounds that are needed to
45//! type-check the closure body (e.g., here it informs us that `T`
46//! outlives the late-bound region `'a`).
47//!
48//! Note that by delaying the gathering of implied bounds until all
49//! inference information is known, we may find relationships between
50//! bound regions and other regions in the environment. For example,
51//! when we first check a closure like the one expected as argument
52//! to `foo`:
53//!
54//! ```
55//! fn foo<U, F: for<'a> FnMut(&'a U)>(_f: F) {}
56//! ```
57//!
58//! the type of the closure's first argument would be `&'a ?U`. We
59//! might later infer `?U` to something like `&'b u32`, which would
60//! imply that `'b: 'a`.
61
62use rustc_data_structures::transitive_relation::{TransitiveRelation, TransitiveRelationBuilder};
63use rustc_data_structures::undo_log::UndoLogs;
64use rustc_middle::mir::ConstraintCategory;
65use rustc_middle::ty::outlives::{Component, push_outlives_components};
66use rustc_middle::ty::{
67    self, GenericArgKind, GenericArgs, PolyTypeOutlivesClause, Region, RegionVid, Ty, TyCtxt,
68    TypeVisitableExt, Upcast,
69};
70use rustc_span::bug;
71use rustc_type_ir::region_constraint::{self, LeafRegionConstraint};
72use smallvec::smallvec;
73use tracing::{debug, instrument};
74
75use super::env::OutlivesEnvironment;
76use crate::infer::outlives::env::RegionBoundPairs;
77use crate::infer::outlives::verify::VerifyBoundCx;
78use crate::infer::snapshot::undo_log::UndoLog;
79use crate::infer::{
80    self, GenericKind, InferCtxt, SolverRegionConstraint, SubregionOrigin, TypeOutlivesConstraint,
81    VerifyBound,
82};
83use crate::traits::{ObligationCause, ObligationCauseCode};
84
85impl<'tcx> InferCtxt<'tcx> {
86    pub fn register_outlives_constraint(
87        &self,
88        ty::OutlivesClause(arg, r2): ty::ArgOutlivesClause<'tcx>,
89        vis: ty::VisibleForLeakCheck,
90        cause: &ObligationCause<'tcx>,
91    ) {
92        match arg.kind() {
93            ty::GenericArgKind::Lifetime(r1) => {
94                self.register_region_outlives_constraint(ty::OutlivesClause(r1, r2), vis, cause);
95            }
96            ty::GenericArgKind::Type(ty1) => {
97                self.register_type_outlives_constraint(ty1, r2, cause);
98            }
99            ty::GenericArgKind::Const(_) => ::core::panicking::unreachable_default_msg()unreachable!(),
100        }
101    }
102
103    pub fn register_region_eq_constraint(
104        &self,
105        ty::RegionEqPredicate(r_a, r_b): ty::RegionEqPredicate<'tcx>,
106        vis: ty::VisibleForLeakCheck,
107        cause: &ObligationCause<'tcx>,
108    ) {
109        let origin = SubregionOrigin::from_obligation_cause(cause, || {
110            SubregionOrigin::RelateRegionParamBound(cause.span, None)
111        });
112        self.equate_regions(origin, r_a, r_b, vis);
113    }
114
115    pub fn register_region_outlives_constraint(
116        &self,
117        ty::OutlivesClause(r_a, r_b): ty::RegionOutlivesClause<'tcx>,
118        vis: ty::VisibleForLeakCheck,
119        cause: &ObligationCause<'tcx>,
120    ) {
121        let origin = SubregionOrigin::from_obligation_cause(cause, || {
122            SubregionOrigin::RelateRegionParamBound(cause.span, None)
123        });
124        // `'a: 'b` ==> `'b <= 'a`
125        self.sub_regions(origin, r_b, r_a, vis);
126    }
127
128    /// Registers that the given region obligation must be resolved
129    /// from within the scope of `body_id`. These regions are enqueued
130    /// and later processed by regionck, when full type information is
131    /// available (see `region_obligations` field for more
132    /// information).
133    {}
#[allow(clippy :: suspicious_else_formatting)]
{
    let __tracing_attr_span;
    let __tracing_attr_guard;
    if ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() ||
            { false } {
        __tracing_attr_span =
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("register_type_outlives_constraint_inner",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(133u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&[{
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("obligation")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("obligation");
                                                        NAME.as_str()
                                                    }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::SPAN)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let mut interest = ::tracing::subscriber::Interest::never();
                if ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::STATIC_MAX_LEVEL &&
                                ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::LevelFilter::current() &&
                            { interest = __CALLSITE.interest(); !interest.is_never() }
                        &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest) {
                    let meta = __CALLSITE.metadata();
                    ::tracing::Span::new(meta,
                        &{
                                #[allow(unused_imports)]
                                use ::tracing::field::{debug, display, Value};
                                meta.fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&obligation)
                                                            as &dyn ::tracing::field::Value))])
                            })
                } else {
                    let span =
                        ::tracing::__macro_support::__disabled_span(__CALLSITE.metadata());
                    {};
                    span
                }
            };
        __tracing_attr_guard = __tracing_attr_span.enter();
    }

    #[warn(clippy :: suspicious_else_formatting)]
    {

        #[allow(unknown_lints, unreachable_code, clippy ::
        diverging_sub_expression, clippy :: empty_loop, clippy ::
        let_unit_value, clippy :: let_with_type_underscore, clippy ::
        needless_return, clippy :: unreachable)]
        if false {
            let __tracing_attr_fake_return: () = loop {};
            return __tracing_attr_fake_return;
        }
        {
            let mut inner = self.inner.borrow_mut();
            inner.undo_log.push(UndoLog::PushTypeOutlivesConstraint);
            inner.region_obligations.push(obligation);
        }
    }
}#[instrument(level = "debug", skip(self))]
134    pub fn register_type_outlives_constraint_inner(
135        &self,
136        obligation: TypeOutlivesConstraint<'tcx>,
137    ) {
138        let mut inner = self.inner.borrow_mut();
139        inner.undo_log.push(UndoLog::PushTypeOutlivesConstraint);
140        inner.region_obligations.push(obligation);
141    }
142
143    pub fn register_solver_region_constraint(&self, c: SolverRegionConstraint<'tcx>) {
144        self.inner.borrow_mut().unwrap_region_constraints().register_solver_constraint(c);
145    }
146
147    pub fn register_type_outlives_constraint(
148        &self,
149        sup_type: Ty<'tcx>,
150        sub_region: Region<'tcx>,
151        cause: &ObligationCause<'tcx>,
152    ) {
153        if !!self.tcx.assumptions_on_binders() {
    ::core::panicking::panic("assertion failed: !self.tcx.assumptions_on_binders()")
};assert!(!self.tcx.assumptions_on_binders());
154
155        // `is_global` means the type has no params, infer, placeholder, or non-`'static`
156        // free regions. If the type has none of these things, then we can skip registering
157        // this outlives obligation since it has no components which affect lifetime
158        // checking in an interesting way.
159        if sup_type.is_global() {
160            return;
161        }
162
163        {
    use ::tracing::__macro_support::Callsite as _;
    static __CALLSITE: ::tracing::callsite::DefaultCallsite =
        {
            static META: ::tracing::Metadata<'static> =
                {
                    ::tracing_core::metadata::Metadata::new("event /rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs:163",
                        "rustc_infer::infer::outlives::obligations",
                        ::tracing::Level::DEBUG,
                        ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                        ::tracing_core::__macro_support::Option::Some(163u32),
                        ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                        ::tracing_core::field::FieldSet::new(&[{
                                            const NAME:
                                                ::tracing::__macro_support::FieldName<{
                                                    ::tracing::__macro_support::FieldName::len("sup_type")
                                                }> =
                                                ::tracing::__macro_support::FieldName::new("sup_type");
                                            NAME.as_str()
                                        },
                                        {
                                            const NAME:
                                                ::tracing::__macro_support::FieldName<{
                                                    ::tracing::__macro_support::FieldName::len("sub_region")
                                                }> =
                                                ::tracing::__macro_support::FieldName::new("sub_region");
                                            NAME.as_str()
                                        },
                                        {
                                            const NAME:
                                                ::tracing::__macro_support::FieldName<{
                                                    ::tracing::__macro_support::FieldName::len("cause")
                                                }> =
                                                ::tracing::__macro_support::FieldName::new("cause");
                                            NAME.as_str()
                                        }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                        ::tracing::metadata::Kind::EVENT)
                };
            ::tracing::callsite::DefaultCallsite::new(&META)
        };
    let enabled =
        ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() &&
            {
                let interest = __CALLSITE.interest();
                !interest.is_never() &&
                    ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                        interest)
            };
    if enabled {
        (|value_set: ::tracing::field::ValueSet|
                    {
                        let meta = __CALLSITE.metadata();
                        ::tracing::Event::dispatch(meta, &value_set);
                        ;
                    })({
                #[allow(unused_imports)]
                use ::tracing::field::{debug, display, Value};
                __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&sup_type)
                                            as &dyn ::tracing::field::Value)),
                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&sub_region)
                                            as &dyn ::tracing::field::Value)),
                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&cause)
                                            as &dyn ::tracing::field::Value))])
            });
    } else { ; }
};debug!(?sup_type, ?sub_region, ?cause);
164        let origin = SubregionOrigin::from_obligation_cause(cause, || {
165            SubregionOrigin::RelateParamBound(
166                cause.span,
167                sup_type,
168                match cause.code().peel_derives() {
169                    ObligationCauseCode::WhereClause(_, span)
170                    | ObligationCauseCode::WhereClauseInExpr(_, span, ..)
171                    | ObligationCauseCode::OpaqueTypeBound(span, _)
172                        if !span.is_dummy() =>
173                    {
174                        Some(*span)
175                    }
176                    _ => None,
177                },
178            )
179        });
180
181        self.register_type_outlives_constraint_inner(TypeOutlivesConstraint {
182            sup_type,
183            sub_region,
184            origin,
185        });
186    }
187
188    /// Trait queries just want to pass back type obligations "as is"
189    pub fn take_registered_region_obligations(&self) -> Vec<TypeOutlivesConstraint<'tcx>> {
190        if !!self.in_snapshot() {
    {
        ::core::panicking::panic_fmt(format_args!("cannot take registered region obligations in a snapshot"));
    }
};assert!(!self.in_snapshot(), "cannot take registered region obligations in a snapshot");
191        std::mem::take(&mut self.inner.borrow_mut().region_obligations)
192    }
193
194    pub fn num_registered_region_obligations(&self) -> usize {
195        self.inner.borrow().region_obligations.len()
196    }
197
198    pub fn registered_region_obligations_since(
199        &self,
200        prev: usize,
201    ) -> Vec<TypeOutlivesConstraint<'tcx>> {
202        self.inner.borrow().region_obligations.iter().skip(prev).cloned().collect()
203    }
204
205    pub fn clone_registered_region_obligations(&self) -> Vec<TypeOutlivesConstraint<'tcx>> {
206        self.inner.borrow().region_obligations.clone()
207    }
208
209    pub fn register_region_assumption(&self, assumption: ty::ArgOutlivesClause<'tcx>) {
210        let mut inner = self.inner.borrow_mut();
211        inner.undo_log.push(UndoLog::PushRegionAssumption);
212        inner.region_assumptions.push(assumption);
213    }
214
215    pub fn take_registered_region_assumptions(&self) -> Vec<ty::ArgOutlivesClause<'tcx>> {
216        if !!self.in_snapshot() {
    {
        ::core::panicking::panic_fmt(format_args!("cannot take registered region assumptions in a snapshot"));
    }
};assert!(!self.in_snapshot(), "cannot take registered region assumptions in a snapshot");
217        std::mem::take(&mut self.inner.borrow_mut().region_assumptions)
218    }
219
220    pub fn destructure_solver_region_constraints_for_regionck(
221        &self,
222        outlives_env: &OutlivesEnvironment<'tcx>,
223    ) {
224        // `FreeRegionMap::relation` stores `'sub <= 'sup` edges while
225        // `Assumptions::region_outlives` expects `'longer: 'shorter` ones, so the
226        // edges have to be inverted here.
227        let mut region_outlives = TransitiveRelationBuilder::default();
228        for (r1, r2) in outlives_env.free_region_map().relation.base_edges() {
229            region_outlives.add(r2, r1);
230        }
231        let assumptions = rustc_type_ir::region_constraint::Assumptions::new(
232            self,
233            assumed_type_outlives(
234                self.tcx,
235                outlives_env.known_type_outlives(),
236                outlives_env.region_bound_pairs(),
237            ),
238            region_outlives.freeze(),
239            ty::UniverseIndex::ROOT,
240        );
241        self.destructure_solver_region_constraints(assumptions, self);
242    }
243
244    pub fn destructure_solver_region_constraints_for_borrowck(
245        &self,
246        // this is always ConstraintConversion but lol
247        conversion: impl TypeOutlivesDelegate<'tcx>,
248        known_type_outlives: &[PolyTypeOutlivesClause<'tcx>],
249        region_bound_pairs: &RegionBoundPairs<'tcx>,
250        region_outlives: TransitiveRelation<RegionVid>,
251    ) {
252        let assumptions = region_constraint::Assumptions::new(
253            self,
254            assumed_type_outlives(self.tcx, known_type_outlives, region_bound_pairs),
255            region_outlives.maybe_map(|r| Some(Region::new_var(self.tcx, r))).unwrap(),
256            ty::UniverseIndex::ROOT,
257        );
258        self.destructure_solver_region_constraints(assumptions, conversion);
259    }
260
261    {}
#[allow(clippy :: suspicious_else_formatting)]
{
    let __tracing_attr_span;
    let __tracing_attr_guard;
    if ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() ||
            { false } {
        __tracing_attr_span =
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("destructure_solver_region_constraints",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(261u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&[{
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("assumptions")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("assumptions");
                                                        NAME.as_str()
                                                    }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::SPAN)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let mut interest = ::tracing::subscriber::Interest::never();
                if ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::STATIC_MAX_LEVEL &&
                                ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::LevelFilter::current() &&
                            { interest = __CALLSITE.interest(); !interest.is_never() }
                        &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest) {
                    let meta = __CALLSITE.metadata();
                    ::tracing::Span::new(meta,
                        &{
                                #[allow(unused_imports)]
                                use ::tracing::field::{debug, display, Value};
                                meta.fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&assumptions)
                                                            as &dyn ::tracing::field::Value))])
                            })
                } else {
                    let span =
                        ::tracing::__macro_support::__disabled_span(__CALLSITE.metadata());
                    {};
                    span
                }
            };
        __tracing_attr_guard = __tracing_attr_span.enter();
    }

    #[warn(clippy :: suspicious_else_formatting)]
    {

        #[allow(unknown_lints, unreachable_code, clippy ::
        diverging_sub_expression, clippy :: empty_loop, clippy ::
        let_unit_value, clippy :: let_with_type_underscore, clippy ::
        needless_return, clippy :: unreachable)]
        if false {
            let __tracing_attr_fake_return: () = loop {};
            return __tracing_attr_fake_return;
        }
        {
            if !self.tcx.assumptions_on_binders() {
                ::core::panicking::panic("assertion failed: self.tcx.assumptions_on_binders()")
            };
            if !self.next_trait_solver() {
                ::core::panicking::panic("assertion failed: self.next_trait_solver()")
            };
            use LeafRegionConstraint::*;
            let solver_constraint = self.get_solver_region_constraint();
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("event /rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs:272",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(272u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&[{
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("solver_constraint")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("solver_constraint");
                                                        NAME.as_str()
                                                    }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::EVENT)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let enabled =
                    ::tracing::Level::DEBUG <=
                                ::tracing::level_filters::STATIC_MAX_LEVEL &&
                            ::tracing::Level::DEBUG <=
                                ::tracing::level_filters::LevelFilter::current() &&
                        {
                            let interest = __CALLSITE.interest();
                            !interest.is_never() &&
                                ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                                    interest)
                        };
                if enabled {
                    (|value_set: ::tracing::field::ValueSet|
                                {
                                    let meta = __CALLSITE.metadata();
                                    ::tracing::Event::dispatch(meta, &value_set);
                                    ;
                                })({
                            #[allow(unused_imports)]
                            use ::tracing::field::{debug, display, Value};
                            __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&solver_constraint)
                                                        as &dyn ::tracing::field::Value))])
                        });
                } else { ; }
            };
            let region_constraint::RootDestructuredConstraints {
                    constraint, failing_leafs } =
                region_constraint::destructure_type_outlives_constraints_in_root(self,
                    solver_constraint, &assumptions);
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("event /rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs:279",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(279u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&[{
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("constraint")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("constraint");
                                                        NAME.as_str()
                                                    }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::EVENT)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let enabled =
                    ::tracing::Level::DEBUG <=
                                ::tracing::level_filters::STATIC_MAX_LEVEL &&
                            ::tracing::Level::DEBUG <=
                                ::tracing::level_filters::LevelFilter::current() &&
                        {
                            let interest = __CALLSITE.interest();
                            !interest.is_never() &&
                                ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                                    interest)
                        };
                if enabled {
                    (|value_set: ::tracing::field::ValueSet|
                                {
                                    let meta = __CALLSITE.metadata();
                                    ::tracing::Event::dispatch(meta, &value_set);
                                    ;
                                })({
                            #[allow(unused_imports)]
                            use ::tracing::field::{debug, display, Value};
                            __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&constraint)
                                                        as &dyn ::tracing::field::Value))])
                        });
                } else { ; }
            };
            if constraint.is_false() {
                match failing_leafs.first() {
                    Some(PlaceholderTyOutlives(_a, _b, span)) => {
                        self.dcx().struct_span_err(*span,
                                "unable to satisfy constraints because it cannot be proven").emit();
                    }
                    Some(AliasTyOutlivesViaEnv(_, span)) => {
                        self.dcx().struct_span_err(*span,
                                "unable to satisfy constraints because it cannot be proven").emit();
                    }
                    _ => { ::core::panicking::unreachable_default_msg() }
                }
            }
            for c in
                constraint.and_constraint.0.into_iter().chain(constraint.or_constraint.0.into_iter().flat_map(|and_constraint|
                            and_constraint.0.into_iter())) {
                match c {
                    Ambiguity(span) => {
                        self.dcx().struct_span_err(span,
                                "unable to satisfy constraints involving placeholders due to unknown implied bounds").emit();
                    }
                    RegionOutlives(a, b, span) => {
                        let origin = SubregionOrigin::SolverRegionConstraint(span);
                        let category = origin.to_constraint_category();
                        conversion.push_sub_region_constraint(origin, b, a,
                            category);
                    }
                    AliasTyOutlivesViaEnv(..) | PlaceholderTyOutlives(..) => {
                        ::core::panicking::unreachable_default_msg()
                    }
                }
            }
        }
    }
}#[instrument(level = "debug", skip(self, conversion))]
262    pub fn destructure_solver_region_constraints(
263        &self,
264        assumptions: rustc_type_ir::region_constraint::Assumptions<TyCtxt<'tcx>>,
265        mut conversion: impl TypeOutlivesDelegate<'tcx>,
266    ) {
267        assert!(self.tcx.assumptions_on_binders());
268        assert!(self.next_trait_solver());
269        use LeafRegionConstraint::*;
270
271        let solver_constraint = self.get_solver_region_constraint();
272        debug!(?solver_constraint);
273        let region_constraint::RootDestructuredConstraints { constraint, failing_leafs } =
274            region_constraint::destructure_type_outlives_constraints_in_root(
275                self,
276                solver_constraint,
277                &assumptions,
278            );
279        debug!(?constraint);
280
281        if constraint.is_false() {
282            match failing_leafs.first() {
283                Some(PlaceholderTyOutlives(_a, _b, span)) => {
284                    self.dcx()
285                        .struct_span_err(
286                            *span,
287                            "unable to satisfy constraints because it cannot be proven",
288                        )
289                        .emit();
290                }
291                Some(AliasTyOutlivesViaEnv(_, span)) => {
292                    self.dcx()
293                        .struct_span_err(
294                            *span,
295                            "unable to satisfy constraints because it cannot be proven",
296                        )
297                        .emit();
298                }
299                _ => {
300                    unreachable!()
301                }
302            }
303        }
304
305        // FIXME(-Zassumptions-on-binders): actually implement OR as an  OR
306        for c in constraint.and_constraint.0.into_iter().chain(
307            constraint
308                .or_constraint
309                .0
310                .into_iter()
311                .flat_map(|and_constraint| and_constraint.0.into_iter()),
312        ) {
313            match c {
314                Ambiguity(span) => {
315                    self.dcx()
316                        .struct_span_err(
317                            span,
318                            "unable to satisfy constraints involving placeholders due to unknown implied bounds",
319                        )
320                        .emit();
321                }
322                RegionOutlives(a, b, span) => {
323                    let origin = SubregionOrigin::SolverRegionConstraint(span);
324                    let category = origin.to_constraint_category();
325                    conversion.push_sub_region_constraint(
326                        origin, // we flip these because regionck is silly :>
327                        b, a, category,
328                    );
329                }
330                AliasTyOutlivesViaEnv(..) | PlaceholderTyOutlives(..) => {
331                    unreachable!()
332                }
333            }
334        }
335    }
336
337    /// Process the region obligations that must be proven (during
338    /// `regionck`) for the given `body_id`, given information about
339    /// the region bounds in scope and so forth.
340    ///
341    /// See the `region_obligations` field of `InferCtxt` for some
342    /// comments about how this function fits into the overall expected
343    /// flow of the inferencer. The key point is that it is
344    /// invoked after all type-inference variables have been bound --
345    /// right before lexical region resolution.
346    {}
#[allow(clippy :: suspicious_else_formatting)]
{
    let __tracing_attr_span;
    let __tracing_attr_guard;
    if ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() ||
            { false } {
        __tracing_attr_span =
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("process_registered_region_obligations",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(346u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&[],
                                        ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::SPAN)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let mut interest = ::tracing::subscriber::Interest::never();
                if ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::STATIC_MAX_LEVEL &&
                                ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::LevelFilter::current() &&
                            { interest = __CALLSITE.interest(); !interest.is_never() }
                        &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest) {
                    let meta = __CALLSITE.metadata();
                    ::tracing::Span::new(meta,
                        &{ meta.fields().value_set_all(&[]) })
                } else {
                    let span =
                        ::tracing::__macro_support::__disabled_span(__CALLSITE.metadata());
                    {};
                    span
                }
            };
        __tracing_attr_guard = __tracing_attr_span.enter();
    }

    #[warn(clippy :: suspicious_else_formatting)]
    {

        #[allow(unknown_lints, unreachable_code, clippy ::
        diverging_sub_expression, clippy :: empty_loop, clippy ::
        let_unit_value, clippy :: let_with_type_underscore, clippy ::
        needless_return, clippy :: unreachable)]
        if false {
            let __tracing_attr_fake_return: () = loop {};
            return __tracing_attr_fake_return;
        }
        {
            if !!self.in_snapshot() {
                {
                    ::core::panicking::panic_fmt(format_args!("cannot process registered region obligations in a snapshot"));
                }
            };
            if self.tcx.assumptions_on_binders() {
                self.destructure_solver_region_constraints_for_regionck(outlives_env);
            }
            for iteration in 0.. {
                let my_region_obligations =
                    self.take_registered_region_obligations();
                if my_region_obligations.is_empty() { break; }
                if !self.tcx.recursion_limit().value_within_limit(iteration) {
                    ::rustc_span::macros::bug_impl(None,
                        format_args!("unexpected overflowed when processing region obligations: {0:#?}",
                            my_region_obligations), Location::caller());
                }
                for TypeOutlivesConstraint { sup_type, sub_region, origin } in
                    my_region_obligations {
                    #[allow(rustc::usage_of_type_ir_traits)]
                    let (sup_type, sub_region) =
                        self.deeply_resolve_via_unification_table((sup_type,
                                sub_region));
                    if self.tcx.sess.opts.unstable_opts.higher_ranked_assumptions
                            &&
                            outlives_env.higher_ranked_assumptions().contains(&ty::OutlivesClause(sup_type.into(),
                                        sub_region)) {
                        continue;
                    }
                    {
                        use ::tracing::__macro_support::Callsite as _;
                        static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                            {
                                static META: ::tracing::Metadata<'static> =
                                    {
                                        ::tracing_core::metadata::Metadata::new("event /rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs:389",
                                            "rustc_infer::infer::outlives::obligations",
                                            ::tracing::Level::DEBUG,
                                            ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                            ::tracing_core::__macro_support::Option::Some(389u32),
                                            ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                            ::tracing_core::field::FieldSet::new(&[{
                                                                const NAME:
                                                                    ::tracing::__macro_support::FieldName<{
                                                                        ::tracing::__macro_support::FieldName::len("sup_type")
                                                                    }> =
                                                                    ::tracing::__macro_support::FieldName::new("sup_type");
                                                                NAME.as_str()
                                                            },
                                                            {
                                                                const NAME:
                                                                    ::tracing::__macro_support::FieldName<{
                                                                        ::tracing::__macro_support::FieldName::len("sub_region")
                                                                    }> =
                                                                    ::tracing::__macro_support::FieldName::new("sub_region");
                                                                NAME.as_str()
                                                            },
                                                            {
                                                                const NAME:
                                                                    ::tracing::__macro_support::FieldName<{
                                                                        ::tracing::__macro_support::FieldName::len("origin")
                                                                    }> =
                                                                    ::tracing::__macro_support::FieldName::new("origin");
                                                                NAME.as_str()
                                                            }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                            ::tracing::metadata::Kind::EVENT)
                                    };
                                ::tracing::callsite::DefaultCallsite::new(&META)
                            };
                        let enabled =
                            ::tracing::Level::DEBUG <=
                                        ::tracing::level_filters::STATIC_MAX_LEVEL &&
                                    ::tracing::Level::DEBUG <=
                                        ::tracing::level_filters::LevelFilter::current() &&
                                {
                                    let interest = __CALLSITE.interest();
                                    !interest.is_never() &&
                                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                                            interest)
                                };
                        if enabled {
                            (|value_set: ::tracing::field::ValueSet|
                                        {
                                            let meta = __CALLSITE.metadata();
                                            ::tracing::Event::dispatch(meta, &value_set);
                                            ;
                                        })({
                                    #[allow(unused_imports)]
                                    use ::tracing::field::{debug, display, Value};
                                    __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&sup_type)
                                                                as &dyn ::tracing::field::Value)),
                                                    (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&sub_region)
                                                                as &dyn ::tracing::field::Value)),
                                                    (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&origin)
                                                                as &dyn ::tracing::field::Value))])
                                });
                        } else { ; }
                    };
                    let outlives =
                        &mut TypeOutlives::new(self, self.tcx,
                                outlives_env.region_bound_pairs(), None,
                                outlives_env.known_type_outlives());
                    let category = origin.to_constraint_category();
                    outlives.type_must_outlive(origin, sup_type, sub_region,
                        category);
                }
            }
        }
    }
}#[instrument(level = "debug", skip(self, outlives_env))]
347    pub fn process_registered_region_obligations(&self, outlives_env: &OutlivesEnvironment<'tcx>) {
348        assert!(!self.in_snapshot(), "cannot process registered region obligations in a snapshot");
349
350        if self.tcx.assumptions_on_binders() {
351            self.destructure_solver_region_constraints_for_regionck(outlives_env);
352        }
353
354        // Must loop since the process of normalizing may itself register region obligations.
355        for iteration in 0.. {
356            let my_region_obligations = self.take_registered_region_obligations();
357            if my_region_obligations.is_empty() {
358                break;
359            }
360
361            if !self.tcx.recursion_limit().value_within_limit(iteration) {
362                // This may actually be reachable. If so, we should convert
363                // this to a proper error/consider whether we should detect
364                // this somewhere else.
365                bug!(
366                    "unexpected overflowed when processing region obligations: {my_region_obligations:#?}"
367                );
368            }
369
370            for TypeOutlivesConstraint { sup_type, sub_region, origin } in my_region_obligations {
371                // `TypeOutlives` is structural, so we should try to opportunistically resolve all
372                // region vids before processing regions, so we have a better chance to match clauses
373                // in our param-env.
374                //
375                // We *want* this folder to live in `rustc_type_ir`. Our best way to call into it is
376                // through `InferCtxtLike` and it is not defined as an inherent method on `InferCtxt`.
377                #[allow(rustc::usage_of_type_ir_traits)]
378                let (sup_type, sub_region) =
379                    self.deeply_resolve_via_unification_table((sup_type, sub_region));
380
381                if self.tcx.sess.opts.unstable_opts.higher_ranked_assumptions
382                    && outlives_env
383                        .higher_ranked_assumptions()
384                        .contains(&ty::OutlivesClause(sup_type.into(), sub_region))
385                {
386                    continue;
387                }
388
389                debug!(?sup_type, ?sub_region, ?origin);
390
391                let outlives = &mut TypeOutlives::new(
392                    self,
393                    self.tcx,
394                    outlives_env.region_bound_pairs(),
395                    None,
396                    outlives_env.known_type_outlives(),
397                );
398                let category = origin.to_constraint_category();
399                outlives.type_must_outlive(origin, sup_type, sub_region, category);
400            }
401        }
402    }
403}
404
405/// The type outlives assumptions available in the root context, as clauses for
406/// [`region_constraint::Assumptions::new`] to elaborate.
407///
408/// `known_type_outlives` only contains the explicit `Ty: 'a` where clauses. The implied bounds,
409/// e.g. `T: 'a` from a `&'a T` argument, are only tracked in `region_bound_pairs` so we have to
410/// pull them in separately. Without them we'd fail to prove `T: 'a` for a `&'a T` argument
411/// whenever the only explicit bound on `T` mentions a different region.
412fn assumed_type_outlives<'tcx>(
413    tcx: TyCtxt<'tcx>,
414    known_type_outlives: &[PolyTypeOutlivesClause<'tcx>],
415    region_bound_pairs: &RegionBoundPairs<'tcx>,
416) -> Vec<ty::Clause<'tcx>> {
417    known_type_outlives
418        .iter()
419        .copied()
420        .chain(region_bound_pairs.iter().map(|&ty::OutlivesClause(kind, r)| {
421            ty::Binder::dummy(ty::OutlivesClause(kind.to_ty(tcx), r))
422        }))
423        .map(|c| c.map_bound(ty::ClauseKind::TypeOutlives).upcast(tcx))
424        .collect()
425}
426
427/// The `TypeOutlives` struct has the job of "lowering" a `T: 'a`
428/// obligation into a series of `'a: 'b` constraints and "verify"s, as
429/// described on the module comment. The final constraints are emitted
430/// via a "delegate" of type `D` -- this is usually the `infcx`, which
431/// accrues them into the `region_obligations` code, but for NLL we
432/// use something else.
433pub struct TypeOutlives<'cx, 'tcx, D>
434where
435    D: TypeOutlivesDelegate<'tcx>,
436{
437    // See the comments on `process_registered_region_obligations` for the meaning
438    // of these fields.
439    delegate: D,
440    tcx: TyCtxt<'tcx>,
441    verify_bound: VerifyBoundCx<'cx, 'tcx>,
442}
443
444pub trait TypeOutlivesDelegate<'tcx> {
445    fn push_sub_region_constraint(
446        &mut self,
447        origin: SubregionOrigin<'tcx>,
448        a: ty::Region<'tcx>,
449        b: ty::Region<'tcx>,
450        constraint_category: ConstraintCategory<'tcx>,
451    );
452
453    fn push_verify(
454        &mut self,
455        origin: SubregionOrigin<'tcx>,
456        kind: GenericKind<'tcx>,
457        a: ty::Region<'tcx>,
458        bound: VerifyBound<'tcx>,
459    );
460}
461
462impl<'cx, 'tcx, D> TypeOutlives<'cx, 'tcx, D>
463where
464    D: TypeOutlivesDelegate<'tcx>,
465{
466    pub fn new(
467        delegate: D,
468        tcx: TyCtxt<'tcx>,
469        region_bound_pairs: &'cx RegionBoundPairs<'tcx>,
470        implicit_region_bound: Option<ty::Region<'tcx>>,
471        caller_bounds: &'cx [ty::PolyTypeOutlivesClause<'tcx>],
472    ) -> Self {
473        Self {
474            delegate,
475            tcx,
476            verify_bound: VerifyBoundCx::new(
477                tcx,
478                region_bound_pairs,
479                implicit_region_bound,
480                caller_bounds,
481            ),
482        }
483    }
484
485    /// Adds constraints to inference such that `T: 'a` holds (or
486    /// reports an error if it cannot).
487    ///
488    /// # Parameters
489    ///
490    /// - `origin`, the reason we need this constraint
491    /// - `ty`, the type `T`
492    /// - `region`, the region `'a`
493    {}
#[allow(clippy :: suspicious_else_formatting)]
{
    let __tracing_attr_span;
    let __tracing_attr_guard;
    if ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() ||
            { false } {
        __tracing_attr_span =
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("type_must_outlive",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(493u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&[{
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("origin")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("origin");
                                                        NAME.as_str()
                                                    },
                                                    {
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("ty")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("ty");
                                                        NAME.as_str()
                                                    },
                                                    {
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("region")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("region");
                                                        NAME.as_str()
                                                    },
                                                    {
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("category")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("category");
                                                        NAME.as_str()
                                                    }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::SPAN)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let mut interest = ::tracing::subscriber::Interest::never();
                if ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::STATIC_MAX_LEVEL &&
                                ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::LevelFilter::current() &&
                            { interest = __CALLSITE.interest(); !interest.is_never() }
                        &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest) {
                    let meta = __CALLSITE.metadata();
                    ::tracing::Span::new(meta,
                        &{
                                #[allow(unused_imports)]
                                use ::tracing::field::{debug, display, Value};
                                meta.fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&origin)
                                                            as &dyn ::tracing::field::Value)),
                                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&ty)
                                                            as &dyn ::tracing::field::Value)),
                                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&region)
                                                            as &dyn ::tracing::field::Value)),
                                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&category)
                                                            as &dyn ::tracing::field::Value))])
                            })
                } else {
                    let span =
                        ::tracing::__macro_support::__disabled_span(__CALLSITE.metadata());
                    {};
                    span
                }
            };
        __tracing_attr_guard = __tracing_attr_span.enter();
    }

    #[warn(clippy :: suspicious_else_formatting)]
    {

        #[allow(unknown_lints, unreachable_code, clippy ::
        diverging_sub_expression, clippy :: empty_loop, clippy ::
        let_unit_value, clippy :: let_with_type_underscore, clippy ::
        needless_return, clippy :: unreachable)]
        if false {
            let __tracing_attr_fake_return: () = loop {};
            return __tracing_attr_fake_return;
        }
        {
            if !!ty.has_escaping_bound_vars() {
                ::core::panicking::panic("assertion failed: !ty.has_escaping_bound_vars()")
            };
            if true {
                if !!ty.has_non_region_infer() {
                    ::core::panicking::panic("assertion failed: !ty.has_non_region_infer()")
                };
            };
            if true {
                if !(!self.tcx.next_trait_solver_globally() ||
                            !ty.has_non_rigid_aliases()) {
                    {
                        ::core::panicking::panic_fmt(format_args!("{0:?} has non-rigid aliases",
                                ty));
                    }
                };
            };
            let mut components = ::smallvec::SmallVec::new();
            push_outlives_components(self.tcx, ty, &mut components);
            self.components_must_outlive(origin, &components, region,
                category);
        }
    }
}#[instrument(level = "debug", skip(self))]
494    pub fn type_must_outlive(
495        &mut self,
496        origin: infer::SubregionOrigin<'tcx>,
497        ty: Ty<'tcx>,
498        region: ty::Region<'tcx>,
499        category: ConstraintCategory<'tcx>,
500    ) {
501        assert!(!ty.has_escaping_bound_vars());
502        debug_assert!(!ty.has_non_region_infer());
503        debug_assert!(
504            !self.tcx.next_trait_solver_globally() || !ty.has_non_rigid_aliases(),
505            "{ty:?} has non-rigid aliases"
506        );
507
508        let mut components = smallvec![];
509        push_outlives_components(self.tcx, ty, &mut components);
510        self.components_must_outlive(origin, &components, region, category);
511    }
512
513    fn components_must_outlive(
514        &mut self,
515        origin: infer::SubregionOrigin<'tcx>,
516        components: &[Component<TyCtxt<'tcx>>],
517        region: ty::Region<'tcx>,
518        category: ConstraintCategory<'tcx>,
519    ) {
520        for component in components.iter() {
521            let origin = origin.clone();
522            match component {
523                Component::Region(region1) => {
524                    self.delegate.push_sub_region_constraint(origin, region, *region1, category);
525                }
526                Component::Param(param_ty) => {
527                    self.param_ty_must_outlive(origin, region, *param_ty);
528                }
529                Component::Placeholder(placeholder_ty) => {
530                    self.placeholder_ty_must_outlive(origin, region, *placeholder_ty);
531                }
532                Component::Alias(is_rigid, alias_ty) => {
533                    if true {
    {
        match (&*is_rigid, &ty::IsRigid::yes_if_next_solver(self.tcx)) {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    let kind = ::core::panicking::AssertKind::Eq;
                    ::core::panicking::assert_failed(kind, &*left_val,
                        &*right_val, ::core::option::Option::None);
                }
            }
        }
    };
};debug_assert_eq!(*is_rigid, ty::IsRigid::yes_if_next_solver(self.tcx));
534                    self.alias_ty_must_outlive(origin, region, *alias_ty);
535                }
536                Component::EscapingAlias(subcomponents) => {
537                    self.components_must_outlive(origin, subcomponents, region, category);
538                }
539                Component::UnresolvedInferenceVariable(v) => {
540                    // Ignore this, we presume it will yield an error later,
541                    // since if a type variable is not resolved by this point
542                    // it never will be.
543                    self.tcx.dcx().span_delayed_bug(
544                        origin.span(),
545                        ::alloc::__export::must_use({
        ::alloc::fmt::format(format_args!("unresolved inference variable in outlives: {0:?}",
                v))
    })format!("unresolved inference variable in outlives: {v:?}"),
546                    );
547                }
548            }
549        }
550    }
551
552    {}
#[allow(clippy :: suspicious_else_formatting)]
{
    let __tracing_attr_span;
    let __tracing_attr_guard;
    if ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() ||
            { false } {
        __tracing_attr_span =
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("param_ty_must_outlive",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(552u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&[{
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("origin")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("origin");
                                                        NAME.as_str()
                                                    },
                                                    {
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("region")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("region");
                                                        NAME.as_str()
                                                    },
                                                    {
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("param_ty")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("param_ty");
                                                        NAME.as_str()
                                                    }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::SPAN)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let mut interest = ::tracing::subscriber::Interest::never();
                if ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::STATIC_MAX_LEVEL &&
                                ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::LevelFilter::current() &&
                            { interest = __CALLSITE.interest(); !interest.is_never() }
                        &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest) {
                    let meta = __CALLSITE.metadata();
                    ::tracing::Span::new(meta,
                        &{
                                #[allow(unused_imports)]
                                use ::tracing::field::{debug, display, Value};
                                meta.fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&origin)
                                                            as &dyn ::tracing::field::Value)),
                                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&region)
                                                            as &dyn ::tracing::field::Value)),
                                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&param_ty)
                                                            as &dyn ::tracing::field::Value))])
                            })
                } else {
                    let span =
                        ::tracing::__macro_support::__disabled_span(__CALLSITE.metadata());
                    {};
                    span
                }
            };
        __tracing_attr_guard = __tracing_attr_span.enter();
    }

    #[warn(clippy :: suspicious_else_formatting)]
    {

        #[allow(unknown_lints, unreachable_code, clippy ::
        diverging_sub_expression, clippy :: empty_loop, clippy ::
        let_unit_value, clippy :: let_with_type_underscore, clippy ::
        needless_return, clippy :: unreachable)]
        if false {
            let __tracing_attr_fake_return: () = loop {};
            return __tracing_attr_fake_return;
        }
        {
            let verify_bound =
                self.verify_bound.param_or_placeholder_bound(param_ty.to_ty(self.tcx));
            self.delegate.push_verify(origin, GenericKind::Param(param_ty),
                region, verify_bound);
        }
    }
}#[instrument(level = "debug", skip(self))]
553    fn param_ty_must_outlive(
554        &mut self,
555        origin: infer::SubregionOrigin<'tcx>,
556        region: ty::Region<'tcx>,
557        param_ty: ty::ParamTy,
558    ) {
559        let verify_bound = self.verify_bound.param_or_placeholder_bound(param_ty.to_ty(self.tcx));
560        self.delegate.push_verify(origin, GenericKind::Param(param_ty), region, verify_bound);
561    }
562
563    {}
#[allow(clippy :: suspicious_else_formatting)]
{
    let __tracing_attr_span;
    let __tracing_attr_guard;
    if ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() ||
            { false } {
        __tracing_attr_span =
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("placeholder_ty_must_outlive",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(563u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&[{
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("origin")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("origin");
                                                        NAME.as_str()
                                                    },
                                                    {
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("region")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("region");
                                                        NAME.as_str()
                                                    },
                                                    {
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("placeholder_ty")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("placeholder_ty");
                                                        NAME.as_str()
                                                    }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::SPAN)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let mut interest = ::tracing::subscriber::Interest::never();
                if ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::STATIC_MAX_LEVEL &&
                                ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::LevelFilter::current() &&
                            { interest = __CALLSITE.interest(); !interest.is_never() }
                        &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest) {
                    let meta = __CALLSITE.metadata();
                    ::tracing::Span::new(meta,
                        &{
                                #[allow(unused_imports)]
                                use ::tracing::field::{debug, display, Value};
                                meta.fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&origin)
                                                            as &dyn ::tracing::field::Value)),
                                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&region)
                                                            as &dyn ::tracing::field::Value)),
                                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&placeholder_ty)
                                                            as &dyn ::tracing::field::Value))])
                            })
                } else {
                    let span =
                        ::tracing::__macro_support::__disabled_span(__CALLSITE.metadata());
                    {};
                    span
                }
            };
        __tracing_attr_guard = __tracing_attr_span.enter();
    }

    #[warn(clippy :: suspicious_else_formatting)]
    {

        #[allow(unknown_lints, unreachable_code, clippy ::
        diverging_sub_expression, clippy :: empty_loop, clippy ::
        let_unit_value, clippy :: let_with_type_underscore, clippy ::
        needless_return, clippy :: unreachable)]
        if false {
            let __tracing_attr_fake_return: () = loop {};
            return __tracing_attr_fake_return;
        }
        {
            let verify_bound =
                self.verify_bound.param_or_placeholder_bound(Ty::new_placeholder(self.tcx,
                        placeholder_ty));
            self.delegate.push_verify(origin,
                GenericKind::Placeholder(placeholder_ty), region,
                verify_bound);
        }
    }
}#[instrument(level = "debug", skip(self))]
564    fn placeholder_ty_must_outlive(
565        &mut self,
566        origin: infer::SubregionOrigin<'tcx>,
567        region: ty::Region<'tcx>,
568        placeholder_ty: ty::PlaceholderType<'tcx>,
569    ) {
570        let verify_bound = self
571            .verify_bound
572            .param_or_placeholder_bound(Ty::new_placeholder(self.tcx, placeholder_ty));
573        self.delegate.push_verify(
574            origin,
575            GenericKind::Placeholder(placeholder_ty),
576            region,
577            verify_bound,
578        );
579    }
580
581    {}
#[allow(clippy :: suspicious_else_formatting)]
{
    let __tracing_attr_span;
    let __tracing_attr_guard;
    if ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() ||
            { false } {
        __tracing_attr_span =
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("alias_ty_must_outlive",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(581u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&[{
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("origin")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("origin");
                                                        NAME.as_str()
                                                    },
                                                    {
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("region")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("region");
                                                        NAME.as_str()
                                                    },
                                                    {
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("alias_ty")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("alias_ty");
                                                        NAME.as_str()
                                                    }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::SPAN)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let mut interest = ::tracing::subscriber::Interest::never();
                if ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::STATIC_MAX_LEVEL &&
                                ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::LevelFilter::current() &&
                            { interest = __CALLSITE.interest(); !interest.is_never() }
                        &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest) {
                    let meta = __CALLSITE.metadata();
                    ::tracing::Span::new(meta,
                        &{
                                #[allow(unused_imports)]
                                use ::tracing::field::{debug, display, Value};
                                meta.fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&origin)
                                                            as &dyn ::tracing::field::Value)),
                                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&region)
                                                            as &dyn ::tracing::field::Value)),
                                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&alias_ty)
                                                            as &dyn ::tracing::field::Value))])
                            })
                } else {
                    let span =
                        ::tracing::__macro_support::__disabled_span(__CALLSITE.metadata());
                    {};
                    span
                }
            };
        __tracing_attr_guard = __tracing_attr_span.enter();
    }

    #[warn(clippy :: suspicious_else_formatting)]
    {

        #[allow(unknown_lints, unreachable_code, clippy ::
        diverging_sub_expression, clippy :: empty_loop, clippy ::
        let_unit_value, clippy :: let_with_type_underscore, clippy ::
        needless_return, clippy :: unreachable)]
        if false {
            let __tracing_attr_fake_return: () = loop {};
            return __tracing_attr_fake_return;
        }
        {
            if alias_ty.args.is_empty() { return; }
            if alias_ty.has_non_region_infer() {
                self.tcx.dcx().span_delayed_bug(origin.span(),
                    "an alias has infers during region solving");
                return;
            }
            let trait_bounds: Vec<_> =
                rustc_type_ir::outlives::declared_bounds_from_definition(self.tcx,
                        alias_ty).collect();
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("event /rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs:620",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(620u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&[{
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("trait_bounds")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("trait_bounds");
                                                        NAME.as_str()
                                                    }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::EVENT)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let enabled =
                    ::tracing::Level::DEBUG <=
                                ::tracing::level_filters::STATIC_MAX_LEVEL &&
                            ::tracing::Level::DEBUG <=
                                ::tracing::level_filters::LevelFilter::current() &&
                        {
                            let interest = __CALLSITE.interest();
                            !interest.is_never() &&
                                ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                                    interest)
                        };
                if enabled {
                    (|value_set: ::tracing::field::ValueSet|
                                {
                                    let meta = __CALLSITE.metadata();
                                    ::tracing::Event::dispatch(meta, &value_set);
                                    ;
                                })({
                            #[allow(unused_imports)]
                            use ::tracing::field::{debug, display, Value};
                            __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&trait_bounds)
                                                        as &dyn ::tracing::field::Value))])
                        });
                } else { ; }
            };
            let approx_env_bounds =
                self.verify_bound.approx_declared_bounds_from_env(alias_ty);
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("event /rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs:626",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(626u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&[{
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("approx_env_bounds")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("approx_env_bounds");
                                                        NAME.as_str()
                                                    }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::EVENT)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let enabled =
                    ::tracing::Level::DEBUG <=
                                ::tracing::level_filters::STATIC_MAX_LEVEL &&
                            ::tracing::Level::DEBUG <=
                                ::tracing::level_filters::LevelFilter::current() &&
                        {
                            let interest = __CALLSITE.interest();
                            !interest.is_never() &&
                                ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                                    interest)
                        };
                if enabled {
                    (|value_set: ::tracing::field::ValueSet|
                                {
                                    let meta = __CALLSITE.metadata();
                                    ::tracing::Event::dispatch(meta, &value_set);
                                    ;
                                })({
                            #[allow(unused_imports)]
                            use ::tracing::field::{debug, display, Value};
                            __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&approx_env_bounds)
                                                        as &dyn ::tracing::field::Value))])
                        });
                } else { ; }
            };
            let kind = alias_ty.kind;
            if approx_env_bounds.is_empty() && trait_bounds.is_empty() &&
                    (alias_ty.has_infer_regions() ||
                            #[allow(non_exhaustive_omitted_patterns)] match kind {
                                ty::Opaque { .. } => true,
                                _ => false,
                            }) {
                {
                    use ::tracing::__macro_support::Callsite as _;
                    static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                        {
                            static META: ::tracing::Metadata<'static> =
                                {
                                    ::tracing_core::metadata::Metadata::new("event /rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs:647",
                                        "rustc_infer::infer::outlives::obligations",
                                        ::tracing::Level::DEBUG,
                                        ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                        ::tracing_core::__macro_support::Option::Some(647u32),
                                        ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                        ::tracing_core::field::FieldSet::new(&["message"],
                                            ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                        ::tracing::metadata::Kind::EVENT)
                                };
                            ::tracing::callsite::DefaultCallsite::new(&META)
                        };
                    let enabled =
                        ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::STATIC_MAX_LEVEL &&
                                ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::LevelFilter::current() &&
                            {
                                let interest = __CALLSITE.interest();
                                !interest.is_never() &&
                                    ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                                        interest)
                            };
                    if enabled {
                        (|value_set: ::tracing::field::ValueSet|
                                    {
                                        let meta = __CALLSITE.metadata();
                                        ::tracing::Event::dispatch(meta, &value_set);
                                        ;
                                    })({
                                #[allow(unused_imports)]
                                use ::tracing::field::{debug, display, Value};
                                __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("no declared bounds")
                                                            as &dyn ::tracing::field::Value))])
                            });
                    } else { ; }
                };
                let opt_variances = self.tcx.opt_alias_variances(kind);
                self.args_must_outlive(alias_ty.args, origin, region,
                    opt_variances);
                return;
            }
            if !trait_bounds.is_empty() &&
                    trait_bounds[1..].iter().map(|r|
                                    Some(*r)).chain(approx_env_bounds.iter().map(|b|
                                    b.map_bound(|b|
                                                b.1).no_bound_vars())).all(|b| b == Some(trait_bounds[0])) {
                let unique_bound = trait_bounds[0];
                {
                    use ::tracing::__macro_support::Callsite as _;
                    static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                        {
                            static META: ::tracing::Metadata<'static> =
                                {
                                    ::tracing_core::metadata::Metadata::new("event /rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs:678",
                                        "rustc_infer::infer::outlives::obligations",
                                        ::tracing::Level::DEBUG,
                                        ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                        ::tracing_core::__macro_support::Option::Some(678u32),
                                        ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                        ::tracing_core::field::FieldSet::new(&[{
                                                            const NAME:
                                                                ::tracing::__macro_support::FieldName<{
                                                                    ::tracing::__macro_support::FieldName::len("unique_bound")
                                                                }> =
                                                                ::tracing::__macro_support::FieldName::new("unique_bound");
                                                            NAME.as_str()
                                                        }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                        ::tracing::metadata::Kind::EVENT)
                                };
                            ::tracing::callsite::DefaultCallsite::new(&META)
                        };
                    let enabled =
                        ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::STATIC_MAX_LEVEL &&
                                ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::LevelFilter::current() &&
                            {
                                let interest = __CALLSITE.interest();
                                !interest.is_never() &&
                                    ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                                        interest)
                            };
                    if enabled {
                        (|value_set: ::tracing::field::ValueSet|
                                    {
                                        let meta = __CALLSITE.metadata();
                                        ::tracing::Event::dispatch(meta, &value_set);
                                        ;
                                    })({
                                #[allow(unused_imports)]
                                use ::tracing::field::{debug, display, Value};
                                __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&unique_bound)
                                                            as &dyn ::tracing::field::Value))])
                            });
                    } else { ; }
                };
                {
                    use ::tracing::__macro_support::Callsite as _;
                    static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                        {
                            static META: ::tracing::Metadata<'static> =
                                {
                                    ::tracing_core::metadata::Metadata::new("event /rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs:679",
                                        "rustc_infer::infer::outlives::obligations",
                                        ::tracing::Level::DEBUG,
                                        ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                        ::tracing_core::__macro_support::Option::Some(679u32),
                                        ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                        ::tracing_core::field::FieldSet::new(&["message"],
                                            ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                        ::tracing::metadata::Kind::EVENT)
                                };
                            ::tracing::callsite::DefaultCallsite::new(&META)
                        };
                    let enabled =
                        ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::STATIC_MAX_LEVEL &&
                                ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::LevelFilter::current() &&
                            {
                                let interest = __CALLSITE.interest();
                                !interest.is_never() &&
                                    ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                                        interest)
                            };
                    if enabled {
                        (|value_set: ::tracing::field::ValueSet|
                                    {
                                        let meta = __CALLSITE.metadata();
                                        ::tracing::Event::dispatch(meta, &value_set);
                                        ;
                                    })({
                                #[allow(unused_imports)]
                                use ::tracing::field::{debug, display, Value};
                                __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("unique declared bound appears in trait ref")
                                                            as &dyn ::tracing::field::Value))])
                            });
                    } else { ; }
                };
                let category = origin.to_constraint_category();
                self.delegate.push_sub_region_constraint(origin, region,
                    unique_bound, category);
                return;
            }
            let verify_bound = self.verify_bound.alias_bound(alias_ty);
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("event /rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs:691",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(691u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&["message"],
                                        ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::EVENT)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let enabled =
                    ::tracing::Level::DEBUG <=
                                ::tracing::level_filters::STATIC_MAX_LEVEL &&
                            ::tracing::Level::DEBUG <=
                                ::tracing::level_filters::LevelFilter::current() &&
                        {
                            let interest = __CALLSITE.interest();
                            !interest.is_never() &&
                                ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                                    interest)
                        };
                if enabled {
                    (|value_set: ::tracing::field::ValueSet|
                                {
                                    let meta = __CALLSITE.metadata();
                                    ::tracing::Event::dispatch(meta, &value_set);
                                    ;
                                })({
                            #[allow(unused_imports)]
                            use ::tracing::field::{debug, display, Value};
                            __CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("alias_must_outlive: pushing {0:?}",
                                                                verify_bound) as &dyn ::tracing::field::Value))])
                        });
                } else { ; }
            };
            self.delegate.push_verify(origin, GenericKind::Alias(alias_ty),
                region, verify_bound);
        }
    }
}#[instrument(level = "debug", skip(self))]
582    fn alias_ty_must_outlive(
583        &mut self,
584        origin: infer::SubregionOrigin<'tcx>,
585        region: ty::Region<'tcx>,
586        alias_ty: ty::AliasTy<'tcx>,
587    ) {
588        // An optimization for a common case with opaque types.
589        if alias_ty.args.is_empty() {
590            return;
591        }
592
593        if alias_ty.has_non_region_infer() {
594            self.tcx
595                .dcx()
596                .span_delayed_bug(origin.span(), "an alias has infers during region solving");
597            return;
598        }
599
600        // This case is thorny for inference. The fundamental problem is
601        // that there are many cases where we have choice, and inference
602        // doesn't like choice (the current region inference in
603        // particular). :) First off, we have to choose between using the
604        // OutlivesProjectionEnv, OutlivesProjectionTraitDef, and
605        // OutlivesProjectionComponent rules, any one of which is
606        // sufficient. If there are no inference variables involved, it's
607        // not hard to pick the right rule, but if there are, we're in a
608        // bit of a catch 22: if we picked which rule we were going to
609        // use, we could add constraints to the region inference graph
610        // that make it apply, but if we don't add those constraints, the
611        // rule might not apply (but another rule might). For now, we err
612        // on the side of adding too few edges into the graph.
613
614        // Compute the bounds we can derive from the trait definition.
615        // These are guaranteed to apply, no matter the inference
616        // results.
617        let trait_bounds: Vec<_> =
618            rustc_type_ir::outlives::declared_bounds_from_definition(self.tcx, alias_ty).collect();
619
620        debug!(?trait_bounds);
621
622        // Compute the bounds we can derive from the environment. This
623        // is an "approximate" match -- in some cases, these bounds
624        // may not apply.
625        let approx_env_bounds = self.verify_bound.approx_declared_bounds_from_env(alias_ty);
626        debug!(?approx_env_bounds);
627
628        // If declared bounds list is empty, the only applicable rule is
629        // OutlivesProjectionComponent. If there are inference variables,
630        // then, we can break down the outlives into more primitive
631        // components without adding unnecessary edges.
632        //
633        // If there are *no* inference variables, however, we COULD do
634        // this, but we choose not to, because the error messages are less
635        // good. For example, a requirement like `T::Item: 'r` would be
636        // translated to a requirement that `T: 'r`; when this is reported
637        // to the user, it will thus say "T: 'r must hold so that T::Item:
638        // 'r holds". But that makes it sound like the only way to fix
639        // the problem is to add `T: 'r`, which isn't true. So, if there are no
640        // inference variables, we use a verify constraint instead of adding
641        // edges, which winds up enforcing the same condition.
642        let kind = alias_ty.kind;
643        if approx_env_bounds.is_empty()
644            && trait_bounds.is_empty()
645            && (alias_ty.has_infer_regions() || matches!(kind, ty::Opaque { .. }))
646        {
647            debug!("no declared bounds");
648            let opt_variances = self.tcx.opt_alias_variances(kind);
649            self.args_must_outlive(alias_ty.args, origin, region, opt_variances);
650            return;
651        }
652
653        // If we found a unique bound `'b` from the trait, and we
654        // found nothing else from the environment, then the best
655        // action is to require that `'b: 'r`, so do that.
656        //
657        // This is best no matter what rule we use:
658        //
659        // - OutlivesProjectionEnv: these would translate to the requirement that `'b:'r`
660        // - OutlivesProjectionTraitDef: these would translate to the requirement that `'b:'r`
661        // - OutlivesProjectionComponent: this would require `'b:'r`
662        //   in addition to other conditions
663        if !trait_bounds.is_empty()
664            && trait_bounds[1..]
665                .iter()
666                .map(|r| Some(*r))
667                .chain(
668                    // NB: The environment may contain `for<'a> T: 'a` style bounds.
669                    // In that case, we don't know if they are equal to the trait bound
670                    // or not (since we don't *know* whether the environment bound even applies),
671                    // so just map to `None` here if there are bound vars, ensuring that
672                    // the call to `all` will fail below.
673                    approx_env_bounds.iter().map(|b| b.map_bound(|b| b.1).no_bound_vars()),
674                )
675                .all(|b| b == Some(trait_bounds[0]))
676        {
677            let unique_bound = trait_bounds[0];
678            debug!(?unique_bound);
679            debug!("unique declared bound appears in trait ref");
680            let category = origin.to_constraint_category();
681            self.delegate.push_sub_region_constraint(origin, region, unique_bound, category);
682            return;
683        }
684
685        // Fallback to verifying after the fact that there exists a
686        // declared bound, or that all the components appearing in the
687        // projection outlive; in some cases, this may add insufficient
688        // edges into the inference graph, leading to inference failures
689        // even though a satisfactory solution exists.
690        let verify_bound = self.verify_bound.alias_bound(alias_ty);
691        debug!("alias_must_outlive: pushing {:?}", verify_bound);
692        self.delegate.push_verify(origin, GenericKind::Alias(alias_ty), region, verify_bound);
693    }
694
695    {}
#[allow(clippy :: suspicious_else_formatting)]
{
    let __tracing_attr_span;
    let __tracing_attr_guard;
    if ::tracing::Level::DEBUG <= ::tracing::level_filters::STATIC_MAX_LEVEL
                &&
                ::tracing::Level::DEBUG <=
                    ::tracing::level_filters::LevelFilter::current() ||
            { false } {
        __tracing_attr_span =
            {
                use ::tracing::__macro_support::Callsite as _;
                static __CALLSITE: ::tracing::callsite::DefaultCallsite =
                    {
                        static META: ::tracing::Metadata<'static> =
                            {
                                ::tracing_core::metadata::Metadata::new("args_must_outlive",
                                    "rustc_infer::infer::outlives::obligations",
                                    ::tracing::Level::DEBUG,
                                    ::tracing_core::__macro_support::Option::Some("/rustc-dev/5f4effd579500175af844241eb179e756190f1e7/compiler/rustc_infer/src/infer/outlives/obligations.rs"),
                                    ::tracing_core::__macro_support::Option::Some(695u32),
                                    ::tracing_core::__macro_support::Option::Some("rustc_infer::infer::outlives::obligations"),
                                    ::tracing_core::field::FieldSet::new(&[{
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("args")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("args");
                                                        NAME.as_str()
                                                    },
                                                    {
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("origin")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("origin");
                                                        NAME.as_str()
                                                    },
                                                    {
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("region")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("region");
                                                        NAME.as_str()
                                                    },
                                                    {
                                                        const NAME:
                                                            ::tracing::__macro_support::FieldName<{
                                                                ::tracing::__macro_support::FieldName::len("opt_variances")
                                                            }> =
                                                            ::tracing::__macro_support::FieldName::new("opt_variances");
                                                        NAME.as_str()
                                                    }], ::tracing_core::callsite::Identifier(&__CALLSITE)),
                                    ::tracing::metadata::Kind::SPAN)
                            };
                        ::tracing::callsite::DefaultCallsite::new(&META)
                    };
                let mut interest = ::tracing::subscriber::Interest::never();
                if ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::STATIC_MAX_LEVEL &&
                                ::tracing::Level::DEBUG <=
                                    ::tracing::level_filters::LevelFilter::current() &&
                            { interest = __CALLSITE.interest(); !interest.is_never() }
                        &&
                        ::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
                            interest) {
                    let meta = __CALLSITE.metadata();
                    ::tracing::Span::new(meta,
                        &{
                                #[allow(unused_imports)]
                                use ::tracing::field::{debug, display, Value};
                                meta.fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&args)
                                                            as &dyn ::tracing::field::Value)),
                                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&origin)
                                                            as &dyn ::tracing::field::Value)),
                                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&region)
                                                            as &dyn ::tracing::field::Value)),
                                                (::tracing::__macro_support::Option::Some(&::tracing::field::debug(&opt_variances)
                                                            as &dyn ::tracing::field::Value))])
                            })
                } else {
                    let span =
                        ::tracing::__macro_support::__disabled_span(__CALLSITE.metadata());
                    {};
                    span
                }
            };
        __tracing_attr_guard = __tracing_attr_span.enter();
    }

    #[warn(clippy :: suspicious_else_formatting)]
    {

        #[allow(unknown_lints, unreachable_code, clippy ::
        diverging_sub_expression, clippy :: empty_loop, clippy ::
        let_unit_value, clippy :: let_with_type_underscore, clippy ::
        needless_return, clippy :: unreachable)]
        if false {
            let __tracing_attr_fake_return: () = loop {};
            return __tracing_attr_fake_return;
        }
        {
            let constraint = origin.to_constraint_category();
            for (index, arg) in args.iter().enumerate() {
                match arg.kind() {
                    GenericArgKind::Lifetime(lt) => {
                        let variance =
                            if let Some(variances) = opt_variances {
                                variances[index]
                            } else { ty::Invariant };
                        if variance == ty::Invariant {
                            self.delegate.push_sub_region_constraint(origin.clone(),
                                region, lt, constraint);
                        }
                    }
                    GenericArgKind::Type(ty) => {
                        self.type_must_outlive(origin.clone(), ty, region,
                            constraint);
                    }
                    GenericArgKind::Const(_) => {}
                }
            }
        }
    }
}#[instrument(level = "debug", skip(self))]
696    fn args_must_outlive(
697        &mut self,
698        args: GenericArgs<'tcx>,
699        origin: infer::SubregionOrigin<'tcx>,
700        region: ty::Region<'tcx>,
701        opt_variances: Option<&[ty::Variance]>,
702    ) {
703        let constraint = origin.to_constraint_category();
704        for (index, arg) in args.iter().enumerate() {
705            match arg.kind() {
706                GenericArgKind::Lifetime(lt) => {
707                    let variance = if let Some(variances) = opt_variances {
708                        variances[index]
709                    } else {
710                        ty::Invariant
711                    };
712                    if variance == ty::Invariant {
713                        self.delegate.push_sub_region_constraint(
714                            origin.clone(),
715                            region,
716                            lt,
717                            constraint,
718                        );
719                    }
720                }
721                GenericArgKind::Type(ty) => {
722                    self.type_must_outlive(origin.clone(), ty, region, constraint);
723                }
724                GenericArgKind::Const(_) => {
725                    // Const parameters don't impose constraints.
726                }
727            }
728        }
729    }
730}
731
732impl<'cx, 'tcx> TypeOutlivesDelegate<'tcx> for &'cx InferCtxt<'tcx> {
733    fn push_sub_region_constraint(
734        &mut self,
735        origin: SubregionOrigin<'tcx>,
736        a: ty::Region<'tcx>,
737        b: ty::Region<'tcx>,
738        _constraint_category: ConstraintCategory<'tcx>,
739    ) {
740        // We don't do leak check in lexical region resolution
741        self.sub_regions(origin, a, b, ty::VisibleForLeakCheck::Unreachable)
742    }
743
744    fn push_verify(
745        &mut self,
746        origin: SubregionOrigin<'tcx>,
747        kind: GenericKind<'tcx>,
748        a: ty::Region<'tcx>,
749        bound: VerifyBound<'tcx>,
750    ) {
751        self.verify_generic_bound(origin, kind, a, bound)
752    }
753}