1 use super::universal_regions::UniversalRegions;
2 use crate::borrow_check::nll::constraints::graph::NormalConstraintGraph;
3 use crate::borrow_check::nll::constraints::{
4 ConstraintSccIndex, OutlivesConstraint, OutlivesConstraintSet,
6 use crate::borrow_check::nll::pick_constraints::PickConstraintSet;
7 use crate::borrow_check::nll::region_infer::values::{
8 PlaceholderIndices, RegionElement, ToElementIndex,
10 use crate::borrow_check::nll::type_check::free_region_relations::UniversalRegionRelations;
11 use crate::borrow_check::nll::type_check::Locations;
12 use crate::borrow_check::Upvar;
13 use rustc::hir::def_id::DefId;
14 use rustc::infer::canonical::QueryOutlivesConstraint;
15 use rustc::infer::opaque_types;
16 use rustc::infer::region_constraints::{GenericKind, VarInfos, VerifyBound};
17 use rustc::infer::{InferCtxt, NLLRegionVariableOrigin, RegionVariableOrigin};
19 Body, ClosureOutlivesRequirement, ClosureOutlivesSubject, ClosureRegionRequirements,
20 ConstraintCategory, Local, Location,
22 use rustc::ty::{self, subst::SubstsRef, RegionVid, Ty, TyCtxt, TypeFoldable};
23 use rustc::util::common::{self, ErrorReported};
24 use rustc_data_structures::bit_set::BitSet;
25 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
26 use crate::rustc_data_structures::graph::WithSuccessors;
27 use rustc_data_structures::graph::scc::Sccs;
28 use rustc_data_structures::graph::vec_graph::VecGraph;
29 use rustc_data_structures::indexed_vec::IndexVec;
30 use rustc_errors::{Diagnostic, DiagnosticBuilder};
37 crate use self::error_reporting::{RegionName, RegionNameSource};
40 use self::values::{LivenessValues, RegionValueElements, RegionValues};
42 use super::ToRegionVid;
44 pub struct RegionInferenceContext<'tcx> {
45 /// Contains the definition for every region variable. Region
46 /// variables are identified by their index (`RegionVid`). The
47 /// definition contains information about where the region came
48 /// from as well as its final inferred value.
49 definitions: IndexVec<RegionVid, RegionDefinition<'tcx>>,
51 /// The liveness constraints added to each region. For most
52 /// regions, these start out empty and steadily grow, though for
53 /// each universally quantified region R they start out containing
54 /// the entire CFG and `end(R)`.
55 liveness_constraints: LivenessValues<RegionVid>,
57 /// The outlives constraints computed by the type-check.
58 constraints: Rc<OutlivesConstraintSet>,
60 /// The constraint-set, but in graph form, making it easy to traverse
61 /// the constraints adjacent to a particular region. Used to construct
62 /// the SCC (see `constraint_sccs`) and for error reporting.
63 constraint_graph: Rc<NormalConstraintGraph>,
65 /// The SCC computed from `constraints` and the constraint
66 /// graph. We have an edge from SCC A to SCC B if `A: B`. Used to
67 /// compute the values of each region.
68 constraint_sccs: Rc<Sccs<RegionVid, ConstraintSccIndex>>,
70 /// Reverse of the SCC constraint graph -- i.e., an edge `A -> B`
71 /// exists if `B: A`. Computed lazilly.
72 rev_constraint_graph: Option<Rc<VecGraph<ConstraintSccIndex>>>,
74 /// The "pick R0 from [R1..Rn]" constraints, indexed by SCC.
75 pick_constraints: Rc<PickConstraintSet<'tcx, ConstraintSccIndex>>,
77 /// Map closure bounds to a `Span` that should be used for error reporting.
78 closure_bounds_mapping:
79 FxHashMap<Location, FxHashMap<(RegionVid, RegionVid), (ConstraintCategory, Span)>>,
81 /// Contains the minimum universe of any variable within the same
82 /// SCC. We will ensure that no SCC contains values that are not
83 /// visible from this index.
84 scc_universes: IndexVec<ConstraintSccIndex, ty::UniverseIndex>,
86 /// Contains a "representative" from each SCC. This will be the
87 /// minimal RegionVid belonging to that universe. It is used as a
88 /// kind of hacky way to manage checking outlives relationships,
89 /// since we can 'canonicalize' each region to the representative
90 /// of its SCC and be sure that -- if they have the same repr --
91 /// they *must* be equal (though not having the same repr does not
92 /// mean they are unequal).
93 scc_representatives: IndexVec<ConstraintSccIndex, ty::RegionVid>,
95 /// The final inferred values of the region variables; we compute
96 /// one value per SCC. To get the value for any given *region*,
97 /// you first find which scc it is a part of.
98 scc_values: RegionValues<ConstraintSccIndex>,
100 /// Type constraints that we check after solving.
101 type_tests: Vec<TypeTest<'tcx>>,
103 /// Information about the universally quantified regions in scope
104 /// on this function.
105 universal_regions: Rc<UniversalRegions<'tcx>>,
107 /// Information about how the universally quantified regions in
108 /// scope on this function relate to one another.
109 universal_region_relations: Rc<UniversalRegionRelations<'tcx>>,
112 struct RegionDefinition<'tcx> {
113 /// What kind of variable is this -- a free region? existential
114 /// variable? etc. (See the `NLLRegionVariableOrigin` for more
116 origin: NLLRegionVariableOrigin,
118 /// Which universe is this region variable defined in? This is
119 /// most often `ty::UniverseIndex::ROOT`, but when we encounter
120 /// forall-quantifiers like `for<'a> { 'a = 'b }`, we would create
121 /// the variable for `'a` in a fresh universe that extends ROOT.
122 universe: ty::UniverseIndex,
124 /// If this is 'static or an early-bound region, then this is
125 /// `Some(X)` where `X` is the name of the region.
126 external_name: Option<ty::Region<'tcx>>,
129 /// N.B., the variants in `Cause` are intentionally ordered. Lower
130 /// values are preferred when it comes to error messages. Do not
131 /// reorder willy nilly.
132 #[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
133 pub(crate) enum Cause {
134 /// point inserted because Local was live at the given Location
135 LiveVar(Local, Location),
137 /// point inserted because Local was dropped at the given Location
138 DropVar(Local, Location),
141 /// A "type test" corresponds to an outlives constraint between a type
142 /// and a lifetime, like `T: 'x` or `<T as Foo>::Bar: 'x`. They are
143 /// translated from the `Verify` region constraints in the ordinary
144 /// inference context.
146 /// These sorts of constraints are handled differently than ordinary
147 /// constraints, at least at present. During type checking, the
148 /// `InferCtxt::process_registered_region_obligations` method will
149 /// attempt to convert a type test like `T: 'x` into an ordinary
150 /// outlives constraint when possible (for example, `&'a T: 'b` will
151 /// be converted into `'a: 'b` and registered as a `Constraint`).
153 /// In some cases, however, there are outlives relationships that are
154 /// not converted into a region constraint, but rather into one of
155 /// these "type tests". The distinction is that a type test does not
156 /// influence the inference result, but instead just examines the
157 /// values that we ultimately inferred for each region variable and
158 /// checks that they meet certain extra criteria. If not, an error
161 /// One reason for this is that these type tests typically boil down
162 /// to a check like `'a: 'x` where `'a` is a universally quantified
163 /// region -- and therefore not one whose value is really meant to be
164 /// *inferred*, precisely (this is not always the case: one can have a
165 /// type test like `<Foo as Trait<'?0>>::Bar: 'x`, where `'?0` is an
166 /// inference variable). Another reason is that these type tests can
167 /// involve *disjunction* -- that is, they can be satisfied in more
170 /// For more information about this translation, see
171 /// `InferCtxt::process_registered_region_obligations` and
172 /// `InferCtxt::type_must_outlive` in `rustc::infer::outlives`.
173 #[derive(Clone, Debug)]
174 pub struct TypeTest<'tcx> {
175 /// The type `T` that must outlive the region.
176 pub generic_kind: GenericKind<'tcx>,
178 /// The region `'x` that the type must outlive.
179 pub lower_bound: RegionVid,
181 /// Where did this constraint arise and why?
182 pub locations: Locations,
184 /// A test which, if met by the region `'x`, proves that this type
185 /// constraint is satisfied.
186 pub verify_bound: VerifyBound<'tcx>,
189 impl<'tcx> RegionInferenceContext<'tcx> {
190 /// Creates a new region inference context with a total of
191 /// `num_region_variables` valid inference variables; the first N
192 /// of those will be constant regions representing the free
193 /// regions defined in `universal_regions`.
195 /// The `outlives_constraints` and `type_tests` are an initial set
196 /// of constraints produced by the MIR type check.
199 universal_regions: Rc<UniversalRegions<'tcx>>,
200 placeholder_indices: Rc<PlaceholderIndices>,
201 universal_region_relations: Rc<UniversalRegionRelations<'tcx>>,
203 outlives_constraints: OutlivesConstraintSet,
204 pick_constraints_in: PickConstraintSet<'tcx, RegionVid>,
205 closure_bounds_mapping: FxHashMap<
207 FxHashMap<(RegionVid, RegionVid), (ConstraintCategory, Span)>,
209 type_tests: Vec<TypeTest<'tcx>>,
210 liveness_constraints: LivenessValues<RegionVid>,
211 elements: &Rc<RegionValueElements>,
213 // Create a RegionDefinition for each inference variable.
214 let definitions: IndexVec<_, _> = var_infos
216 .map(|info| RegionDefinition::new(info.universe, info.origin))
219 let constraints = Rc::new(outlives_constraints); // freeze constraints
220 let constraint_graph = Rc::new(constraints.graph(definitions.len()));
221 let fr_static = universal_regions.fr_static;
222 let constraint_sccs = Rc::new(constraints.compute_sccs(&constraint_graph, fr_static));
225 RegionValues::new(elements, universal_regions.len(), &placeholder_indices);
227 for region in liveness_constraints.rows() {
228 let scc = constraint_sccs.scc(region);
229 scc_values.merge_liveness(scc, region, &liveness_constraints);
232 let scc_universes = Self::compute_scc_universes(&constraint_sccs, &definitions);
234 let scc_representatives = Self::compute_scc_representatives(&constraint_sccs, &definitions);
236 let pick_constraints = Rc::new(pick_constraints_in.into_mapped(|r| constraint_sccs.scc(r)));
238 let mut result = Self {
240 liveness_constraints,
244 rev_constraint_graph: None,
246 closure_bounds_mapping,
252 universal_region_relations,
255 result.init_free_and_bound_regions();
260 /// Each SCC is the combination of many region variables which
261 /// have been equated. Therefore, we can associate a universe with
262 /// each SCC which is minimum of all the universes of its
263 /// constituent regions -- this is because whatever value the SCC
264 /// takes on must be a value that each of the regions within the
265 /// SCC could have as well. This implies that the SCC must have
266 /// the minimum, or narrowest, universe.
267 fn compute_scc_universes(
268 constraints_scc: &Sccs<RegionVid, ConstraintSccIndex>,
269 definitions: &IndexVec<RegionVid, RegionDefinition<'tcx>>,
270 ) -> IndexVec<ConstraintSccIndex, ty::UniverseIndex> {
271 let num_sccs = constraints_scc.num_sccs();
272 let mut scc_universes = IndexVec::from_elem_n(ty::UniverseIndex::MAX, num_sccs);
274 for (region_vid, region_definition) in definitions.iter_enumerated() {
275 let scc = constraints_scc.scc(region_vid);
276 let scc_universe = &mut scc_universes[scc];
277 *scc_universe = ::std::cmp::min(*scc_universe, region_definition.universe);
280 debug!("compute_scc_universes: scc_universe = {:#?}", scc_universes);
285 /// For each SCC, we compute a unique `RegionVid` (in fact, the
286 /// minimal one that belongs to the SCC). See
287 /// `scc_representatives` field of `RegionInferenceContext` for
289 fn compute_scc_representatives(
290 constraints_scc: &Sccs<RegionVid, ConstraintSccIndex>,
291 definitions: &IndexVec<RegionVid, RegionDefinition<'tcx>>,
292 ) -> IndexVec<ConstraintSccIndex, ty::RegionVid> {
293 let num_sccs = constraints_scc.num_sccs();
294 let next_region_vid = definitions.next_index();
295 let mut scc_representatives = IndexVec::from_elem_n(next_region_vid, num_sccs);
297 for region_vid in definitions.indices() {
298 let scc = constraints_scc.scc(region_vid);
299 let prev_min = scc_representatives[scc];
300 scc_representatives[scc] = region_vid.min(prev_min);
306 /// Initializes the region variables for each universally
307 /// quantified region (lifetime parameter). The first N variables
308 /// always correspond to the regions appearing in the function
309 /// signature (both named and anonymous) and where-clauses. This
310 /// function iterates over those regions and initializes them with
315 /// fn foo<'a, 'b>(..) where 'a: 'b
317 /// would initialize two variables like so:
319 /// R0 = { CFG, R0 } // 'a
320 /// R1 = { CFG, R0, R1 } // 'b
322 /// Here, R0 represents `'a`, and it contains (a) the entire CFG
323 /// and (b) any universally quantified regions that it outlives,
324 /// which in this case is just itself. R1 (`'b`) in contrast also
325 /// outlives `'a` and hence contains R0 and R1.
326 fn init_free_and_bound_regions(&mut self) {
327 // Update the names (if any)
328 for (external_name, variable) in self.universal_regions.named_universal_regions() {
330 "init_universal_regions: region {:?} has external name {:?}",
331 variable, external_name
333 self.definitions[variable].external_name = Some(external_name);
336 for variable in self.definitions.indices() {
337 let scc = self.constraint_sccs.scc(variable);
339 match self.definitions[variable].origin {
340 NLLRegionVariableOrigin::FreeRegion => {
341 // For each free, universally quantified region X:
343 // Add all nodes in the CFG to liveness constraints
344 self.liveness_constraints.add_all_points(variable);
345 self.scc_values.add_all_points(scc);
347 // Add `end(X)` into the set for X.
348 self.scc_values.add_element(scc, variable);
351 NLLRegionVariableOrigin::Placeholder(placeholder) => {
352 // Each placeholder region is only visible from
353 // its universe `ui` and its extensions. So we
354 // can't just add it into `scc` unless the
355 // universe of the scc can name this region.
356 let scc_universe = self.scc_universes[scc];
357 if scc_universe.can_name(placeholder.universe) {
358 self.scc_values.add_element(scc, placeholder);
361 "init_free_and_bound_regions: placeholder {:?} is \
362 not compatible with universe {:?} of its SCC {:?}",
363 placeholder, scc_universe, scc,
365 self.add_incompatible_universe(scc);
369 NLLRegionVariableOrigin::Existential => {
370 // For existential, regions, nothing to do.
376 /// Returns an iterator over all the region indices.
377 pub fn regions(&self) -> impl Iterator<Item = RegionVid> {
378 self.definitions.indices()
381 /// Given a universal region in scope on the MIR, returns the
382 /// corresponding index.
384 /// (Panics if `r` is not a registered universal region.)
385 pub fn to_region_vid(&self, r: ty::Region<'tcx>) -> RegionVid {
386 self.universal_regions.to_region_vid(r)
389 /// Adds annotations for `#[rustc_regions]`; see `UniversalRegions::annotate`.
390 crate fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut DiagnosticBuilder<'_>) {
391 self.universal_regions.annotate(tcx, err)
394 /// Returns `true` if the region `r` contains the point `p`.
396 /// Panics if called before `solve()` executes,
397 crate fn region_contains(&self, r: impl ToRegionVid, p: impl ToElementIndex) -> bool {
398 let scc = self.constraint_sccs.scc(r.to_region_vid());
399 self.scc_values.contains(scc, p)
402 /// Returns access to the value of `r` for debugging purposes.
403 crate fn region_value_str(&self, r: RegionVid) -> String {
404 let scc = self.constraint_sccs.scc(r.to_region_vid());
405 self.scc_values.region_value_str(scc)
408 /// Returns access to the value of `r` for debugging purposes.
409 crate fn region_universe(&self, r: RegionVid) -> ty::UniverseIndex {
410 let scc = self.constraint_sccs.scc(r.to_region_vid());
411 self.scc_universes[scc]
414 /// Performs region inference and report errors if we see any
415 /// unsatisfiable constraints. If this is a closure, returns the
416 /// region requirements to propagate to our creator, if any.
419 infcx: &InferCtxt<'_, 'tcx>,
423 errors_buffer: &mut Vec<Diagnostic>,
424 ) -> Option<ClosureRegionRequirements<'tcx>> {
426 infcx.tcx.sess.time_extended(),
427 Some(infcx.tcx.sess),
428 &format!("solve_nll_region_constraints({:?})", mir_def_id),
429 || self.solve_inner(infcx, body, upvars, mir_def_id, errors_buffer),
435 infcx: &InferCtxt<'_, 'tcx>,
439 errors_buffer: &mut Vec<Diagnostic>,
440 ) -> Option<ClosureRegionRequirements<'tcx>> {
441 self.propagate_constraints(body);
443 // If this is a closure, we can propagate unsatisfied
444 // `outlives_requirements` to our creator, so create a vector
445 // to store those. Otherwise, we'll pass in `None` to the
446 // functions below, which will trigger them to report errors
448 let mut outlives_requirements =
449 if infcx.tcx.is_closure(mir_def_id) { Some(vec![]) } else { None };
451 self.check_type_tests(
455 outlives_requirements.as_mut(),
459 self.check_universal_regions(
464 outlives_requirements.as_mut(),
468 self.check_pick_constraints(infcx, mir_def_id, errors_buffer);
470 let outlives_requirements = outlives_requirements.unwrap_or(vec![]);
472 if outlives_requirements.is_empty() {
475 let num_external_vids = self.universal_regions.num_global_and_external_regions();
476 Some(ClosureRegionRequirements { num_external_vids, outlives_requirements })
480 /// Propagate the region constraints: this will grow the values
481 /// for each region variable until all the constraints are
482 /// satisfied. Note that some values may grow **too** large to be
483 /// feasible, but we check this later.
484 fn propagate_constraints(&mut self, _body: &Body<'tcx>) {
485 debug!("propagate_constraints()");
487 debug!("propagate_constraints: constraints={:#?}", {
488 let mut constraints: Vec<_> = self.constraints.outlives().iter().collect();
492 .map(|c| (c, self.constraint_sccs.scc(c.sup), self.constraint_sccs.scc(c.sub)))
496 // To propagate constraints, we walk the DAG induced by the
497 // SCC. For each SCC, we visit its successors and compute
498 // their values, then we union all those values to get our
500 let visited = &mut BitSet::new_empty(self.constraint_sccs.num_sccs());
501 for scc_index in self.constraint_sccs.all_sccs() {
502 self.propagate_constraint_sccs_if_new(scc_index, visited);
506 /// Computes the value of the SCC `scc_a` if it has not already
507 /// been computed. The `visited` parameter is a bitset
509 fn propagate_constraint_sccs_if_new(
511 scc_a: ConstraintSccIndex,
512 visited: &mut BitSet<ConstraintSccIndex>,
514 if visited.insert(scc_a) {
515 self.propagate_constraint_sccs_new(scc_a, visited);
519 /// Computes the value of the SCC `scc_a`, which has not yet been
520 /// computed. This works by first computing all successors of the
521 /// SCC (if they haven't been computed already) and then unioning
522 /// together their elements.
523 fn propagate_constraint_sccs_new(
525 scc_a: ConstraintSccIndex,
526 visited: &mut BitSet<ConstraintSccIndex>,
528 let constraint_sccs = self.constraint_sccs.clone();
530 // Walk each SCC `B` such that `A: B`...
531 for &scc_b in constraint_sccs.successors(scc_a) {
532 debug!("propagate_constraint_sccs: scc_a = {:?} scc_b = {:?}", scc_a, scc_b);
534 // ...compute the value of `B`...
535 self.propagate_constraint_sccs_if_new(scc_b, visited);
537 // ...and add elements from `B` into `A`. One complication
538 // arises because of universes: If `B` contains something
539 // that `A` cannot name, then `A` can only contain `B` if
540 // it outlives static.
541 if self.universe_compatible(scc_b, scc_a) {
542 // `A` can name everything that is in `B`, so just
544 self.scc_values.add_region(scc_a, scc_b);
546 self.add_incompatible_universe(scc_a);
550 // Now take pick constraints into account
551 let pick_constraints = self.pick_constraints.clone();
552 for p_c_i in pick_constraints.indices(scc_a) {
553 self.apply_pick_constraint(scc_a, pick_constraints.option_regions(p_c_i));
557 "propagate_constraint_sccs: scc_a = {:?} has value {:?}",
559 self.scc_values.region_value_str(scc_a),
563 /// Invoked for each `pick R0 from [R1..Rn]` constraint.
565 /// `scc` is the SCC containing R0, and `option_regions` are the
566 /// `R1..Rn` regions -- they are always known to be universal
567 /// regions (and if that's not true, we just don't attempt to
568 /// enforce the constraint).
570 /// The current value of `scc` at the time the method is invoked
571 /// is considered a *lower bound*. If possible, we will modify
572 /// the constraint to set it equal to one of the option regions.
573 /// If we make any changes, returns true, else false.
574 fn apply_pick_constraint(
576 scc: ConstraintSccIndex,
577 option_regions: &[ty::RegionVid],
579 debug!("apply_pick_constraint(scc={:?}, option_regions={:#?})", scc, option_regions,);
582 option_regions.iter().find(|&&r| !self.universal_regions.is_universal_region(r))
584 debug!("apply_pick_constraint: option region `{:?}` is not a universal region", uh_oh);
588 // Create a mutable vector of the options. We'll try to winnow
590 let mut option_regions: Vec<ty::RegionVid> = option_regions.to_vec();
592 // The 'pick-region' in a pick-constraint is part of the
593 // hidden type, which must be in the root universe. Therefore,
594 // it cannot have any placeholders in its value.
595 assert!(self.scc_universes[scc] == ty::UniverseIndex::ROOT);
597 self.scc_values.placeholders_contained_in(scc).next().is_none(),
598 "scc {:?} in a pick-constraint has placeholder value: {:?}",
600 self.scc_values.region_value_str(scc),
603 // The existing value for `scc` is a lower-bound. This will
604 // consist of some set {P} + {LB} of points {P} and
605 // lower-bound free regions {LB}. As each option region O is a
606 // free region, it will outlive the points. But we can only
607 // consider the option O if O: LB.
608 option_regions.retain(|&o_r| {
610 .universal_regions_outlived_by(scc)
611 .all(|lb| self.universal_region_relations.outlives(o_r, lb))
613 debug!("apply_pick_constraint: after lb, option_regions={:?}", option_regions);
615 // Now find all the *upper bounds* -- that is, each UB is a free
616 // region that must outlive pick region R0 (`UB: R0`). Therefore,
617 // we need only keep an option O if `UB: O` for all UB.
618 if option_regions.len() > 1 {
619 let universal_region_relations = self.universal_region_relations.clone();
620 for ub in self.upper_bounds(scc) {
621 debug!("apply_pick_constraint: ub={:?}", ub);
622 option_regions.retain(|&o_r| universal_region_relations.outlives(ub, o_r));
624 debug!("apply_pick_constraint: after ub, option_regions={:?}", option_regions);
627 // If we ruled everything out, we're done.
628 if option_regions.is_empty() {
632 // Otherwise, we need to find the minimum option, if any, and take that.
633 debug!("apply_pick_constraint: option_regions remaining are {:#?}", option_regions);
634 let min = |r1: ty::RegionVid, r2: ty::RegionVid| -> Option<ty::RegionVid> {
635 let r1_outlives_r2 = self.universal_region_relations.outlives(r1, r2);
636 let r2_outlives_r1 = self.universal_region_relations.outlives(r2, r1);
637 if r1_outlives_r2 && r2_outlives_r1 {
639 } else if r1_outlives_r2 {
641 } else if r2_outlives_r1 {
647 let mut best_option = option_regions[0];
648 for &other_option in &option_regions[1..] {
650 "apply_pick_constraint: best_option={:?} other_option={:?}",
651 best_option, other_option,
653 match min(best_option, other_option) {
654 Some(m) => best_option = m,
657 "apply_pick_constraint: {:?} and {:?} are incomparable --> no best choice",
658 best_option, other_option,
665 let best_option_scc = self.constraint_sccs.scc(best_option);
667 "apply_pick_constraint: best_choice={:?} best_option_scc={:?}",
671 self.scc_values.add_region(scc, best_option_scc)
674 /// Compute and return the reverse SCC-based constraint graph (lazilly).
677 scc0: ConstraintSccIndex,
678 ) -> Vec<RegionVid> {
679 // I wanted to return an `impl Iterator` here, but it's
680 // annoying because the `rev_constraint_graph` is in a local
681 // variable. We'd need a "once-cell" or some such thing to let
682 // us borrow it for the right amount of time.
683 let rev_constraint_graph = self.rev_constraint_graph();
684 let scc_values = &self.scc_values;
685 let mut duplicates = FxHashSet::default();
687 .depth_first_search(scc0)
689 .flat_map(|scc1| scc_values.universal_regions_outlived_by(scc1))
690 .filter(|&r| duplicates.insert(r))
694 /// Compute and return the reverse SCC-based constraint graph (lazilly).
695 fn rev_constraint_graph(
697 ) -> Rc<VecGraph<ConstraintSccIndex>> {
698 if let Some(g) = &self.rev_constraint_graph {
702 let rev_graph = Rc::new(self.constraint_sccs.reverse());
703 self.rev_constraint_graph = Some(rev_graph.clone());
707 /// Returns `true` if all the elements in the value of `scc_b` are nameable
708 /// in `scc_a`. Used during constraint propagation, and only once
709 /// the value of `scc_b` has been computed.
710 fn universe_compatible(&self, scc_b: ConstraintSccIndex, scc_a: ConstraintSccIndex) -> bool {
711 let universe_a = self.scc_universes[scc_a];
713 // Quick check: if scc_b's declared universe is a subset of
714 // scc_a's declared univese (typically, both are ROOT), then
715 // it cannot contain any problematic universe elements.
716 if universe_a.can_name(self.scc_universes[scc_b]) {
720 // Otherwise, we have to iterate over the universe elements in
721 // B's value, and check whether all of them are nameable
723 self.scc_values.placeholders_contained_in(scc_b).all(|p| universe_a.can_name(p.universe))
726 /// Extend `scc` so that it can outlive some placeholder region
727 /// from a universe it can't name; at present, the only way for
728 /// this to be true is if `scc` outlives `'static`. This is
729 /// actually stricter than necessary: ideally, we'd support bounds
730 /// like `for<'a: 'b`>` that might then allow us to approximate
731 /// `'a` with `'b` and not `'static`. But it will have to do for
733 fn add_incompatible_universe(&mut self, scc: ConstraintSccIndex) {
734 debug!("add_incompatible_universe(scc={:?})", scc);
736 let fr_static = self.universal_regions.fr_static;
737 self.scc_values.add_all_points(scc);
738 self.scc_values.add_element(scc, fr_static);
741 /// Once regions have been propagated, this method is used to see
742 /// whether the "type tests" produced by typeck were satisfied;
743 /// type tests encode type-outlives relationships like `T:
744 /// 'a`. See `TypeTest` for more details.
747 infcx: &InferCtxt<'_, 'tcx>,
750 mut propagated_outlives_requirements: Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
751 errors_buffer: &mut Vec<Diagnostic>,
755 // Sometimes we register equivalent type-tests that would
756 // result in basically the exact same error being reported to
757 // the user. Avoid that.
758 let mut deduplicate_errors = FxHashSet::default();
760 for type_test in &self.type_tests {
761 debug!("check_type_test: {:?}", type_test);
763 let generic_ty = type_test.generic_kind.to_ty(tcx);
764 if self.eval_verify_bound(
768 type_test.lower_bound,
769 &type_test.verify_bound,
774 if let Some(propagated_outlives_requirements) = &mut propagated_outlives_requirements {
775 if self.try_promote_type_test(
779 propagated_outlives_requirements,
785 // Type-test failed. Report the error.
787 // Try to convert the lower-bound region into something named we can print for the user.
788 let lower_bound_region = self.to_error_region(type_test.lower_bound);
790 // Skip duplicate-ish errors.
791 let type_test_span = type_test.locations.span(body);
792 let erased_generic_kind = tcx.erase_regions(&type_test.generic_kind);
793 if !deduplicate_errors.insert((
801 "check_type_test: reporting error for erased_generic_kind={:?}, \
802 lower_bound_region={:?}, \
803 type_test.locations={:?}",
804 erased_generic_kind, lower_bound_region, type_test.locations,
808 if let Some(lower_bound_region) = lower_bound_region {
809 let region_scope_tree = &tcx.region_scope_tree(mir_def_id);
811 .construct_generic_bound_failure(
815 type_test.generic_kind,
818 .buffer(errors_buffer);
820 // FIXME. We should handle this case better. It
821 // indicates that we have e.g., some region variable
822 // whose value is like `'a+'b` where `'a` and `'b` are
823 // distinct unrelated univesal regions that are not
824 // known to outlive one another. It'd be nice to have
825 // some examples where this arises to decide how best
826 // to report it; we could probably handle it by
827 // iterating over the universal regions and reporting
828 // an error that multiple bounds are required.
832 &format!("`{}` does not live long enough", type_test.generic_kind,),
834 .buffer(errors_buffer);
839 /// Converts a region inference variable into a `ty::Region` that
840 /// we can use for error reporting. If `r` is universally bound,
841 /// then we use the name that we have on record for it. If `r` is
842 /// existentially bound, then we check its inferred value and try
843 /// to find a good name from that. Returns `None` if we can't find
844 /// one (e.g., this is just some random part of the CFG).
845 pub fn to_error_region(&self, r: RegionVid) -> Option<ty::Region<'tcx>> {
846 self.to_error_region_vid(r).and_then(|r| self.definitions[r].external_name)
849 /// Returns the [RegionVid] corresponding to the region returned by
850 /// `to_error_region`.
851 pub fn to_error_region_vid(&self, r: RegionVid) -> Option<RegionVid> {
852 if self.universal_regions.is_universal_region(r) {
855 let r_scc = self.constraint_sccs.scc(r);
856 let upper_bound = self.universal_upper_bound(r);
857 if self.scc_values.contains(r_scc, upper_bound) {
858 self.to_error_region_vid(upper_bound)
865 /// Invoked when we have some type-test (e.g., `T: 'X`) that we cannot
866 /// prove to be satisfied. If this is a closure, we will attempt to
867 /// "promote" this type-test into our `ClosureRegionRequirements` and
868 /// hence pass it up the creator. To do this, we have to phrase the
869 /// type-test in terms of external free regions, as local free
870 /// regions are not nameable by the closure's creator.
872 /// Promotion works as follows: we first check that the type `T`
873 /// contains only regions that the creator knows about. If this is
874 /// true, then -- as a consequence -- we know that all regions in
875 /// the type `T` are free regions that outlive the closure body. If
876 /// false, then promotion fails.
878 /// Once we've promoted T, we have to "promote" `'X` to some region
879 /// that is "external" to the closure. Generally speaking, a region
880 /// may be the union of some points in the closure body as well as
881 /// various free lifetimes. We can ignore the points in the closure
882 /// body: if the type T can be expressed in terms of external regions,
883 /// we know it outlives the points in the closure body. That
884 /// just leaves the free regions.
886 /// The idea then is to lower the `T: 'X` constraint into multiple
887 /// bounds -- e.g., if `'X` is the union of two free lifetimes,
888 /// `'1` and `'2`, then we would create `T: '1` and `T: '2`.
889 fn try_promote_type_test(
891 infcx: &InferCtxt<'_, 'tcx>,
893 type_test: &TypeTest<'tcx>,
894 propagated_outlives_requirements: &mut Vec<ClosureOutlivesRequirement<'tcx>>,
898 let TypeTest { generic_kind, lower_bound, locations, verify_bound: _ } = type_test;
900 let generic_ty = generic_kind.to_ty(tcx);
901 let subject = match self.try_promote_type_test_subject(infcx, generic_ty) {
903 None => return false,
906 // For each region outlived by lower_bound find a non-local,
907 // universal region (it may be the same region) and add it to
908 // `ClosureOutlivesRequirement`.
909 let r_scc = self.constraint_sccs.scc(*lower_bound);
910 for ur in self.scc_values.universal_regions_outlived_by(r_scc) {
911 // Check whether we can already prove that the "subject" outlives `ur`.
912 // If so, we don't have to propagate this requirement to our caller.
914 // To continue the example from the function, if we are trying to promote
915 // a requirement that `T: 'X`, and we know that `'X = '1 + '2` (i.e., the union
916 // `'1` and `'2`), then in this loop `ur` will be `'1` (and `'2`). So here
917 // we check whether `T: '1` is something we *can* prove. If so, no need
918 // to propagate that requirement.
920 // This is needed because -- particularly in the case
921 // where `ur` is a local bound -- we are sometimes in a
922 // position to prove things that our caller cannot. See
923 // #53570 for an example.
924 if self.eval_verify_bound(tcx, body, generic_ty, ur, &type_test.verify_bound) {
928 debug!("try_promote_type_test: ur={:?}", ur);
930 let non_local_ub = self.universal_region_relations.non_local_upper_bounds(&ur);
931 debug!("try_promote_type_test: non_local_ub={:?}", non_local_ub);
933 // This is slightly too conservative. To show T: '1, given `'2: '1`
934 // and `'3: '1` we only need to prove that T: '2 *or* T: '3, but to
935 // avoid potential non-determinism we approximate this by requiring
937 for &upper_bound in non_local_ub {
938 debug_assert!(self.universal_regions.is_universal_region(upper_bound));
939 debug_assert!(!self.universal_regions.is_local_free_region(upper_bound));
941 let requirement = ClosureOutlivesRequirement {
943 outlived_free_region: upper_bound,
944 blame_span: locations.span(body),
945 category: ConstraintCategory::Boring,
947 debug!("try_promote_type_test: pushing {:#?}", requirement);
948 propagated_outlives_requirements.push(requirement);
954 /// When we promote a type test `T: 'r`, we have to convert the
955 /// type `T` into something we can store in a query result (so
956 /// something allocated for `'tcx`). This is problematic if `ty`
957 /// contains regions. During the course of NLL region checking, we
958 /// will have replaced all of those regions with fresh inference
959 /// variables. To create a test subject, we want to replace those
960 /// inference variables with some region from the closure
961 /// signature -- this is not always possible, so this is a
962 /// fallible process. Presuming we do find a suitable region, we
963 /// will represent it with a `ReClosureBound`, which is a
964 /// `RegionKind` variant that can be allocated in the gcx.
965 fn try_promote_type_test_subject(
967 infcx: &InferCtxt<'_, 'tcx>,
969 ) -> Option<ClosureOutlivesSubject<'tcx>> {
972 debug!("try_promote_type_test_subject(ty = {:?})", ty);
974 let ty = tcx.fold_regions(&ty, &mut false, |r, _depth| {
975 let region_vid = self.to_region_vid(r);
977 // The challenge if this. We have some region variable `r`
978 // whose value is a set of CFG points and universal
979 // regions. We want to find if that set is *equivalent* to
980 // any of the named regions found in the closure.
982 // To do so, we compute the
983 // `non_local_universal_upper_bound`. This will be a
984 // non-local, universal region that is greater than `r`.
985 // However, it might not be *contained* within `r`, so
986 // then we further check whether this bound is contained
987 // in `r`. If so, we can say that `r` is equivalent to the
990 // Let's work through a few examples. For these, imagine
991 // that we have 3 non-local regions (I'll denote them as
992 // `'static`, `'a`, and `'b`, though of course in the code
993 // they would be represented with indices) where:
998 // First, let's assume that `r` is some existential
999 // variable with an inferred value `{'a, 'static}` (plus
1000 // some CFG nodes). In this case, the non-local upper
1001 // bound is `'static`, since that outlives `'a`. `'static`
1002 // is also a member of `r` and hence we consider `r`
1003 // equivalent to `'static` (and replace it with
1006 // Now let's consider the inferred value `{'a, 'b}`. This
1007 // means `r` is effectively `'a | 'b`. I'm not sure if
1008 // this can come about, actually, but assuming it did, we
1009 // would get a non-local upper bound of `'static`. Since
1010 // `'static` is not contained in `r`, we would fail to
1011 // find an equivalent.
1012 let upper_bound = self.non_local_universal_upper_bound(region_vid);
1013 if self.region_contains(region_vid, upper_bound) {
1014 tcx.mk_region(ty::ReClosureBound(upper_bound))
1016 // In the case of a failure, use a `ReVar`
1017 // result. This will cause the `lift` later on to
1022 debug!("try_promote_type_test_subject: folded ty = {:?}", ty);
1024 // `has_local_value` will only be true if we failed to promote some region.
1025 if ty.has_local_value() {
1029 Some(ClosureOutlivesSubject::Ty(ty))
1032 /// Given some universal or existential region `r`, finds a
1033 /// non-local, universal region `r+` that outlives `r` at entry to (and
1034 /// exit from) the closure. In the worst case, this will be
1037 /// This is used for two purposes. First, if we are propagated
1038 /// some requirement `T: r`, we can use this method to enlarge `r`
1039 /// to something we can encode for our creator (which only knows
1040 /// about non-local, universal regions). It is also used when
1041 /// encoding `T` as part of `try_promote_type_test_subject` (see
1042 /// that fn for details).
1044 /// This is based on the result `'y` of `universal_upper_bound`,
1045 /// except that it converts further takes the non-local upper
1046 /// bound of `'y`, so that the final result is non-local.
1047 fn non_local_universal_upper_bound(&self, r: RegionVid) -> RegionVid {
1048 debug!("non_local_universal_upper_bound(r={:?}={})", r, self.region_value_str(r));
1050 let lub = self.universal_upper_bound(r);
1052 // Grow further to get smallest universal region known to
1054 let non_local_lub = self.universal_region_relations.non_local_upper_bound(lub);
1056 debug!("non_local_universal_upper_bound: non_local_lub={:?}", non_local_lub);
1061 /// Returns a universally quantified region that outlives the
1062 /// value of `r` (`r` may be existentially or universally
1065 /// Since `r` is (potentially) an existential region, it has some
1066 /// value which may include (a) any number of points in the CFG
1067 /// and (b) any number of `end('x)` elements of universally
1068 /// quantified regions. To convert this into a single universal
1069 /// region we do as follows:
1071 /// - Ignore the CFG points in `'r`. All universally quantified regions
1072 /// include the CFG anyhow.
1073 /// - For each `end('x)` element in `'r`, compute the mutual LUB, yielding
1075 fn universal_upper_bound(&self, r: RegionVid) -> RegionVid {
1076 debug!("universal_upper_bound(r={:?}={})", r, self.region_value_str(r));
1078 // Find the smallest universal region that contains all other
1079 // universal regions within `region`.
1080 let mut lub = self.universal_regions.fr_fn_body;
1081 let r_scc = self.constraint_sccs.scc(r);
1082 for ur in self.scc_values.universal_regions_outlived_by(r_scc) {
1083 lub = self.universal_region_relations.postdom_upper_bound(lub, ur);
1086 debug!("universal_upper_bound: r={:?} lub={:?}", r, lub);
1091 /// Tests if `test` is true when applied to `lower_bound` at
1093 fn eval_verify_bound(
1097 generic_ty: Ty<'tcx>,
1098 lower_bound: RegionVid,
1099 verify_bound: &VerifyBound<'tcx>,
1101 debug!("eval_verify_bound(lower_bound={:?}, verify_bound={:?})", lower_bound, verify_bound);
1103 match verify_bound {
1104 VerifyBound::IfEq(test_ty, verify_bound1) => {
1105 self.eval_if_eq(tcx, body, generic_ty, lower_bound, test_ty, verify_bound1)
1108 VerifyBound::OutlivedBy(r) => {
1109 let r_vid = self.to_region_vid(r);
1110 self.eval_outlives(r_vid, lower_bound)
1113 VerifyBound::AnyBound(verify_bounds) => verify_bounds.iter().any(|verify_bound| {
1114 self.eval_verify_bound(tcx, body, generic_ty, lower_bound, verify_bound)
1117 VerifyBound::AllBounds(verify_bounds) => verify_bounds.iter().all(|verify_bound| {
1118 self.eval_verify_bound(tcx, body, generic_ty, lower_bound, verify_bound)
1127 generic_ty: Ty<'tcx>,
1128 lower_bound: RegionVid,
1130 verify_bound: &VerifyBound<'tcx>,
1132 let generic_ty_normalized = self.normalize_to_scc_representatives(tcx, generic_ty);
1133 let test_ty_normalized = self.normalize_to_scc_representatives(tcx, test_ty);
1134 if generic_ty_normalized == test_ty_normalized {
1135 self.eval_verify_bound(tcx, body, generic_ty, lower_bound, verify_bound)
1141 /// This is a conservative normalization procedure. It takes every
1142 /// free region in `value` and replaces it with the
1143 /// "representative" of its SCC (see `scc_representatives` field).
1144 /// We are guaranteed that if two values normalize to the same
1145 /// thing, then they are equal; this is a conservative check in
1146 /// that they could still be equal even if they normalize to
1147 /// different results. (For example, there might be two regions
1148 /// with the same value that are not in the same SCC).
1150 /// N.B., this is not an ideal approach and I would like to revisit
1151 /// it. However, it works pretty well in practice. In particular,
1152 /// this is needed to deal with projection outlives bounds like
1154 /// <T as Foo<'0>>::Item: '1
1156 /// In particular, this routine winds up being important when
1157 /// there are bounds like `where <T as Foo<'a>>::Item: 'b` in the
1158 /// environment. In this case, if we can show that `'0 == 'a`,
1159 /// and that `'b: '1`, then we know that the clause is
1160 /// satisfied. In such cases, particularly due to limitations of
1161 /// the trait solver =), we usually wind up with a where-clause like
1162 /// `T: Foo<'a>` in scope, which thus forces `'0 == 'a` to be added as
1163 /// a constraint, and thus ensures that they are in the same SCC.
1165 /// So why can't we do a more correct routine? Well, we could
1166 /// *almost* use the `relate_tys` code, but the way it is
1167 /// currently setup it creates inference variables to deal with
1168 /// higher-ranked things and so forth, and right now the inference
1169 /// context is not permitted to make more inference variables. So
1170 /// we use this kind of hacky solution.
1171 fn normalize_to_scc_representatives<T>(&self, tcx: TyCtxt<'tcx>, value: T) -> T
1173 T: TypeFoldable<'tcx>,
1175 tcx.fold_regions(&value, &mut false, |r, _db| {
1176 let vid = self.to_region_vid(r);
1177 let scc = self.constraint_sccs.scc(vid);
1178 let repr = self.scc_representatives[scc];
1179 tcx.mk_region(ty::ReVar(repr))
1183 // Evaluate whether `sup_region == sub_region`.
1184 fn eval_equal(&self, r1: RegionVid, r2: RegionVid) -> bool {
1185 self.eval_outlives(r1, r2) && self.eval_outlives(r2, r1)
1188 // Evaluate whether `sup_region: sub_region`.
1189 fn eval_outlives(&self, sup_region: RegionVid, sub_region: RegionVid) -> bool {
1190 debug!("eval_outlives({:?}: {:?})", sup_region, sub_region);
1193 "eval_outlives: sup_region's value = {:?} universal={:?}",
1194 self.region_value_str(sup_region),
1195 self.universal_regions.is_universal_region(sup_region),
1198 "eval_outlives: sub_region's value = {:?} universal={:?}",
1199 self.region_value_str(sub_region),
1200 self.universal_regions.is_universal_region(sub_region),
1203 let sub_region_scc = self.constraint_sccs.scc(sub_region);
1204 let sup_region_scc = self.constraint_sccs.scc(sup_region);
1206 // Both the `sub_region` and `sup_region` consist of the union
1207 // of some number of universal regions (along with the union
1208 // of various points in the CFG; ignore those points for
1209 // now). Therefore, the sup-region outlives the sub-region if,
1210 // for each universal region R1 in the sub-region, there
1211 // exists some region R2 in the sup-region that outlives R1.
1212 let universal_outlives =
1213 self.scc_values.universal_regions_outlived_by(sub_region_scc).all(|r1| {
1215 .universal_regions_outlived_by(sup_region_scc)
1216 .any(|r2| self.universal_region_relations.outlives(r2, r1))
1219 if !universal_outlives {
1223 // Now we have to compare all the points in the sub region and make
1224 // sure they exist in the sup region.
1226 if self.universal_regions.is_universal_region(sup_region) {
1227 // Micro-opt: universal regions contain all points.
1231 self.scc_values.contains_points(sup_region_scc, sub_region_scc)
1234 /// Once regions have been propagated, this method is used to see
1235 /// whether any of the constraints were too strong. In particular,
1236 /// we want to check for a case where a universally quantified
1237 /// region exceeded its bounds. Consider:
1239 /// fn foo<'a, 'b>(x: &'a u32) -> &'b u32 { x }
1241 /// In this case, returning `x` requires `&'a u32 <: &'b u32`
1242 /// and hence we establish (transitively) a constraint that
1243 /// `'a: 'b`. The `propagate_constraints` code above will
1244 /// therefore add `end('a)` into the region for `'b` -- but we
1245 /// have no evidence that `'b` outlives `'a`, so we want to report
1248 /// If `propagated_outlives_requirements` is `Some`, then we will
1249 /// push unsatisfied obligations into there. Otherwise, we'll
1250 /// report them as errors.
1251 fn check_universal_regions(
1253 infcx: &InferCtxt<'_, 'tcx>,
1257 mut propagated_outlives_requirements: Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
1258 errors_buffer: &mut Vec<Diagnostic>,
1260 for (fr, fr_definition) in self.definitions.iter_enumerated() {
1261 match fr_definition.origin {
1262 NLLRegionVariableOrigin::FreeRegion => {
1263 // Go through each of the universal regions `fr` and check that
1264 // they did not grow too large, accumulating any requirements
1265 // for our caller into the `outlives_requirements` vector.
1266 self.check_universal_region(
1272 &mut propagated_outlives_requirements,
1277 NLLRegionVariableOrigin::Placeholder(placeholder) => {
1278 self.check_bound_universal_region(infcx, body, mir_def_id, fr, placeholder);
1281 NLLRegionVariableOrigin::Existential => {
1282 // nothing to check here
1288 /// Checks the final value for the free region `fr` to see if it
1289 /// grew too large. In particular, examine what `end(X)` points
1290 /// wound up in `fr`'s final value; for each `end(X)` where `X !=
1291 /// fr`, we want to check that `fr: X`. If not, that's either an
1292 /// error, or something we have to propagate to our creator.
1294 /// Things that are to be propagated are accumulated into the
1295 /// `outlives_requirements` vector.
1296 fn check_universal_region(
1298 infcx: &InferCtxt<'_, 'tcx>,
1302 longer_fr: RegionVid,
1303 propagated_outlives_requirements: &mut Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
1304 errors_buffer: &mut Vec<Diagnostic>,
1306 debug!("check_universal_region(fr={:?})", longer_fr);
1308 let longer_fr_scc = self.constraint_sccs.scc(longer_fr);
1310 // Because this free region must be in the ROOT universe, we
1311 // know it cannot contain any bound universes.
1312 assert!(self.scc_universes[longer_fr_scc] == ty::UniverseIndex::ROOT);
1313 debug_assert!(self.scc_values.placeholders_contained_in(longer_fr_scc).next().is_none());
1315 // Only check all of the relations for the main representative of each
1316 // SCC, otherwise just check that we outlive said representative. This
1317 // reduces the number of redundant relations propagated out of
1319 // Note that the representative will be a universal region if there is
1320 // one in this SCC, so we will always check the representative here.
1321 let representative = self.scc_representatives[longer_fr_scc];
1322 if representative != longer_fr {
1323 self.check_universal_region_relation(
1330 propagated_outlives_requirements,
1336 // Find every region `o` such that `fr: o`
1337 // (because `fr` includes `end(o)`).
1338 for shorter_fr in self.scc_values.universal_regions_outlived_by(longer_fr_scc) {
1339 if let Some(ErrorReported) = self.check_universal_region_relation(
1346 propagated_outlives_requirements,
1349 // continuing to iterate just reports more errors than necessary
1355 fn check_universal_region_relation(
1357 longer_fr: RegionVid,
1358 shorter_fr: RegionVid,
1359 infcx: &InferCtxt<'_, 'tcx>,
1363 propagated_outlives_requirements: &mut Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,
1364 errors_buffer: &mut Vec<Diagnostic>,
1365 ) -> Option<ErrorReported> {
1366 // If it is known that `fr: o`, carry on.
1367 if self.universal_region_relations.outlives(longer_fr, shorter_fr) {
1372 "check_universal_region_relation: fr={:?} does not outlive shorter_fr={:?}",
1373 longer_fr, shorter_fr,
1376 if let Some(propagated_outlives_requirements) = propagated_outlives_requirements {
1377 // Shrink `longer_fr` until we find a non-local region (if we do).
1378 // We'll call it `fr-` -- it's ever so slightly smaller than
1381 if let Some(fr_minus) = self.universal_region_relations.non_local_lower_bound(longer_fr)
1383 debug!("check_universal_region: fr_minus={:?}", fr_minus);
1385 let blame_span_category =
1386 self.find_outlives_blame_span(body, longer_fr, shorter_fr);
1388 // Grow `shorter_fr` until we find some non-local regions. (We
1389 // always will.) We'll call them `shorter_fr+` -- they're ever
1390 // so slightly larger than `shorter_fr`.
1391 let shorter_fr_plus =
1392 self.universal_region_relations.non_local_upper_bounds(&shorter_fr);
1393 debug!("check_universal_region: shorter_fr_plus={:?}", shorter_fr_plus);
1394 for &&fr in &shorter_fr_plus {
1395 // Push the constraint `fr-: shorter_fr+`
1396 propagated_outlives_requirements.push(ClosureOutlivesRequirement {
1397 subject: ClosureOutlivesSubject::Region(fr_minus),
1398 outlived_free_region: fr,
1399 blame_span: blame_span_category.1,
1400 category: blame_span_category.0,
1407 // If we are not in a context where we can't propagate errors, or we
1408 // could not shrink `fr` to something smaller, then just report an
1411 // Note: in this case, we use the unapproximated regions to report the
1412 // error. This gives better error messages in some cases.
1413 self.report_error(body, upvars, infcx, mir_def_id, longer_fr, shorter_fr, errors_buffer);
1417 fn check_bound_universal_region(
1419 infcx: &InferCtxt<'_, 'tcx>,
1422 longer_fr: RegionVid,
1423 placeholder: ty::PlaceholderRegion,
1425 debug!("check_bound_universal_region(fr={:?}, placeholder={:?})", longer_fr, placeholder,);
1427 let longer_fr_scc = self.constraint_sccs.scc(longer_fr);
1428 debug!("check_bound_universal_region: longer_fr_scc={:?}", longer_fr_scc,);
1430 // If we have some bound universal region `'a`, then the only
1431 // elements it can contain is itself -- we don't know anything
1433 let error_element = match {
1434 self.scc_values.elements_contained_in(longer_fr_scc).find(|element| match element {
1435 RegionElement::Location(_) => true,
1436 RegionElement::RootUniversalRegion(_) => true,
1437 RegionElement::PlaceholderRegion(placeholder1) => placeholder != *placeholder1,
1443 debug!("check_bound_universal_region: error_element = {:?}", error_element);
1445 // Find the region that introduced this `error_element`.
1446 let error_region = match error_element {
1447 RegionElement::Location(l) => self.find_sub_region_live_at(longer_fr, l),
1448 RegionElement::RootUniversalRegion(r) => r,
1449 RegionElement::PlaceholderRegion(error_placeholder) => self
1452 .filter_map(|(r, definition)| match definition.origin {
1453 NLLRegionVariableOrigin::Placeholder(p) if p == error_placeholder => Some(r),
1460 // Find the code to blame for the fact that `longer_fr` outlives `error_fr`.
1461 let (_, span) = self.find_outlives_blame_span(body, longer_fr, error_region);
1463 // Obviously, this error message is far from satisfactory.
1464 // At present, though, it only appears in unit tests --
1465 // the AST-based checker uses a more conservative check,
1466 // so to even see this error, one must pass in a special
1468 let mut diag = infcx.tcx.sess.struct_span_err(span, "higher-ranked subtype error");
1472 fn check_pick_constraints(
1474 infcx: &InferCtxt<'_, 'tcx>,
1476 errors_buffer: &mut Vec<Diagnostic>, // TODO
1478 let pick_constraints = self.pick_constraints.clone();
1479 for p_c_i in pick_constraints.all_indices() {
1480 debug!("check_pick_constraint(p_c_i={:?})", p_c_i);
1481 let p_c = &pick_constraints[p_c_i];
1482 let pick_region_vid = p_c.pick_region_vid;
1483 debug!("check_pick_constraint: pick_region_vid={:?} with value {}", pick_region_vid, self.region_value_str(pick_region_vid));
1484 let option_regions = pick_constraints.option_regions(p_c_i);
1485 debug!("check_pick_constraint: option_regions={:?}", option_regions);
1487 // did the pick-region wind up equal to any of the option regions?
1488 if let Some(o) = option_regions.iter().find(|&&o_r| self.eval_equal(o_r, p_c.pick_region_vid)) {
1489 debug!("check_pick_constraint: evaluated as equal to {:?}", o);
1493 // if not, report an error
1494 let region_scope_tree = &infcx.tcx.region_scope_tree(mir_def_id);
1495 let pick_region = infcx.tcx.mk_region(ty::ReVar(pick_region_vid)); // XXX
1496 opaque_types::unexpected_hidden_region_diagnostic(
1498 Some(region_scope_tree),
1499 p_c.opaque_type_def_id,
1503 .buffer(errors_buffer);
1508 impl<'tcx> RegionDefinition<'tcx> {
1509 fn new(universe: ty::UniverseIndex, rv_origin: RegionVariableOrigin) -> Self {
1510 // Create a new region definition. Note that, for free
1511 // regions, the `external_name` field gets updated later in
1512 // `init_universal_regions`.
1514 let origin = match rv_origin {
1515 RegionVariableOrigin::NLL(origin) => origin,
1516 _ => NLLRegionVariableOrigin::Existential,
1519 Self { origin, universe, external_name: None }
1523 pub trait ClosureRegionRequirementsExt<'tcx> {
1524 fn apply_requirements(
1527 closure_def_id: DefId,
1528 closure_substs: SubstsRef<'tcx>,
1529 ) -> Vec<QueryOutlivesConstraint<'tcx>>;
1531 fn subst_closure_mapping<T>(
1534 closure_mapping: &IndexVec<RegionVid, ty::Region<'tcx>>,
1538 T: TypeFoldable<'tcx>;
1541 impl<'tcx> ClosureRegionRequirementsExt<'tcx> for ClosureRegionRequirements<'tcx> {
1542 /// Given an instance T of the closure type, this method
1543 /// instantiates the "extra" requirements that we computed for the
1544 /// closure into the inference context. This has the effect of
1545 /// adding new outlives obligations to existing variables.
1547 /// As described on `ClosureRegionRequirements`, the extra
1548 /// requirements are expressed in terms of regionvids that index
1549 /// into the free regions that appear on the closure type. So, to
1550 /// do this, we first copy those regions out from the type T into
1551 /// a vector. Then we can just index into that vector to extract
1552 /// out the corresponding region from T and apply the
1554 fn apply_requirements(
1557 closure_def_id: DefId,
1558 closure_substs: SubstsRef<'tcx>,
1559 ) -> Vec<QueryOutlivesConstraint<'tcx>> {
1561 "apply_requirements(closure_def_id={:?}, closure_substs={:?})",
1562 closure_def_id, closure_substs
1565 // Extract the values of the free regions in `closure_substs`
1566 // into a vector. These are the regions that we will be
1567 // relating to one another.
1568 let closure_mapping = &UniversalRegions::closure_mapping(
1571 self.num_external_vids,
1572 tcx.closure_base_def_id(closure_def_id),
1574 debug!("apply_requirements: closure_mapping={:?}", closure_mapping);
1576 // Create the predicates.
1577 self.outlives_requirements
1579 .map(|outlives_requirement| {
1580 let outlived_region = closure_mapping[outlives_requirement.outlived_free_region];
1582 match outlives_requirement.subject {
1583 ClosureOutlivesSubject::Region(region) => {
1584 let region = closure_mapping[region];
1586 "apply_requirements: region={:?} \
1587 outlived_region={:?} \
1588 outlives_requirement={:?}",
1589 region, outlived_region, outlives_requirement,
1591 ty::Binder::dummy(ty::OutlivesPredicate(region.into(), outlived_region))
1594 ClosureOutlivesSubject::Ty(ty) => {
1595 let ty = self.subst_closure_mapping(tcx, closure_mapping, &ty);
1597 "apply_requirements: ty={:?} \
1598 outlived_region={:?} \
1599 outlives_requirement={:?}",
1600 ty, outlived_region, outlives_requirement,
1602 ty::Binder::dummy(ty::OutlivesPredicate(ty.into(), outlived_region))
1609 fn subst_closure_mapping<T>(
1612 closure_mapping: &IndexVec<RegionVid, ty::Region<'tcx>>,
1616 T: TypeFoldable<'tcx>,
1618 tcx.fold_regions(value, &mut false, |r, _depth| {
1619 if let ty::ReClosureBound(vid) = r {
1620 closure_mapping[*vid]
1622 bug!("subst_closure_mapping: encountered non-closure bound free region {:?}", r)