1 use std
::collections
::VecDeque
;
4 use rustc_data_structures
::binary_search_util
;
5 use rustc_data_structures
::frozen
::Frozen
;
6 use rustc_data_structures
::fx
::{FxHashMap, FxHashSet}
;
7 use rustc_data_structures
::graph
::scc
::Sccs
;
8 use rustc_hir
::def_id
::DefId
;
9 use rustc_index
::vec
::IndexVec
;
10 use rustc_infer
::infer
::canonical
::QueryOutlivesConstraint
;
11 use rustc_infer
::infer
::region_constraints
::{GenericKind, VarInfos, VerifyBound}
;
12 use rustc_infer
::infer
::{InferCtxt, NLLRegionVariableOrigin, RegionVariableOrigin}
;
13 use rustc_middle
::mir
::{
14 Body
, ClosureOutlivesRequirement
, ClosureOutlivesSubject
, ClosureRegionRequirements
,
15 ConstraintCategory
, Local
, Location
,
17 use rustc_middle
::ty
::{self, subst::SubstsRef, RegionVid, Ty, TyCtxt, TypeFoldable}
;
20 use crate::borrow_check
::{
22 graph
::NormalConstraintGraph
, ConstraintSccIndex
, OutlivesConstraint
, OutlivesConstraintSet
,
24 diagnostics
::{RegionErrorKind, RegionErrors}
,
25 member_constraints
::{MemberConstraintSet, NllMemberConstraintIndex}
,
26 nll
::{PoloniusOutput, ToRegionVid}
,
27 region_infer
::reverse_sccs
::ReverseSccGraph
,
28 region_infer
::values
::{
29 LivenessValues
, PlaceholderIndices
, RegionElement
, RegionValueElements
, RegionValues
,
32 type_check
::{free_region_relations::UniversalRegionRelations, Locations}
,
33 universal_regions
::UniversalRegions
,
43 pub struct RegionInferenceContext
<'tcx
> {
44 /// Contains the definition for every region variable. Region
45 /// variables are identified by their index (`RegionVid`). The
46 /// definition contains information about where the region came
47 /// from as well as its final inferred value.
48 definitions
: IndexVec
<RegionVid
, RegionDefinition
<'tcx
>>,
50 /// The liveness constraints added to each region. For most
51 /// regions, these start out empty and steadily grow, though for
52 /// each universally quantified region R they start out containing
53 /// the entire CFG and `end(R)`.
54 liveness_constraints
: LivenessValues
<RegionVid
>,
56 /// The outlives constraints computed by the type-check.
57 constraints
: Frozen
<OutlivesConstraintSet
>,
59 /// The constraint-set, but in graph form, making it easy to traverse
60 /// the constraints adjacent to a particular region. Used to construct
61 /// the SCC (see `constraint_sccs`) and for error reporting.
62 constraint_graph
: Frozen
<NormalConstraintGraph
>,
64 /// The SCC computed from `constraints` and the constraint
65 /// graph. We have an edge from SCC A to SCC B if `A: B`. Used to
66 /// compute the values of each region.
67 constraint_sccs
: Rc
<Sccs
<RegionVid
, ConstraintSccIndex
>>,
69 /// Reverse of the SCC constraint graph -- i.e., an edge `A -> B` exists if
70 /// `B: A`. This is used to compute the universal regions that are required
71 /// to outlive a given SCC. Computed lazily.
72 rev_scc_graph
: Option
<Rc
<ReverseSccGraph
>>,
74 /// The "R0 member of [R1..Rn]" constraints, indexed by SCC.
75 member_constraints
: Rc
<MemberConstraintSet
<'tcx
, ConstraintSccIndex
>>,
77 /// Records the member constraints that we applied to each scc.
78 /// This is useful for error reporting. Once constraint
79 /// propagation is done, this vector is sorted according to
80 /// `member_region_scc`.
81 member_constraints_applied
: Vec
<AppliedMemberConstraint
>,
83 /// Map closure bounds to a `Span` that should be used for error reporting.
84 closure_bounds_mapping
:
85 FxHashMap
<Location
, FxHashMap
<(RegionVid
, RegionVid
), (ConstraintCategory
, Span
)>>,
87 /// Contains the minimum universe of any variable within the same
88 /// SCC. We will ensure that no SCC contains values that are not
89 /// visible from this index.
90 scc_universes
: IndexVec
<ConstraintSccIndex
, ty
::UniverseIndex
>,
92 /// Contains a "representative" from each SCC. This will be the
93 /// minimal RegionVid belonging to that universe. It is used as a
94 /// kind of hacky way to manage checking outlives relationships,
95 /// since we can 'canonicalize' each region to the representative
96 /// of its SCC and be sure that -- if they have the same repr --
97 /// they *must* be equal (though not having the same repr does not
98 /// mean they are unequal).
99 scc_representatives
: IndexVec
<ConstraintSccIndex
, ty
::RegionVid
>,
101 /// The final inferred values of the region variables; we compute
102 /// one value per SCC. To get the value for any given *region*,
103 /// you first find which scc it is a part of.
104 scc_values
: RegionValues
<ConstraintSccIndex
>,
106 /// Type constraints that we check after solving.
107 type_tests
: Vec
<TypeTest
<'tcx
>>,
109 /// Information about the universally quantified regions in scope
110 /// on this function.
111 universal_regions
: Rc
<UniversalRegions
<'tcx
>>,
113 /// Information about how the universally quantified regions in
114 /// scope on this function relate to one another.
115 universal_region_relations
: Frozen
<UniversalRegionRelations
<'tcx
>>,
118 /// Each time that `apply_member_constraint` is successful, it appends
119 /// one of these structs to the `member_constraints_applied` field.
120 /// This is used in error reporting to trace out what happened.
122 /// The way that `apply_member_constraint` works is that it effectively
123 /// adds a new lower bound to the SCC it is analyzing: so you wind up
124 /// with `'R: 'O` where `'R` is the pick-region and `'O` is the
125 /// minimal viable option.
126 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]
127 pub(crate) struct AppliedMemberConstraint
{
128 /// The SCC that was affected. (The "member region".)
130 /// The vector if `AppliedMemberConstraint` elements is kept sorted
132 pub(in crate::borrow_check
) member_region_scc
: ConstraintSccIndex
,
134 /// The "best option" that `apply_member_constraint` found -- this was
135 /// added as an "ad-hoc" lower-bound to `member_region_scc`.
136 pub(in crate::borrow_check
) min_choice
: ty
::RegionVid
,
138 /// The "member constraint index" -- we can find out details about
139 /// the constraint from
140 /// `set.member_constraints[member_constraint_index]`.
141 pub(in crate::borrow_check
) member_constraint_index
: NllMemberConstraintIndex
,
144 pub(crate) struct RegionDefinition
<'tcx
> {
145 /// What kind of variable is this -- a free region? existential
146 /// variable? etc. (See the `NLLRegionVariableOrigin` for more
148 pub(in crate::borrow_check
) origin
: NLLRegionVariableOrigin
,
150 /// Which universe is this region variable defined in? This is
151 /// most often `ty::UniverseIndex::ROOT`, but when we encounter
152 /// forall-quantifiers like `for<'a> { 'a = 'b }`, we would create
153 /// the variable for `'a` in a fresh universe that extends ROOT.
154 pub(in crate::borrow_check
) universe
: ty
::UniverseIndex
,
156 /// If this is 'static or an early-bound region, then this is
157 /// `Some(X)` where `X` is the name of the region.
158 pub(in crate::borrow_check
) external_name
: Option
<ty
::Region
<'tcx
>>,
161 /// N.B., the variants in `Cause` are intentionally ordered. Lower
162 /// values are preferred when it comes to error messages. Do not
163 /// reorder willy nilly.
164 #[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
165 pub(crate) enum Cause
{
166 /// point inserted because Local was live at the given Location
167 LiveVar(Local
, Location
),
169 /// point inserted because Local was dropped at the given Location
170 DropVar(Local
, Location
),
173 /// A "type test" corresponds to an outlives constraint between a type
174 /// and a lifetime, like `T: 'x` or `<T as Foo>::Bar: 'x`. They are
175 /// translated from the `Verify` region constraints in the ordinary
176 /// inference context.
178 /// These sorts of constraints are handled differently than ordinary
179 /// constraints, at least at present. During type checking, the
180 /// `InferCtxt::process_registered_region_obligations` method will
181 /// attempt to convert a type test like `T: 'x` into an ordinary
182 /// outlives constraint when possible (for example, `&'a T: 'b` will
183 /// be converted into `'a: 'b` and registered as a `Constraint`).
185 /// In some cases, however, there are outlives relationships that are
186 /// not converted into a region constraint, but rather into one of
187 /// these "type tests". The distinction is that a type test does not
188 /// influence the inference result, but instead just examines the
189 /// values that we ultimately inferred for each region variable and
190 /// checks that they meet certain extra criteria. If not, an error
193 /// One reason for this is that these type tests typically boil down
194 /// to a check like `'a: 'x` where `'a` is a universally quantified
195 /// region -- and therefore not one whose value is really meant to be
196 /// *inferred*, precisely (this is not always the case: one can have a
197 /// type test like `<Foo as Trait<'?0>>::Bar: 'x`, where `'?0` is an
198 /// inference variable). Another reason is that these type tests can
199 /// involve *disjunction* -- that is, they can be satisfied in more
202 /// For more information about this translation, see
203 /// `InferCtxt::process_registered_region_obligations` and
204 /// `InferCtxt::type_must_outlive` in `rustc_infer::infer::InferCtxt`.
205 #[derive(Clone, Debug)]
206 pub struct TypeTest
<'tcx
> {
207 /// The type `T` that must outlive the region.
208 pub generic_kind
: GenericKind
<'tcx
>,
210 /// The region `'x` that the type must outlive.
211 pub lower_bound
: RegionVid
,
213 /// Where did this constraint arise and why?
214 pub locations
: Locations
,
216 /// A test which, if met by the region `'x`, proves that this type
217 /// constraint is satisfied.
218 pub verify_bound
: VerifyBound
<'tcx
>,
221 /// When we have an unmet lifetime constraint, we try to propagate it outward (e.g. to a closure
222 /// environment). If we can't, it is an error.
223 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
224 enum RegionRelationCheckResult
{
230 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
233 FromOutlivesConstraint(OutlivesConstraint
),
237 impl<'tcx
> RegionInferenceContext
<'tcx
> {
238 /// Creates a new region inference context with a total of
239 /// `num_region_variables` valid inference variables; the first N
240 /// of those will be constant regions representing the free
241 /// regions defined in `universal_regions`.
243 /// The `outlives_constraints` and `type_tests` are an initial set
244 /// of constraints produced by the MIR type check.
245 pub(in crate::borrow_check
) fn new(
247 universal_regions
: Rc
<UniversalRegions
<'tcx
>>,
248 placeholder_indices
: Rc
<PlaceholderIndices
>,
249 universal_region_relations
: Frozen
<UniversalRegionRelations
<'tcx
>>,
250 outlives_constraints
: OutlivesConstraintSet
,
251 member_constraints_in
: MemberConstraintSet
<'tcx
, RegionVid
>,
252 closure_bounds_mapping
: FxHashMap
<
254 FxHashMap
<(RegionVid
, RegionVid
), (ConstraintCategory
, Span
)>,
256 type_tests
: Vec
<TypeTest
<'tcx
>>,
257 liveness_constraints
: LivenessValues
<RegionVid
>,
258 elements
: &Rc
<RegionValueElements
>,
260 // Create a RegionDefinition for each inference variable.
261 let definitions
: IndexVec
<_
, _
> = var_infos
263 .map(|info
| RegionDefinition
::new(info
.universe
, info
.origin
))
266 let constraints
= Frozen
::freeze(outlives_constraints
);
267 let constraint_graph
= Frozen
::freeze(constraints
.graph(definitions
.len()));
268 let fr_static
= universal_regions
.fr_static
;
269 let constraint_sccs
= Rc
::new(constraints
.compute_sccs(&constraint_graph
, fr_static
));
272 RegionValues
::new(elements
, universal_regions
.len(), &placeholder_indices
);
274 for region
in liveness_constraints
.rows() {
275 let scc
= constraint_sccs
.scc(region
);
276 scc_values
.merge_liveness(scc
, region
, &liveness_constraints
);
279 let scc_universes
= Self::compute_scc_universes(&constraint_sccs
, &definitions
);
281 let scc_representatives
= Self::compute_scc_representatives(&constraint_sccs
, &definitions
);
283 let member_constraints
=
284 Rc
::new(member_constraints_in
.into_mapped(|r
| constraint_sccs
.scc(r
)));
286 let mut result
= Self {
288 liveness_constraints
,
294 member_constraints_applied
: Vec
::new(),
295 closure_bounds_mapping
,
301 universal_region_relations
,
304 result
.init_free_and_bound_regions();
309 /// Each SCC is the combination of many region variables which
310 /// have been equated. Therefore, we can associate a universe with
311 /// each SCC which is minimum of all the universes of its
312 /// constituent regions -- this is because whatever value the SCC
313 /// takes on must be a value that each of the regions within the
314 /// SCC could have as well. This implies that the SCC must have
315 /// the minimum, or narrowest, universe.
316 fn compute_scc_universes(
317 constraint_sccs
: &Sccs
<RegionVid
, ConstraintSccIndex
>,
318 definitions
: &IndexVec
<RegionVid
, RegionDefinition
<'tcx
>>,
319 ) -> IndexVec
<ConstraintSccIndex
, ty
::UniverseIndex
> {
320 let num_sccs
= constraint_sccs
.num_sccs();
321 let mut scc_universes
= IndexVec
::from_elem_n(ty
::UniverseIndex
::MAX
, num_sccs
);
323 debug
!("compute_scc_universes()");
325 // For each region R in universe U, ensure that the universe for the SCC
326 // that contains R is "no bigger" than U. This effectively sets the universe
327 // for each SCC to be the minimum of the regions within.
328 for (region_vid
, region_definition
) in definitions
.iter_enumerated() {
329 let scc
= constraint_sccs
.scc(region_vid
);
330 let scc_universe
= &mut scc_universes
[scc
];
331 let scc_min
= std
::cmp
::min(region_definition
.universe
, *scc_universe
);
332 if scc_min
!= *scc_universe
{
333 *scc_universe
= scc_min
;
335 "compute_scc_universes: lowered universe of {scc:?} to {scc_min:?} \
336 because it contains {region_vid:?} in {region_universe:?}",
339 region_vid
= region_vid
,
340 region_universe
= region_definition
.universe
,
345 // Walk each SCC `A` and `B` such that `A: B`
346 // and ensure that universe(A) can see universe(B).
348 // This serves to enforce the 'empty/placeholder' hierarchy
349 // (described in more detail on `RegionKind`):
354 // empty(U0) placeholder(U1)
359 // In particular, imagine we have variables R0 in U0 and R1
360 // created in U1, and constraints like this;
363 // R1: !1 // R1 outlives the placeholder in U1
364 // R1: R0 // R1 outlives R0
367 // Here, we wish for R1 to be `'static`, because it
368 // cannot outlive `placeholder(U1)` and `empty(U0)` any other way.
370 // Thanks to this loop, what happens is that the `R1: R0`
371 // constraint lowers the universe of `R1` to `U0`, which in turn
372 // means that the `R1: !1` constraint will (later) cause
373 // `R1` to become `'static`.
374 for scc_a
in constraint_sccs
.all_sccs() {
375 for &scc_b
in constraint_sccs
.successors(scc_a
) {
376 let scc_universe_a
= scc_universes
[scc_a
];
377 let scc_universe_b
= scc_universes
[scc_b
];
378 let scc_universe_min
= std
::cmp
::min(scc_universe_a
, scc_universe_b
);
379 if scc_universe_a
!= scc_universe_min
{
380 scc_universes
[scc_a
] = scc_universe_min
;
383 "compute_scc_universes: lowered universe of {scc_a:?} to {scc_universe_min:?} \
384 because {scc_a:?}: {scc_b:?} and {scc_b:?} is in universe {scc_universe_b:?}",
387 scc_universe_min
= scc_universe_min
,
388 scc_universe_b
= scc_universe_b
394 debug
!("compute_scc_universes: scc_universe = {:#?}", scc_universes
);
399 /// For each SCC, we compute a unique `RegionVid` (in fact, the
400 /// minimal one that belongs to the SCC). See
401 /// `scc_representatives` field of `RegionInferenceContext` for
403 fn compute_scc_representatives(
404 constraints_scc
: &Sccs
<RegionVid
, ConstraintSccIndex
>,
405 definitions
: &IndexVec
<RegionVid
, RegionDefinition
<'tcx
>>,
406 ) -> IndexVec
<ConstraintSccIndex
, ty
::RegionVid
> {
407 let num_sccs
= constraints_scc
.num_sccs();
408 let next_region_vid
= definitions
.next_index();
409 let mut scc_representatives
= IndexVec
::from_elem_n(next_region_vid
, num_sccs
);
411 for region_vid
in definitions
.indices() {
412 let scc
= constraints_scc
.scc(region_vid
);
413 let prev_min
= scc_representatives
[scc
];
414 scc_representatives
[scc
] = region_vid
.min(prev_min
);
420 /// Initializes the region variables for each universally
421 /// quantified region (lifetime parameter). The first N variables
422 /// always correspond to the regions appearing in the function
423 /// signature (both named and anonymous) and where-clauses. This
424 /// function iterates over those regions and initializes them with
429 /// fn foo<'a, 'b>(..) where 'a: 'b
431 /// would initialize two variables like so:
433 /// R0 = { CFG, R0 } // 'a
434 /// R1 = { CFG, R0, R1 } // 'b
436 /// Here, R0 represents `'a`, and it contains (a) the entire CFG
437 /// and (b) any universally quantified regions that it outlives,
438 /// which in this case is just itself. R1 (`'b`) in contrast also
439 /// outlives `'a` and hence contains R0 and R1.
440 fn init_free_and_bound_regions(&mut self) {
441 // Update the names (if any)
442 for (external_name
, variable
) in self.universal_regions
.named_universal_regions() {
444 "init_universal_regions: region {:?} has external name {:?}",
445 variable
, external_name
447 self.definitions
[variable
].external_name
= Some(external_name
);
450 for variable
in self.definitions
.indices() {
451 let scc
= self.constraint_sccs
.scc(variable
);
453 match self.definitions
[variable
].origin
{
454 NLLRegionVariableOrigin
::FreeRegion
=> {
455 // For each free, universally quantified region X:
457 // Add all nodes in the CFG to liveness constraints
458 self.liveness_constraints
.add_all_points(variable
);
459 self.scc_values
.add_all_points(scc
);
461 // Add `end(X)` into the set for X.
462 self.scc_values
.add_element(scc
, variable
);
465 NLLRegionVariableOrigin
::Placeholder(placeholder
) => {
466 // Each placeholder region is only visible from
467 // its universe `ui` and its extensions. So we
468 // can't just add it into `scc` unless the
469 // universe of the scc can name this region.
470 let scc_universe
= self.scc_universes
[scc
];
471 if scc_universe
.can_name(placeholder
.universe
) {
472 self.scc_values
.add_element(scc
, placeholder
);
475 "init_free_and_bound_regions: placeholder {:?} is \
476 not compatible with universe {:?} of its SCC {:?}",
477 placeholder
, scc_universe
, scc
,
479 self.add_incompatible_universe(scc
);
483 NLLRegionVariableOrigin
::RootEmptyRegion
484 | NLLRegionVariableOrigin
::Existential { .. }
=> {
485 // For existential, regions, nothing to do.
491 /// Returns an iterator over all the region indices.
492 pub fn regions(&self) -> impl Iterator
<Item
= RegionVid
> {
493 self.definitions
.indices()
496 /// Given a universal region in scope on the MIR, returns the
497 /// corresponding index.
499 /// (Panics if `r` is not a registered universal region.)
500 pub fn to_region_vid(&self, r
: ty
::Region
<'tcx
>) -> RegionVid
{
501 self.universal_regions
.to_region_vid(r
)
504 /// Adds annotations for `#[rustc_regions]`; see `UniversalRegions::annotate`.
505 crate fn annotate(&self, tcx
: TyCtxt
<'tcx
>, err
: &mut rustc_errors
::DiagnosticBuilder
<'_
>) {
506 self.universal_regions
.annotate(tcx
, err
)
509 /// Returns `true` if the region `r` contains the point `p`.
511 /// Panics if called before `solve()` executes,
512 crate fn region_contains(&self, r
: impl ToRegionVid
, p
: impl ToElementIndex
) -> bool
{
513 let scc
= self.constraint_sccs
.scc(r
.to_region_vid());
514 self.scc_values
.contains(scc
, p
)
517 /// Returns access to the value of `r` for debugging purposes.
518 crate fn region_value_str(&self, r
: RegionVid
) -> String
{
519 let scc
= self.constraint_sccs
.scc(r
.to_region_vid());
520 self.scc_values
.region_value_str(scc
)
523 /// Returns access to the value of `r` for debugging purposes.
524 crate fn region_universe(&self, r
: RegionVid
) -> ty
::UniverseIndex
{
525 let scc
= self.constraint_sccs
.scc(r
.to_region_vid());
526 self.scc_universes
[scc
]
529 /// Once region solving has completed, this function will return
530 /// the member constraints that were applied to the value of a given
531 /// region `r`. See `AppliedMemberConstraint`.
532 pub(in crate::borrow_check
) fn applied_member_constraints(
535 ) -> &[AppliedMemberConstraint
] {
536 let scc
= self.constraint_sccs
.scc(r
.to_region_vid());
537 binary_search_util
::binary_search_slice(
538 &self.member_constraints_applied
,
539 |applied
| applied
.member_region_scc
,
544 /// Performs region inference and report errors if we see any
545 /// unsatisfiable constraints. If this is a closure, returns the
546 /// region requirements to propagate to our creator, if any.
549 infcx
: &InferCtxt
<'_
, 'tcx
>,
552 polonius_output
: Option
<Rc
<PoloniusOutput
>>,
553 ) -> (Option
<ClosureRegionRequirements
<'tcx
>>, RegionErrors
<'tcx
>) {
554 self.propagate_constraints(body
);
556 let mut errors_buffer
= RegionErrors
::new();
558 // If this is a closure, we can propagate unsatisfied
559 // `outlives_requirements` to our creator, so create a vector
560 // to store those. Otherwise, we'll pass in `None` to the
561 // functions below, which will trigger them to report errors
563 let mut outlives_requirements
= infcx
.tcx
.is_closure(mir_def_id
).then(Vec
::new
);
565 self.check_type_tests(infcx
, body
, outlives_requirements
.as_mut(), &mut errors_buffer
);
567 // In Polonius mode, the errors about missing universal region relations are in the output
568 // and need to be emitted or propagated. Otherwise, we need to check whether the
569 // constraints were too strong, and if so, emit or propagate those errors.
570 if infcx
.tcx
.sess
.opts
.debugging_opts
.polonius
{
571 self.check_polonius_subset_errors(
573 outlives_requirements
.as_mut(),
575 polonius_output
.expect("Polonius output is unavailable despite `-Z polonius`"),
578 self.check_universal_regions(body
, outlives_requirements
.as_mut(), &mut errors_buffer
);
581 if errors_buffer
.is_empty() {
582 self.check_member_constraints(infcx
, &mut errors_buffer
);
585 let outlives_requirements
= outlives_requirements
.unwrap_or(vec
![]);
587 if outlives_requirements
.is_empty() {
588 (None
, errors_buffer
)
590 let num_external_vids
= self.universal_regions
.num_global_and_external_regions();
592 Some(ClosureRegionRequirements { num_external_vids, outlives_requirements }
),
598 /// Propagate the region constraints: this will grow the values
599 /// for each region variable until all the constraints are
600 /// satisfied. Note that some values may grow **too** large to be
601 /// feasible, but we check this later.
602 fn propagate_constraints(&mut self, _body
: &Body
<'tcx
>) {
603 debug
!("propagate_constraints()");
605 debug
!("propagate_constraints: constraints={:#?}", {
606 let mut constraints
: Vec
<_
> = self.constraints
.outlives().iter().collect();
610 .map(|c
| (c
, self.constraint_sccs
.scc(c
.sup
), self.constraint_sccs
.scc(c
.sub
)))
614 // To propagate constraints, we walk the DAG induced by the
615 // SCC. For each SCC, we visit its successors and compute
616 // their values, then we union all those values to get our
618 let constraint_sccs
= self.constraint_sccs
.clone();
619 for scc
in constraint_sccs
.all_sccs() {
620 self.compute_value_for_scc(scc
);
623 // Sort the applied member constraints so we can binary search
624 // through them later.
625 self.member_constraints_applied
.sort_by_key(|applied
| applied
.member_region_scc
);
628 /// Computes the value of the SCC `scc_a`, which has not yet been
629 /// computed, by unioning the values of its successors.
630 /// Assumes that all successors have been computed already
631 /// (which is assured by iterating over SCCs in dependency order).
632 fn compute_value_for_scc(&mut self, scc_a
: ConstraintSccIndex
) {
633 let constraint_sccs
= self.constraint_sccs
.clone();
635 // Walk each SCC `B` such that `A: B`...
636 for &scc_b
in constraint_sccs
.successors(scc_a
) {
637 debug
!("propagate_constraint_sccs: scc_a = {:?} scc_b = {:?}", scc_a
, scc_b
);
639 // ...and add elements from `B` into `A`. One complication
640 // arises because of universes: If `B` contains something
641 // that `A` cannot name, then `A` can only contain `B` if
642 // it outlives static.
643 if self.universe_compatible(scc_b
, scc_a
) {
644 // `A` can name everything that is in `B`, so just
646 self.scc_values
.add_region(scc_a
, scc_b
);
648 self.add_incompatible_universe(scc_a
);
652 // Now take member constraints into account.
653 let member_constraints
= self.member_constraints
.clone();
654 for m_c_i
in member_constraints
.indices(scc_a
) {
655 self.apply_member_constraint(scc_a
, m_c_i
, member_constraints
.choice_regions(m_c_i
));
659 "propagate_constraint_sccs: scc_a = {:?} has value {:?}",
661 self.scc_values
.region_value_str(scc_a
),
665 /// Invoked for each `R0 member of [R1..Rn]` constraint.
667 /// `scc` is the SCC containing R0, and `choice_regions` are the
668 /// `R1..Rn` regions -- they are always known to be universal
669 /// regions (and if that's not true, we just don't attempt to
670 /// enforce the constraint).
672 /// The current value of `scc` at the time the method is invoked
673 /// is considered a *lower bound*. If possible, we will modify
674 /// the constraint to set it equal to one of the option regions.
675 /// If we make any changes, returns true, else false.
676 fn apply_member_constraint(
678 scc
: ConstraintSccIndex
,
679 member_constraint_index
: NllMemberConstraintIndex
,
680 choice_regions
: &[ty
::RegionVid
],
682 debug
!("apply_member_constraint(scc={:?}, choice_regions={:#?})", scc
, choice_regions
,);
685 choice_regions
.iter().find(|&&r
| !self.universal_regions
.is_universal_region(r
))
687 // FIXME(#61773): This case can only occur with
688 // `impl_trait_in_bindings`, I believe, and we are just
689 // opting not to handle it for now. See #61773 for
692 "member constraint for `{:?}` has an option region `{:?}` \
693 that is not a universal region",
694 self.member_constraints
[member_constraint_index
].opaque_type_def_id
,
699 // Create a mutable vector of the options. We'll try to winnow
701 let mut choice_regions
: Vec
<ty
::RegionVid
> = choice_regions
.to_vec();
703 // The 'member region' in a member constraint is part of the
704 // hidden type, which must be in the root universe. Therefore,
705 // it cannot have any placeholders in its value.
706 assert
!(self.scc_universes
[scc
] == ty
::UniverseIndex
::ROOT
);
708 self.scc_values
.placeholders_contained_in(scc
).next().is_none(),
709 "scc {:?} in a member constraint has placeholder value: {:?}",
711 self.scc_values
.region_value_str(scc
),
714 // The existing value for `scc` is a lower-bound. This will
715 // consist of some set `{P} + {LB}` of points `{P}` and
716 // lower-bound free regions `{LB}`. As each choice region `O`
717 // is a free region, it will outlive the points. But we can
718 // only consider the option `O` if `O: LB`.
719 choice_regions
.retain(|&o_r
| {
721 .universal_regions_outlived_by(scc
)
722 .all(|lb
| self.universal_region_relations
.outlives(o_r
, lb
))
724 debug
!("apply_member_constraint: after lb, choice_regions={:?}", choice_regions
);
726 // Now find all the *upper bounds* -- that is, each UB is a
727 // free region that must outlive the member region `R0` (`UB:
728 // R0`). Therefore, we need only keep an option `O` if `UB: O`
730 let rev_scc_graph
= self.reverse_scc_graph();
731 let universal_region_relations
= &self.universal_region_relations
;
732 for ub
in rev_scc_graph
.upper_bounds(scc
) {
733 debug
!("apply_member_constraint: ub={:?}", ub
);
734 choice_regions
.retain(|&o_r
| universal_region_relations
.outlives(ub
, o_r
));
736 debug
!("apply_member_constraint: after ub, choice_regions={:?}", choice_regions
);
738 // If we ruled everything out, we're done.
739 if choice_regions
.is_empty() {
743 // Otherwise, we need to find the minimum remaining choice, if
744 // any, and take that.
745 debug
!("apply_member_constraint: choice_regions remaining are {:#?}", choice_regions
);
746 let min
= |r1
: ty
::RegionVid
, r2
: ty
::RegionVid
| -> Option
<ty
::RegionVid
> {
747 let r1_outlives_r2
= self.universal_region_relations
.outlives(r1
, r2
);
748 let r2_outlives_r1
= self.universal_region_relations
.outlives(r2
, r1
);
749 match (r1_outlives_r2
, r2_outlives_r1
) {
750 (true, true) => Some(r1
.min(r2
)),
751 (true, false) => Some(r2
),
752 (false, true) => Some(r1
),
753 (false, false) => None
,
756 let mut min_choice
= choice_regions
[0];
757 for &other_option
in &choice_regions
[1..] {
759 "apply_member_constraint: min_choice={:?} other_option={:?}",
760 min_choice
, other_option
,
762 match min(min_choice
, other_option
) {
763 Some(m
) => min_choice
= m
,
766 "apply_member_constraint: {:?} and {:?} are incomparable; no min choice",
767 min_choice
, other_option
,
774 let min_choice_scc
= self.constraint_sccs
.scc(min_choice
);
776 "apply_member_constraint: min_choice={:?} best_choice_scc={:?}",
777 min_choice
, min_choice_scc
,
779 if self.scc_values
.add_region(scc
, min_choice_scc
) {
780 self.member_constraints_applied
.push(AppliedMemberConstraint
{
781 member_region_scc
: scc
,
783 member_constraint_index
,
792 /// Returns `true` if all the elements in the value of `scc_b` are nameable
793 /// in `scc_a`. Used during constraint propagation, and only once
794 /// the value of `scc_b` has been computed.
795 fn universe_compatible(&self, scc_b
: ConstraintSccIndex
, scc_a
: ConstraintSccIndex
) -> bool
{
796 let universe_a
= self.scc_universes
[scc_a
];
798 // Quick check: if scc_b's declared universe is a subset of
799 // scc_a's declared univese (typically, both are ROOT), then
800 // it cannot contain any problematic universe elements.
801 if universe_a
.can_name(self.scc_universes
[scc_b
]) {
805 // Otherwise, we have to iterate over the universe elements in
806 // B's value, and check whether all of them are nameable
808 self.scc_values
.placeholders_contained_in(scc_b
).all(|p
| universe_a
.can_name(p
.universe
))
811 /// Extend `scc` so that it can outlive some placeholder region
812 /// from a universe it can't name; at present, the only way for
813 /// this to be true is if `scc` outlives `'static`. This is
814 /// actually stricter than necessary: ideally, we'd support bounds
815 /// like `for<'a: 'b`>` that might then allow us to approximate
816 /// `'a` with `'b` and not `'static`. But it will have to do for
818 fn add_incompatible_universe(&mut self, scc
: ConstraintSccIndex
) {
819 debug
!("add_incompatible_universe(scc={:?})", scc
);
821 let fr_static
= self.universal_regions
.fr_static
;
822 self.scc_values
.add_all_points(scc
);
823 self.scc_values
.add_element(scc
, fr_static
);
826 /// Once regions have been propagated, this method is used to see
827 /// whether the "type tests" produced by typeck were satisfied;
828 /// type tests encode type-outlives relationships like `T:
829 /// 'a`. See `TypeTest` for more details.
832 infcx
: &InferCtxt
<'_
, 'tcx
>,
834 mut propagated_outlives_requirements
: Option
<&mut Vec
<ClosureOutlivesRequirement
<'tcx
>>>,
835 errors_buffer
: &mut RegionErrors
<'tcx
>,
839 // Sometimes we register equivalent type-tests that would
840 // result in basically the exact same error being reported to
841 // the user. Avoid that.
842 let mut deduplicate_errors
= FxHashSet
::default();
844 for type_test
in &self.type_tests
{
845 debug
!("check_type_test: {:?}", type_test
);
847 let generic_ty
= type_test
.generic_kind
.to_ty(tcx
);
848 if self.eval_verify_bound(
852 type_test
.lower_bound
,
853 &type_test
.verify_bound
,
858 if let Some(propagated_outlives_requirements
) = &mut propagated_outlives_requirements
{
859 if self.try_promote_type_test(
863 propagated_outlives_requirements
,
869 // Type-test failed. Report the error.
870 let erased_generic_kind
= infcx
.tcx
.erase_regions(&type_test
.generic_kind
);
872 // Skip duplicate-ish errors.
873 if deduplicate_errors
.insert((
875 type_test
.lower_bound
,
879 "check_type_test: reporting error for erased_generic_kind={:?}, \
880 lower_bound_region={:?}, \
881 type_test.locations={:?}",
882 erased_generic_kind
, type_test
.lower_bound
, type_test
.locations
,
885 errors_buffer
.push(RegionErrorKind
::TypeTestError { type_test: type_test.clone() }
);
890 /// Invoked when we have some type-test (e.g., `T: 'X`) that we cannot
891 /// prove to be satisfied. If this is a closure, we will attempt to
892 /// "promote" this type-test into our `ClosureRegionRequirements` and
893 /// hence pass it up the creator. To do this, we have to phrase the
894 /// type-test in terms of external free regions, as local free
895 /// regions are not nameable by the closure's creator.
897 /// Promotion works as follows: we first check that the type `T`
898 /// contains only regions that the creator knows about. If this is
899 /// true, then -- as a consequence -- we know that all regions in
900 /// the type `T` are free regions that outlive the closure body. If
901 /// false, then promotion fails.
903 /// Once we've promoted T, we have to "promote" `'X` to some region
904 /// that is "external" to the closure. Generally speaking, a region
905 /// may be the union of some points in the closure body as well as
906 /// various free lifetimes. We can ignore the points in the closure
907 /// body: if the type T can be expressed in terms of external regions,
908 /// we know it outlives the points in the closure body. That
909 /// just leaves the free regions.
911 /// The idea then is to lower the `T: 'X` constraint into multiple
912 /// bounds -- e.g., if `'X` is the union of two free lifetimes,
913 /// `'1` and `'2`, then we would create `T: '1` and `T: '2`.
914 fn try_promote_type_test(
916 infcx
: &InferCtxt
<'_
, 'tcx
>,
918 type_test
: &TypeTest
<'tcx
>,
919 propagated_outlives_requirements
: &mut Vec
<ClosureOutlivesRequirement
<'tcx
>>,
923 let TypeTest { generic_kind, lower_bound, locations, verify_bound: _ }
= type_test
;
925 let generic_ty
= generic_kind
.to_ty(tcx
);
926 let subject
= match self.try_promote_type_test_subject(infcx
, generic_ty
) {
928 None
=> return false,
931 // For each region outlived by lower_bound find a non-local,
932 // universal region (it may be the same region) and add it to
933 // `ClosureOutlivesRequirement`.
934 let r_scc
= self.constraint_sccs
.scc(*lower_bound
);
935 for ur
in self.scc_values
.universal_regions_outlived_by(r_scc
) {
936 // Check whether we can already prove that the "subject" outlives `ur`.
937 // If so, we don't have to propagate this requirement to our caller.
939 // To continue the example from the function, if we are trying to promote
940 // a requirement that `T: 'X`, and we know that `'X = '1 + '2` (i.e., the union
941 // `'1` and `'2`), then in this loop `ur` will be `'1` (and `'2`). So here
942 // we check whether `T: '1` is something we *can* prove. If so, no need
943 // to propagate that requirement.
945 // This is needed because -- particularly in the case
946 // where `ur` is a local bound -- we are sometimes in a
947 // position to prove things that our caller cannot. See
948 // #53570 for an example.
949 if self.eval_verify_bound(tcx
, body
, generic_ty
, ur
, &type_test
.verify_bound
) {
953 debug
!("try_promote_type_test: ur={:?}", ur
);
955 let non_local_ub
= self.universal_region_relations
.non_local_upper_bounds(&ur
);
956 debug
!("try_promote_type_test: non_local_ub={:?}", non_local_ub
);
958 // This is slightly too conservative. To show T: '1, given `'2: '1`
959 // and `'3: '1` we only need to prove that T: '2 *or* T: '3, but to
960 // avoid potential non-determinism we approximate this by requiring
962 for &upper_bound
in non_local_ub
{
963 debug_assert
!(self.universal_regions
.is_universal_region(upper_bound
));
964 debug_assert
!(!self.universal_regions
.is_local_free_region(upper_bound
));
966 let requirement
= ClosureOutlivesRequirement
{
968 outlived_free_region
: upper_bound
,
969 blame_span
: locations
.span(body
),
970 category
: ConstraintCategory
::Boring
,
972 debug
!("try_promote_type_test: pushing {:#?}", requirement
);
973 propagated_outlives_requirements
.push(requirement
);
979 /// When we promote a type test `T: 'r`, we have to convert the
980 /// type `T` into something we can store in a query result (so
981 /// something allocated for `'tcx`). This is problematic if `ty`
982 /// contains regions. During the course of NLL region checking, we
983 /// will have replaced all of those regions with fresh inference
984 /// variables. To create a test subject, we want to replace those
985 /// inference variables with some region from the closure
986 /// signature -- this is not always possible, so this is a
987 /// fallible process. Presuming we do find a suitable region, we
988 /// will use it's *external name*, which will be a `RegionKind`
989 /// variant that can be used in query responses such as
991 fn try_promote_type_test_subject(
993 infcx
: &InferCtxt
<'_
, 'tcx
>,
995 ) -> Option
<ClosureOutlivesSubject
<'tcx
>> {
998 debug
!("try_promote_type_test_subject(ty = {:?})", ty
);
1000 let ty
= tcx
.fold_regions(&ty
, &mut false, |r
, _depth
| {
1001 let region_vid
= self.to_region_vid(r
);
1003 // The challenge if this. We have some region variable `r`
1004 // whose value is a set of CFG points and universal
1005 // regions. We want to find if that set is *equivalent* to
1006 // any of the named regions found in the closure.
1008 // To do so, we compute the
1009 // `non_local_universal_upper_bound`. This will be a
1010 // non-local, universal region that is greater than `r`.
1011 // However, it might not be *contained* within `r`, so
1012 // then we further check whether this bound is contained
1013 // in `r`. If so, we can say that `r` is equivalent to the
1016 // Let's work through a few examples. For these, imagine
1017 // that we have 3 non-local regions (I'll denote them as
1018 // `'static`, `'a`, and `'b`, though of course in the code
1019 // they would be represented with indices) where:
1024 // First, let's assume that `r` is some existential
1025 // variable with an inferred value `{'a, 'static}` (plus
1026 // some CFG nodes). In this case, the non-local upper
1027 // bound is `'static`, since that outlives `'a`. `'static`
1028 // is also a member of `r` and hence we consider `r`
1029 // equivalent to `'static` (and replace it with
1032 // Now let's consider the inferred value `{'a, 'b}`. This
1033 // means `r` is effectively `'a | 'b`. I'm not sure if
1034 // this can come about, actually, but assuming it did, we
1035 // would get a non-local upper bound of `'static`. Since
1036 // `'static` is not contained in `r`, we would fail to
1037 // find an equivalent.
1038 let upper_bound
= self.non_local_universal_upper_bound(region_vid
);
1039 if self.region_contains(region_vid
, upper_bound
) {
1040 self.definitions
[upper_bound
].external_name
.unwrap_or(r
)
1042 // In the case of a failure, use a `ReVar` result. This will
1043 // cause the `needs_infer` later on to return `None`.
1048 debug
!("try_promote_type_test_subject: folded ty = {:?}", ty
);
1050 // `needs_infer` will only be true if we failed to promote some region.
1051 if ty
.needs_infer() {
1055 Some(ClosureOutlivesSubject
::Ty(ty
))
1058 /// Given some universal or existential region `r`, finds a
1059 /// non-local, universal region `r+` that outlives `r` at entry to (and
1060 /// exit from) the closure. In the worst case, this will be
1063 /// This is used for two purposes. First, if we are propagated
1064 /// some requirement `T: r`, we can use this method to enlarge `r`
1065 /// to something we can encode for our creator (which only knows
1066 /// about non-local, universal regions). It is also used when
1067 /// encoding `T` as part of `try_promote_type_test_subject` (see
1068 /// that fn for details).
1070 /// This is based on the result `'y` of `universal_upper_bound`,
1071 /// except that it converts further takes the non-local upper
1072 /// bound of `'y`, so that the final result is non-local.
1073 fn non_local_universal_upper_bound(&self, r
: RegionVid
) -> RegionVid
{
1074 debug
!("non_local_universal_upper_bound(r={:?}={})", r
, self.region_value_str(r
));
1076 let lub
= self.universal_upper_bound(r
);
1078 // Grow further to get smallest universal region known to
1080 let non_local_lub
= self.universal_region_relations
.non_local_upper_bound(lub
);
1082 debug
!("non_local_universal_upper_bound: non_local_lub={:?}", non_local_lub
);
1087 /// Returns a universally quantified region that outlives the
1088 /// value of `r` (`r` may be existentially or universally
1091 /// Since `r` is (potentially) an existential region, it has some
1092 /// value which may include (a) any number of points in the CFG
1093 /// and (b) any number of `end('x)` elements of universally
1094 /// quantified regions. To convert this into a single universal
1095 /// region we do as follows:
1097 /// - Ignore the CFG points in `'r`. All universally quantified regions
1098 /// include the CFG anyhow.
1099 /// - For each `end('x)` element in `'r`, compute the mutual LUB, yielding
1101 pub(in crate::borrow_check
) fn universal_upper_bound(&self, r
: RegionVid
) -> RegionVid
{
1102 debug
!("universal_upper_bound(r={:?}={})", r
, self.region_value_str(r
));
1104 // Find the smallest universal region that contains all other
1105 // universal regions within `region`.
1106 let mut lub
= self.universal_regions
.fr_fn_body
;
1107 let r_scc
= self.constraint_sccs
.scc(r
);
1108 for ur
in self.scc_values
.universal_regions_outlived_by(r_scc
) {
1109 lub
= self.universal_region_relations
.postdom_upper_bound(lub
, ur
);
1112 debug
!("universal_upper_bound: r={:?} lub={:?}", r
, lub
);
1117 /// Tests if `test` is true when applied to `lower_bound` at
1119 fn eval_verify_bound(
1123 generic_ty
: Ty
<'tcx
>,
1124 lower_bound
: RegionVid
,
1125 verify_bound
: &VerifyBound
<'tcx
>,
1127 debug
!("eval_verify_bound(lower_bound={:?}, verify_bound={:?})", lower_bound
, verify_bound
);
1129 match verify_bound
{
1130 VerifyBound
::IfEq(test_ty
, verify_bound1
) => {
1131 self.eval_if_eq(tcx
, body
, generic_ty
, lower_bound
, test_ty
, verify_bound1
)
1134 VerifyBound
::IsEmpty
=> {
1135 let lower_bound_scc
= self.constraint_sccs
.scc(lower_bound
);
1136 self.scc_values
.elements_contained_in(lower_bound_scc
).next().is_none()
1139 VerifyBound
::OutlivedBy(r
) => {
1140 let r_vid
= self.to_region_vid(r
);
1141 self.eval_outlives(r_vid
, lower_bound
)
1144 VerifyBound
::AnyBound(verify_bounds
) => verify_bounds
.iter().any(|verify_bound
| {
1145 self.eval_verify_bound(tcx
, body
, generic_ty
, lower_bound
, verify_bound
)
1148 VerifyBound
::AllBounds(verify_bounds
) => verify_bounds
.iter().all(|verify_bound
| {
1149 self.eval_verify_bound(tcx
, body
, generic_ty
, lower_bound
, verify_bound
)
1158 generic_ty
: Ty
<'tcx
>,
1159 lower_bound
: RegionVid
,
1161 verify_bound
: &VerifyBound
<'tcx
>,
1163 let generic_ty_normalized
= self.normalize_to_scc_representatives(tcx
, generic_ty
);
1164 let test_ty_normalized
= self.normalize_to_scc_representatives(tcx
, test_ty
);
1165 if generic_ty_normalized
== test_ty_normalized
{
1166 self.eval_verify_bound(tcx
, body
, generic_ty
, lower_bound
, verify_bound
)
1172 /// This is a conservative normalization procedure. It takes every
1173 /// free region in `value` and replaces it with the
1174 /// "representative" of its SCC (see `scc_representatives` field).
1175 /// We are guaranteed that if two values normalize to the same
1176 /// thing, then they are equal; this is a conservative check in
1177 /// that they could still be equal even if they normalize to
1178 /// different results. (For example, there might be two regions
1179 /// with the same value that are not in the same SCC).
1181 /// N.B., this is not an ideal approach and I would like to revisit
1182 /// it. However, it works pretty well in practice. In particular,
1183 /// this is needed to deal with projection outlives bounds like
1185 /// <T as Foo<'0>>::Item: '1
1187 /// In particular, this routine winds up being important when
1188 /// there are bounds like `where <T as Foo<'a>>::Item: 'b` in the
1189 /// environment. In this case, if we can show that `'0 == 'a`,
1190 /// and that `'b: '1`, then we know that the clause is
1191 /// satisfied. In such cases, particularly due to limitations of
1192 /// the trait solver =), we usually wind up with a where-clause like
1193 /// `T: Foo<'a>` in scope, which thus forces `'0 == 'a` to be added as
1194 /// a constraint, and thus ensures that they are in the same SCC.
1196 /// So why can't we do a more correct routine? Well, we could
1197 /// *almost* use the `relate_tys` code, but the way it is
1198 /// currently setup it creates inference variables to deal with
1199 /// higher-ranked things and so forth, and right now the inference
1200 /// context is not permitted to make more inference variables. So
1201 /// we use this kind of hacky solution.
1202 fn normalize_to_scc_representatives
<T
>(&self, tcx
: TyCtxt
<'tcx
>, value
: T
) -> T
1204 T
: TypeFoldable
<'tcx
>,
1206 tcx
.fold_regions(&value
, &mut false, |r
, _db
| {
1207 let vid
= self.to_region_vid(r
);
1208 let scc
= self.constraint_sccs
.scc(vid
);
1209 let repr
= self.scc_representatives
[scc
];
1210 tcx
.mk_region(ty
::ReVar(repr
))
1214 // Evaluate whether `sup_region == sub_region`.
1215 fn eval_equal(&self, r1
: RegionVid
, r2
: RegionVid
) -> bool
{
1216 self.eval_outlives(r1
, r2
) && self.eval_outlives(r2
, r1
)
1219 // Evaluate whether `sup_region: sub_region`.
1220 fn eval_outlives(&self, sup_region
: RegionVid
, sub_region
: RegionVid
) -> bool
{
1221 debug
!("eval_outlives({:?}: {:?})", sup_region
, sub_region
);
1224 "eval_outlives: sup_region's value = {:?} universal={:?}",
1225 self.region_value_str(sup_region
),
1226 self.universal_regions
.is_universal_region(sup_region
),
1229 "eval_outlives: sub_region's value = {:?} universal={:?}",
1230 self.region_value_str(sub_region
),
1231 self.universal_regions
.is_universal_region(sub_region
),
1234 let sub_region_scc
= self.constraint_sccs
.scc(sub_region
);
1235 let sup_region_scc
= self.constraint_sccs
.scc(sup_region
);
1237 // Both the `sub_region` and `sup_region` consist of the union
1238 // of some number of universal regions (along with the union
1239 // of various points in the CFG; ignore those points for
1240 // now). Therefore, the sup-region outlives the sub-region if,
1241 // for each universal region R1 in the sub-region, there
1242 // exists some region R2 in the sup-region that outlives R1.
1243 let universal_outlives
=
1244 self.scc_values
.universal_regions_outlived_by(sub_region_scc
).all(|r1
| {
1246 .universal_regions_outlived_by(sup_region_scc
)
1247 .any(|r2
| self.universal_region_relations
.outlives(r2
, r1
))
1250 if !universal_outlives
{
1254 // Now we have to compare all the points in the sub region and make
1255 // sure they exist in the sup region.
1257 if self.universal_regions
.is_universal_region(sup_region
) {
1258 // Micro-opt: universal regions contain all points.
1262 self.scc_values
.contains_points(sup_region_scc
, sub_region_scc
)
1265 /// Once regions have been propagated, this method is used to see
1266 /// whether any of the constraints were too strong. In particular,
1267 /// we want to check for a case where a universally quantified
1268 /// region exceeded its bounds. Consider:
1270 /// fn foo<'a, 'b>(x: &'a u32) -> &'b u32 { x }
1272 /// In this case, returning `x` requires `&'a u32 <: &'b u32`
1273 /// and hence we establish (transitively) a constraint that
1274 /// `'a: 'b`. The `propagate_constraints` code above will
1275 /// therefore add `end('a)` into the region for `'b` -- but we
1276 /// have no evidence that `'b` outlives `'a`, so we want to report
1279 /// If `propagated_outlives_requirements` is `Some`, then we will
1280 /// push unsatisfied obligations into there. Otherwise, we'll
1281 /// report them as errors.
1282 fn check_universal_regions(
1285 mut propagated_outlives_requirements
: Option
<&mut Vec
<ClosureOutlivesRequirement
<'tcx
>>>,
1286 errors_buffer
: &mut RegionErrors
<'tcx
>,
1288 for (fr
, fr_definition
) in self.definitions
.iter_enumerated() {
1289 match fr_definition
.origin
{
1290 NLLRegionVariableOrigin
::FreeRegion
=> {
1291 // Go through each of the universal regions `fr` and check that
1292 // they did not grow too large, accumulating any requirements
1293 // for our caller into the `outlives_requirements` vector.
1294 self.check_universal_region(
1297 &mut propagated_outlives_requirements
,
1302 NLLRegionVariableOrigin
::Placeholder(placeholder
) => {
1303 self.check_bound_universal_region(fr
, placeholder
, errors_buffer
);
1306 NLLRegionVariableOrigin
::RootEmptyRegion
1307 | NLLRegionVariableOrigin
::Existential { .. }
=> {
1308 // nothing to check here
1314 /// Checks if Polonius has found any unexpected free region relations.
1316 /// In Polonius terms, a "subset error" (or "illegal subset relation error") is the equivalent
1317 /// of NLL's "checking if any region constraints were too strong": a placeholder origin `'a`
1318 /// was unexpectedly found to be a subset of another placeholder origin `'b`, and means in NLL
1319 /// terms that the "longer free region" `'a` outlived the "shorter free region" `'b`.
1321 /// More details can be found in this blog post by Niko:
1322 /// http://smallcultfollowing.com/babysteps/blog/2019/01/17/polonius-and-region-errors/
1324 /// In the canonical example
1326 /// fn foo<'a, 'b>(x: &'a u32) -> &'b u32 { x }
1328 /// returning `x` requires `&'a u32 <: &'b u32` and hence we establish (transitively) a
1329 /// constraint that `'a: 'b`. It is an error that we have no evidence that this
1330 /// constraint holds.
1332 /// If `propagated_outlives_requirements` is `Some`, then we will
1333 /// push unsatisfied obligations into there. Otherwise, we'll
1334 /// report them as errors.
1335 fn check_polonius_subset_errors(
1338 mut propagated_outlives_requirements
: Option
<&mut Vec
<ClosureOutlivesRequirement
<'tcx
>>>,
1339 errors_buffer
: &mut RegionErrors
<'tcx
>,
1340 polonius_output
: Rc
<PoloniusOutput
>,
1343 "check_polonius_subset_errors: {} subset_errors",
1344 polonius_output
.subset_errors
.len()
1347 // Similarly to `check_universal_regions`: a free region relation, which was not explicitly
1348 // declared ("known") was found by Polonius, so emit an error, or propagate the
1349 // requirements for our caller into the `propagated_outlives_requirements` vector.
1351 // Polonius doesn't model regions ("origins") as CFG-subsets or durations, but the
1352 // `longer_fr` and `shorter_fr` terminology will still be used here, for consistency with
1353 // the rest of the NLL infrastructure. The "subset origin" is the "longer free region",
1354 // and the "superset origin" is the outlived "shorter free region".
1356 // Note: Polonius will produce a subset error at every point where the unexpected
1357 // `longer_fr`'s "placeholder loan" is contained in the `shorter_fr`. This can be helpful
1358 // for diagnostics in the future, e.g. to point more precisely at the key locations
1359 // requiring this constraint to hold. However, the error and diagnostics code downstream
1360 // expects that these errors are not duplicated (and that they are in a certain order).
1361 // Otherwise, diagnostics messages such as the ones giving names like `'1` to elided or
1362 // anonymous lifetimes for example, could give these names differently, while others like
1363 // the outlives suggestions or the debug output from `#[rustc_regions]` would be
1364 // duplicated. The polonius subset errors are deduplicated here, while keeping the
1365 // CFG-location ordering.
1366 let mut subset_errors
: Vec
<_
> = polonius_output
1369 .flat_map(|(_location
, subset_errors
)| subset_errors
.iter())
1371 subset_errors
.sort();
1372 subset_errors
.dedup();
1374 for (longer_fr
, shorter_fr
) in subset_errors
.into_iter() {
1376 "check_polonius_subset_errors: subset_error longer_fr={:?},\
1378 longer_fr
, shorter_fr
1381 let propagated
= self.try_propagate_universal_region_error(
1385 &mut propagated_outlives_requirements
,
1387 if propagated
== RegionRelationCheckResult
::Error
{
1388 errors_buffer
.push(RegionErrorKind
::RegionError
{
1389 longer_fr
: *longer_fr
,
1390 shorter_fr
: *shorter_fr
,
1391 fr_origin
: NLLRegionVariableOrigin
::FreeRegion
,
1397 // Handle the placeholder errors as usual, until the chalk-rustc-polonius triumvirate has
1398 // a more complete picture on how to separate this responsibility.
1399 for (fr
, fr_definition
) in self.definitions
.iter_enumerated() {
1400 match fr_definition
.origin
{
1401 NLLRegionVariableOrigin
::FreeRegion
=> {
1402 // handled by polonius above
1405 NLLRegionVariableOrigin
::Placeholder(placeholder
) => {
1406 self.check_bound_universal_region(fr
, placeholder
, errors_buffer
);
1409 NLLRegionVariableOrigin
::RootEmptyRegion
1410 | NLLRegionVariableOrigin
::Existential { .. }
=> {
1411 // nothing to check here
1417 /// Checks the final value for the free region `fr` to see if it
1418 /// grew too large. In particular, examine what `end(X)` points
1419 /// wound up in `fr`'s final value; for each `end(X)` where `X !=
1420 /// fr`, we want to check that `fr: X`. If not, that's either an
1421 /// error, or something we have to propagate to our creator.
1423 /// Things that are to be propagated are accumulated into the
1424 /// `outlives_requirements` vector.
1425 fn check_universal_region(
1428 longer_fr
: RegionVid
,
1429 propagated_outlives_requirements
: &mut Option
<&mut Vec
<ClosureOutlivesRequirement
<'tcx
>>>,
1430 errors_buffer
: &mut RegionErrors
<'tcx
>,
1432 debug
!("check_universal_region(fr={:?})", longer_fr
);
1434 let longer_fr_scc
= self.constraint_sccs
.scc(longer_fr
);
1436 // Because this free region must be in the ROOT universe, we
1437 // know it cannot contain any bound universes.
1438 assert
!(self.scc_universes
[longer_fr_scc
] == ty
::UniverseIndex
::ROOT
);
1439 debug_assert
!(self.scc_values
.placeholders_contained_in(longer_fr_scc
).next().is_none());
1441 // Only check all of the relations for the main representative of each
1442 // SCC, otherwise just check that we outlive said representative. This
1443 // reduces the number of redundant relations propagated out of
1445 // Note that the representative will be a universal region if there is
1446 // one in this SCC, so we will always check the representative here.
1447 let representative
= self.scc_representatives
[longer_fr_scc
];
1448 if representative
!= longer_fr
{
1449 if let RegionRelationCheckResult
::Error
= self.check_universal_region_relation(
1453 propagated_outlives_requirements
,
1455 errors_buffer
.push(RegionErrorKind
::RegionError
{
1457 shorter_fr
: representative
,
1458 fr_origin
: NLLRegionVariableOrigin
::FreeRegion
,
1465 // Find every region `o` such that `fr: o`
1466 // (because `fr` includes `end(o)`).
1467 let mut error_reported
= false;
1468 for shorter_fr
in self.scc_values
.universal_regions_outlived_by(longer_fr_scc
) {
1469 if let RegionRelationCheckResult
::Error
= self.check_universal_region_relation(
1473 propagated_outlives_requirements
,
1475 // We only report the first region error. Subsequent errors are hidden so as
1476 // not to overwhelm the user, but we do record them so as to potentially print
1477 // better diagnostics elsewhere...
1478 errors_buffer
.push(RegionErrorKind
::RegionError
{
1481 fr_origin
: NLLRegionVariableOrigin
::FreeRegion
,
1482 is_reported
: !error_reported
,
1485 error_reported
= true;
1490 /// Checks that we can prove that `longer_fr: shorter_fr`. If we can't we attempt to propagate
1491 /// the constraint outward (e.g. to a closure environment), but if that fails, there is an
1493 fn check_universal_region_relation(
1495 longer_fr
: RegionVid
,
1496 shorter_fr
: RegionVid
,
1498 propagated_outlives_requirements
: &mut Option
<&mut Vec
<ClosureOutlivesRequirement
<'tcx
>>>,
1499 ) -> RegionRelationCheckResult
{
1500 // If it is known that `fr: o`, carry on.
1501 if self.universal_region_relations
.outlives(longer_fr
, shorter_fr
) {
1502 RegionRelationCheckResult
::Ok
1504 // If we are not in a context where we can't propagate errors, or we
1505 // could not shrink `fr` to something smaller, then just report an
1508 // Note: in this case, we use the unapproximated regions to report the
1509 // error. This gives better error messages in some cases.
1510 self.try_propagate_universal_region_error(
1514 propagated_outlives_requirements
,
1519 /// Attempt to propagate a region error (e.g. `'a: 'b`) that is not met to a closure's
1520 /// creator. If we cannot, then the caller should report an error to the user.
1521 fn try_propagate_universal_region_error(
1523 longer_fr
: RegionVid
,
1524 shorter_fr
: RegionVid
,
1526 propagated_outlives_requirements
: &mut Option
<&mut Vec
<ClosureOutlivesRequirement
<'tcx
>>>,
1527 ) -> RegionRelationCheckResult
{
1528 if let Some(propagated_outlives_requirements
) = propagated_outlives_requirements
{
1529 // Shrink `longer_fr` until we find a non-local region (if we do).
1530 // We'll call it `fr-` -- it's ever so slightly smaller than
1532 if let Some(fr_minus
) = self.universal_region_relations
.non_local_lower_bound(longer_fr
)
1534 debug
!("try_propagate_universal_region_error: fr_minus={:?}", fr_minus
);
1536 let blame_span_category
= self.find_outlives_blame_span(
1539 NLLRegionVariableOrigin
::FreeRegion
,
1543 // Grow `shorter_fr` until we find some non-local regions. (We
1544 // always will.) We'll call them `shorter_fr+` -- they're ever
1545 // so slightly larger than `shorter_fr`.
1546 let shorter_fr_plus
=
1547 self.universal_region_relations
.non_local_upper_bounds(&shorter_fr
);
1549 "try_propagate_universal_region_error: shorter_fr_plus={:?}",
1552 for &&fr
in &shorter_fr_plus
{
1553 // Push the constraint `fr-: shorter_fr+`
1554 propagated_outlives_requirements
.push(ClosureOutlivesRequirement
{
1555 subject
: ClosureOutlivesSubject
::Region(fr_minus
),
1556 outlived_free_region
: fr
,
1557 blame_span
: blame_span_category
.1,
1558 category
: blame_span_category
.0,
1561 return RegionRelationCheckResult
::Propagated
;
1565 RegionRelationCheckResult
::Error
1568 fn check_bound_universal_region(
1570 longer_fr
: RegionVid
,
1571 placeholder
: ty
::PlaceholderRegion
,
1572 errors_buffer
: &mut RegionErrors
<'tcx
>,
1574 debug
!("check_bound_universal_region(fr={:?}, placeholder={:?})", longer_fr
, placeholder
,);
1576 let longer_fr_scc
= self.constraint_sccs
.scc(longer_fr
);
1577 debug
!("check_bound_universal_region: longer_fr_scc={:?}", longer_fr_scc
,);
1579 // If we have some bound universal region `'a`, then the only
1580 // elements it can contain is itself -- we don't know anything
1582 let error_element
= match {
1583 self.scc_values
.elements_contained_in(longer_fr_scc
).find(|element
| match element
{
1584 RegionElement
::Location(_
) => true,
1585 RegionElement
::RootUniversalRegion(_
) => true,
1586 RegionElement
::PlaceholderRegion(placeholder1
) => placeholder
!= *placeholder1
,
1592 debug
!("check_bound_universal_region: error_element = {:?}", error_element
);
1594 // Find the region that introduced this `error_element`.
1595 errors_buffer
.push(RegionErrorKind
::BoundUniversalRegionError
{
1598 fr_origin
: NLLRegionVariableOrigin
::Placeholder(placeholder
),
1602 fn check_member_constraints(
1604 infcx
: &InferCtxt
<'_
, 'tcx
>,
1605 errors_buffer
: &mut RegionErrors
<'tcx
>,
1607 let member_constraints
= self.member_constraints
.clone();
1608 for m_c_i
in member_constraints
.all_indices() {
1609 debug
!("check_member_constraint(m_c_i={:?})", m_c_i
);
1610 let m_c
= &member_constraints
[m_c_i
];
1611 let member_region_vid
= m_c
.member_region_vid
;
1613 "check_member_constraint: member_region_vid={:?} with value {}",
1615 self.region_value_str(member_region_vid
),
1617 let choice_regions
= member_constraints
.choice_regions(m_c_i
);
1618 debug
!("check_member_constraint: choice_regions={:?}", choice_regions
);
1620 // Did the member region wind up equal to any of the option regions?
1622 choice_regions
.iter().find(|&&o_r
| self.eval_equal(o_r
, m_c
.member_region_vid
))
1624 debug
!("check_member_constraint: evaluated as equal to {:?}", o
);
1628 // If not, report an error.
1629 let member_region
= infcx
.tcx
.mk_region(ty
::ReVar(member_region_vid
));
1630 errors_buffer
.push(RegionErrorKind
::UnexpectedHiddenRegion
{
1631 span
: m_c
.definition_span
,
1632 hidden_ty
: m_c
.hidden_ty
,
1638 /// We have a constraint `fr1: fr2` that is not satisfied, where
1639 /// `fr2` represents some universal region. Here, `r` is some
1640 /// region where we know that `fr1: r` and this function has the
1641 /// job of determining whether `r` is "to blame" for the fact that
1642 /// `fr1: fr2` is required.
1644 /// This is true under two conditions:
1647 /// - `fr2` is `'static` and `r` is some placeholder in a universe
1648 /// that cannot be named by `fr1`; in that case, we will require
1649 /// that `fr1: 'static` because it is the only way to `fr1: r` to
1650 /// be satisfied. (See `add_incompatible_universe`.)
1651 crate fn provides_universal_region(
1657 debug
!("provides_universal_region(r={:?}, fr1={:?}, fr2={:?})", r
, fr1
, fr2
);
1660 fr2
== self.universal_regions
.fr_static
&& self.cannot_name_placeholder(fr1
, r
)
1663 debug
!("provides_universal_region: result = {:?}", result
);
1667 /// If `r2` represents a placeholder region, then this returns
1668 /// `true` if `r1` cannot name that placeholder in its
1669 /// value; otherwise, returns `false`.
1670 crate fn cannot_name_placeholder(&self, r1
: RegionVid
, r2
: RegionVid
) -> bool
{
1671 debug
!("cannot_name_value_of(r1={:?}, r2={:?})", r1
, r2
);
1673 match self.definitions
[r2
].origin
{
1674 NLLRegionVariableOrigin
::Placeholder(placeholder
) => {
1675 let universe1
= self.definitions
[r1
].universe
;
1677 "cannot_name_value_of: universe1={:?} placeholder={:?}",
1678 universe1
, placeholder
1680 universe1
.cannot_name(placeholder
.universe
)
1683 NLLRegionVariableOrigin
::RootEmptyRegion
1684 | NLLRegionVariableOrigin
::FreeRegion
1685 | NLLRegionVariableOrigin
::Existential { .. }
=> false,
1689 crate fn retrieve_closure_constraint_info(
1692 constraint
: &OutlivesConstraint
,
1693 ) -> (ConstraintCategory
, bool
, Span
) {
1694 let loc
= match constraint
.locations
{
1695 Locations
::All(span
) => return (constraint
.category
, false, span
),
1696 Locations
::Single(loc
) => loc
,
1699 let opt_span_category
=
1700 self.closure_bounds_mapping
[&loc
].get(&(constraint
.sup
, constraint
.sub
));
1701 opt_span_category
.map(|&(category
, span
)| (category
, true, span
)).unwrap_or((
1702 constraint
.category
,
1704 body
.source_info(loc
).span
,
1708 /// Finds a good span to blame for the fact that `fr1` outlives `fr2`.
1709 crate fn find_outlives_blame_span(
1713 fr1_origin
: NLLRegionVariableOrigin
,
1715 ) -> (ConstraintCategory
, Span
) {
1716 let (category
, _
, span
) = self.best_blame_constraint(body
, fr1
, fr1_origin
, |r
| {
1717 self.provides_universal_region(r
, fr1
, fr2
)
1722 /// Walks the graph of constraints (where `'a: 'b` is considered
1723 /// an edge `'a -> 'b`) to find all paths from `from_region` to
1724 /// `to_region`. The paths are accumulated into the vector
1725 /// `results`. The paths are stored as a series of
1726 /// `ConstraintIndex` values -- in other words, a list of *edges*.
1728 /// Returns: a series of constraints as well as the region `R`
1729 /// that passed the target test.
1730 crate fn find_constraint_paths_between_regions(
1732 from_region
: RegionVid
,
1733 target_test
: impl Fn(RegionVid
) -> bool
,
1734 ) -> Option
<(Vec
<OutlivesConstraint
>, RegionVid
)> {
1735 let mut context
= IndexVec
::from_elem(Trace
::NotVisited
, &self.definitions
);
1736 context
[from_region
] = Trace
::StartRegion
;
1738 // Use a deque so that we do a breadth-first search. We will
1739 // stop at the first match, which ought to be the shortest
1740 // path (fewest constraints).
1741 let mut deque
= VecDeque
::new();
1742 deque
.push_back(from_region
);
1744 while let Some(r
) = deque
.pop_front() {
1746 "find_constraint_paths_between_regions: from_region={:?} r={:?} value={}",
1749 self.region_value_str(r
),
1752 // Check if we reached the region we were looking for. If so,
1753 // we can reconstruct the path that led to it and return it.
1755 let mut result
= vec
![];
1759 Trace
::NotVisited
=> {
1760 bug
!("found unvisited region {:?} on path to {:?}", p
, r
)
1763 Trace
::FromOutlivesConstraint(c
) => {
1768 Trace
::StartRegion
=> {
1770 return Some((result
, r
));
1776 // Otherwise, walk over the outgoing constraints and
1777 // enqueue any regions we find, keeping track of how we
1780 // A constraint like `'r: 'x` can come from our constraint
1782 let fr_static
= self.universal_regions
.fr_static
;
1783 let outgoing_edges_from_graph
=
1784 self.constraint_graph
.outgoing_edges(r
, &self.constraints
, fr_static
);
1786 // Always inline this closure because it can be hot.
1787 let mut handle_constraint
= #[inline(always)]
1788 |constraint
: OutlivesConstraint
| {
1789 debug_assert_eq
!(constraint
.sup
, r
);
1790 let sub_region
= constraint
.sub
;
1791 if let Trace
::NotVisited
= context
[sub_region
] {
1792 context
[sub_region
] = Trace
::FromOutlivesConstraint(constraint
);
1793 deque
.push_back(sub_region
);
1797 // This loop can be hot.
1798 for constraint
in outgoing_edges_from_graph
{
1799 handle_constraint(constraint
);
1802 // Member constraints can also give rise to `'r: 'x` edges that
1803 // were not part of the graph initially, so watch out for those.
1804 // (But they are extremely rare; this loop is very cold.)
1805 for constraint
in self.applied_member_constraints(r
) {
1806 let p_c
= &self.member_constraints
[constraint
.member_constraint_index
];
1807 let constraint
= OutlivesConstraint
{
1809 sub
: constraint
.min_choice
,
1810 locations
: Locations
::All(p_c
.definition_span
),
1811 category
: ConstraintCategory
::OpaqueType
,
1813 handle_constraint(constraint
);
1820 /// Finds some region R such that `fr1: R` and `R` is live at `elem`.
1821 crate fn find_sub_region_live_at(&self, fr1
: RegionVid
, elem
: Location
) -> RegionVid
{
1822 debug
!("find_sub_region_live_at(fr1={:?}, elem={:?})", fr1
, elem
);
1823 debug
!("find_sub_region_live_at: {:?} is in scc {:?}", fr1
, self.constraint_sccs
.scc(fr1
));
1825 "find_sub_region_live_at: {:?} is in universe {:?}",
1827 self.scc_universes
[self.constraint_sccs
.scc(fr1
)]
1829 self.find_constraint_paths_between_regions(fr1
, |r
| {
1830 // First look for some `r` such that `fr1: r` and `r` is live at `elem`
1832 "find_sub_region_live_at: liveness_constraints for {:?} are {:?}",
1834 self.liveness_constraints
.region_value_str(r
),
1836 self.liveness_constraints
.contains(r
, elem
)
1839 // If we fail to find that, we may find some `r` such that
1840 // `fr1: r` and `r` is a placeholder from some universe
1841 // `fr1` cannot name. This would force `fr1` to be
1843 self.find_constraint_paths_between_regions(fr1
, |r
| {
1844 self.cannot_name_placeholder(fr1
, r
)
1848 // If we fail to find THAT, it may be that `fr1` is a
1849 // placeholder that cannot "fit" into its SCC. In that
1850 // case, there should be some `r` where `fr1: r` and `fr1` is a
1851 // placeholder that `r` cannot name. We can blame that
1854 // Remember that if `R1: R2`, then the universe of R1
1855 // must be able to name the universe of R2, because R2 will
1856 // be at least `'empty(Universe(R2))`, and `R1` must be at
1857 // larger than that.
1858 self.find_constraint_paths_between_regions(fr1
, |r
| {
1859 self.cannot_name_placeholder(r
, fr1
)
1862 .map(|(_path
, r
)| r
)
1866 /// Get the region outlived by `longer_fr` and live at `element`.
1867 crate fn region_from_element(&self, longer_fr
: RegionVid
, element
: RegionElement
) -> RegionVid
{
1869 RegionElement
::Location(l
) => self.find_sub_region_live_at(longer_fr
, l
),
1870 RegionElement
::RootUniversalRegion(r
) => r
,
1871 RegionElement
::PlaceholderRegion(error_placeholder
) => self
1874 .find_map(|(r
, definition
)| match definition
.origin
{
1875 NLLRegionVariableOrigin
::Placeholder(p
) if p
== error_placeholder
=> Some(r
),
1882 /// Get the region definition of `r`.
1883 crate fn region_definition(&self, r
: RegionVid
) -> &RegionDefinition
<'tcx
> {
1884 &self.definitions
[r
]
1887 /// Check if the SCC of `r` contains `upper`.
1888 crate fn upper_bound_in_region_scc(&self, r
: RegionVid
, upper
: RegionVid
) -> bool
{
1889 let r_scc
= self.constraint_sccs
.scc(r
);
1890 self.scc_values
.contains(r_scc
, upper
)
1893 crate fn universal_regions(&self) -> &UniversalRegions
<'tcx
> {
1894 self.universal_regions
.as_ref()
1897 /// Tries to find the best constraint to blame for the fact that
1898 /// `R: from_region`, where `R` is some region that meets
1899 /// `target_test`. This works by following the constraint graph,
1900 /// creating a constraint path that forces `R` to outlive
1901 /// `from_region`, and then finding the best choices within that
1903 crate fn best_blame_constraint(
1906 from_region
: RegionVid
,
1907 from_region_origin
: NLLRegionVariableOrigin
,
1908 target_test
: impl Fn(RegionVid
) -> bool
,
1909 ) -> (ConstraintCategory
, bool
, Span
) {
1911 "best_blame_constraint(from_region={:?}, from_region_origin={:?})",
1912 from_region
, from_region_origin
1916 let (path
, target_region
) =
1917 self.find_constraint_paths_between_regions(from_region
, target_test
).unwrap();
1919 "best_blame_constraint: path={:#?}",
1922 "{:?} ({:?}: {:?})",
1924 self.constraint_sccs
.scc(c
.sup
),
1925 self.constraint_sccs
.scc(c
.sub
),
1927 .collect
::<Vec
<_
>>()
1930 // Classify each of the constraints along the path.
1931 let mut categorized_path
: Vec
<(ConstraintCategory
, bool
, Span
)> = path
1934 if constraint
.category
== ConstraintCategory
::ClosureBounds
{
1935 self.retrieve_closure_constraint_info(body
, &constraint
)
1937 (constraint
.category
, false, constraint
.locations
.span(body
))
1941 debug
!("best_blame_constraint: categorized_path={:#?}", categorized_path
);
1943 // To find the best span to cite, we first try to look for the
1944 // final constraint that is interesting and where the `sup` is
1945 // not unified with the ultimate target region. The reason
1946 // for this is that we have a chain of constraints that lead
1947 // from the source to the target region, something like:
1949 // '0: '1 ('0 is the source)
1954 // '5: '6 ('6 is the target)
1956 // Some of those regions are unified with `'6` (in the same
1957 // SCC). We want to screen those out. After that point, the
1958 // "closest" constraint we have to the end is going to be the
1959 // most likely to be the point where the value escapes -- but
1960 // we still want to screen for an "interesting" point to
1961 // highlight (e.g., a call site or something).
1962 let target_scc
= self.constraint_sccs
.scc(target_region
);
1963 let mut range
= 0..path
.len();
1965 // As noted above, when reporting an error, there is typically a chain of constraints
1966 // leading from some "source" region which must outlive some "target" region.
1967 // In most cases, we prefer to "blame" the constraints closer to the target --
1968 // but there is one exception. When constraints arise from higher-ranked subtyping,
1969 // we generally prefer to blame the source value,
1970 // as the "target" in this case tends to be some type annotation that the user gave.
1971 // Therefore, if we find that the region origin is some instantiation
1972 // of a higher-ranked region, we start our search from the "source" point
1973 // rather than the "target", and we also tweak a few other things.
1975 // An example might be this bit of Rust code:
1978 // let x: fn(&'static ()) = |_| {};
1979 // let y: for<'a> fn(&'a ()) = x;
1982 // In MIR, this will be converted into a combination of assignments and type ascriptions.
1983 // In particular, the 'static is imposed through a type ascription:
1987 // AscribeUserType(x, fn(&'static ())
1991 // We wind up ultimately with constraints like
1994 // !a: 'temp1 // from the `y = x` statement
1996 // 'temp2: 'static // from the AscribeUserType
1999 // and here we prefer to blame the source (the y = x statement).
2000 let blame_source
= match from_region_origin
{
2001 NLLRegionVariableOrigin
::FreeRegion
2002 | NLLRegionVariableOrigin
::Existential { from_forall: false }
=> true,
2003 NLLRegionVariableOrigin
::RootEmptyRegion
2004 | NLLRegionVariableOrigin
::Placeholder(_
)
2005 | NLLRegionVariableOrigin
::Existential { from_forall: true }
=> false,
2008 let find_region
= |i
: &usize| {
2009 let constraint
= path
[*i
];
2011 let constraint_sup_scc
= self.constraint_sccs
.scc(constraint
.sup
);
2014 match categorized_path
[*i
].0 {
2015 ConstraintCategory
::OpaqueType
2016 | ConstraintCategory
::Boring
2017 | ConstraintCategory
::BoringNoLocation
2018 | ConstraintCategory
::Internal
=> false,
2019 ConstraintCategory
::TypeAnnotation
2020 | ConstraintCategory
::Return
2021 | ConstraintCategory
::Yield
=> true,
2022 _
=> constraint_sup_scc
!= target_scc
,
2025 match categorized_path
[*i
].0 {
2026 ConstraintCategory
::OpaqueType
2027 | ConstraintCategory
::Boring
2028 | ConstraintCategory
::BoringNoLocation
2029 | ConstraintCategory
::Internal
=> false,
2036 if blame_source { range.rev().find(find_region) }
else { range.find(find_region) }
;
2039 "best_blame_constraint: best_choice={:?} blame_source={}",
2040 best_choice
, blame_source
2043 if let Some(i
) = best_choice
{
2044 if let Some(next
) = categorized_path
.get(i
+ 1) {
2045 if categorized_path
[i
].0 == ConstraintCategory
::Return
2046 && next
.0 == ConstraintCategory
::OpaqueType
2048 // The return expression is being influenced by the return type being
2049 // impl Trait, point at the return type and not the return expr.
2053 return categorized_path
[i
];
2056 // If that search fails, that is.. unusual. Maybe everything
2057 // is in the same SCC or something. In that case, find what
2058 // appears to be the most interesting point to report to the
2059 // user via an even more ad-hoc guess.
2060 categorized_path
.sort_by(|p0
, p1
| p0
.0
.cmp(&p1
.0
));
2061 debug
!("`: sorted_path={:#?}", categorized_path
);
2063 *categorized_path
.first().unwrap()
2067 impl<'tcx
> RegionDefinition
<'tcx
> {
2068 fn new(universe
: ty
::UniverseIndex
, rv_origin
: RegionVariableOrigin
) -> Self {
2069 // Create a new region definition. Note that, for free
2070 // regions, the `external_name` field gets updated later in
2071 // `init_universal_regions`.
2073 let origin
= match rv_origin
{
2074 RegionVariableOrigin
::NLL(origin
) => origin
,
2075 _
=> NLLRegionVariableOrigin
::Existential { from_forall: false }
,
2078 Self { origin, universe, external_name: None }
2082 pub trait ClosureRegionRequirementsExt
<'tcx
> {
2083 fn apply_requirements(
2086 closure_def_id
: DefId
,
2087 closure_substs
: SubstsRef
<'tcx
>,
2088 ) -> Vec
<QueryOutlivesConstraint
<'tcx
>>;
2091 impl<'tcx
> ClosureRegionRequirementsExt
<'tcx
> for ClosureRegionRequirements
<'tcx
> {
2092 /// Given an instance T of the closure type, this method
2093 /// instantiates the "extra" requirements that we computed for the
2094 /// closure into the inference context. This has the effect of
2095 /// adding new outlives obligations to existing variables.
2097 /// As described on `ClosureRegionRequirements`, the extra
2098 /// requirements are expressed in terms of regionvids that index
2099 /// into the free regions that appear on the closure type. So, to
2100 /// do this, we first copy those regions out from the type T into
2101 /// a vector. Then we can just index into that vector to extract
2102 /// out the corresponding region from T and apply the
2104 fn apply_requirements(
2107 closure_def_id
: DefId
,
2108 closure_substs
: SubstsRef
<'tcx
>,
2109 ) -> Vec
<QueryOutlivesConstraint
<'tcx
>> {
2111 "apply_requirements(closure_def_id={:?}, closure_substs={:?})",
2112 closure_def_id
, closure_substs
2115 // Extract the values of the free regions in `closure_substs`
2116 // into a vector. These are the regions that we will be
2117 // relating to one another.
2118 let closure_mapping
= &UniversalRegions
::closure_mapping(
2121 self.num_external_vids
,
2122 tcx
.closure_base_def_id(closure_def_id
),
2124 debug
!("apply_requirements: closure_mapping={:?}", closure_mapping
);
2126 // Create the predicates.
2127 self.outlives_requirements
2129 .map(|outlives_requirement
| {
2130 let outlived_region
= closure_mapping
[outlives_requirement
.outlived_free_region
];
2132 match outlives_requirement
.subject
{
2133 ClosureOutlivesSubject
::Region(region
) => {
2134 let region
= closure_mapping
[region
];
2136 "apply_requirements: region={:?} \
2137 outlived_region={:?} \
2138 outlives_requirement={:?}",
2139 region
, outlived_region
, outlives_requirement
,
2141 ty
::Binder
::dummy(ty
::OutlivesPredicate(region
.into(), outlived_region
))
2144 ClosureOutlivesSubject
::Ty(ty
) => {
2146 "apply_requirements: ty={:?} \
2147 outlived_region={:?} \
2148 outlives_requirement={:?}",
2149 ty
, outlived_region
, outlives_requirement
,
2151 ty
::Binder
::dummy(ty
::OutlivesPredicate(ty
.into(), outlived_region
))