rustc_borrowck/region_infer/
mod.rs

1use std::collections::VecDeque;
2use std::rc::Rc;
3
4use rustc_data_structures::frozen::Frozen;
5use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
6use rustc_data_structures::graph::scc::Sccs;
7use rustc_errors::Diag;
8use rustc_hir::def_id::CRATE_DEF_ID;
9use rustc_index::IndexVec;
10use rustc_infer::infer::outlives::test_type_match;
11use rustc_infer::infer::region_constraints::{GenericKind, VerifyBound, VerifyIfEq};
12use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin};
13use rustc_middle::bug;
14use rustc_middle::mir::{
15    AnnotationSource, BasicBlock, Body, ConstraintCategory, Local, Location, ReturnConstraint,
16    TerminatorKind,
17};
18use rustc_middle::traits::{ObligationCause, ObligationCauseCode};
19use rustc_middle::ty::{self, RegionVid, Ty, TyCtxt, TypeFoldable, UniverseIndex, fold_regions};
20use rustc_mir_dataflow::points::DenseLocationMap;
21use rustc_span::hygiene::DesugaringKind;
22use rustc_span::{DUMMY_SP, Span};
23use tracing::{Level, debug, enabled, instrument, trace};
24
25use crate::constraints::graph::NormalConstraintGraph;
26use crate::constraints::{ConstraintSccIndex, OutlivesConstraint, OutlivesConstraintSet};
27use crate::dataflow::BorrowIndex;
28use crate::diagnostics::{RegionErrorKind, RegionErrors, UniverseInfo};
29use crate::handle_placeholders::{LoweredConstraints, RegionTracker};
30use crate::polonius::LiveLoans;
31use crate::polonius::legacy::PoloniusOutput;
32use crate::region_infer::values::{LivenessValues, RegionElement, RegionValues, ToElementIndex};
33use crate::type_check::Locations;
34use crate::type_check::free_region_relations::UniversalRegionRelations;
35use crate::universal_regions::UniversalRegions;
36use crate::{
37    BorrowckInferCtxt, ClosureOutlivesRequirement, ClosureOutlivesSubject,
38    ClosureOutlivesSubjectTy, ClosureRegionRequirements,
39};
40
41mod dump_mir;
42mod graphviz;
43pub(crate) mod opaque_types;
44mod reverse_sccs;
45
46pub(crate) mod values;
47
48/// The representative region variable for an SCC, tagged by its origin.
49/// We prefer placeholders over existentially quantified variables, otherwise
50/// it's the one with the smallest Region Variable ID. In other words,
51/// the order of this enumeration really matters!
52#[derive(Copy, Debug, Clone, PartialEq, PartialOrd, Eq, Ord)]
53pub(crate) enum Representative {
54    FreeRegion(RegionVid),
55    Placeholder(RegionVid),
56    Existential(RegionVid),
57}
58
59impl Representative {
60    pub(crate) fn rvid(self) -> RegionVid {
61        match self {
62            Representative::FreeRegion(region_vid)
63            | Representative::Placeholder(region_vid)
64            | Representative::Existential(region_vid) => region_vid,
65        }
66    }
67
68    pub(crate) fn new(r: RegionVid, definition: &RegionDefinition<'_>) -> Self {
69        match definition.origin {
70            NllRegionVariableOrigin::FreeRegion => Representative::FreeRegion(r),
71            NllRegionVariableOrigin::Placeholder(_) => Representative::Placeholder(r),
72            NllRegionVariableOrigin::Existential { .. } => Representative::Existential(r),
73        }
74    }
75}
76
77pub(crate) type ConstraintSccs = Sccs<RegionVid, ConstraintSccIndex>;
78
79pub struct RegionInferenceContext<'tcx> {
80    /// Contains the definition for every region variable. Region
81    /// variables are identified by their index (`RegionVid`). The
82    /// definition contains information about where the region came
83    /// from as well as its final inferred value.
84    pub(crate) definitions: Frozen<IndexVec<RegionVid, RegionDefinition<'tcx>>>,
85
86    /// The liveness constraints added to each region. For most
87    /// regions, these start out empty and steadily grow, though for
88    /// each universally quantified region R they start out containing
89    /// the entire CFG and `end(R)`.
90    liveness_constraints: LivenessValues,
91
92    /// The outlives constraints computed by the type-check.
93    constraints: Frozen<OutlivesConstraintSet<'tcx>>,
94
95    /// The constraint-set, but in graph form, making it easy to traverse
96    /// the constraints adjacent to a particular region. Used to construct
97    /// the SCC (see `constraint_sccs`) and for error reporting.
98    constraint_graph: Frozen<NormalConstraintGraph>,
99
100    /// The SCC computed from `constraints` and the constraint
101    /// graph. We have an edge from SCC A to SCC B if `A: B`. Used to
102    /// compute the values of each region.
103    constraint_sccs: ConstraintSccs,
104
105    scc_annotations: IndexVec<ConstraintSccIndex, RegionTracker>,
106
107    /// Map universe indexes to information on why we created it.
108    universe_causes: FxIndexMap<ty::UniverseIndex, UniverseInfo<'tcx>>,
109
110    /// The final inferred values of the region variables; we compute
111    /// one value per SCC. To get the value for any given *region*,
112    /// you first find which scc it is a part of.
113    scc_values: RegionValues<ConstraintSccIndex>,
114
115    /// Type constraints that we check after solving.
116    type_tests: Vec<TypeTest<'tcx>>,
117
118    /// Information about how the universally quantified regions in
119    /// scope on this function relate to one another.
120    universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
121}
122
123#[derive(Debug)]
124pub(crate) struct RegionDefinition<'tcx> {
125    /// What kind of variable is this -- a free region? existential
126    /// variable? etc. (See the `NllRegionVariableOrigin` for more
127    /// info.)
128    pub(crate) origin: NllRegionVariableOrigin,
129
130    /// Which universe is this region variable defined in? This is
131    /// most often `ty::UniverseIndex::ROOT`, but when we encounter
132    /// forall-quantifiers like `for<'a> { 'a = 'b }`, we would create
133    /// the variable for `'a` in a fresh universe that extends ROOT.
134    pub(crate) universe: ty::UniverseIndex,
135
136    /// If this is 'static or an early-bound region, then this is
137    /// `Some(X)` where `X` is the name of the region.
138    pub(crate) external_name: Option<ty::Region<'tcx>>,
139}
140
141/// N.B., the variants in `Cause` are intentionally ordered. Lower
142/// values are preferred when it comes to error messages. Do not
143/// reorder willy nilly.
144#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
145pub(crate) enum Cause {
146    /// point inserted because Local was live at the given Location
147    LiveVar(Local, Location),
148
149    /// point inserted because Local was dropped at the given Location
150    DropVar(Local, Location),
151}
152
153/// A "type test" corresponds to an outlives constraint between a type
154/// and a lifetime, like `T: 'x` or `<T as Foo>::Bar: 'x`. They are
155/// translated from the `Verify` region constraints in the ordinary
156/// inference context.
157///
158/// These sorts of constraints are handled differently than ordinary
159/// constraints, at least at present. During type checking, the
160/// `InferCtxt::process_registered_region_obligations` method will
161/// attempt to convert a type test like `T: 'x` into an ordinary
162/// outlives constraint when possible (for example, `&'a T: 'b` will
163/// be converted into `'a: 'b` and registered as a `Constraint`).
164///
165/// In some cases, however, there are outlives relationships that are
166/// not converted into a region constraint, but rather into one of
167/// these "type tests". The distinction is that a type test does not
168/// influence the inference result, but instead just examines the
169/// values that we ultimately inferred for each region variable and
170/// checks that they meet certain extra criteria. If not, an error
171/// can be issued.
172///
173/// One reason for this is that these type tests typically boil down
174/// to a check like `'a: 'x` where `'a` is a universally quantified
175/// region -- and therefore not one whose value is really meant to be
176/// *inferred*, precisely (this is not always the case: one can have a
177/// type test like `<Foo as Trait<'?0>>::Bar: 'x`, where `'?0` is an
178/// inference variable). Another reason is that these type tests can
179/// involve *disjunction* -- that is, they can be satisfied in more
180/// than one way.
181///
182/// For more information about this translation, see
183/// `InferCtxt::process_registered_region_obligations` and
184/// `InferCtxt::type_must_outlive` in `rustc_infer::infer::InferCtxt`.
185#[derive(Clone, Debug)]
186pub(crate) struct TypeTest<'tcx> {
187    /// The type `T` that must outlive the region.
188    pub generic_kind: GenericKind<'tcx>,
189
190    /// The region `'x` that the type must outlive.
191    pub lower_bound: RegionVid,
192
193    /// The span to blame.
194    pub span: Span,
195
196    /// A test which, if met by the region `'x`, proves that this type
197    /// constraint is satisfied.
198    pub verify_bound: VerifyBound<'tcx>,
199}
200
201/// When we have an unmet lifetime constraint, we try to propagate it outward (e.g. to a closure
202/// environment). If we can't, it is an error.
203#[derive(Clone, Copy, Debug, Eq, PartialEq)]
204enum RegionRelationCheckResult {
205    Ok,
206    Propagated,
207    Error,
208}
209
210#[derive(Clone, PartialEq, Eq, Debug)]
211enum Trace<'a, 'tcx> {
212    StartRegion,
213    FromGraph(&'a OutlivesConstraint<'tcx>),
214    FromStatic(RegionVid),
215    NotVisited,
216}
217
218#[instrument(skip(infcx, sccs), level = "debug")]
219fn sccs_info<'tcx>(infcx: &BorrowckInferCtxt<'tcx>, sccs: &ConstraintSccs) {
220    use crate::renumber::RegionCtxt;
221
222    let var_to_origin = infcx.reg_var_to_origin.borrow();
223
224    let mut var_to_origin_sorted = var_to_origin.clone().into_iter().collect::<Vec<_>>();
225    var_to_origin_sorted.sort_by_key(|vto| vto.0);
226
227    if enabled!(Level::DEBUG) {
228        let mut reg_vars_to_origins_str = "region variables to origins:\n".to_string();
229        for (reg_var, origin) in var_to_origin_sorted.into_iter() {
230            reg_vars_to_origins_str.push_str(&format!("{reg_var:?}: {origin:?}\n"));
231        }
232        debug!("{}", reg_vars_to_origins_str);
233    }
234
235    let num_components = sccs.num_sccs();
236    let mut components = vec![FxIndexSet::default(); num_components];
237
238    for (reg_var, scc_idx) in sccs.scc_indices().iter_enumerated() {
239        let origin = var_to_origin.get(&reg_var).unwrap_or(&RegionCtxt::Unknown);
240        components[scc_idx.as_usize()].insert((reg_var, *origin));
241    }
242
243    if enabled!(Level::DEBUG) {
244        let mut components_str = "strongly connected components:".to_string();
245        for (scc_idx, reg_vars_origins) in components.iter().enumerate() {
246            let regions_info = reg_vars_origins.clone().into_iter().collect::<Vec<_>>();
247            components_str.push_str(&format!(
248                "{:?}: {:?},\n)",
249                ConstraintSccIndex::from_usize(scc_idx),
250                regions_info,
251            ))
252        }
253        debug!("{}", components_str);
254    }
255
256    // calculate the best representative for each component
257    let components_representatives = components
258        .into_iter()
259        .enumerate()
260        .map(|(scc_idx, region_ctxts)| {
261            let repr = region_ctxts
262                .into_iter()
263                .map(|reg_var_origin| reg_var_origin.1)
264                .max_by(|x, y| x.preference_value().cmp(&y.preference_value()))
265                .unwrap();
266
267            (ConstraintSccIndex::from_usize(scc_idx), repr)
268        })
269        .collect::<FxIndexMap<_, _>>();
270
271    let mut scc_node_to_edges = FxIndexMap::default();
272    for (scc_idx, repr) in components_representatives.iter() {
273        let edge_representatives = sccs
274            .successors(*scc_idx)
275            .iter()
276            .map(|scc_idx| components_representatives[scc_idx])
277            .collect::<Vec<_>>();
278        scc_node_to_edges.insert((scc_idx, repr), edge_representatives);
279    }
280
281    debug!("SCC edges {:#?}", scc_node_to_edges);
282}
283
284impl<'tcx> RegionInferenceContext<'tcx> {
285    /// Creates a new region inference context with a total of
286    /// `num_region_variables` valid inference variables; the first N
287    /// of those will be constant regions representing the free
288    /// regions defined in `universal_regions`.
289    ///
290    /// The `outlives_constraints` and `type_tests` are an initial set
291    /// of constraints produced by the MIR type check.
292    pub(crate) fn new(
293        infcx: &BorrowckInferCtxt<'tcx>,
294        lowered_constraints: LoweredConstraints<'tcx>,
295        universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
296        location_map: Rc<DenseLocationMap>,
297    ) -> Self {
298        let universal_regions = &universal_region_relations.universal_regions;
299
300        let LoweredConstraints {
301            constraint_sccs,
302            definitions,
303            outlives_constraints,
304            scc_annotations,
305            type_tests,
306            liveness_constraints,
307            universe_causes,
308            placeholder_indices,
309        } = lowered_constraints;
310
311        debug!("universal_regions: {:#?}", universal_region_relations.universal_regions);
312        debug!("outlives constraints: {:#?}", outlives_constraints);
313        debug!("placeholder_indices: {:#?}", placeholder_indices);
314        debug!("type tests: {:#?}", type_tests);
315
316        let constraint_graph = Frozen::freeze(outlives_constraints.graph(definitions.len()));
317
318        if cfg!(debug_assertions) {
319            sccs_info(infcx, &constraint_sccs);
320        }
321
322        let mut scc_values =
323            RegionValues::new(location_map, universal_regions.len(), placeholder_indices);
324
325        for region in liveness_constraints.regions() {
326            let scc = constraint_sccs.scc(region);
327            scc_values.merge_liveness(scc, region, &liveness_constraints);
328        }
329
330        let mut result = Self {
331            definitions,
332            liveness_constraints,
333            constraints: outlives_constraints,
334            constraint_graph,
335            constraint_sccs,
336            scc_annotations,
337            universe_causes,
338            scc_values,
339            type_tests,
340            universal_region_relations,
341        };
342
343        result.init_free_and_bound_regions();
344
345        result
346    }
347
348    /// Initializes the region variables for each universally
349    /// quantified region (lifetime parameter). The first N variables
350    /// always correspond to the regions appearing in the function
351    /// signature (both named and anonymous) and where-clauses. This
352    /// function iterates over those regions and initializes them with
353    /// minimum values.
354    ///
355    /// For example:
356    /// ```ignore (illustrative)
357    /// fn foo<'a, 'b>( /* ... */ ) where 'a: 'b { /* ... */ }
358    /// ```
359    /// would initialize two variables like so:
360    /// ```ignore (illustrative)
361    /// R0 = { CFG, R0 } // 'a
362    /// R1 = { CFG, R0, R1 } // 'b
363    /// ```
364    /// Here, R0 represents `'a`, and it contains (a) the entire CFG
365    /// and (b) any universally quantified regions that it outlives,
366    /// which in this case is just itself. R1 (`'b`) in contrast also
367    /// outlives `'a` and hence contains R0 and R1.
368    ///
369    /// This bit of logic also handles invalid universe relations
370    /// for higher-kinded types.
371    ///
372    /// We Walk each SCC `A` and `B` such that `A: B`
373    /// and ensure that universe(A) can see universe(B).
374    ///
375    /// This serves to enforce the 'empty/placeholder' hierarchy
376    /// (described in more detail on `RegionKind`):
377    ///
378    /// ```ignore (illustrative)
379    /// static -----+
380    ///   |         |
381    /// empty(U0) placeholder(U1)
382    ///   |      /
383    /// empty(U1)
384    /// ```
385    ///
386    /// In particular, imagine we have variables R0 in U0 and R1
387    /// created in U1, and constraints like this;
388    ///
389    /// ```ignore (illustrative)
390    /// R1: !1 // R1 outlives the placeholder in U1
391    /// R1: R0 // R1 outlives R0
392    /// ```
393    ///
394    /// Here, we wish for R1 to be `'static`, because it
395    /// cannot outlive `placeholder(U1)` and `empty(U0)` any other way.
396    ///
397    /// Thanks to this loop, what happens is that the `R1: R0`
398    /// constraint has lowered the universe of `R1` to `U0`, which in turn
399    /// means that the `R1: !1` constraint here will cause
400    /// `R1` to become `'static`.
401    fn init_free_and_bound_regions(&mut self) {
402        for variable in self.definitions.indices() {
403            let scc = self.constraint_sccs.scc(variable);
404
405            match self.definitions[variable].origin {
406                NllRegionVariableOrigin::FreeRegion => {
407                    // For each free, universally quantified region X:
408
409                    // Add all nodes in the CFG to liveness constraints
410                    self.liveness_constraints.add_all_points(variable);
411                    self.scc_values.add_all_points(scc);
412
413                    // Add `end(X)` into the set for X.
414                    self.scc_values.add_element(scc, variable);
415                }
416
417                NllRegionVariableOrigin::Placeholder(placeholder) => {
418                    self.scc_values.add_element(scc, placeholder);
419                }
420
421                NllRegionVariableOrigin::Existential { .. } => {
422                    // For existential, regions, nothing to do.
423                }
424            }
425        }
426    }
427
428    /// Returns an iterator over all the region indices.
429    pub(crate) fn regions(&self) -> impl Iterator<Item = RegionVid> + 'tcx {
430        self.definitions.indices()
431    }
432
433    /// Given a universal region in scope on the MIR, returns the
434    /// corresponding index.
435    ///
436    /// Panics if `r` is not a registered universal region, most notably
437    /// if it is a placeholder. Handling placeholders requires access to the
438    /// `MirTypeckRegionConstraints`.
439    pub(crate) fn to_region_vid(&self, r: ty::Region<'tcx>) -> RegionVid {
440        self.universal_regions().to_region_vid(r)
441    }
442
443    /// Returns an iterator over all the outlives constraints.
444    pub(crate) fn outlives_constraints(&self) -> impl Iterator<Item = OutlivesConstraint<'tcx>> {
445        self.constraints.outlives().iter().copied()
446    }
447
448    /// Adds annotations for `#[rustc_regions]`; see `UniversalRegions::annotate`.
449    pub(crate) fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diag<'_, ()>) {
450        self.universal_regions().annotate(tcx, err)
451    }
452
453    /// Returns `true` if the region `r` contains the point `p`.
454    ///
455    /// Panics if called before `solve()` executes,
456    pub(crate) fn region_contains(&self, r: RegionVid, p: impl ToElementIndex) -> bool {
457        let scc = self.constraint_sccs.scc(r);
458        self.scc_values.contains(scc, p)
459    }
460
461    /// Returns the lowest statement index in `start..=end` which is not contained by `r`.
462    ///
463    /// Panics if called before `solve()` executes.
464    pub(crate) fn first_non_contained_inclusive(
465        &self,
466        r: RegionVid,
467        block: BasicBlock,
468        start: usize,
469        end: usize,
470    ) -> Option<usize> {
471        let scc = self.constraint_sccs.scc(r);
472        self.scc_values.first_non_contained_inclusive(scc, block, start, end)
473    }
474
475    /// Returns access to the value of `r` for debugging purposes.
476    pub(crate) fn region_value_str(&self, r: RegionVid) -> String {
477        let scc = self.constraint_sccs.scc(r);
478        self.scc_values.region_value_str(scc)
479    }
480
481    pub(crate) fn placeholders_contained_in(
482        &self,
483        r: RegionVid,
484    ) -> impl Iterator<Item = ty::PlaceholderRegion> {
485        let scc = self.constraint_sccs.scc(r);
486        self.scc_values.placeholders_contained_in(scc)
487    }
488
489    /// Performs region inference and report errors if we see any
490    /// unsatisfiable constraints. If this is a closure, returns the
491    /// region requirements to propagate to our creator, if any.
492    #[instrument(skip(self, infcx, body, polonius_output), level = "debug")]
493    pub(super) fn solve(
494        &mut self,
495        infcx: &InferCtxt<'tcx>,
496        body: &Body<'tcx>,
497        polonius_output: Option<Box<PoloniusOutput>>,
498    ) -> (Option<ClosureRegionRequirements<'tcx>>, RegionErrors<'tcx>) {
499        let mir_def_id = body.source.def_id();
500        self.propagate_constraints();
501
502        let mut errors_buffer = RegionErrors::new(infcx.tcx);
503
504        // If this is a closure, we can propagate unsatisfied
505        // `outlives_requirements` to our creator, so create a vector
506        // to store those. Otherwise, we'll pass in `None` to the
507        // functions below, which will trigger them to report errors
508        // eagerly.
509        let mut outlives_requirements = infcx.tcx.is_typeck_child(mir_def_id).then(Vec::new);
510
511        self.check_type_tests(infcx, outlives_requirements.as_mut(), &mut errors_buffer);
512
513        debug!(?errors_buffer);
514        debug!(?outlives_requirements);
515
516        // In Polonius mode, the errors about missing universal region relations are in the output
517        // and need to be emitted or propagated. Otherwise, we need to check whether the
518        // constraints were too strong, and if so, emit or propagate those errors.
519        if infcx.tcx.sess.opts.unstable_opts.polonius.is_legacy_enabled() {
520            self.check_polonius_subset_errors(
521                outlives_requirements.as_mut(),
522                &mut errors_buffer,
523                polonius_output
524                    .as_ref()
525                    .expect("Polonius output is unavailable despite `-Z polonius`"),
526            );
527        } else {
528            self.check_universal_regions(outlives_requirements.as_mut(), &mut errors_buffer);
529        }
530
531        debug!(?errors_buffer);
532
533        let outlives_requirements = outlives_requirements.unwrap_or_default();
534
535        if outlives_requirements.is_empty() {
536            (None, errors_buffer)
537        } else {
538            let num_external_vids = self.universal_regions().num_global_and_external_regions();
539            (
540                Some(ClosureRegionRequirements { num_external_vids, outlives_requirements }),
541                errors_buffer,
542            )
543        }
544    }
545
546    /// Propagate the region constraints: this will grow the values
547    /// for each region variable until all the constraints are
548    /// satisfied. Note that some values may grow **too** large to be
549    /// feasible, but we check this later.
550    #[instrument(skip(self), level = "debug")]
551    fn propagate_constraints(&mut self) {
552        debug!("constraints={:#?}", {
553            let mut constraints: Vec<_> = self.outlives_constraints().collect();
554            constraints.sort_by_key(|c| (c.sup, c.sub));
555            constraints
556                .into_iter()
557                .map(|c| (c, self.constraint_sccs.scc(c.sup), self.constraint_sccs.scc(c.sub)))
558                .collect::<Vec<_>>()
559        });
560
561        // To propagate constraints, we walk the DAG induced by the
562        // SCC. For each SCC `A`, we visit its successors and compute
563        // their values, then we union all those values to get our
564        // own.
565        for scc_a in self.constraint_sccs.all_sccs() {
566            // Walk each SCC `B` such that `A: B`...
567            for &scc_b in self.constraint_sccs.successors(scc_a) {
568                debug!(?scc_b);
569                self.scc_values.add_region(scc_a, scc_b);
570            }
571        }
572    }
573
574    /// Returns `true` if all the placeholders in the value of `scc_b` are nameable
575    /// in `scc_a`. Used during constraint propagation, and only once
576    /// the value of `scc_b` has been computed.
577    fn can_name_all_placeholders(
578        &self,
579        scc_a: ConstraintSccIndex,
580        scc_b: ConstraintSccIndex,
581    ) -> bool {
582        self.scc_annotations[scc_a].can_name_all_placeholders(self.scc_annotations[scc_b])
583    }
584
585    /// Once regions have been propagated, this method is used to see
586    /// whether the "type tests" produced by typeck were satisfied;
587    /// type tests encode type-outlives relationships like `T:
588    /// 'a`. See `TypeTest` for more details.
589    fn check_type_tests(
590        &self,
591        infcx: &InferCtxt<'tcx>,
592        mut propagated_outlives_requirements: Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
593        errors_buffer: &mut RegionErrors<'tcx>,
594    ) {
595        let tcx = infcx.tcx;
596
597        // Sometimes we register equivalent type-tests that would
598        // result in basically the exact same error being reported to
599        // the user. Avoid that.
600        let mut deduplicate_errors = FxIndexSet::default();
601
602        for type_test in &self.type_tests {
603            debug!("check_type_test: {:?}", type_test);
604
605            let generic_ty = type_test.generic_kind.to_ty(tcx);
606            if self.eval_verify_bound(
607                infcx,
608                generic_ty,
609                type_test.lower_bound,
610                &type_test.verify_bound,
611            ) {
612                continue;
613            }
614
615            if let Some(propagated_outlives_requirements) = &mut propagated_outlives_requirements
616                && self.try_promote_type_test(infcx, type_test, propagated_outlives_requirements)
617            {
618                continue;
619            }
620
621            // Type-test failed. Report the error.
622            let erased_generic_kind = infcx.tcx.erase_and_anonymize_regions(type_test.generic_kind);
623
624            // Skip duplicate-ish errors.
625            if deduplicate_errors.insert((
626                erased_generic_kind,
627                type_test.lower_bound,
628                type_test.span,
629            )) {
630                debug!(
631                    "check_type_test: reporting error for erased_generic_kind={:?}, \
632                     lower_bound_region={:?}, \
633                     type_test.span={:?}",
634                    erased_generic_kind, type_test.lower_bound, type_test.span,
635                );
636
637                errors_buffer.push(RegionErrorKind::TypeTestError { type_test: type_test.clone() });
638            }
639        }
640    }
641
642    /// Invoked when we have some type-test (e.g., `T: 'X`) that we cannot
643    /// prove to be satisfied. If this is a closure, we will attempt to
644    /// "promote" this type-test into our `ClosureRegionRequirements` and
645    /// hence pass it up the creator. To do this, we have to phrase the
646    /// type-test in terms of external free regions, as local free
647    /// regions are not nameable by the closure's creator.
648    ///
649    /// Promotion works as follows: we first check that the type `T`
650    /// contains only regions that the creator knows about. If this is
651    /// true, then -- as a consequence -- we know that all regions in
652    /// the type `T` are free regions that outlive the closure body. If
653    /// false, then promotion fails.
654    ///
655    /// Once we've promoted T, we have to "promote" `'X` to some region
656    /// that is "external" to the closure. Generally speaking, a region
657    /// may be the union of some points in the closure body as well as
658    /// various free lifetimes. We can ignore the points in the closure
659    /// body: if the type T can be expressed in terms of external regions,
660    /// we know it outlives the points in the closure body. That
661    /// just leaves the free regions.
662    ///
663    /// The idea then is to lower the `T: 'X` constraint into multiple
664    /// bounds -- e.g., if `'X` is the union of two free lifetimes,
665    /// `'1` and `'2`, then we would create `T: '1` and `T: '2`.
666    #[instrument(level = "debug", skip(self, infcx, propagated_outlives_requirements))]
667    fn try_promote_type_test(
668        &self,
669        infcx: &InferCtxt<'tcx>,
670        type_test: &TypeTest<'tcx>,
671        propagated_outlives_requirements: &mut Vec<ClosureOutlivesRequirement<'tcx>>,
672    ) -> bool {
673        let tcx = infcx.tcx;
674        let TypeTest { generic_kind, lower_bound, span: blame_span, verify_bound: _ } = *type_test;
675
676        let generic_ty = generic_kind.to_ty(tcx);
677        let Some(subject) = self.try_promote_type_test_subject(infcx, generic_ty) else {
678            return false;
679        };
680
681        let r_scc = self.constraint_sccs.scc(lower_bound);
682        debug!(
683            "lower_bound = {:?} r_scc={:?} universe={:?}",
684            lower_bound,
685            r_scc,
686            self.max_nameable_universe(r_scc)
687        );
688        // If the type test requires that `T: 'a` where `'a` is a
689        // placeholder from another universe, that effectively requires
690        // `T: 'static`, so we have to propagate that requirement.
691        //
692        // It doesn't matter *what* universe because the promoted `T` will
693        // always be in the root universe.
694        if let Some(p) = self.scc_values.placeholders_contained_in(r_scc).next() {
695            debug!("encountered placeholder in higher universe: {:?}, requiring 'static", p);
696            let static_r = self.universal_regions().fr_static;
697            propagated_outlives_requirements.push(ClosureOutlivesRequirement {
698                subject,
699                outlived_free_region: static_r,
700                blame_span,
701                category: ConstraintCategory::Boring,
702            });
703
704            // we can return here -- the code below might push add'l constraints
705            // but they would all be weaker than this one.
706            return true;
707        }
708
709        // For each region outlived by lower_bound find a non-local,
710        // universal region (it may be the same region) and add it to
711        // `ClosureOutlivesRequirement`.
712        let mut found_outlived_universal_region = false;
713        for ur in self.scc_values.universal_regions_outlived_by(r_scc) {
714            found_outlived_universal_region = true;
715            debug!("universal_region_outlived_by ur={:?}", ur);
716            let non_local_ub = self.universal_region_relations.non_local_upper_bounds(ur);
717            debug!(?non_local_ub);
718
719            // This is slightly too conservative. To show T: '1, given `'2: '1`
720            // and `'3: '1` we only need to prove that T: '2 *or* T: '3, but to
721            // avoid potential non-determinism we approximate this by requiring
722            // T: '1 and T: '2.
723            for upper_bound in non_local_ub {
724                debug_assert!(self.universal_regions().is_universal_region(upper_bound));
725                debug_assert!(!self.universal_regions().is_local_free_region(upper_bound));
726
727                let requirement = ClosureOutlivesRequirement {
728                    subject,
729                    outlived_free_region: upper_bound,
730                    blame_span,
731                    category: ConstraintCategory::Boring,
732                };
733                debug!(?requirement, "adding closure requirement");
734                propagated_outlives_requirements.push(requirement);
735            }
736        }
737        // If we succeed to promote the subject, i.e. it only contains non-local regions,
738        // and fail to prove the type test inside of the closure, the `lower_bound` has to
739        // also be at least as large as some universal region, as the type test is otherwise
740        // trivial.
741        assert!(found_outlived_universal_region);
742        true
743    }
744
745    /// When we promote a type test `T: 'r`, we have to replace all region
746    /// variables in the type `T` with an equal universal region from the
747    /// closure signature.
748    /// This is not always possible, so this is a fallible process.
749    #[instrument(level = "debug", skip(self, infcx), ret)]
750    fn try_promote_type_test_subject(
751        &self,
752        infcx: &InferCtxt<'tcx>,
753        ty: Ty<'tcx>,
754    ) -> Option<ClosureOutlivesSubject<'tcx>> {
755        let tcx = infcx.tcx;
756        let mut failed = false;
757        let ty = fold_regions(tcx, ty, |r, _depth| {
758            let r_vid = self.to_region_vid(r);
759            let r_scc = self.constraint_sccs.scc(r_vid);
760
761            // The challenge is this. We have some region variable `r`
762            // whose value is a set of CFG points and universal
763            // regions. We want to find if that set is *equivalent* to
764            // any of the named regions found in the closure.
765            // To do so, we simply check every candidate `u_r` for equality.
766            self.scc_values
767                .universal_regions_outlived_by(r_scc)
768                .filter(|&u_r| !self.universal_regions().is_local_free_region(u_r))
769                .find(|&u_r| self.eval_equal(u_r, r_vid))
770                .map(|u_r| ty::Region::new_var(tcx, u_r))
771                // In case we could not find a named region to map to,
772                // we will return `None` below.
773                .unwrap_or_else(|| {
774                    failed = true;
775                    r
776                })
777        });
778
779        debug!("try_promote_type_test_subject: folded ty = {:?}", ty);
780
781        // This will be true if we failed to promote some region.
782        if failed {
783            return None;
784        }
785
786        Some(ClosureOutlivesSubject::Ty(ClosureOutlivesSubjectTy::bind(tcx, ty)))
787    }
788
789    /// Like `universal_upper_bound`, but returns an approximation more suitable
790    /// for diagnostics. If `r` contains multiple disjoint universal regions
791    /// (e.g. 'a and 'b in `fn foo<'a, 'b> { ... }`, we pick the lower-numbered region.
792    /// This corresponds to picking named regions over unnamed regions
793    /// (e.g. picking early-bound regions over a closure late-bound region).
794    ///
795    /// This means that the returned value may not be a true upper bound, since
796    /// only 'static is known to outlive disjoint universal regions.
797    /// Therefore, this method should only be used in diagnostic code,
798    /// where displaying *some* named universal region is better than
799    /// falling back to 'static.
800    #[instrument(level = "debug", skip(self))]
801    pub(crate) fn approx_universal_upper_bound(&self, r: RegionVid) -> RegionVid {
802        debug!("{}", self.region_value_str(r));
803
804        // Find the smallest universal region that contains all other
805        // universal regions within `region`.
806        let mut lub = self.universal_regions().fr_fn_body;
807        let r_scc = self.constraint_sccs.scc(r);
808        let static_r = self.universal_regions().fr_static;
809        for ur in self.scc_values.universal_regions_outlived_by(r_scc) {
810            let new_lub = self.universal_region_relations.postdom_upper_bound(lub, ur);
811            debug!(?ur, ?lub, ?new_lub);
812            // The upper bound of two non-static regions is static: this
813            // means we know nothing about the relationship between these
814            // two regions. Pick a 'better' one to use when constructing
815            // a diagnostic
816            if ur != static_r && lub != static_r && new_lub == static_r {
817                // Prefer the region with an `external_name` - this
818                // indicates that the region is early-bound, so working with
819                // it can produce a nicer error.
820                if self.region_definition(ur).external_name.is_some() {
821                    lub = ur;
822                } else if self.region_definition(lub).external_name.is_some() {
823                    // Leave lub unchanged
824                } else {
825                    // If we get here, we don't have any reason to prefer
826                    // one region over the other. Just pick the
827                    // one with the lower index for now.
828                    lub = std::cmp::min(ur, lub);
829                }
830            } else {
831                lub = new_lub;
832            }
833        }
834
835        debug!(?r, ?lub);
836
837        lub
838    }
839
840    /// Tests if `test` is true when applied to `lower_bound` at
841    /// `point`.
842    fn eval_verify_bound(
843        &self,
844        infcx: &InferCtxt<'tcx>,
845        generic_ty: Ty<'tcx>,
846        lower_bound: RegionVid,
847        verify_bound: &VerifyBound<'tcx>,
848    ) -> bool {
849        debug!("eval_verify_bound(lower_bound={:?}, verify_bound={:?})", lower_bound, verify_bound);
850
851        match verify_bound {
852            VerifyBound::IfEq(verify_if_eq_b) => {
853                self.eval_if_eq(infcx, generic_ty, lower_bound, *verify_if_eq_b)
854            }
855
856            VerifyBound::IsEmpty => {
857                let lower_bound_scc = self.constraint_sccs.scc(lower_bound);
858                self.scc_values.elements_contained_in(lower_bound_scc).next().is_none()
859            }
860
861            VerifyBound::OutlivedBy(r) => {
862                let r_vid = self.to_region_vid(*r);
863                self.eval_outlives(r_vid, lower_bound)
864            }
865
866            VerifyBound::AnyBound(verify_bounds) => verify_bounds.iter().any(|verify_bound| {
867                self.eval_verify_bound(infcx, generic_ty, lower_bound, verify_bound)
868            }),
869
870            VerifyBound::AllBounds(verify_bounds) => verify_bounds.iter().all(|verify_bound| {
871                self.eval_verify_bound(infcx, generic_ty, lower_bound, verify_bound)
872            }),
873        }
874    }
875
876    fn eval_if_eq(
877        &self,
878        infcx: &InferCtxt<'tcx>,
879        generic_ty: Ty<'tcx>,
880        lower_bound: RegionVid,
881        verify_if_eq_b: ty::Binder<'tcx, VerifyIfEq<'tcx>>,
882    ) -> bool {
883        let generic_ty = self.normalize_to_scc_representatives(infcx.tcx, generic_ty);
884        let verify_if_eq_b = self.normalize_to_scc_representatives(infcx.tcx, verify_if_eq_b);
885        match test_type_match::extract_verify_if_eq(infcx.tcx, &verify_if_eq_b, generic_ty) {
886            Some(r) => {
887                let r_vid = self.to_region_vid(r);
888                self.eval_outlives(r_vid, lower_bound)
889            }
890            None => false,
891        }
892    }
893
894    /// This is a conservative normalization procedure. It takes every
895    /// free region in `value` and replaces it with the
896    /// "representative" of its SCC (see `scc_representatives` field).
897    /// We are guaranteed that if two values normalize to the same
898    /// thing, then they are equal; this is a conservative check in
899    /// that they could still be equal even if they normalize to
900    /// different results. (For example, there might be two regions
901    /// with the same value that are not in the same SCC).
902    ///
903    /// N.B., this is not an ideal approach and I would like to revisit
904    /// it. However, it works pretty well in practice. In particular,
905    /// this is needed to deal with projection outlives bounds like
906    ///
907    /// ```text
908    /// <T as Foo<'0>>::Item: '1
909    /// ```
910    ///
911    /// In particular, this routine winds up being important when
912    /// there are bounds like `where <T as Foo<'a>>::Item: 'b` in the
913    /// environment. In this case, if we can show that `'0 == 'a`,
914    /// and that `'b: '1`, then we know that the clause is
915    /// satisfied. In such cases, particularly due to limitations of
916    /// the trait solver =), we usually wind up with a where-clause like
917    /// `T: Foo<'a>` in scope, which thus forces `'0 == 'a` to be added as
918    /// a constraint, and thus ensures that they are in the same SCC.
919    ///
920    /// So why can't we do a more correct routine? Well, we could
921    /// *almost* use the `relate_tys` code, but the way it is
922    /// currently setup it creates inference variables to deal with
923    /// higher-ranked things and so forth, and right now the inference
924    /// context is not permitted to make more inference variables. So
925    /// we use this kind of hacky solution.
926    fn normalize_to_scc_representatives<T>(&self, tcx: TyCtxt<'tcx>, value: T) -> T
927    where
928        T: TypeFoldable<TyCtxt<'tcx>>,
929    {
930        fold_regions(tcx, value, |r, _db| {
931            let vid = self.to_region_vid(r);
932            let scc = self.constraint_sccs.scc(vid);
933            let repr = self.scc_representative(scc);
934            ty::Region::new_var(tcx, repr)
935        })
936    }
937
938    /// Evaluate whether `sup_region == sub_region`.
939    ///
940    /// Panics if called before `solve()` executes,
941    // This is `pub` because it's used by unstable external borrowck data users, see `consumers.rs`.
942    pub fn eval_equal(&self, r1: RegionVid, r2: RegionVid) -> bool {
943        self.eval_outlives(r1, r2) && self.eval_outlives(r2, r1)
944    }
945
946    /// Evaluate whether `sup_region: sub_region`.
947    ///
948    /// Panics if called before `solve()` executes,
949    // This is `pub` because it's used by unstable external borrowck data users, see `consumers.rs`.
950    #[instrument(skip(self), level = "debug", ret)]
951    pub fn eval_outlives(&self, sup_region: RegionVid, sub_region: RegionVid) -> bool {
952        debug!(
953            "sup_region's value = {:?} universal={:?}",
954            self.region_value_str(sup_region),
955            self.universal_regions().is_universal_region(sup_region),
956        );
957        debug!(
958            "sub_region's value = {:?} universal={:?}",
959            self.region_value_str(sub_region),
960            self.universal_regions().is_universal_region(sub_region),
961        );
962
963        let sub_region_scc = self.constraint_sccs.scc(sub_region);
964        let sup_region_scc = self.constraint_sccs.scc(sup_region);
965
966        if sub_region_scc == sup_region_scc {
967            debug!("{sup_region:?}: {sub_region:?} holds trivially; they are in the same SCC");
968            return true;
969        }
970
971        let fr_static = self.universal_regions().fr_static;
972
973        // If we are checking that `'sup: 'sub`, and `'sub` contains
974        // some placeholder that `'sup` cannot name, then this is only
975        // true if `'sup` outlives static.
976        //
977        // Avoid infinite recursion if `sub_region` is already `'static`
978        if sub_region != fr_static
979            && !self.can_name_all_placeholders(sup_region_scc, sub_region_scc)
980        {
981            debug!(
982                "sub universe `{sub_region_scc:?}` is not nameable \
983                by super `{sup_region_scc:?}`, promoting to static",
984            );
985
986            return self.eval_outlives(sup_region, fr_static);
987        }
988
989        // Both the `sub_region` and `sup_region` consist of the union
990        // of some number of universal regions (along with the union
991        // of various points in the CFG; ignore those points for
992        // now). Therefore, the sup-region outlives the sub-region if,
993        // for each universal region R1 in the sub-region, there
994        // exists some region R2 in the sup-region that outlives R1.
995        let universal_outlives =
996            self.scc_values.universal_regions_outlived_by(sub_region_scc).all(|r1| {
997                self.scc_values
998                    .universal_regions_outlived_by(sup_region_scc)
999                    .any(|r2| self.universal_region_relations.outlives(r2, r1))
1000            });
1001
1002        if !universal_outlives {
1003            debug!("sub region contains a universal region not present in super");
1004            return false;
1005        }
1006
1007        // Now we have to compare all the points in the sub region and make
1008        // sure they exist in the sup region.
1009
1010        if self.universal_regions().is_universal_region(sup_region) {
1011            // Micro-opt: universal regions contain all points.
1012            debug!("super is universal and hence contains all points");
1013            return true;
1014        }
1015
1016        debug!("comparison between points in sup/sub");
1017
1018        self.scc_values.contains_points(sup_region_scc, sub_region_scc)
1019    }
1020
1021    /// Once regions have been propagated, this method is used to see
1022    /// whether any of the constraints were too strong. In particular,
1023    /// we want to check for a case where a universally quantified
1024    /// region exceeded its bounds. Consider:
1025    /// ```compile_fail
1026    /// fn foo<'a, 'b>(x: &'a u32) -> &'b u32 { x }
1027    /// ```
1028    /// In this case, returning `x` requires `&'a u32 <: &'b u32`
1029    /// and hence we establish (transitively) a constraint that
1030    /// `'a: 'b`. The `propagate_constraints` code above will
1031    /// therefore add `end('a)` into the region for `'b` -- but we
1032    /// have no evidence that `'b` outlives `'a`, so we want to report
1033    /// an error.
1034    ///
1035    /// If `propagated_outlives_requirements` is `Some`, then we will
1036    /// push unsatisfied obligations into there. Otherwise, we'll
1037    /// report them as errors.
1038    fn check_universal_regions(
1039        &self,
1040        mut propagated_outlives_requirements: Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
1041        errors_buffer: &mut RegionErrors<'tcx>,
1042    ) {
1043        for (fr, fr_definition) in self.definitions.iter_enumerated() {
1044            debug!(?fr, ?fr_definition);
1045            match fr_definition.origin {
1046                NllRegionVariableOrigin::FreeRegion => {
1047                    // Go through each of the universal regions `fr` and check that
1048                    // they did not grow too large, accumulating any requirements
1049                    // for our caller into the `outlives_requirements` vector.
1050                    self.check_universal_region(
1051                        fr,
1052                        &mut propagated_outlives_requirements,
1053                        errors_buffer,
1054                    );
1055                }
1056
1057                NllRegionVariableOrigin::Placeholder(placeholder) => {
1058                    self.check_bound_universal_region(fr, placeholder, errors_buffer);
1059                }
1060
1061                NllRegionVariableOrigin::Existential { .. } => {
1062                    // nothing to check here
1063                }
1064            }
1065        }
1066    }
1067
1068    /// Checks if Polonius has found any unexpected free region relations.
1069    ///
1070    /// In Polonius terms, a "subset error" (or "illegal subset relation error") is the equivalent
1071    /// of NLL's "checking if any region constraints were too strong": a placeholder origin `'a`
1072    /// was unexpectedly found to be a subset of another placeholder origin `'b`, and means in NLL
1073    /// terms that the "longer free region" `'a` outlived the "shorter free region" `'b`.
1074    ///
1075    /// More details can be found in this blog post by Niko:
1076    /// <https://smallcultfollowing.com/babysteps/blog/2019/01/17/polonius-and-region-errors/>
1077    ///
1078    /// In the canonical example
1079    /// ```compile_fail
1080    /// fn foo<'a, 'b>(x: &'a u32) -> &'b u32 { x }
1081    /// ```
1082    /// returning `x` requires `&'a u32 <: &'b u32` and hence we establish (transitively) a
1083    /// constraint that `'a: 'b`. It is an error that we have no evidence that this
1084    /// constraint holds.
1085    ///
1086    /// If `propagated_outlives_requirements` is `Some`, then we will
1087    /// push unsatisfied obligations into there. Otherwise, we'll
1088    /// report them as errors.
1089    fn check_polonius_subset_errors(
1090        &self,
1091        mut propagated_outlives_requirements: Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
1092        errors_buffer: &mut RegionErrors<'tcx>,
1093        polonius_output: &PoloniusOutput,
1094    ) {
1095        debug!(
1096            "check_polonius_subset_errors: {} subset_errors",
1097            polonius_output.subset_errors.len()
1098        );
1099
1100        // Similarly to `check_universal_regions`: a free region relation, which was not explicitly
1101        // declared ("known") was found by Polonius, so emit an error, or propagate the
1102        // requirements for our caller into the `propagated_outlives_requirements` vector.
1103        //
1104        // Polonius doesn't model regions ("origins") as CFG-subsets or durations, but the
1105        // `longer_fr` and `shorter_fr` terminology will still be used here, for consistency with
1106        // the rest of the NLL infrastructure. The "subset origin" is the "longer free region",
1107        // and the "superset origin" is the outlived "shorter free region".
1108        //
1109        // Note: Polonius will produce a subset error at every point where the unexpected
1110        // `longer_fr`'s "placeholder loan" is contained in the `shorter_fr`. This can be helpful
1111        // for diagnostics in the future, e.g. to point more precisely at the key locations
1112        // requiring this constraint to hold. However, the error and diagnostics code downstream
1113        // expects that these errors are not duplicated (and that they are in a certain order).
1114        // Otherwise, diagnostics messages such as the ones giving names like `'1` to elided or
1115        // anonymous lifetimes for example, could give these names differently, while others like
1116        // the outlives suggestions or the debug output from `#[rustc_regions]` would be
1117        // duplicated. The polonius subset errors are deduplicated here, while keeping the
1118        // CFG-location ordering.
1119        // We can iterate the HashMap here because the result is sorted afterwards.
1120        #[allow(rustc::potential_query_instability)]
1121        let mut subset_errors: Vec<_> = polonius_output
1122            .subset_errors
1123            .iter()
1124            .flat_map(|(_location, subset_errors)| subset_errors.iter())
1125            .collect();
1126        subset_errors.sort();
1127        subset_errors.dedup();
1128
1129        for &(longer_fr, shorter_fr) in subset_errors.into_iter() {
1130            debug!(
1131                "check_polonius_subset_errors: subset_error longer_fr={:?},\
1132                 shorter_fr={:?}",
1133                longer_fr, shorter_fr
1134            );
1135
1136            let propagated = self.try_propagate_universal_region_error(
1137                longer_fr.into(),
1138                shorter_fr.into(),
1139                &mut propagated_outlives_requirements,
1140            );
1141            if propagated == RegionRelationCheckResult::Error {
1142                errors_buffer.push(RegionErrorKind::RegionError {
1143                    longer_fr: longer_fr.into(),
1144                    shorter_fr: shorter_fr.into(),
1145                    fr_origin: NllRegionVariableOrigin::FreeRegion,
1146                    is_reported: true,
1147                });
1148            }
1149        }
1150
1151        // Handle the placeholder errors as usual, until the chalk-rustc-polonius triumvirate has
1152        // a more complete picture on how to separate this responsibility.
1153        for (fr, fr_definition) in self.definitions.iter_enumerated() {
1154            match fr_definition.origin {
1155                NllRegionVariableOrigin::FreeRegion => {
1156                    // handled by polonius above
1157                }
1158
1159                NllRegionVariableOrigin::Placeholder(placeholder) => {
1160                    self.check_bound_universal_region(fr, placeholder, errors_buffer);
1161                }
1162
1163                NllRegionVariableOrigin::Existential { .. } => {
1164                    // nothing to check here
1165                }
1166            }
1167        }
1168    }
1169
1170    /// The largest universe of any region nameable from this SCC.
1171    fn max_nameable_universe(&self, scc: ConstraintSccIndex) -> UniverseIndex {
1172        self.scc_annotations[scc].max_nameable_universe()
1173    }
1174
1175    /// Checks the final value for the free region `fr` to see if it
1176    /// grew too large. In particular, examine what `end(X)` points
1177    /// wound up in `fr`'s final value; for each `end(X)` where `X !=
1178    /// fr`, we want to check that `fr: X`. If not, that's either an
1179    /// error, or something we have to propagate to our creator.
1180    ///
1181    /// Things that are to be propagated are accumulated into the
1182    /// `outlives_requirements` vector.
1183    #[instrument(skip(self, propagated_outlives_requirements, errors_buffer), level = "debug")]
1184    fn check_universal_region(
1185        &self,
1186        longer_fr: RegionVid,
1187        propagated_outlives_requirements: &mut Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
1188        errors_buffer: &mut RegionErrors<'tcx>,
1189    ) {
1190        let longer_fr_scc = self.constraint_sccs.scc(longer_fr);
1191
1192        // Because this free region must be in the ROOT universe, we
1193        // know it cannot contain any bound universes.
1194        assert!(self.max_nameable_universe(longer_fr_scc).is_root());
1195
1196        // Only check all of the relations for the main representative of each
1197        // SCC, otherwise just check that we outlive said representative. This
1198        // reduces the number of redundant relations propagated out of
1199        // closures.
1200        // Note that the representative will be a universal region if there is
1201        // one in this SCC, so we will always check the representative here.
1202        let representative = self.scc_representative(longer_fr_scc);
1203        if representative != longer_fr {
1204            if let RegionRelationCheckResult::Error = self.check_universal_region_relation(
1205                longer_fr,
1206                representative,
1207                propagated_outlives_requirements,
1208            ) {
1209                errors_buffer.push(RegionErrorKind::RegionError {
1210                    longer_fr,
1211                    shorter_fr: representative,
1212                    fr_origin: NllRegionVariableOrigin::FreeRegion,
1213                    is_reported: true,
1214                });
1215            }
1216            return;
1217        }
1218
1219        // Find every region `o` such that `fr: o`
1220        // (because `fr` includes `end(o)`).
1221        let mut error_reported = false;
1222        for shorter_fr in self.scc_values.universal_regions_outlived_by(longer_fr_scc) {
1223            if let RegionRelationCheckResult::Error = self.check_universal_region_relation(
1224                longer_fr,
1225                shorter_fr,
1226                propagated_outlives_requirements,
1227            ) {
1228                // We only report the first region error. Subsequent errors are hidden so as
1229                // not to overwhelm the user, but we do record them so as to potentially print
1230                // better diagnostics elsewhere...
1231                errors_buffer.push(RegionErrorKind::RegionError {
1232                    longer_fr,
1233                    shorter_fr,
1234                    fr_origin: NllRegionVariableOrigin::FreeRegion,
1235                    is_reported: !error_reported,
1236                });
1237
1238                error_reported = true;
1239            }
1240        }
1241    }
1242
1243    /// Checks that we can prove that `longer_fr: shorter_fr`. If we can't we attempt to propagate
1244    /// the constraint outward (e.g. to a closure environment), but if that fails, there is an
1245    /// error.
1246    fn check_universal_region_relation(
1247        &self,
1248        longer_fr: RegionVid,
1249        shorter_fr: RegionVid,
1250        propagated_outlives_requirements: &mut Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
1251    ) -> RegionRelationCheckResult {
1252        // If it is known that `fr: o`, carry on.
1253        if self.universal_region_relations.outlives(longer_fr, shorter_fr) {
1254            RegionRelationCheckResult::Ok
1255        } else {
1256            // If we are not in a context where we can't propagate errors, or we
1257            // could not shrink `fr` to something smaller, then just report an
1258            // error.
1259            //
1260            // Note: in this case, we use the unapproximated regions to report the
1261            // error. This gives better error messages in some cases.
1262            self.try_propagate_universal_region_error(
1263                longer_fr,
1264                shorter_fr,
1265                propagated_outlives_requirements,
1266            )
1267        }
1268    }
1269
1270    /// Attempt to propagate a region error (e.g. `'a: 'b`) that is not met to a closure's
1271    /// creator. If we cannot, then the caller should report an error to the user.
1272    fn try_propagate_universal_region_error(
1273        &self,
1274        longer_fr: RegionVid,
1275        shorter_fr: RegionVid,
1276        propagated_outlives_requirements: &mut Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
1277    ) -> RegionRelationCheckResult {
1278        if let Some(propagated_outlives_requirements) = propagated_outlives_requirements
1279            // Shrink `longer_fr` until we find a non-local region (if we do).
1280            // We'll call it `fr-` -- it's ever so slightly smaller than
1281            // `longer_fr`.
1282            && let Some(fr_minus) = self.universal_region_relations.non_local_lower_bound(longer_fr)
1283        {
1284            debug!("try_propagate_universal_region_error: fr_minus={:?}", fr_minus);
1285
1286            let blame_constraint = self
1287                .best_blame_constraint(longer_fr, NllRegionVariableOrigin::FreeRegion, shorter_fr)
1288                .0;
1289
1290            // Grow `shorter_fr` until we find some non-local regions. (We
1291            // always will.)  We'll call them `shorter_fr+` -- they're ever
1292            // so slightly larger than `shorter_fr`.
1293            let shorter_fr_plus =
1294                self.universal_region_relations.non_local_upper_bounds(shorter_fr);
1295            debug!("try_propagate_universal_region_error: shorter_fr_plus={:?}", shorter_fr_plus);
1296            for fr in shorter_fr_plus {
1297                // Push the constraint `fr-: shorter_fr+`
1298                propagated_outlives_requirements.push(ClosureOutlivesRequirement {
1299                    subject: ClosureOutlivesSubject::Region(fr_minus),
1300                    outlived_free_region: fr,
1301                    blame_span: blame_constraint.cause.span,
1302                    category: blame_constraint.category,
1303                });
1304            }
1305            return RegionRelationCheckResult::Propagated;
1306        }
1307
1308        RegionRelationCheckResult::Error
1309    }
1310
1311    fn check_bound_universal_region(
1312        &self,
1313        longer_fr: RegionVid,
1314        placeholder: ty::PlaceholderRegion,
1315        errors_buffer: &mut RegionErrors<'tcx>,
1316    ) {
1317        debug!("check_bound_universal_region(fr={:?}, placeholder={:?})", longer_fr, placeholder,);
1318
1319        let longer_fr_scc = self.constraint_sccs.scc(longer_fr);
1320        debug!("check_bound_universal_region: longer_fr_scc={:?}", longer_fr_scc,);
1321
1322        // If we have some bound universal region `'a`, then the only
1323        // elements it can contain is itself -- we don't know anything
1324        // else about it!
1325        if let Some(error_element) = self
1326            .scc_values
1327            .elements_contained_in(longer_fr_scc)
1328            .find(|e| *e != RegionElement::PlaceholderRegion(placeholder))
1329        {
1330            // Stop after the first error, it gets too noisy otherwise, and does not provide more information.
1331            errors_buffer.push(RegionErrorKind::BoundUniversalRegionError {
1332                longer_fr,
1333                error_element,
1334                placeholder,
1335            });
1336        } else {
1337            debug!("check_bound_universal_region: all bounds satisfied");
1338        }
1339    }
1340
1341    pub(crate) fn constraint_path_between_regions(
1342        &self,
1343        from_region: RegionVid,
1344        to_region: RegionVid,
1345    ) -> Option<Vec<OutlivesConstraint<'tcx>>> {
1346        if from_region == to_region {
1347            bug!("Tried to find a path between {from_region:?} and itself!");
1348        }
1349        self.constraint_path_to(from_region, |to| to == to_region, true).map(|o| o.0)
1350    }
1351
1352    /// Walks the graph of constraints (where `'a: 'b` is considered
1353    /// an edge `'a -> 'b`) to find a path from `from_region` to
1354    /// `to_region`.
1355    ///
1356    /// Returns: a series of constraints as well as the region `R`
1357    /// that passed the target test.
1358    /// If `include_static_outlives_all` is `true`, then the synthetic
1359    /// outlives constraints `'static -> a` for every region `a` are
1360    /// considered in the search, otherwise they are ignored.
1361    #[instrument(skip(self, target_test), ret)]
1362    pub(crate) fn constraint_path_to(
1363        &self,
1364        from_region: RegionVid,
1365        target_test: impl Fn(RegionVid) -> bool,
1366        include_placeholder_static: bool,
1367    ) -> Option<(Vec<OutlivesConstraint<'tcx>>, RegionVid)> {
1368        self.find_constraint_path_between_regions_inner(
1369            true,
1370            from_region,
1371            &target_test,
1372            include_placeholder_static,
1373        )
1374        .or_else(|| {
1375            self.find_constraint_path_between_regions_inner(
1376                false,
1377                from_region,
1378                &target_test,
1379                include_placeholder_static,
1380            )
1381        })
1382    }
1383
1384    /// The constraints we get from equating the hidden type of each use of an opaque
1385    /// with its final concrete type may end up getting preferred over other, potentially
1386    /// longer constraint paths.
1387    ///
1388    /// Given that we compute the final concrete type by relying on this existing constraint
1389    /// path, this can easily end up hiding the actual reason for why we require these regions
1390    /// to be equal.
1391    ///
1392    /// To handle this, we first look at the path while ignoring these constraints and then
1393    /// retry while considering them. This is not perfect, as the `from_region` may have already
1394    /// been partially related to its argument region, so while we rely on a member constraint
1395    /// to get a complete path, the most relevant step of that path already existed before then.
1396    fn find_constraint_path_between_regions_inner(
1397        &self,
1398        ignore_opaque_type_constraints: bool,
1399        from_region: RegionVid,
1400        target_test: impl Fn(RegionVid) -> bool,
1401        include_placeholder_static: bool,
1402    ) -> Option<(Vec<OutlivesConstraint<'tcx>>, RegionVid)> {
1403        let mut context = IndexVec::from_elem(Trace::NotVisited, &self.definitions);
1404        context[from_region] = Trace::StartRegion;
1405
1406        let fr_static = self.universal_regions().fr_static;
1407
1408        // Use a deque so that we do a breadth-first search. We will
1409        // stop at the first match, which ought to be the shortest
1410        // path (fewest constraints).
1411        let mut deque = VecDeque::new();
1412        deque.push_back(from_region);
1413
1414        while let Some(r) = deque.pop_front() {
1415            debug!(
1416                "constraint_path_to: from_region={:?} r={:?} value={}",
1417                from_region,
1418                r,
1419                self.region_value_str(r),
1420            );
1421
1422            // Check if we reached the region we were looking for. If so,
1423            // we can reconstruct the path that led to it and return it.
1424            if target_test(r) {
1425                let mut result = vec![];
1426                let mut p = r;
1427                // This loop is cold and runs at the end, which is why we delay
1428                // `OutlivesConstraint` construction until now.
1429                loop {
1430                    match context[p] {
1431                        Trace::FromGraph(c) => {
1432                            p = c.sup;
1433                            result.push(*c);
1434                        }
1435
1436                        Trace::FromStatic(sub) => {
1437                            let c = OutlivesConstraint {
1438                                sup: fr_static,
1439                                sub,
1440                                locations: Locations::All(DUMMY_SP),
1441                                span: DUMMY_SP,
1442                                category: ConstraintCategory::Internal,
1443                                variance_info: ty::VarianceDiagInfo::default(),
1444                                from_closure: false,
1445                            };
1446                            p = c.sup;
1447                            result.push(c);
1448                        }
1449
1450                        Trace::StartRegion => {
1451                            result.reverse();
1452                            return Some((result, r));
1453                        }
1454
1455                        Trace::NotVisited => {
1456                            bug!("found unvisited region {:?} on path to {:?}", p, r)
1457                        }
1458                    }
1459                }
1460            }
1461
1462            // Otherwise, walk over the outgoing constraints and
1463            // enqueue any regions we find, keeping track of how we
1464            // reached them.
1465
1466            // A constraint like `'r: 'x` can come from our constraint
1467            // graph.
1468
1469            // Always inline this closure because it can be hot.
1470            let mut handle_trace = #[inline(always)]
1471            |sub, trace| {
1472                if let Trace::NotVisited = context[sub] {
1473                    context[sub] = trace;
1474                    deque.push_back(sub);
1475                }
1476            };
1477
1478            // If this is the `'static` region and the graph's direction is normal, then set up the
1479            // Edges iterator to return all regions (#53178).
1480            if r == fr_static && self.constraint_graph.is_normal() {
1481                for sub in self.constraint_graph.outgoing_edges_from_static() {
1482                    handle_trace(sub, Trace::FromStatic(sub));
1483                }
1484            } else {
1485                let edges = self.constraint_graph.outgoing_edges_from_graph(r, &self.constraints);
1486                // This loop can be hot.
1487                for constraint in edges {
1488                    match constraint.category {
1489                        ConstraintCategory::OutlivesUnnameablePlaceholder(_)
1490                            if !include_placeholder_static =>
1491                        {
1492                            debug!("Ignoring illegal placeholder constraint: {constraint:?}");
1493                            continue;
1494                        }
1495                        ConstraintCategory::OpaqueType if ignore_opaque_type_constraints => {
1496                            debug!("Ignoring member constraint: {constraint:?}");
1497                            continue;
1498                        }
1499                        _ => {}
1500                    }
1501
1502                    debug_assert_eq!(constraint.sup, r);
1503                    handle_trace(constraint.sub, Trace::FromGraph(constraint));
1504                }
1505            }
1506        }
1507
1508        None
1509    }
1510
1511    /// Finds some region R such that `fr1: R` and `R` is live at `location`.
1512    #[instrument(skip(self), level = "trace", ret)]
1513    pub(crate) fn find_sub_region_live_at(&self, fr1: RegionVid, location: Location) -> RegionVid {
1514        trace!(scc = ?self.constraint_sccs.scc(fr1));
1515        trace!(universe = ?self.max_nameable_universe(self.constraint_sccs.scc(fr1)));
1516        self.constraint_path_to(fr1, |r| {
1517            trace!(?r, liveness_constraints=?self.liveness_constraints.pretty_print_live_points(r));
1518            self.liveness_constraints.is_live_at(r, location)
1519        }, true).unwrap().1
1520    }
1521
1522    /// Get the region outlived by `longer_fr` and live at `element`.
1523    pub(crate) fn region_from_element(
1524        &self,
1525        longer_fr: RegionVid,
1526        element: &RegionElement,
1527    ) -> RegionVid {
1528        match *element {
1529            RegionElement::Location(l) => self.find_sub_region_live_at(longer_fr, l),
1530            RegionElement::RootUniversalRegion(r) => r,
1531            RegionElement::PlaceholderRegion(error_placeholder) => self
1532                .definitions
1533                .iter_enumerated()
1534                .find_map(|(r, definition)| match definition.origin {
1535                    NllRegionVariableOrigin::Placeholder(p) if p == error_placeholder => Some(r),
1536                    _ => None,
1537                })
1538                .unwrap(),
1539        }
1540    }
1541
1542    /// Get the region definition of `r`.
1543    pub(crate) fn region_definition(&self, r: RegionVid) -> &RegionDefinition<'tcx> {
1544        &self.definitions[r]
1545    }
1546
1547    /// Check if the SCC of `r` contains `upper`.
1548    pub(crate) fn upper_bound_in_region_scc(&self, r: RegionVid, upper: RegionVid) -> bool {
1549        let r_scc = self.constraint_sccs.scc(r);
1550        self.scc_values.contains(r_scc, upper)
1551    }
1552
1553    pub(crate) fn universal_regions(&self) -> &UniversalRegions<'tcx> {
1554        &self.universal_region_relations.universal_regions
1555    }
1556
1557    /// Tries to find the best constraint to blame for the fact that
1558    /// `R: from_region`, where `R` is some region that meets
1559    /// `target_test`. This works by following the constraint graph,
1560    /// creating a constraint path that forces `R` to outlive
1561    /// `from_region`, and then finding the best choices within that
1562    /// path to blame.
1563    #[instrument(level = "debug", skip(self))]
1564    pub(crate) fn best_blame_constraint(
1565        &self,
1566        from_region: RegionVid,
1567        from_region_origin: NllRegionVariableOrigin,
1568        to_region: RegionVid,
1569    ) -> (BlameConstraint<'tcx>, Vec<OutlivesConstraint<'tcx>>) {
1570        assert!(from_region != to_region, "Trying to blame a region for itself!");
1571
1572        let path = self.constraint_path_between_regions(from_region, to_region).unwrap();
1573
1574        // If we are passing through a constraint added because we reached an unnameable placeholder `'unnameable`,
1575        // redirect search towards `'unnameable`.
1576        let due_to_placeholder_outlives = path.iter().find_map(|c| {
1577            if let ConstraintCategory::OutlivesUnnameablePlaceholder(unnameable) = c.category {
1578                Some(unnameable)
1579            } else {
1580                None
1581            }
1582        });
1583
1584        // Edge case: it's possible that `'from_region` is an unnameable placeholder.
1585        let path = if let Some(unnameable) = due_to_placeholder_outlives
1586            && unnameable != from_region
1587        {
1588            // We ignore the extra edges due to unnameable placeholders to get
1589            // an explanation that was present in the original constraint graph.
1590            self.constraint_path_to(from_region, |r| r == unnameable, false).unwrap().0
1591        } else {
1592            path
1593        };
1594
1595        debug!(
1596            "path={:#?}",
1597            path.iter()
1598                .map(|c| format!(
1599                    "{:?} ({:?}: {:?})",
1600                    c,
1601                    self.constraint_sccs.scc(c.sup),
1602                    self.constraint_sccs.scc(c.sub),
1603                ))
1604                .collect::<Vec<_>>()
1605        );
1606
1607        // We try to avoid reporting a `ConstraintCategory::Predicate` as our best constraint.
1608        // Instead, we use it to produce an improved `ObligationCauseCode`.
1609        // FIXME - determine what we should do if we encounter multiple
1610        // `ConstraintCategory::Predicate` constraints. Currently, we just pick the first one.
1611        let cause_code = path
1612            .iter()
1613            .find_map(|constraint| {
1614                if let ConstraintCategory::Predicate(predicate_span) = constraint.category {
1615                    // We currently do not store the `DefId` in the `ConstraintCategory`
1616                    // for performances reasons. The error reporting code used by NLL only
1617                    // uses the span, so this doesn't cause any problems at the moment.
1618                    Some(ObligationCauseCode::WhereClause(CRATE_DEF_ID.to_def_id(), predicate_span))
1619                } else {
1620                    None
1621                }
1622            })
1623            .unwrap_or_else(|| ObligationCauseCode::Misc);
1624
1625        // When reporting an error, there is typically a chain of constraints leading from some
1626        // "source" region which must outlive some "target" region.
1627        // In most cases, we prefer to "blame" the constraints closer to the target --
1628        // but there is one exception. When constraints arise from higher-ranked subtyping,
1629        // we generally prefer to blame the source value,
1630        // as the "target" in this case tends to be some type annotation that the user gave.
1631        // Therefore, if we find that the region origin is some instantiation
1632        // of a higher-ranked region, we start our search from the "source" point
1633        // rather than the "target", and we also tweak a few other things.
1634        //
1635        // An example might be this bit of Rust code:
1636        //
1637        // ```rust
1638        // let x: fn(&'static ()) = |_| {};
1639        // let y: for<'a> fn(&'a ()) = x;
1640        // ```
1641        //
1642        // In MIR, this will be converted into a combination of assignments and type ascriptions.
1643        // In particular, the 'static is imposed through a type ascription:
1644        //
1645        // ```rust
1646        // x = ...;
1647        // AscribeUserType(x, fn(&'static ())
1648        // y = x;
1649        // ```
1650        //
1651        // We wind up ultimately with constraints like
1652        //
1653        // ```rust
1654        // !a: 'temp1 // from the `y = x` statement
1655        // 'temp1: 'temp2
1656        // 'temp2: 'static // from the AscribeUserType
1657        // ```
1658        //
1659        // and here we prefer to blame the source (the y = x statement).
1660        let blame_source = match from_region_origin {
1661            NllRegionVariableOrigin::FreeRegion => true,
1662            NllRegionVariableOrigin::Placeholder(_) => false,
1663            // `'existential: 'whatever` never results in a region error by itself.
1664            // We may always infer it to `'static` afterall. This means while an error
1665            // path may go through an existential, these existentials are never the
1666            // `from_region`.
1667            NllRegionVariableOrigin::Existential { name: _ } => {
1668                unreachable!("existentials can outlive everything")
1669            }
1670        };
1671
1672        // To pick a constraint to blame, we organize constraints by how interesting we expect them
1673        // to be in diagnostics, then pick the most interesting one closest to either the source or
1674        // the target on our constraint path.
1675        let constraint_interest = |constraint: &OutlivesConstraint<'tcx>| {
1676            // Try to avoid blaming constraints from desugarings, since they may not clearly match
1677            // match what users have written. As an exception, allow blaming returns generated by
1678            // `?` desugaring, since the correspondence is fairly clear.
1679            let category = if let Some(kind) = constraint.span.desugaring_kind()
1680                && (kind != DesugaringKind::QuestionMark
1681                    || !matches!(constraint.category, ConstraintCategory::Return(_)))
1682            {
1683                ConstraintCategory::Boring
1684            } else {
1685                constraint.category
1686            };
1687
1688            let interest = match category {
1689                // Returns usually provide a type to blame and have specially written diagnostics,
1690                // so prioritize them.
1691                ConstraintCategory::Return(_) => 0,
1692                // Unsizing coercions are interesting, since we have a note for that:
1693                // `BorrowExplanation::add_object_lifetime_default_note`.
1694                // FIXME(dianne): That note shouldn't depend on a coercion being blamed; see issue
1695                // #131008 for an example of where we currently don't emit it but should.
1696                // Once the note is handled properly, this case should be removed. Until then, it
1697                // should be as limited as possible; the note is prone to false positives and this
1698                // constraint usually isn't best to blame.
1699                ConstraintCategory::Cast {
1700                    unsize_to: Some(unsize_ty),
1701                    is_implicit_coercion: true,
1702                } if to_region == self.universal_regions().fr_static
1703                    // Mirror the note's condition, to minimize how often this diverts blame.
1704                    && let ty::Adt(_, args) = unsize_ty.kind()
1705                    && args.iter().any(|arg| arg.as_type().is_some_and(|ty| ty.is_trait()))
1706                    // Mimic old logic for this, to minimize false positives in tests.
1707                    && !path
1708                        .iter()
1709                        .any(|c| matches!(c.category, ConstraintCategory::TypeAnnotation(_))) =>
1710                {
1711                    1
1712                }
1713                // Between other interesting constraints, order by their position on the `path`.
1714                ConstraintCategory::Yield
1715                | ConstraintCategory::UseAsConst
1716                | ConstraintCategory::UseAsStatic
1717                | ConstraintCategory::TypeAnnotation(
1718                    AnnotationSource::Ascription
1719                    | AnnotationSource::Declaration
1720                    | AnnotationSource::OpaqueCast,
1721                )
1722                | ConstraintCategory::Cast { .. }
1723                | ConstraintCategory::CallArgument(_)
1724                | ConstraintCategory::CopyBound
1725                | ConstraintCategory::SizedBound
1726                | ConstraintCategory::Assignment
1727                | ConstraintCategory::Usage
1728                | ConstraintCategory::ClosureUpvar(_) => 2,
1729                // Generic arguments are unlikely to be what relates regions together
1730                ConstraintCategory::TypeAnnotation(AnnotationSource::GenericArg) => 3,
1731                // We handle predicates and opaque types specially; don't prioritize them here.
1732                ConstraintCategory::Predicate(_) | ConstraintCategory::OpaqueType => 4,
1733                // `Boring` constraints can correspond to user-written code and have useful spans,
1734                // but don't provide any other useful information for diagnostics.
1735                ConstraintCategory::Boring => 5,
1736                // `BoringNoLocation` constraints can point to user-written code, but are less
1737                // specific, and are not used for relations that would make sense to blame.
1738                ConstraintCategory::BoringNoLocation => 6,
1739                // Do not blame internal constraints.
1740                ConstraintCategory::OutlivesUnnameablePlaceholder(_) => 7,
1741                ConstraintCategory::Internal => 8,
1742            };
1743
1744            debug!("constraint {constraint:?} category: {category:?}, interest: {interest:?}");
1745
1746            interest
1747        };
1748
1749        let best_choice = if blame_source {
1750            path.iter().enumerate().rev().min_by_key(|(_, c)| constraint_interest(c)).unwrap().0
1751        } else {
1752            path.iter().enumerate().min_by_key(|(_, c)| constraint_interest(c)).unwrap().0
1753        };
1754
1755        debug!(?best_choice, ?blame_source);
1756
1757        let best_constraint = if let Some(next) = path.get(best_choice + 1)
1758            && matches!(path[best_choice].category, ConstraintCategory::Return(_))
1759            && next.category == ConstraintCategory::OpaqueType
1760        {
1761            // The return expression is being influenced by the return type being
1762            // impl Trait, point at the return type and not the return expr.
1763            *next
1764        } else if path[best_choice].category == ConstraintCategory::Return(ReturnConstraint::Normal)
1765            && let Some(field) = path.iter().find_map(|p| {
1766                if let ConstraintCategory::ClosureUpvar(f) = p.category { Some(f) } else { None }
1767            })
1768        {
1769            OutlivesConstraint {
1770                category: ConstraintCategory::Return(ReturnConstraint::ClosureUpvar(field)),
1771                ..path[best_choice]
1772            }
1773        } else {
1774            path[best_choice]
1775        };
1776
1777        assert!(
1778            !matches!(
1779                best_constraint.category,
1780                ConstraintCategory::OutlivesUnnameablePlaceholder(_)
1781            ),
1782            "Illegal placeholder constraint blamed; should have redirected to other region relation"
1783        );
1784
1785        let blame_constraint = BlameConstraint {
1786            category: best_constraint.category,
1787            from_closure: best_constraint.from_closure,
1788            cause: ObligationCause::new(best_constraint.span, CRATE_DEF_ID, cause_code.clone()),
1789            variance_info: best_constraint.variance_info,
1790        };
1791        (blame_constraint, path)
1792    }
1793
1794    pub(crate) fn universe_info(&self, universe: ty::UniverseIndex) -> UniverseInfo<'tcx> {
1795        // Query canonicalization can create local superuniverses (for example in
1796        // `InferCtx::query_response_instantiation_guess`), but they don't have an associated
1797        // `UniverseInfo` explaining why they were created.
1798        // This can cause ICEs if these causes are accessed in diagnostics, for example in issue
1799        // #114907 where this happens via liveness and dropck outlives results.
1800        // Therefore, we return a default value in case that happens, which should at worst emit a
1801        // suboptimal error, instead of the ICE.
1802        self.universe_causes.get(&universe).cloned().unwrap_or_else(UniverseInfo::other)
1803    }
1804
1805    /// Tries to find the terminator of the loop in which the region 'r' resides.
1806    /// Returns the location of the terminator if found.
1807    pub(crate) fn find_loop_terminator_location(
1808        &self,
1809        r: RegionVid,
1810        body: &Body<'_>,
1811    ) -> Option<Location> {
1812        let scc = self.constraint_sccs.scc(r);
1813        let locations = self.scc_values.locations_outlived_by(scc);
1814        for location in locations {
1815            let bb = &body[location.block];
1816            if let Some(terminator) = &bb.terminator
1817                // terminator of a loop should be TerminatorKind::FalseUnwind
1818                && let TerminatorKind::FalseUnwind { .. } = terminator.kind
1819            {
1820                return Some(location);
1821            }
1822        }
1823        None
1824    }
1825
1826    /// Access to the SCC constraint graph.
1827    /// This can be used to quickly under-approximate the regions which are equal to each other
1828    /// and their relative orderings.
1829    // This is `pub` because it's used by unstable external borrowck data users, see `consumers.rs`.
1830    pub fn constraint_sccs(&self) -> &ConstraintSccs {
1831        &self.constraint_sccs
1832    }
1833
1834    /// Returns the representative `RegionVid` for a given SCC.
1835    /// See `RegionTracker` for how a region variable ID is chosen.
1836    ///
1837    /// It is a hacky way to manage checking regions for equality,
1838    /// since we can 'canonicalize' each region to the representative
1839    /// of its SCC and be sure that -- if they have the same repr --
1840    /// they *must* be equal (though not having the same repr does not
1841    /// mean they are unequal).
1842    fn scc_representative(&self, scc: ConstraintSccIndex) -> RegionVid {
1843        self.scc_annotations[scc].representative.rvid()
1844    }
1845
1846    pub(crate) fn liveness_constraints(&self) -> &LivenessValues {
1847        &self.liveness_constraints
1848    }
1849
1850    /// When using `-Zpolonius=next`, records the given live loans for the loan scopes and active
1851    /// loans dataflow computations.
1852    pub(crate) fn record_live_loans(&mut self, live_loans: LiveLoans) {
1853        self.liveness_constraints.record_live_loans(live_loans);
1854    }
1855
1856    /// Returns whether the `loan_idx` is live at the given `location`: whether its issuing
1857    /// region is contained within the type of a variable that is live at this point.
1858    /// Note: for now, the sets of live loans is only available when using `-Zpolonius=next`.
1859    pub(crate) fn is_loan_live_at(&self, loan_idx: BorrowIndex, location: Location) -> bool {
1860        let point = self.liveness_constraints.point_from_location(location);
1861        self.liveness_constraints.is_loan_live_at(loan_idx, point)
1862    }
1863}
1864
1865#[derive(Clone, Debug)]
1866pub(crate) struct BlameConstraint<'tcx> {
1867    pub category: ConstraintCategory<'tcx>,
1868    pub from_closure: bool,
1869    pub cause: ObligationCause<'tcx>,
1870    pub variance_info: ty::VarianceDiagInfo<TyCtxt<'tcx>>,
1871}