1use std::collections::VecDeque;2use std::rc::Rc;34use rustc_data_structures::frozen::Frozen;5use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};6use rustc_data_structures::graph::scc::Sccs;7use rustc_errors::Diag;8use rustc_hir::def_id::CRATE_DEF_ID;9use rustc_index::IndexVec;10use rustc_infer::infer::outlives::test_type_match;11use rustc_infer::infer::region_constraints::{GenericKind, VerifyBound, VerifyIfEq};12use rustc_infer::infer::{InferCtxt, NllRegionVariableOrigin};13use rustc_middle::bug;14use rustc_middle::mir::{15 AnnotationSource, BasicBlock, Body, ConstraintCategory, Local, Location, ReturnConstraint,16 TerminatorKind,17};18use rustc_middle::traits::{ObligationCause, ObligationCauseCode};19use rustc_middle::ty::{self, RegionVid, Ty, TyCtxt, TypeFoldable, UniverseIndex, fold_regions};20use rustc_mir_dataflow::points::DenseLocationMap;21use rustc_span::hygiene::DesugaringKind;22use rustc_span::{DUMMY_SP, Span};23use tracing::{Level, debug, enabled, instrument, trace};2425use crate::constraints::graph::NormalConstraintGraph;26use crate::constraints::{ConstraintSccIndex, OutlivesConstraint, OutlivesConstraintSet};27use crate::dataflow::BorrowIndex;28use crate::diagnostics::{RegionErrorKind, RegionErrors, UniverseInfo};29use crate::handle_placeholders::{LoweredConstraints, RegionTracker};30use crate::polonius::LiveLoans;31use crate::polonius::legacy::PoloniusOutput;32use crate::region_infer::values::{LivenessValues, RegionElement, RegionValues, ToElementIndex};33use crate::type_check::Locations;34use crate::type_check::free_region_relations::UniversalRegionRelations;35use crate::universal_regions::UniversalRegions;36use crate::{37 BorrowckInferCtxt, ClosureOutlivesRequirement, ClosureOutlivesSubject,38 ClosureOutlivesSubjectTy, ClosureRegionRequirements,39};4041mod dump_mir;42mod graphviz;43pub(crate) mod opaque_types;44mod reverse_sccs;4546pub(crate) mod values;4748/// The representative region variable for an SCC, tagged by its origin.49/// We prefer placeholders over existentially quantified variables, otherwise50/// it's the one with the smallest Region Variable ID. In other words,51/// the order of this enumeration really matters!52#[derive(Copy, Debug, Clone, PartialEq, PartialOrd, Eq, Ord)]53pub(crate) enum Representative {54 FreeRegion(RegionVid),55 Placeholder(RegionVid),56 Existential(RegionVid),57}5859impl Representative {60 pub(crate) fn rvid(self) -> RegionVid {61 match self {62 Representative::FreeRegion(region_vid)63 | Representative::Placeholder(region_vid)64 | Representative::Existential(region_vid) => region_vid,65 }66 }6768 pub(crate) fn new(r: RegionVid, definition: &RegionDefinition<'_>) -> Self {69 match definition.origin {70 NllRegionVariableOrigin::FreeRegion => Representative::FreeRegion(r),71 NllRegionVariableOrigin::Placeholder(_) => Representative::Placeholder(r),72 NllRegionVariableOrigin::Existential { .. } => Representative::Existential(r),73 }74 }75}7677pub(crate) type ConstraintSccs = Sccs<RegionVid, ConstraintSccIndex>;7879pub struct RegionInferenceContext<'tcx> {80 /// Contains the definition for every region variable. Region81 /// variables are identified by their index (`RegionVid`). The82 /// definition contains information about where the region came83 /// from as well as its final inferred value.84 pub(crate) definitions: Frozen<IndexVec<RegionVid, RegionDefinition<'tcx>>>,8586 /// The liveness constraints added to each region. For most87 /// regions, these start out empty and steadily grow, though for88 /// each universally quantified region R they start out containing89 /// the entire CFG and `end(R)`.90 liveness_constraints: LivenessValues,9192 /// The outlives constraints computed by the type-check.93 constraints: Frozen<OutlivesConstraintSet<'tcx>>,9495 /// The constraint-set, but in graph form, making it easy to traverse96 /// the constraints adjacent to a particular region. Used to construct97 /// the SCC (see `constraint_sccs`) and for error reporting.98 constraint_graph: Frozen<NormalConstraintGraph>,99100 /// The SCC computed from `constraints` and the constraint101 /// graph. We have an edge from SCC A to SCC B if `A: B`. Used to102 /// compute the values of each region.103 constraint_sccs: ConstraintSccs,104105 scc_annotations: IndexVec<ConstraintSccIndex, RegionTracker>,106107 /// Map universe indexes to information on why we created it.108 universe_causes: FxIndexMap<ty::UniverseIndex, UniverseInfo<'tcx>>,109110 /// The final inferred values of the region variables; we compute111 /// one value per SCC. To get the value for any given *region*,112 /// you first find which scc it is a part of.113 scc_values: RegionValues<'tcx, ConstraintSccIndex>,114115 /// Type constraints that we check after solving.116 type_tests: Vec<TypeTest<'tcx>>,117118 /// Information about how the universally quantified regions in119 /// scope on this function relate to one another.120 universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,121}122123#[derive(Debug)]124pub(crate) struct RegionDefinition<'tcx> {125 /// What kind of variable is this -- a free region? existential126 /// variable? etc. (See the `NllRegionVariableOrigin` for more127 /// info.)128 pub(crate) origin: NllRegionVariableOrigin<'tcx>,129130 /// Which universe is this region variable defined in? This is131 /// most often `ty::UniverseIndex::ROOT`, but when we encounter132 /// forall-quantifiers like `for<'a> { 'a = 'b }`, we would create133 /// the variable for `'a` in a fresh universe that extends ROOT.134 pub(crate) universe: ty::UniverseIndex,135136 /// If this is 'static or an early-bound region, then this is137 /// `Some(X)` where `X` is the name of the region.138 pub(crate) external_name: Option<ty::Region<'tcx>>,139}140141/// N.B., the variants in `Cause` are intentionally ordered. Lower142/// values are preferred when it comes to error messages. Do not143/// reorder willy nilly.144#[derive(Copy, Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]145pub(crate) enum Cause {146 /// point inserted because Local was live at the given Location147 LiveVar(Local, Location),148149 /// point inserted because Local was dropped at the given Location150 DropVar(Local, Location),151}152153/// A "type test" corresponds to an outlives constraint between a type154/// and a lifetime, like `T: 'x` or `<T as Foo>::Bar: 'x`. They are155/// translated from the `Verify` region constraints in the ordinary156/// inference context.157///158/// These sorts of constraints are handled differently than ordinary159/// constraints, at least at present. During type checking, the160/// `InferCtxt::process_registered_region_obligations` method will161/// attempt to convert a type test like `T: 'x` into an ordinary162/// outlives constraint when possible (for example, `&'a T: 'b` will163/// be converted into `'a: 'b` and registered as a `Constraint`).164///165/// In some cases, however, there are outlives relationships that are166/// not converted into a region constraint, but rather into one of167/// these "type tests". The distinction is that a type test does not168/// influence the inference result, but instead just examines the169/// values that we ultimately inferred for each region variable and170/// checks that they meet certain extra criteria. If not, an error171/// can be issued.172///173/// One reason for this is that these type tests typically boil down174/// to a check like `'a: 'x` where `'a` is a universally quantified175/// region -- and therefore not one whose value is really meant to be176/// *inferred*, precisely (this is not always the case: one can have a177/// type test like `<Foo as Trait<'?0>>::Bar: 'x`, where `'?0` is an178/// inference variable). Another reason is that these type tests can179/// involve *disjunction* -- that is, they can be satisfied in more180/// than one way.181///182/// For more information about this translation, see183/// `InferCtxt::process_registered_region_obligations` and184/// `InferCtxt::type_must_outlive` in `rustc_infer::infer::InferCtxt`.185#[derive(Clone, Debug)]186pub(crate) struct TypeTest<'tcx> {187 /// The type `T` that must outlive the region.188 pub generic_kind: GenericKind<'tcx>,189190 /// The region `'x` that the type must outlive.191 pub lower_bound: RegionVid,192193 /// The span to blame.194 pub span: Span,195196 /// A test which, if met by the region `'x`, proves that this type197 /// constraint is satisfied.198 pub verify_bound: VerifyBound<'tcx>,199}200201/// When we have an unmet lifetime constraint, we try to propagate it outward (e.g. to a closure202/// environment). If we can't, it is an error.203#[derive(Clone, Copy, Debug, Eq, PartialEq)]204enum RegionRelationCheckResult {205 Ok,206 Propagated,207 Error,208}209210#[derive(Clone, PartialEq, Eq, Debug)]211enum Trace<'a, 'tcx> {212 StartRegion,213 FromGraph(&'a OutlivesConstraint<'tcx>),214 FromStatic(RegionVid),215 NotVisited,216}217218#[instrument(skip(infcx, sccs), level = "debug")]219fn sccs_info<'tcx>(infcx: &BorrowckInferCtxt<'tcx>, sccs: &ConstraintSccs) {220 use crate::renumber::RegionCtxt;221222 let var_to_origin = infcx.reg_var_to_origin.borrow();223224 let mut var_to_origin_sorted = var_to_origin.clone().into_iter().collect::<Vec<_>>();225 var_to_origin_sorted.sort_by_key(|vto| vto.0);226227 if enabled!(Level::DEBUG) {228 let mut reg_vars_to_origins_str = "region variables to origins:\n".to_string();229 for (reg_var, origin) in var_to_origin_sorted.into_iter() {230 reg_vars_to_origins_str.push_str(&format!("{reg_var:?}: {origin:?}\n"));231 }232 debug!("{}", reg_vars_to_origins_str);233 }234235 let num_components = sccs.num_sccs();236 let mut components = vec![FxIndexSet::default(); num_components];237238 for (reg_var, scc_idx) in sccs.scc_indices().iter_enumerated() {239 let origin = var_to_origin.get(®_var).unwrap_or(&RegionCtxt::Unknown);240 components[scc_idx.as_usize()].insert((reg_var, *origin));241 }242243 if enabled!(Level::DEBUG) {244 let mut components_str = "strongly connected components:".to_string();245 for (scc_idx, reg_vars_origins) in components.iter().enumerate() {246 let regions_info = reg_vars_origins.clone().into_iter().collect::<Vec<_>>();247 components_str.push_str(&format!(248 "{:?}: {:?},\n)",249 ConstraintSccIndex::from_usize(scc_idx),250 regions_info,251 ))252 }253 debug!("{}", components_str);254 }255256 // calculate the best representative for each component257 let components_representatives = components258 .into_iter()259 .enumerate()260 .map(|(scc_idx, region_ctxts)| {261 let repr = region_ctxts262 .into_iter()263 .map(|reg_var_origin| reg_var_origin.1)264 .max_by(|x, y| x.preference_value().cmp(&y.preference_value()))265 .unwrap();266267 (ConstraintSccIndex::from_usize(scc_idx), repr)268 })269 .collect::<FxIndexMap<_, _>>();270271 let mut scc_node_to_edges = FxIndexMap::default();272 for (scc_idx, repr) in components_representatives.iter() {273 let edge_representatives = sccs274 .successors(*scc_idx)275 .iter()276 .map(|scc_idx| components_representatives[scc_idx])277 .collect::<Vec<_>>();278 scc_node_to_edges.insert((scc_idx, repr), edge_representatives);279 }280281 debug!("SCC edges {:#?}", scc_node_to_edges);282}283284impl<'tcx> RegionInferenceContext<'tcx> {285 /// Creates a new region inference context with a total of286 /// `num_region_variables` valid inference variables; the first N287 /// of those will be constant regions representing the free288 /// regions defined in `universal_regions`.289 ///290 /// The `outlives_constraints` and `type_tests` are an initial set291 /// of constraints produced by the MIR type check.292 pub(crate) fn new(293 infcx: &BorrowckInferCtxt<'tcx>,294 lowered_constraints: LoweredConstraints<'tcx>,295 universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,296 location_map: Rc<DenseLocationMap>,297 ) -> Self {298 let universal_regions = &universal_region_relations.universal_regions;299300 let LoweredConstraints {301 constraint_sccs,302 definitions,303 outlives_constraints,304 scc_annotations,305 type_tests,306 liveness_constraints,307 universe_causes,308 placeholder_indices,309 } = lowered_constraints;310311 debug!("universal_regions: {:#?}", universal_region_relations.universal_regions);312 debug!("outlives constraints: {:#?}", outlives_constraints);313 debug!("placeholder_indices: {:#?}", placeholder_indices);314 debug!("type tests: {:#?}", type_tests);315316 let constraint_graph = Frozen::freeze(outlives_constraints.graph(definitions.len()));317318 if cfg!(debug_assertions) {319 sccs_info(infcx, &constraint_sccs);320 }321322 let mut scc_values =323 RegionValues::new(location_map, universal_regions.len(), placeholder_indices);324325 for region in liveness_constraints.regions() {326 let scc = constraint_sccs.scc(region);327 scc_values.merge_liveness(scc, region, &liveness_constraints);328 }329330 let mut result = Self {331 definitions,332 liveness_constraints,333 constraints: outlives_constraints,334 constraint_graph,335 constraint_sccs,336 scc_annotations,337 universe_causes,338 scc_values,339 type_tests,340 universal_region_relations,341 };342343 result.init_free_and_bound_regions();344345 result346 }347348 /// Initializes the region variables for each universally349 /// quantified region (lifetime parameter). The first N variables350 /// always correspond to the regions appearing in the function351 /// signature (both named and anonymous) and where-clauses. This352 /// function iterates over those regions and initializes them with353 /// minimum values.354 ///355 /// For example:356 /// ```ignore (illustrative)357 /// fn foo<'a, 'b>( /* ... */ ) where 'a: 'b { /* ... */ }358 /// ```359 /// would initialize two variables like so:360 /// ```ignore (illustrative)361 /// R0 = { CFG, R0 } // 'a362 /// R1 = { CFG, R0, R1 } // 'b363 /// ```364 /// Here, R0 represents `'a`, and it contains (a) the entire CFG365 /// and (b) any universally quantified regions that it outlives,366 /// which in this case is just itself. R1 (`'b`) in contrast also367 /// outlives `'a` and hence contains R0 and R1.368 ///369 /// This bit of logic also handles invalid universe relations370 /// for higher-kinded types.371 ///372 /// We Walk each SCC `A` and `B` such that `A: B`373 /// and ensure that universe(A) can see universe(B).374 ///375 /// This serves to enforce the 'empty/placeholder' hierarchy376 /// (described in more detail on `RegionKind`):377 ///378 /// ```ignore (illustrative)379 /// static -----+380 /// | |381 /// empty(U0) placeholder(U1)382 /// | /383 /// empty(U1)384 /// ```385 ///386 /// In particular, imagine we have variables R0 in U0 and R1387 /// created in U1, and constraints like this;388 ///389 /// ```ignore (illustrative)390 /// R1: !1 // R1 outlives the placeholder in U1391 /// R1: R0 // R1 outlives R0392 /// ```393 ///394 /// Here, we wish for R1 to be `'static`, because it395 /// cannot outlive `placeholder(U1)` and `empty(U0)` any other way.396 ///397 /// Thanks to this loop, what happens is that the `R1: R0`398 /// constraint has lowered the universe of `R1` to `U0`, which in turn399 /// means that the `R1: !1` constraint here will cause400 /// `R1` to become `'static`.401 fn init_free_and_bound_regions(&mut self) {402 for variable in self.definitions.indices() {403 let scc = self.constraint_sccs.scc(variable);404405 match self.definitions[variable].origin {406 NllRegionVariableOrigin::FreeRegion => {407 // For each free, universally quantified region X:408409 // Add all nodes in the CFG to liveness constraints410 self.liveness_constraints.add_all_points(variable);411 self.scc_values.add_all_points(scc);412413 // Add `end(X)` into the set for X.414 self.scc_values.add_element(scc, variable);415 }416417 NllRegionVariableOrigin::Placeholder(placeholder) => {418 self.scc_values.add_element(scc, placeholder);419 }420421 NllRegionVariableOrigin::Existential { .. } => {422 // For existential, regions, nothing to do.423 }424 }425 }426 }427428 /// Returns an iterator over all the region indices.429 pub(crate) fn regions(&self) -> impl Iterator<Item = RegionVid> + 'tcx {430 self.definitions.indices()431 }432433 /// Given a universal region in scope on the MIR, returns the434 /// corresponding index.435 ///436 /// Panics if `r` is not a registered universal region, most notably437 /// if it is a placeholder. Handling placeholders requires access to the438 /// `MirTypeckRegionConstraints`.439 pub(crate) fn to_region_vid(&self, r: ty::Region<'tcx>) -> RegionVid {440 self.universal_regions().to_region_vid(r)441 }442443 /// Returns an iterator over all the outlives constraints.444 pub(crate) fn outlives_constraints(&self) -> impl Iterator<Item = OutlivesConstraint<'tcx>> {445 self.constraints.outlives().iter().copied()446 }447448 /// Adds annotations for `#[rustc_regions]`; see `UniversalRegions::annotate`.449 pub(crate) fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diag<'_, ()>) {450 self.universal_regions().annotate(tcx, err)451 }452453 /// Returns `true` if the region `r` contains the point `p`.454 ///455 /// Panics if called before `solve()` executes,456 pub(crate) fn region_contains(&self, r: RegionVid, p: impl ToElementIndex<'tcx>) -> bool {457 let scc = self.constraint_sccs.scc(r);458 self.scc_values.contains(scc, p)459 }460461 /// Returns the lowest statement index in `start..=end` which is not contained by `r`.462 ///463 /// Panics if called before `solve()` executes.464 pub(crate) fn first_non_contained_inclusive(465 &self,466 r: RegionVid,467 block: BasicBlock,468 start: usize,469 end: usize,470 ) -> Option<usize> {471 let scc = self.constraint_sccs.scc(r);472 self.scc_values.first_non_contained_inclusive(scc, block, start, end)473 }474475 /// Returns access to the value of `r` for debugging purposes.476 pub(crate) fn region_value_str(&self, r: RegionVid) -> String {477 let scc = self.constraint_sccs.scc(r);478 self.scc_values.region_value_str(scc)479 }480481 pub(crate) fn placeholders_contained_in(482 &self,483 r: RegionVid,484 ) -> impl Iterator<Item = ty::PlaceholderRegion<'tcx>> {485 let scc = self.constraint_sccs.scc(r);486 self.scc_values.placeholders_contained_in(scc)487 }488489 /// Performs region inference and report errors if we see any490 /// unsatisfiable constraints. If this is a closure, returns the491 /// region requirements to propagate to our creator, if any.492 #[instrument(skip(self, infcx, body, polonius_output), level = "debug")]493 pub(super) fn solve(494 &mut self,495 infcx: &InferCtxt<'tcx>,496 body: &Body<'tcx>,497 polonius_output: Option<Box<PoloniusOutput>>,498 ) -> (Option<ClosureRegionRequirements<'tcx>>, RegionErrors<'tcx>) {499 let mir_def_id = body.source.def_id();500 self.propagate_constraints();501502 let mut errors_buffer = RegionErrors::new(infcx.tcx);503504 // If this is a nested body, we propagate unsatisfied505 // outlives constraints to the parent body instead of506 // eagerly erroing.507 let mut propagated_outlives_requirements =508 infcx.tcx.is_typeck_child(mir_def_id).then(Vec::new);509510 self.check_type_tests(infcx, propagated_outlives_requirements.as_mut(), &mut errors_buffer);511512 debug!(?errors_buffer);513 debug!(?propagated_outlives_requirements);514515 // In Polonius mode, the errors about missing universal region relations are in the output516 // and need to be emitted or propagated. Otherwise, we need to check whether the517 // constraints were too strong, and if so, emit or propagate those errors.518 if infcx.tcx.sess.opts.unstable_opts.polonius.is_legacy_enabled() {519 self.check_polonius_subset_errors(520 propagated_outlives_requirements.as_mut(),521 &mut errors_buffer,522 polonius_output523 .as_ref()524 .expect("Polonius output is unavailable despite `-Z polonius`"),525 );526 } else {527 self.check_universal_regions(528 propagated_outlives_requirements.as_mut(),529 &mut errors_buffer,530 );531 }532533 debug!(?errors_buffer);534535 let propagated_outlives_requirements = propagated_outlives_requirements.unwrap_or_default();536537 if propagated_outlives_requirements.is_empty() {538 (None, errors_buffer)539 } else {540 let num_external_vids = self.universal_regions().num_global_and_external_regions();541 (542 Some(ClosureRegionRequirements {543 num_external_vids,544 outlives_requirements: propagated_outlives_requirements,545 }),546 errors_buffer,547 )548 }549 }550551 /// Propagate the region constraints: this will grow the values552 /// for each region variable until all the constraints are553 /// satisfied. Note that some values may grow **too** large to be554 /// feasible, but we check this later.555 #[instrument(skip(self), level = "debug")]556 fn propagate_constraints(&mut self) {557 debug!("constraints={:#?}", {558 let mut constraints: Vec<_> = self.outlives_constraints().collect();559 constraints.sort_by_key(|c| (c.sup, c.sub));560 constraints561 .into_iter()562 .map(|c| (c, self.constraint_sccs.scc(c.sup), self.constraint_sccs.scc(c.sub)))563 .collect::<Vec<_>>()564 });565566 // To propagate constraints, we walk the DAG induced by the567 // SCC. For each SCC `A`, we visit its successors and compute568 // their values, then we union all those values to get our569 // own.570 for scc_a in self.constraint_sccs.all_sccs() {571 // Walk each SCC `B` such that `A: B`...572 for &scc_b in self.constraint_sccs.successors(scc_a) {573 debug!(?scc_b);574 self.scc_values.add_region(scc_a, scc_b);575 }576 }577 }578579 /// Returns `true` if all the placeholders in the value of `scc_b` are nameable580 /// in `scc_a`. Used during constraint propagation, and only once581 /// the value of `scc_b` has been computed.582 fn can_name_all_placeholders(583 &self,584 scc_a: ConstraintSccIndex,585 scc_b: ConstraintSccIndex,586 ) -> bool {587 self.scc_annotations[scc_a].can_name_all_placeholders(self.scc_annotations[scc_b])588 }589590 /// Once regions have been propagated, this method is used to see591 /// whether the "type tests" produced by typeck were satisfied;592 /// type tests encode type-outlives relationships like `T:593 /// 'a`. See `TypeTest` for more details.594 fn check_type_tests(595 &self,596 infcx: &InferCtxt<'tcx>,597 mut propagated_outlives_requirements: Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,598 errors_buffer: &mut RegionErrors<'tcx>,599 ) {600 let tcx = infcx.tcx;601602 // Sometimes we register equivalent type-tests that would603 // result in basically the exact same error being reported to604 // the user. Avoid that.605 let mut deduplicate_errors = FxIndexSet::default();606607 for type_test in &self.type_tests {608 debug!("check_type_test: {:?}", type_test);609610 let generic_ty = type_test.generic_kind.to_ty(tcx);611 if self.eval_verify_bound(612 infcx,613 generic_ty,614 type_test.lower_bound,615 &type_test.verify_bound,616 ) {617 continue;618 }619620 if let Some(propagated_outlives_requirements) = &mut propagated_outlives_requirements621 && self.try_promote_type_test(infcx, type_test, propagated_outlives_requirements)622 {623 continue;624 }625626 // Type-test failed. Report the error.627 let erased_generic_kind = infcx.tcx.erase_and_anonymize_regions(type_test.generic_kind);628629 // Skip duplicate-ish errors.630 if deduplicate_errors.insert((631 erased_generic_kind,632 type_test.lower_bound,633 type_test.span,634 )) {635 debug!(636 "check_type_test: reporting error for erased_generic_kind={:?}, \637 lower_bound_region={:?}, \638 type_test.span={:?}",639 erased_generic_kind, type_test.lower_bound, type_test.span,640 );641642 errors_buffer.push(RegionErrorKind::TypeTestError { type_test: type_test.clone() });643 }644 }645 }646647 /// Invoked when we have some type-test (e.g., `T: 'X`) that we cannot648 /// prove to be satisfied. If this is a closure, we will attempt to649 /// "promote" this type-test into our `ClosureRegionRequirements` and650 /// hence pass it up the creator. To do this, we have to phrase the651 /// type-test in terms of external free regions, as local free652 /// regions are not nameable by the closure's creator.653 ///654 /// Promotion works as follows: we first check that the type `T`655 /// contains only regions that the creator knows about. If this is656 /// true, then -- as a consequence -- we know that all regions in657 /// the type `T` are free regions that outlive the closure body. If658 /// false, then promotion fails.659 ///660 /// Once we've promoted T, we have to "promote" `'X` to some region661 /// that is "external" to the closure. Generally speaking, a region662 /// may be the union of some points in the closure body as well as663 /// various free lifetimes. We can ignore the points in the closure664 /// body: if the type T can be expressed in terms of external regions,665 /// we know it outlives the points in the closure body. That666 /// just leaves the free regions.667 ///668 /// The idea then is to lower the `T: 'X` constraint into multiple669 /// bounds -- e.g., if `'X` is the union of two free lifetimes,670 /// `'1` and `'2`, then we would create `T: '1` and `T: '2`.671 #[instrument(level = "debug", skip(self, infcx, propagated_outlives_requirements))]672 fn try_promote_type_test(673 &self,674 infcx: &InferCtxt<'tcx>,675 type_test: &TypeTest<'tcx>,676 propagated_outlives_requirements: &mut Vec<ClosureOutlivesRequirement<'tcx>>,677 ) -> bool {678 let tcx = infcx.tcx;679 let TypeTest { generic_kind, lower_bound, span: blame_span, verify_bound: _ } = *type_test;680681 let generic_ty = generic_kind.to_ty(tcx);682 let Some(subject) = self.try_promote_type_test_subject(infcx, generic_ty) else {683 return false;684 };685686 let r_scc = self.constraint_sccs.scc(lower_bound);687 debug!(688 "lower_bound = {:?} r_scc={:?} universe={:?}",689 lower_bound,690 r_scc,691 self.max_nameable_universe(r_scc)692 );693 // If the type test requires that `T: 'a` where `'a` is a694 // placeholder from another universe, that effectively requires695 // `T: 'static`, so we have to propagate that requirement.696 //697 // It doesn't matter *what* universe because the promoted `T` will698 // always be in the root universe.699 if let Some(p) = self.scc_values.placeholders_contained_in(r_scc).next() {700 debug!("encountered placeholder in higher universe: {:?}, requiring 'static", p);701 let static_r = self.universal_regions().fr_static;702 propagated_outlives_requirements.push(ClosureOutlivesRequirement {703 subject,704 outlived_free_region: static_r,705 blame_span,706 category: ConstraintCategory::Boring,707 });708709 // we can return here -- the code below might push add'l constraints710 // but they would all be weaker than this one.711 return true;712 }713714 // For each region outlived by lower_bound find a non-local,715 // universal region (it may be the same region) and add it to716 // `ClosureOutlivesRequirement`.717 let mut found_outlived_universal_region = false;718 for ur in self.scc_values.universal_regions_outlived_by(r_scc) {719 found_outlived_universal_region = true;720 debug!("universal_region_outlived_by ur={:?}", ur);721 let non_local_ub = self.universal_region_relations.non_local_upper_bounds(ur);722 debug!(?non_local_ub);723724 // This is slightly too conservative. To show T: '1, given `'2: '1`725 // and `'3: '1` we only need to prove that T: '2 *or* T: '3, but to726 // avoid potential non-determinism we approximate this by requiring727 // T: '1 and T: '2.728 for upper_bound in non_local_ub {729 debug_assert!(self.universal_regions().is_universal_region(upper_bound));730 debug_assert!(!self.universal_regions().is_local_free_region(upper_bound));731732 let requirement = ClosureOutlivesRequirement {733 subject,734 outlived_free_region: upper_bound,735 blame_span,736 category: ConstraintCategory::Boring,737 };738 debug!(?requirement, "adding closure requirement");739 propagated_outlives_requirements.push(requirement);740 }741 }742 // If we succeed to promote the subject, i.e. it only contains non-local regions,743 // and fail to prove the type test inside of the closure, the `lower_bound` has to744 // also be at least as large as some universal region, as the type test is otherwise745 // trivial.746 assert!(found_outlived_universal_region);747 true748 }749750 /// When we promote a type test `T: 'r`, we have to replace all region751 /// variables in the type `T` with an equal universal region from the752 /// closure signature.753 /// This is not always possible, so this is a fallible process.754 #[instrument(level = "debug", skip(self, infcx), ret)]755 fn try_promote_type_test_subject(756 &self,757 infcx: &InferCtxt<'tcx>,758 ty: Ty<'tcx>,759 ) -> Option<ClosureOutlivesSubject<'tcx>> {760 let tcx = infcx.tcx;761 let mut failed = false;762 let ty = fold_regions(tcx, ty, |r, _depth| {763 let r_vid = self.to_region_vid(r);764 let r_scc = self.constraint_sccs.scc(r_vid);765766 // The challenge is this. We have some region variable `r`767 // whose value is a set of CFG points and universal768 // regions. We want to find if that set is *equivalent* to769 // any of the named regions found in the closure.770 // To do so, we simply check every candidate `u_r` for equality.771 self.scc_values772 .universal_regions_outlived_by(r_scc)773 .filter(|&u_r| !self.universal_regions().is_local_free_region(u_r))774 .find(|&u_r| self.eval_equal(u_r, r_vid))775 .map(|u_r| ty::Region::new_var(tcx, u_r))776 // In case we could not find a named region to map to,777 // we will return `None` below.778 .unwrap_or_else(|| {779 failed = true;780 r781 })782 });783784 debug!("try_promote_type_test_subject: folded ty = {:?}", ty);785786 // This will be true if we failed to promote some region.787 if failed {788 return None;789 }790791 Some(ClosureOutlivesSubject::Ty(ClosureOutlivesSubjectTy::bind(tcx, ty)))792 }793794 /// Like `universal_upper_bound`, but returns an approximation more suitable795 /// for diagnostics. If `r` contains multiple disjoint universal regions796 /// (e.g. 'a and 'b in `fn foo<'a, 'b> { ... }`, we pick the lower-numbered region.797 /// This corresponds to picking named regions over unnamed regions798 /// (e.g. picking early-bound regions over a closure late-bound region).799 ///800 /// This means that the returned value may not be a true upper bound, since801 /// only 'static is known to outlive disjoint universal regions.802 /// Therefore, this method should only be used in diagnostic code,803 /// where displaying *some* named universal region is better than804 /// falling back to 'static.805 #[instrument(level = "debug", skip(self))]806 pub(crate) fn approx_universal_upper_bound(&self, r: RegionVid) -> RegionVid {807 debug!("{}", self.region_value_str(r));808809 // Find the smallest universal region that contains all other810 // universal regions within `region`.811 let mut lub = self.universal_regions().fr_fn_body;812 let r_scc = self.constraint_sccs.scc(r);813 let static_r = self.universal_regions().fr_static;814 for ur in self.scc_values.universal_regions_outlived_by(r_scc) {815 let new_lub = self.universal_region_relations.postdom_upper_bound(lub, ur);816 debug!(?ur, ?lub, ?new_lub);817 // The upper bound of two non-static regions is static: this818 // means we know nothing about the relationship between these819 // two regions. Pick a 'better' one to use when constructing820 // a diagnostic821 if ur != static_r && lub != static_r && new_lub == static_r {822 // Prefer the region with an `external_name` - this823 // indicates that the region is early-bound, so working with824 // it can produce a nicer error.825 if self.region_definition(ur).external_name.is_some() {826 lub = ur;827 } else if self.region_definition(lub).external_name.is_some() {828 // Leave lub unchanged829 } else {830 // If we get here, we don't have any reason to prefer831 // one region over the other. Just pick the832 // one with the lower index for now.833 lub = std::cmp::min(ur, lub);834 }835 } else {836 lub = new_lub;837 }838 }839840 debug!(?r, ?lub);841842 lub843 }844845 /// Tests if `test` is true when applied to `lower_bound` at846 /// `point`.847 fn eval_verify_bound(848 &self,849 infcx: &InferCtxt<'tcx>,850 generic_ty: Ty<'tcx>,851 lower_bound: RegionVid,852 verify_bound: &VerifyBound<'tcx>,853 ) -> bool {854 debug!("eval_verify_bound(lower_bound={:?}, verify_bound={:?})", lower_bound, verify_bound);855856 match verify_bound {857 VerifyBound::IfEq(verify_if_eq_b) => {858 self.eval_if_eq(infcx, generic_ty, lower_bound, *verify_if_eq_b)859 }860861 VerifyBound::IsEmpty => {862 let lower_bound_scc = self.constraint_sccs.scc(lower_bound);863 self.scc_values.elements_contained_in(lower_bound_scc).next().is_none()864 }865866 VerifyBound::OutlivedBy(r) => {867 let r_vid = self.to_region_vid(*r);868 self.eval_outlives(r_vid, lower_bound)869 }870871 VerifyBound::AnyBound(verify_bounds) => verify_bounds.iter().any(|verify_bound| {872 self.eval_verify_bound(infcx, generic_ty, lower_bound, verify_bound)873 }),874875 VerifyBound::AllBounds(verify_bounds) => verify_bounds.iter().all(|verify_bound| {876 self.eval_verify_bound(infcx, generic_ty, lower_bound, verify_bound)877 }),878 }879 }880881 fn eval_if_eq(882 &self,883 infcx: &InferCtxt<'tcx>,884 generic_ty: Ty<'tcx>,885 lower_bound: RegionVid,886 verify_if_eq_b: ty::Binder<'tcx, VerifyIfEq<'tcx>>,887 ) -> bool {888 let generic_ty = self.normalize_to_scc_representatives(infcx.tcx, generic_ty);889 let verify_if_eq_b = self.normalize_to_scc_representatives(infcx.tcx, verify_if_eq_b);890 match test_type_match::extract_verify_if_eq(infcx.tcx, &verify_if_eq_b, generic_ty) {891 Some(r) => {892 let r_vid = self.to_region_vid(r);893 self.eval_outlives(r_vid, lower_bound)894 }895 None => false,896 }897 }898899 /// This is a conservative normalization procedure. It takes every900 /// free region in `value` and replaces it with the901 /// "representative" of its SCC (see `scc_representatives` field).902 /// We are guaranteed that if two values normalize to the same903 /// thing, then they are equal; this is a conservative check in904 /// that they could still be equal even if they normalize to905 /// different results. (For example, there might be two regions906 /// with the same value that are not in the same SCC).907 ///908 /// N.B., this is not an ideal approach and I would like to revisit909 /// it. However, it works pretty well in practice. In particular,910 /// this is needed to deal with projection outlives bounds like911 ///912 /// ```text913 /// <T as Foo<'0>>::Item: '1914 /// ```915 ///916 /// In particular, this routine winds up being important when917 /// there are bounds like `where <T as Foo<'a>>::Item: 'b` in the918 /// environment. In this case, if we can show that `'0 == 'a`,919 /// and that `'b: '1`, then we know that the clause is920 /// satisfied. In such cases, particularly due to limitations of921 /// the trait solver =), we usually wind up with a where-clause like922 /// `T: Foo<'a>` in scope, which thus forces `'0 == 'a` to be added as923 /// a constraint, and thus ensures that they are in the same SCC.924 ///925 /// So why can't we do a more correct routine? Well, we could926 /// *almost* use the `relate_tys` code, but the way it is927 /// currently setup it creates inference variables to deal with928 /// higher-ranked things and so forth, and right now the inference929 /// context is not permitted to make more inference variables. So930 /// we use this kind of hacky solution.931 fn normalize_to_scc_representatives<T>(&self, tcx: TyCtxt<'tcx>, value: T) -> T932 where933 T: TypeFoldable<TyCtxt<'tcx>>,934 {935 fold_regions(tcx, value, |r, _db| {936 let vid = self.to_region_vid(r);937 let scc = self.constraint_sccs.scc(vid);938 let repr = self.scc_representative(scc);939 ty::Region::new_var(tcx, repr)940 })941 }942943 /// Evaluate whether `sup_region == sub_region`.944 ///945 /// Panics if called before `solve()` executes,946 // This is `pub` because it's used by unstable external borrowck data users, see `consumers.rs`.947 pub fn eval_equal(&self, r1: RegionVid, r2: RegionVid) -> bool {948 self.eval_outlives(r1, r2) && self.eval_outlives(r2, r1)949 }950951 /// Evaluate whether `sup_region: sub_region`.952 ///953 /// Panics if called before `solve()` executes,954 // This is `pub` because it's used by unstable external borrowck data users, see `consumers.rs`.955 #[instrument(skip(self), level = "debug", ret)]956 pub fn eval_outlives(&self, sup_region: RegionVid, sub_region: RegionVid) -> bool {957 debug!(958 "sup_region's value = {:?} universal={:?}",959 self.region_value_str(sup_region),960 self.universal_regions().is_universal_region(sup_region),961 );962 debug!(963 "sub_region's value = {:?} universal={:?}",964 self.region_value_str(sub_region),965 self.universal_regions().is_universal_region(sub_region),966 );967968 let sub_region_scc = self.constraint_sccs.scc(sub_region);969 let sup_region_scc = self.constraint_sccs.scc(sup_region);970971 if sub_region_scc == sup_region_scc {972 debug!("{sup_region:?}: {sub_region:?} holds trivially; they are in the same SCC");973 return true;974 }975976 let fr_static = self.universal_regions().fr_static;977978 // If we are checking that `'sup: 'sub`, and `'sub` contains979 // some placeholder that `'sup` cannot name, then this is only980 // true if `'sup` outlives static.981 //982 // Avoid infinite recursion if `sub_region` is already `'static`983 if sub_region != fr_static984 && !self.can_name_all_placeholders(sup_region_scc, sub_region_scc)985 {986 debug!(987 "sub universe `{sub_region_scc:?}` is not nameable \988 by super `{sup_region_scc:?}`, promoting to static",989 );990991 return self.eval_outlives(sup_region, fr_static);992 }993994 // Both the `sub_region` and `sup_region` consist of the union995 // of some number of universal regions (along with the union996 // of various points in the CFG; ignore those points for997 // now). Therefore, the sup-region outlives the sub-region if,998 // for each universal region R1 in the sub-region, there999 // exists some region R2 in the sup-region that outlives R1.1000 let universal_outlives =1001 self.scc_values.universal_regions_outlived_by(sub_region_scc).all(|r1| {1002 self.scc_values1003 .universal_regions_outlived_by(sup_region_scc)1004 .any(|r2| self.universal_region_relations.outlives(r2, r1))1005 });10061007 if !universal_outlives {1008 debug!("sub region contains a universal region not present in super");1009 return false;1010 }10111012 // Now we have to compare all the points in the sub region and make1013 // sure they exist in the sup region.10141015 if self.universal_regions().is_universal_region(sup_region) {1016 // Micro-opt: universal regions contain all points.1017 debug!("super is universal and hence contains all points");1018 return true;1019 }10201021 debug!("comparison between points in sup/sub");10221023 self.scc_values.contains_points(sup_region_scc, sub_region_scc)1024 }10251026 /// Once regions have been propagated, this method is used to see1027 /// whether any of the constraints were too strong. In particular,1028 /// we want to check for a case where a universally quantified1029 /// region exceeded its bounds. Consider:1030 /// ```compile_fail1031 /// fn foo<'a, 'b>(x: &'a u32) -> &'b u32 { x }1032 /// ```1033 /// In this case, returning `x` requires `&'a u32 <: &'b u32`1034 /// and hence we establish (transitively) a constraint that1035 /// `'a: 'b`. The `propagate_constraints` code above will1036 /// therefore add `end('a)` into the region for `'b` -- but we1037 /// have no evidence that `'b` outlives `'a`, so we want to report1038 /// an error.1039 ///1040 /// If `propagated_outlives_requirements` is `Some`, then we will1041 /// push unsatisfied obligations into there. Otherwise, we'll1042 /// report them as errors.1043 fn check_universal_regions(1044 &self,1045 mut propagated_outlives_requirements: Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,1046 errors_buffer: &mut RegionErrors<'tcx>,1047 ) {1048 for (fr, fr_definition) in self.definitions.iter_enumerated() {1049 debug!(?fr, ?fr_definition);1050 match fr_definition.origin {1051 NllRegionVariableOrigin::FreeRegion => {1052 // Go through each of the universal regions `fr` and check that1053 // they did not grow too large, accumulating any requirements1054 // for our caller into the `outlives_requirements` vector.1055 self.check_universal_region(1056 fr,1057 &mut propagated_outlives_requirements,1058 errors_buffer,1059 );1060 }10611062 NllRegionVariableOrigin::Placeholder(placeholder) => {1063 self.check_bound_universal_region(fr, placeholder, errors_buffer);1064 }10651066 NllRegionVariableOrigin::Existential { .. } => {1067 // nothing to check here1068 }1069 }1070 }1071 }10721073 /// Checks if Polonius has found any unexpected free region relations.1074 ///1075 /// In Polonius terms, a "subset error" (or "illegal subset relation error") is the equivalent1076 /// of NLL's "checking if any region constraints were too strong": a placeholder origin `'a`1077 /// was unexpectedly found to be a subset of another placeholder origin `'b`, and means in NLL1078 /// terms that the "longer free region" `'a` outlived the "shorter free region" `'b`.1079 ///1080 /// More details can be found in this blog post by Niko:1081 /// <https://smallcultfollowing.com/babysteps/blog/2019/01/17/polonius-and-region-errors/>1082 ///1083 /// In the canonical example1084 /// ```compile_fail1085 /// fn foo<'a, 'b>(x: &'a u32) -> &'b u32 { x }1086 /// ```1087 /// returning `x` requires `&'a u32 <: &'b u32` and hence we establish (transitively) a1088 /// constraint that `'a: 'b`. It is an error that we have no evidence that this1089 /// constraint holds.1090 ///1091 /// If `propagated_outlives_requirements` is `Some`, then we will1092 /// push unsatisfied obligations into there. Otherwise, we'll1093 /// report them as errors.1094 fn check_polonius_subset_errors(1095 &self,1096 mut propagated_outlives_requirements: Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,1097 errors_buffer: &mut RegionErrors<'tcx>,1098 polonius_output: &PoloniusOutput,1099 ) {1100 debug!(1101 "check_polonius_subset_errors: {} subset_errors",1102 polonius_output.subset_errors.len()1103 );11041105 // Similarly to `check_universal_regions`: a free region relation, which was not explicitly1106 // declared ("known") was found by Polonius, so emit an error, or propagate the1107 // requirements for our caller into the `propagated_outlives_requirements` vector.1108 //1109 // Polonius doesn't model regions ("origins") as CFG-subsets or durations, but the1110 // `longer_fr` and `shorter_fr` terminology will still be used here, for consistency with1111 // the rest of the NLL infrastructure. The "subset origin" is the "longer free region",1112 // and the "superset origin" is the outlived "shorter free region".1113 //1114 // Note: Polonius will produce a subset error at every point where the unexpected1115 // `longer_fr`'s "placeholder loan" is contained in the `shorter_fr`. This can be helpful1116 // for diagnostics in the future, e.g. to point more precisely at the key locations1117 // requiring this constraint to hold. However, the error and diagnostics code downstream1118 // expects that these errors are not duplicated (and that they are in a certain order).1119 // Otherwise, diagnostics messages such as the ones giving names like `'1` to elided or1120 // anonymous lifetimes for example, could give these names differently, while others like1121 // the outlives suggestions or the debug output from `#[rustc_regions]` would be1122 // duplicated. The polonius subset errors are deduplicated here, while keeping the1123 // CFG-location ordering.1124 // We can iterate the HashMap here because the result is sorted afterwards.1125 #[allow(rustc::potential_query_instability)]1126 let mut subset_errors: Vec<_> = polonius_output1127 .subset_errors1128 .iter()1129 .flat_map(|(_location, subset_errors)| subset_errors.iter())1130 .collect();1131 subset_errors.sort();1132 subset_errors.dedup();11331134 for &(longer_fr, shorter_fr) in subset_errors.into_iter() {1135 debug!(1136 "check_polonius_subset_errors: subset_error longer_fr={:?},\1137 shorter_fr={:?}",1138 longer_fr, shorter_fr1139 );11401141 let propagated = self.try_propagate_universal_region_error(1142 longer_fr.into(),1143 shorter_fr.into(),1144 &mut propagated_outlives_requirements,1145 );1146 if propagated == RegionRelationCheckResult::Error {1147 errors_buffer.push(RegionErrorKind::RegionError {1148 longer_fr: longer_fr.into(),1149 shorter_fr: shorter_fr.into(),1150 fr_origin: NllRegionVariableOrigin::FreeRegion,1151 is_reported: true,1152 });1153 }1154 }11551156 // Handle the placeholder errors as usual, until the chalk-rustc-polonius triumvirate has1157 // a more complete picture on how to separate this responsibility.1158 for (fr, fr_definition) in self.definitions.iter_enumerated() {1159 match fr_definition.origin {1160 NllRegionVariableOrigin::FreeRegion => {1161 // handled by polonius above1162 }11631164 NllRegionVariableOrigin::Placeholder(placeholder) => {1165 self.check_bound_universal_region(fr, placeholder, errors_buffer);1166 }11671168 NllRegionVariableOrigin::Existential { .. } => {1169 // nothing to check here1170 }1171 }1172 }1173 }11741175 /// The largest universe of any region nameable from this SCC.1176 fn max_nameable_universe(&self, scc: ConstraintSccIndex) -> UniverseIndex {1177 self.scc_annotations[scc].max_nameable_universe()1178 }11791180 /// Checks the final value for the free region `fr` to see if it1181 /// grew too large. In particular, examine what `end(X)` points1182 /// wound up in `fr`'s final value; for each `end(X)` where `X !=1183 /// fr`, we want to check that `fr: X`. If not, that's either an1184 /// error, or something we have to propagate to our creator.1185 ///1186 /// Things that are to be propagated are accumulated into the1187 /// `outlives_requirements` vector.1188 #[instrument(skip(self, propagated_outlives_requirements, errors_buffer), level = "debug")]1189 fn check_universal_region(1190 &self,1191 longer_fr: RegionVid,1192 propagated_outlives_requirements: &mut Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,1193 errors_buffer: &mut RegionErrors<'tcx>,1194 ) {1195 let longer_fr_scc = self.constraint_sccs.scc(longer_fr);11961197 // Because this free region must be in the ROOT universe, we1198 // know it cannot contain any bound universes.1199 assert!(self.max_nameable_universe(longer_fr_scc).is_root());12001201 // Only check all of the relations for the main representative of each1202 // SCC, otherwise just check that we outlive said representative. This1203 // reduces the number of redundant relations propagated out of1204 // closures.1205 // Note that the representative will be a universal region if there is1206 // one in this SCC, so we will always check the representative here.1207 let representative = self.scc_representative(longer_fr_scc);1208 if representative != longer_fr {1209 if let RegionRelationCheckResult::Error = self.check_universal_region_relation(1210 longer_fr,1211 representative,1212 propagated_outlives_requirements,1213 ) {1214 errors_buffer.push(RegionErrorKind::RegionError {1215 longer_fr,1216 shorter_fr: representative,1217 fr_origin: NllRegionVariableOrigin::FreeRegion,1218 is_reported: true,1219 });1220 }1221 return;1222 }12231224 // Find every region `o` such that `fr: o`1225 // (because `fr` includes `end(o)`).1226 let mut error_reported = false;1227 for shorter_fr in self.scc_values.universal_regions_outlived_by(longer_fr_scc) {1228 if let RegionRelationCheckResult::Error = self.check_universal_region_relation(1229 longer_fr,1230 shorter_fr,1231 propagated_outlives_requirements,1232 ) {1233 // We only report the first region error. Subsequent errors are hidden so as1234 // not to overwhelm the user, but we do record them so as to potentially print1235 // better diagnostics elsewhere...1236 errors_buffer.push(RegionErrorKind::RegionError {1237 longer_fr,1238 shorter_fr,1239 fr_origin: NllRegionVariableOrigin::FreeRegion,1240 is_reported: !error_reported,1241 });12421243 error_reported = true;1244 }1245 }1246 }12471248 /// Checks that we can prove that `longer_fr: shorter_fr`. If we can't we attempt to propagate1249 /// the constraint outward (e.g. to a closure environment), but if that fails, there is an1250 /// error.1251 fn check_universal_region_relation(1252 &self,1253 longer_fr: RegionVid,1254 shorter_fr: RegionVid,1255 propagated_outlives_requirements: &mut Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,1256 ) -> RegionRelationCheckResult {1257 // If it is known that `fr: o`, carry on.1258 if self.universal_region_relations.outlives(longer_fr, shorter_fr) {1259 RegionRelationCheckResult::Ok1260 } else {1261 // If we are not in a context where we can't propagate errors, or we1262 // could not shrink `fr` to something smaller, then just report an1263 // error.1264 //1265 // Note: in this case, we use the unapproximated regions to report the1266 // error. This gives better error messages in some cases.1267 self.try_propagate_universal_region_error(1268 longer_fr,1269 shorter_fr,1270 propagated_outlives_requirements,1271 )1272 }1273 }12741275 /// Attempt to propagate a region error (e.g. `'a: 'b`) that is not met to a closure's1276 /// creator. If we cannot, then the caller should report an error to the user.1277 fn try_propagate_universal_region_error(1278 &self,1279 longer_fr: RegionVid,1280 shorter_fr: RegionVid,1281 propagated_outlives_requirements: &mut Option<&mut Vec<ClosureOutlivesRequirement<'tcx>>>,1282 ) -> RegionRelationCheckResult {1283 if let Some(propagated_outlives_requirements) = propagated_outlives_requirements {1284 // Shrink `longer_fr` until we find some non-local regions.1285 // We'll call them `longer_fr-` -- they are ever so slightly smaller than1286 // `longer_fr`.1287 let longer_fr_minus = self.universal_region_relations.non_local_lower_bounds(longer_fr);12881289 debug!("try_propagate_universal_region_error: fr_minus={:?}", longer_fr_minus);12901291 // If we don't find a any non-local regions, we should error out as there is nothing1292 // to propagate.1293 if longer_fr_minus.is_empty() {1294 return RegionRelationCheckResult::Error;1295 }12961297 let blame_constraint = self1298 .best_blame_constraint(longer_fr, NllRegionVariableOrigin::FreeRegion, shorter_fr)1299 .0;13001301 // Grow `shorter_fr` until we find some non-local regions.1302 // We will always find at least one: `'static`. We'll call1303 // them `shorter_fr+` -- they're ever so slightly larger1304 // than `shorter_fr`.1305 let shorter_fr_plus =1306 self.universal_region_relations.non_local_upper_bounds(shorter_fr);1307 debug!("try_propagate_universal_region_error: shorter_fr_plus={:?}", shorter_fr_plus);13081309 // We then create constraints `longer_fr-: shorter_fr+` that may or may not1310 // be propagated (see below).1311 let mut constraints = vec![];1312 for fr_minus in longer_fr_minus {1313 for shorter_fr_plus in &shorter_fr_plus {1314 constraints.push((fr_minus, *shorter_fr_plus));1315 }1316 }13171318 // We only need to propagate at least one of the constraints for1319 // soundness. However, we want to avoid arbitrary choices here1320 // and currently don't support returning OR constraints.1321 //1322 // If any of the `shorter_fr+` regions are already outlived by `longer_fr-`,1323 // we propagate only those.1324 //1325 // Consider this example (`'b: 'a` == `a -> b`), where we try to propagate `'d: 'a`:1326 // a --> b --> d1327 // \1328 // \-> c1329 // Here, `shorter_fr+` of `'a` == `['b, 'c]`.1330 // Propagating `'d: 'b` is correct and should occur; `'d: 'c` is redundant because of1331 // `'d: 'b` and could reject valid code.1332 //1333 // So we filter the constraints to regions already outlived by `longer_fr-`, but if1334 // the filter yields an empty set, we fall back to the original one.1335 let subset: Vec<_> = constraints1336 .iter()1337 .filter(|&&(fr_minus, shorter_fr_plus)| {1338 self.eval_outlives(fr_minus, shorter_fr_plus)1339 })1340 .copied()1341 .collect();1342 let propagated_constraints = if subset.is_empty() { constraints } else { subset };1343 debug!(1344 "try_propagate_universal_region_error: constraints={:?}",1345 propagated_constraints1346 );13471348 assert!(1349 !propagated_constraints.is_empty(),1350 "Expected at least one constraint to propagate here"1351 );13521353 for (fr_minus, fr_plus) in propagated_constraints {1354 // Push the constraint `long_fr-: shorter_fr+`1355 propagated_outlives_requirements.push(ClosureOutlivesRequirement {1356 subject: ClosureOutlivesSubject::Region(fr_minus),1357 outlived_free_region: fr_plus,1358 blame_span: blame_constraint.cause.span,1359 category: blame_constraint.category,1360 });1361 }1362 return RegionRelationCheckResult::Propagated;1363 }13641365 RegionRelationCheckResult::Error1366 }13671368 fn check_bound_universal_region(1369 &self,1370 longer_fr: RegionVid,1371 placeholder: ty::PlaceholderRegion<'tcx>,1372 errors_buffer: &mut RegionErrors<'tcx>,1373 ) {1374 debug!("check_bound_universal_region(fr={:?}, placeholder={:?})", longer_fr, placeholder,);13751376 let longer_fr_scc = self.constraint_sccs.scc(longer_fr);1377 debug!("check_bound_universal_region: longer_fr_scc={:?}", longer_fr_scc,);13781379 // If we have some bound universal region `'a`, then the only1380 // elements it can contain is itself -- we don't know anything1381 // else about it!1382 if let Some(error_element) = self1383 .scc_values1384 .elements_contained_in(longer_fr_scc)1385 .find(|e| *e != RegionElement::PlaceholderRegion(placeholder))1386 {1387 let illegally_outlived_r = self.region_from_element(longer_fr, &error_element);1388 // Stop after the first error, it gets too noisy otherwise, and does not provide more information.1389 errors_buffer.push(RegionErrorKind::PlaceholderOutlivesIllegalRegion {1390 longer_fr,1391 illegally_outlived_r,1392 });1393 } else {1394 debug!("check_bound_universal_region: all bounds satisfied");1395 }1396 }13971398 pub(crate) fn constraint_path_between_regions(1399 &self,1400 from_region: RegionVid,1401 to_region: RegionVid,1402 ) -> Option<Vec<OutlivesConstraint<'tcx>>> {1403 if from_region == to_region {1404 bug!("Tried to find a path between {from_region:?} and itself!");1405 }1406 self.constraint_path_to(from_region, |to| to == to_region, true).map(|o| o.0)1407 }14081409 /// Walks the graph of constraints (where `'a: 'b` is considered1410 /// an edge `'a -> 'b`) to find a path from `from_region` to1411 /// `to_region`.1412 ///1413 /// Returns: a series of constraints as well as the region `R`1414 /// that passed the target test.1415 /// If `include_static_outlives_all` is `true`, then the synthetic1416 /// outlives constraints `'static -> a` for every region `a` are1417 /// considered in the search, otherwise they are ignored.1418 #[instrument(skip(self, target_test), ret)]1419 pub(crate) fn constraint_path_to(1420 &self,1421 from_region: RegionVid,1422 target_test: impl Fn(RegionVid) -> bool,1423 include_placeholder_static: bool,1424 ) -> Option<(Vec<OutlivesConstraint<'tcx>>, RegionVid)> {1425 self.find_constraint_path_between_regions_inner(1426 true,1427 from_region,1428 &target_test,1429 include_placeholder_static,1430 )1431 .or_else(|| {1432 self.find_constraint_path_between_regions_inner(1433 false,1434 from_region,1435 &target_test,1436 include_placeholder_static,1437 )1438 })1439 }14401441 /// The constraints we get from equating the hidden type of each use of an opaque1442 /// with its final hidden type may end up getting preferred over other, potentially1443 /// longer constraint paths.1444 ///1445 /// Given that we compute the final hidden type by relying on this existing constraint1446 /// path, this can easily end up hiding the actual reason for why we require these regions1447 /// to be equal.1448 ///1449 /// To handle this, we first look at the path while ignoring these constraints and then1450 /// retry while considering them. This is not perfect, as the `from_region` may have already1451 /// been partially related to its argument region, so while we rely on a member constraint1452 /// to get a complete path, the most relevant step of that path already existed before then.1453 fn find_constraint_path_between_regions_inner(1454 &self,1455 ignore_opaque_type_constraints: bool,1456 from_region: RegionVid,1457 target_test: impl Fn(RegionVid) -> bool,1458 include_placeholder_static: bool,1459 ) -> Option<(Vec<OutlivesConstraint<'tcx>>, RegionVid)> {1460 let mut context = IndexVec::from_elem(Trace::NotVisited, &self.definitions);1461 context[from_region] = Trace::StartRegion;14621463 let fr_static = self.universal_regions().fr_static;14641465 // Use a deque so that we do a breadth-first search. We will1466 // stop at the first match, which ought to be the shortest1467 // path (fewest constraints).1468 let mut deque = VecDeque::new();1469 deque.push_back(from_region);14701471 while let Some(r) = deque.pop_front() {1472 debug!(1473 "constraint_path_to: from_region={:?} r={:?} value={}",1474 from_region,1475 r,1476 self.region_value_str(r),1477 );14781479 // Check if we reached the region we were looking for. If so,1480 // we can reconstruct the path that led to it and return it.1481 if target_test(r) {1482 let mut result = vec![];1483 let mut p = r;1484 // This loop is cold and runs at the end, which is why we delay1485 // `OutlivesConstraint` construction until now.1486 loop {1487 match context[p] {1488 Trace::FromGraph(c) => {1489 p = c.sup;1490 result.push(*c);1491 }14921493 Trace::FromStatic(sub) => {1494 let c = OutlivesConstraint {1495 sup: fr_static,1496 sub,1497 locations: Locations::All(DUMMY_SP),1498 span: DUMMY_SP,1499 category: ConstraintCategory::Internal,1500 variance_info: ty::VarianceDiagInfo::default(),1501 from_closure: false,1502 };1503 p = c.sup;1504 result.push(c);1505 }15061507 Trace::StartRegion => {1508 result.reverse();1509 return Some((result, r));1510 }15111512 Trace::NotVisited => {1513 bug!("found unvisited region {:?} on path to {:?}", p, r)1514 }1515 }1516 }1517 }15181519 // Otherwise, walk over the outgoing constraints and1520 // enqueue any regions we find, keeping track of how we1521 // reached them.15221523 // A constraint like `'r: 'x` can come from our constraint1524 // graph.15251526 // Always inline this closure because it can be hot.1527 let mut handle_trace = #[inline(always)]1528 |sub, trace| {1529 if let Trace::NotVisited = context[sub] {1530 context[sub] = trace;1531 deque.push_back(sub);1532 }1533 };15341535 // If this is the `'static` region and the graph's direction is normal, then set up the1536 // Edges iterator to return all regions (#53178).1537 if r == fr_static && self.constraint_graph.is_normal() {1538 for sub in self.constraint_graph.outgoing_edges_from_static() {1539 handle_trace(sub, Trace::FromStatic(sub));1540 }1541 } else {1542 let edges = self.constraint_graph.outgoing_edges_from_graph(r, &self.constraints);1543 // This loop can be hot.1544 for constraint in edges {1545 match constraint.category {1546 ConstraintCategory::OutlivesUnnameablePlaceholder(_)1547 if !include_placeholder_static =>1548 {1549 debug!("Ignoring illegal placeholder constraint: {constraint:?}");1550 continue;1551 }1552 ConstraintCategory::OpaqueType if ignore_opaque_type_constraints => {1553 debug!("Ignoring member constraint: {constraint:?}");1554 continue;1555 }1556 _ => {}1557 }15581559 debug_assert_eq!(constraint.sup, r);1560 handle_trace(constraint.sub, Trace::FromGraph(constraint));1561 }1562 }1563 }15641565 None1566 }15671568 /// Finds some region R such that `fr1: R` and `R` is live at `location`.1569 #[instrument(skip(self), level = "trace", ret)]1570 pub(crate) fn find_sub_region_live_at(&self, fr1: RegionVid, location: Location) -> RegionVid {1571 trace!(scc = ?self.constraint_sccs.scc(fr1));1572 trace!(universe = ?self.max_nameable_universe(self.constraint_sccs.scc(fr1)));1573 self.constraint_path_to(fr1, |r| {1574 trace!(?r, liveness_constraints=?self.liveness_constraints.pretty_print_live_points(r));1575 self.liveness_constraints.is_live_at(r, location)1576 }, true).unwrap().11577 }15781579 /// Get the region outlived by `longer_fr` and live at `element`.1580 fn region_from_element(1581 &self,1582 longer_fr: RegionVid,1583 element: &RegionElement<'tcx>,1584 ) -> RegionVid {1585 match *element {1586 RegionElement::Location(l) => self.find_sub_region_live_at(longer_fr, l),1587 RegionElement::RootUniversalRegion(r) => r,1588 RegionElement::PlaceholderRegion(error_placeholder) => self1589 .definitions1590 .iter_enumerated()1591 .find_map(|(r, definition)| match definition.origin {1592 NllRegionVariableOrigin::Placeholder(p) if p == error_placeholder => Some(r),1593 _ => None,1594 })1595 .unwrap(),1596 }1597 }15981599 /// Get the region definition of `r`.1600 pub(crate) fn region_definition(&self, r: RegionVid) -> &RegionDefinition<'tcx> {1601 &self.definitions[r]1602 }16031604 /// Check if the SCC of `r` contains `upper`.1605 pub(crate) fn upper_bound_in_region_scc(&self, r: RegionVid, upper: RegionVid) -> bool {1606 let r_scc = self.constraint_sccs.scc(r);1607 self.scc_values.contains(r_scc, upper)1608 }16091610 pub(crate) fn universal_regions(&self) -> &UniversalRegions<'tcx> {1611 &self.universal_region_relations.universal_regions1612 }16131614 /// Tries to find the best constraint to blame for the fact that1615 /// `R: from_region`, where `R` is some region that meets1616 /// `target_test`. This works by following the constraint graph,1617 /// creating a constraint path that forces `R` to outlive1618 /// `from_region`, and then finding the best choices within that1619 /// path to blame.1620 #[instrument(level = "debug", skip(self))]1621 pub(crate) fn best_blame_constraint(1622 &self,1623 from_region: RegionVid,1624 from_region_origin: NllRegionVariableOrigin<'tcx>,1625 to_region: RegionVid,1626 ) -> (BlameConstraint<'tcx>, Vec<OutlivesConstraint<'tcx>>) {1627 assert!(from_region != to_region, "Trying to blame a region for itself!");16281629 let path = self.constraint_path_between_regions(from_region, to_region).unwrap();16301631 // If we are passing through a constraint added because we reached an unnameable placeholder `'unnameable`,1632 // redirect search towards `'unnameable`.1633 let due_to_placeholder_outlives = path.iter().find_map(|c| {1634 if let ConstraintCategory::OutlivesUnnameablePlaceholder(unnameable) = c.category {1635 Some(unnameable)1636 } else {1637 None1638 }1639 });16401641 // Edge case: it's possible that `'from_region` is an unnameable placeholder.1642 let path = if let Some(unnameable) = due_to_placeholder_outlives1643 && unnameable != from_region1644 {1645 // We ignore the extra edges due to unnameable placeholders to get1646 // an explanation that was present in the original constraint graph.1647 self.constraint_path_to(from_region, |r| r == unnameable, false).unwrap().01648 } else {1649 path1650 };16511652 debug!(1653 "path={:#?}",1654 path.iter()1655 .map(|c| format!(1656 "{:?} ({:?}: {:?})",1657 c,1658 self.constraint_sccs.scc(c.sup),1659 self.constraint_sccs.scc(c.sub),1660 ))1661 .collect::<Vec<_>>()1662 );16631664 // We try to avoid reporting a `ConstraintCategory::Predicate` as our best constraint.1665 // Instead, we use it to produce an improved `ObligationCauseCode`.1666 // FIXME - determine what we should do if we encounter multiple1667 // `ConstraintCategory::Predicate` constraints. Currently, we just pick the first one.1668 let cause_code = path1669 .iter()1670 .find_map(|constraint| {1671 if let ConstraintCategory::Predicate(predicate_span) = constraint.category {1672 // We currently do not store the `DefId` in the `ConstraintCategory`1673 // for performances reasons. The error reporting code used by NLL only1674 // uses the span, so this doesn't cause any problems at the moment.1675 Some(ObligationCauseCode::WhereClause(CRATE_DEF_ID.to_def_id(), predicate_span))1676 } else {1677 None1678 }1679 })1680 .unwrap_or_else(|| ObligationCauseCode::Misc);16811682 // When reporting an error, there is typically a chain of constraints leading from some1683 // "source" region which must outlive some "target" region.1684 // In most cases, we prefer to "blame" the constraints closer to the target --1685 // but there is one exception. When constraints arise from higher-ranked subtyping,1686 // we generally prefer to blame the source value,1687 // as the "target" in this case tends to be some type annotation that the user gave.1688 // Therefore, if we find that the region origin is some instantiation1689 // of a higher-ranked region, we start our search from the "source" point1690 // rather than the "target", and we also tweak a few other things.1691 //1692 // An example might be this bit of Rust code:1693 //1694 // ```rust1695 // let x: fn(&'static ()) = |_| {};1696 // let y: for<'a> fn(&'a ()) = x;1697 // ```1698 //1699 // In MIR, this will be converted into a combination of assignments and type ascriptions.1700 // In particular, the 'static is imposed through a type ascription:1701 //1702 // ```rust1703 // x = ...;1704 // AscribeUserType(x, fn(&'static ())1705 // y = x;1706 // ```1707 //1708 // We wind up ultimately with constraints like1709 //1710 // ```rust1711 // !a: 'temp1 // from the `y = x` statement1712 // 'temp1: 'temp21713 // 'temp2: 'static // from the AscribeUserType1714 // ```1715 //1716 // and here we prefer to blame the source (the y = x statement).1717 let blame_source = match from_region_origin {1718 NllRegionVariableOrigin::FreeRegion => true,1719 NllRegionVariableOrigin::Placeholder(_) => false,1720 // `'existential: 'whatever` never results in a region error by itself.1721 // We may always infer it to `'static` afterall. This means while an error1722 // path may go through an existential, these existentials are never the1723 // `from_region`.1724 NllRegionVariableOrigin::Existential { name: _ } => {1725 unreachable!("existentials can outlive everything")1726 }1727 };17281729 // To pick a constraint to blame, we organize constraints by how interesting we expect them1730 // to be in diagnostics, then pick the most interesting one closest to either the source or1731 // the target on our constraint path.1732 let constraint_interest = |constraint: &OutlivesConstraint<'tcx>| {1733 // Try to avoid blaming constraints from desugarings, since they may not clearly match1734 // match what users have written. As an exception, allow blaming returns generated by1735 // `?` desugaring, since the correspondence is fairly clear.1736 let category = if let Some(kind) = constraint.span.desugaring_kind()1737 && (kind != DesugaringKind::QuestionMark1738 || !matches!(constraint.category, ConstraintCategory::Return(_)))1739 {1740 ConstraintCategory::Boring1741 } else {1742 constraint.category1743 };17441745 let interest = match category {1746 // Returns usually provide a type to blame and have specially written diagnostics,1747 // so prioritize them.1748 ConstraintCategory::Return(_) => 0,1749 // Unsizing coercions are interesting, since we have a note for that:1750 // `BorrowExplanation::add_object_lifetime_default_note`.1751 // FIXME(dianne): That note shouldn't depend on a coercion being blamed; see issue1752 // #131008 for an example of where we currently don't emit it but should.1753 // Once the note is handled properly, this case should be removed. Until then, it1754 // should be as limited as possible; the note is prone to false positives and this1755 // constraint usually isn't best to blame.1756 ConstraintCategory::Cast {1757 is_raw_ptr_dyn_type_cast: _,1758 unsize_to: Some(unsize_ty),1759 is_implicit_coercion: true,1760 } if to_region == self.universal_regions().fr_static1761 // Mirror the note's condition, to minimize how often this diverts blame.1762 && let ty::Adt(_, args) = unsize_ty.kind()1763 && args.iter().any(|arg| arg.as_type().is_some_and(|ty| ty.is_trait()))1764 // Mimic old logic for this, to minimize false positives in tests.1765 && !path1766 .iter()1767 .any(|c| matches!(c.category, ConstraintCategory::TypeAnnotation(_))) =>1768 {1769 11770 }1771 // Between other interesting constraints, order by their position on the `path`.1772 ConstraintCategory::Yield1773 | ConstraintCategory::UseAsConst1774 | ConstraintCategory::UseAsStatic1775 | ConstraintCategory::TypeAnnotation(1776 AnnotationSource::Ascription1777 | AnnotationSource::Declaration1778 | AnnotationSource::OpaqueCast,1779 )1780 | ConstraintCategory::Cast { .. }1781 | ConstraintCategory::CallArgument(_)1782 | ConstraintCategory::CopyBound1783 | ConstraintCategory::SizedBound1784 | ConstraintCategory::Assignment1785 | ConstraintCategory::Usage1786 | ConstraintCategory::ClosureUpvar(_) => 2,1787 // Generic arguments are unlikely to be what relates regions together1788 ConstraintCategory::TypeAnnotation(AnnotationSource::GenericArg) => 3,1789 // We handle predicates and opaque types specially; don't prioritize them here.1790 ConstraintCategory::Predicate(_) | ConstraintCategory::OpaqueType => 4,1791 // `Boring` constraints can correspond to user-written code and have useful spans,1792 // but don't provide any other useful information for diagnostics.1793 ConstraintCategory::Boring => 5,1794 // `BoringNoLocation` constraints can point to user-written code, but are less1795 // specific, and are not used for relations that would make sense to blame.1796 ConstraintCategory::BoringNoLocation => 6,1797 // Do not blame internal constraints if we can avoid it. Never blame1798 // the `'region: 'static` constraints introduced by placeholder outlives.1799 ConstraintCategory::Internal => 7,1800 ConstraintCategory::OutlivesUnnameablePlaceholder(_) => 8,1801 };18021803 debug!("constraint {constraint:?} category: {category:?}, interest: {interest:?}");18041805 interest1806 };18071808 let best_choice = if blame_source {1809 path.iter().enumerate().rev().min_by_key(|(_, c)| constraint_interest(c)).unwrap().01810 } else {1811 path.iter().enumerate().min_by_key(|(_, c)| constraint_interest(c)).unwrap().01812 };18131814 debug!(?best_choice, ?blame_source);18151816 let best_constraint = if let Some(next) = path.get(best_choice + 1)1817 && matches!(path[best_choice].category, ConstraintCategory::Return(_))1818 && next.category == ConstraintCategory::OpaqueType1819 {1820 // The return expression is being influenced by the return type being1821 // impl Trait, point at the return type and not the return expr.1822 *next1823 } else if path[best_choice].category == ConstraintCategory::Return(ReturnConstraint::Normal)1824 && let Some(field) = path.iter().find_map(|p| {1825 if let ConstraintCategory::ClosureUpvar(f) = p.category { Some(f) } else { None }1826 })1827 {1828 OutlivesConstraint {1829 category: ConstraintCategory::Return(ReturnConstraint::ClosureUpvar(field)),1830 ..path[best_choice]1831 }1832 } else {1833 path[best_choice]1834 };18351836 assert!(1837 !matches!(1838 best_constraint.category,1839 ConstraintCategory::OutlivesUnnameablePlaceholder(_)1840 ),1841 "Illegal placeholder constraint blamed; should have redirected to other region relation"1842 );18431844 let blame_constraint = BlameConstraint {1845 category: best_constraint.category,1846 from_closure: best_constraint.from_closure,1847 cause: ObligationCause::new(best_constraint.span, CRATE_DEF_ID, cause_code.clone()),1848 variance_info: best_constraint.variance_info,1849 };1850 (blame_constraint, path)1851 }18521853 pub(crate) fn universe_info(&self, universe: ty::UniverseIndex) -> UniverseInfo<'tcx> {1854 // Query canonicalization can create local superuniverses (for example in1855 // `InferCtx::query_response_instantiation_guess`), but they don't have an associated1856 // `UniverseInfo` explaining why they were created.1857 // This can cause ICEs if these causes are accessed in diagnostics, for example in issue1858 // #114907 where this happens via liveness and dropck outlives results.1859 // Therefore, we return a default value in case that happens, which should at worst emit a1860 // suboptimal error, instead of the ICE.1861 self.universe_causes.get(&universe).cloned().unwrap_or_else(UniverseInfo::other)1862 }18631864 /// Tries to find the terminator of the loop in which the region 'r' resides.1865 /// Returns the location of the terminator if found.1866 pub(crate) fn find_loop_terminator_location(1867 &self,1868 r: RegionVid,1869 body: &Body<'_>,1870 ) -> Option<Location> {1871 let scc = self.constraint_sccs.scc(r);1872 let locations = self.scc_values.locations_outlived_by(scc);1873 for location in locations {1874 let bb = &body[location.block];1875 if let Some(terminator) = &bb.terminator1876 // terminator of a loop should be TerminatorKind::FalseUnwind1877 && let TerminatorKind::FalseUnwind { .. } = terminator.kind1878 {1879 return Some(location);1880 }1881 }1882 None1883 }18841885 /// Access to the SCC constraint graph.1886 /// This can be used to quickly under-approximate the regions which are equal to each other1887 /// and their relative orderings.1888 // This is `pub` because it's used by unstable external borrowck data users, see `consumers.rs`.1889 pub fn constraint_sccs(&self) -> &ConstraintSccs {1890 &self.constraint_sccs1891 }18921893 /// Returns the representative `RegionVid` for a given SCC.1894 /// See `RegionTracker` for how a region variable ID is chosen.1895 ///1896 /// It is a hacky way to manage checking regions for equality,1897 /// since we can 'canonicalize' each region to the representative1898 /// of its SCC and be sure that -- if they have the same repr --1899 /// they *must* be equal (though not having the same repr does not1900 /// mean they are unequal).1901 fn scc_representative(&self, scc: ConstraintSccIndex) -> RegionVid {1902 self.scc_annotations[scc].representative.rvid()1903 }19041905 pub(crate) fn liveness_constraints(&self) -> &LivenessValues {1906 &self.liveness_constraints1907 }19081909 /// When using `-Zpolonius=next`, records the given live loans for the loan scopes and active1910 /// loans dataflow computations.1911 pub(crate) fn record_live_loans(&mut self, live_loans: LiveLoans) {1912 self.liveness_constraints.record_live_loans(live_loans);1913 }19141915 /// Returns whether the `loan_idx` is live at the given `location`: whether its issuing1916 /// region is contained within the type of a variable that is live at this point.1917 /// Note: for now, the sets of live loans is only available when using `-Zpolonius=next`.1918 pub(crate) fn is_loan_live_at(&self, loan_idx: BorrowIndex, location: Location) -> bool {1919 let point = self.liveness_constraints.point_from_location(location);1920 self.liveness_constraints.is_loan_live_at(loan_idx, point)1921 }1922}19231924#[derive(Clone, Debug)]1925pub(crate) struct BlameConstraint<'tcx> {1926 pub category: ConstraintCategory<'tcx>,1927 pub from_closure: bool,1928 pub cause: ObligationCause<'tcx>,1929 pub variance_info: ty::VarianceDiagInfo<TyCtxt<'tcx>>,1930}
Same data, no extra tab — call code_get_file + code_get_findings over MCP from Claude/Cursor/Copilot.