Struct RegionInferenceContext 

pub struct RegionInferenceContext<'tcx> {
    data: Frozen<RegionInferenceContextInner<'tcx>>,
}

This contains data around region constraints and liveness, up to and after solving. All data is immutable.

Fields

data: Frozen<RegionInferenceContextInner<'tcx>>

Implementations

impl<'tcx> RegionInferenceContext<'tcx>

pub(crate) fn get_var_name_and_span_for_region( &self, tcx: TyCtxt<'tcx>, body: &Body<'tcx>, local_names: &IndexSlice<Local, Option<Symbol>>, upvars: &[&CapturedPlace<'tcx>], fr: RegionVid, ) -> Option<(Option<Symbol>, Span)>

Find the name and span of the variable corresponding to the given region. The returned var will also be ensured to actually be used in body.

pub(crate) fn get_upvar_index_for_region( &self, tcx: TyCtxt<'tcx>, fr: RegionVid, ) -> Option<usize>

Search the upvars (if any) to find one that references fr. Return its index.

pub(crate) fn get_upvar_name_and_span_for_region( &self, tcx: TyCtxt<'tcx>, upvars: &[&CapturedPlace<'tcx>], upvar_index: usize, ) -> (Symbol, Span)

Given the index of an upvar, finds its name and the span from where it was declared.

pub(crate) fn get_user_arg_index_for_region( &self, tcx: TyCtxt<'tcx>, fr: RegionVid, ) -> Option<usize>

Search the argument types for one that references fr (which should be a free region). Returns Some(_) with the index of the input if one is found.

N.B., in the case of a closure, the index is indexing into the signature as seen by the user - in particular, index 0 is not the implicit self parameter.

fn user_arg_index_to_local( &self, body: &Body<'tcx>, user_arg_index: usize, ) -> Local

Given the index of an argument as seen from the user (i.e. excluding implicit inputs), returns the corresponding MIR local.

pub(crate) fn get_argument_name_and_span_for_region( &self, body: &Body<'tcx>, local_names: &IndexSlice<Local, Option<Symbol>>, user_arg_index: usize, ) -> (Option<Symbol>, Span)

Given the index of an argument, finds its name (if any) and the span from where it was declared.

impl<'tcx> RegionInferenceContext<'tcx>

pub(super) fn to_error_region(&self, r: RegionVid) -> Option<Region<'tcx>>

Converts a region inference variable into a ty::Region that we can use for error reporting. If r is universally bound, then we use the name that we have on record for it. If r is existentially bound, then we check its inferred value and try to find a good name from that. Returns None if we can’t find one (e.g., this is just some random part of the CFG).

pub(super) fn to_error_region_vid(&self, r: RegionVid) -> Option<RegionVid>

Returns the RegionVid corresponding to the region returned by to_error_region.

fn name_regions<T>(&self, tcx: TyCtxt<'tcx>, ty: T) -> T

where T: TypeFoldable<TyCtxt<'tcx>>,

Map the regions in the type to named regions, where possible.

fn is_closure_fn_mut(&self, fr: RegionVid) -> bool

Returns true if a closure is inferred to be an FnMut closure.

impl<'tcx> RegionInferenceContext<'tcx>

pub(crate) fn dump_mir( &self, tcx: TyCtxt<'tcx>, out: &mut dyn Write, ) -> Result<()>

Write out our state into the .mir files.

fn for_each_constraint( &self, tcx: TyCtxt<'tcx>, with_msg: &mut dyn FnMut(&str) -> Result<()>, ) -> Result<()>

Debugging aid: Invokes the with_msg callback repeatedly with our internal region constraints. These are dumped into the -Zdump-mir file so that we can figure out why the region inference resulted in the values that it did when debugging.

impl<'tcx> RegionInferenceContext<'tcx>

pub(crate) fn dump_graphviz_raw_constraints( &self, tcx: TyCtxt<'tcx>, w: &mut dyn Write, ) -> Result<()>

Write out the region constraint graph.

pub(crate) fn dump_graphviz_scc_constraints( &self, tcx: TyCtxt<'tcx>, w: &mut dyn Write, ) -> Result<()>

Write out the region constraint SCC graph.

impl<'tcx> RegionInferenceContext<'tcx>

pub(crate) fn name_regions_for_member_constraint<T>( &self, tcx: TyCtxt<'tcx>, ty: T, ) -> T

where T: TypeFoldable<TyCtxt<'tcx>>,

Map the regions in the type to named regions. This is similar to what infer_opaque_types does, but can infer any universal region, not only ones from the args for the opaque type. It also doesn’t double check that the regions produced are in fact equal to the named region they are replaced with. This is fine because this function is only to improve the region names in error messages.

This differs from MirBorrowckCtxt::name_regions since it is particularly lax with mapping region vids that are shorter than a universal region to that universal region. This is useful for member region constraints since we want to suggest a universal region name to capture even if it’s technically not equal to the error region.

Methods from Deref<Target = RegionInferenceContextInner<'tcx>>

pub(crate) fn regions(&self) -> impl Iterator<Item = RegionVid> + 'tcx

Returns an iterator over all the region indices.

pub(crate) fn to_region_vid(&self, r: Region<'tcx>) -> RegionVid

Given a universal region in scope on the MIR, returns the corresponding index.

Panics if r is not a registered universal region, most notably if it is a placeholder. Handling placeholders requires access to the MirTypeckRegionConstraints.

pub(crate) fn outlives_constraints( &self, ) -> impl Iterator<Item = OutlivesConstraint<'tcx>>

Returns an iterator over all the outlives constraints.

pub(crate) fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diag<'_>)

Adds annotations for #[rustc_regions]; see UniversalRegions::annotate.

pub(crate) fn region_contains_point(&self, r: RegionVid, p: Location) -> bool

Returns true if the region r contains the point p.

Panics if called before solve() executes,

pub(crate) fn first_non_contained_inclusive( &self, r: RegionVid, block: BasicBlock, start: usize, end: usize, ) -> Option<usize>

Returns the lowest statement index in start..=end which is not contained by r.

Panics if called before solve() executes.

pub(crate) fn region_value_str(&self, r: RegionVid) -> String

Returns access to the value of r for debugging purposes.

pub(crate) fn placeholders_contained_in( &self, r: RegionVid, ) -> impl Iterator<Item = PlaceholderRegion<'tcx>>

pub(crate) fn approx_universal_upper_bound(&self, r: RegionVid) -> RegionVid

Like universal_upper_bound, but returns an approximation more suitable for diagnostics. If r contains multiple disjoint universal regions (e.g. ’a and ’b in fn foo<'a, 'b> { ... }, we pick the lower-numbered region. This corresponds to picking named regions over unnamed regions (e.g. picking early-bound regions over a closure late-bound region).

This means that the returned value may not be a true upper bound, since only ’static is known to outlive disjoint universal regions. Therefore, this method should only be used in diagnostic code, where displaying some named universal region is better than falling back to ’static.

pub(super) fn max_nameable_universe( &self, scc: ConstraintSccIndex, ) -> UniverseIndex

The largest universe of any region nameable from this SCC.

pub(crate) fn constraint_path_between_regions( &self, from_region: RegionVid, to_region: RegionVid, ) -> Option<Vec<OutlivesConstraint<'tcx>>>

pub(crate) fn constraint_path_to( &self, from_region: RegionVid, target_test: impl Fn(RegionVid) -> bool, include_placeholder_static: bool, ) -> Option<(Vec<OutlivesConstraint<'tcx>>, RegionVid)>

Walks the graph of constraints (where 'a: 'b is considered an edge 'a -> 'b) to find a path from from_region to to_region.

Returns: a series of constraints as well as the region R that passed the target test. If include_static_outlives_all is true, then the synthetic outlives constraints 'static -> a for every region a are considered in the search, otherwise they are ignored.

fn find_constraint_path_between_regions_inner( &self, ignore_opaque_type_constraints: bool, from_region: RegionVid, target_test: impl Fn(RegionVid) -> bool, include_placeholder_static: bool, ) -> Option<(Vec<OutlivesConstraint<'tcx>>, RegionVid)>

The constraints we get from equating the hidden type of each use of an opaque with its final hidden type may end up getting preferred over other, potentially longer constraint paths.

Given that we compute the final hidden type by relying on this existing constraint path, this can easily end up hiding the actual reason for why we require these regions to be equal.

To handle this, we first look at the path while ignoring these constraints and then retry while considering them. This is not perfect, as the from_region may have already been partially related to its argument region, so while we rely on a member constraint to get a complete path, the most relevant step of that path already existed before then.

pub(crate) fn find_sub_region_live_at( &self, fr1: RegionVid, location: Location, ) -> RegionVid

Finds some region R such that fr1: R and R is live at location.

pub(crate) fn region_definition(&self, r: RegionVid) -> &RegionDefinition<'tcx>

Get the region definition of r.

pub(crate) fn upper_bound_in_region_scc( &self, r: RegionVid, upper: RegionVid, ) -> bool

Check if the SCC of r contains upper, a free region.

pub(crate) fn universal_regions(&self) -> &UniversalRegions<'tcx>

pub(crate) fn best_blame_constraint( &self, from_region: RegionVid, from_region_origin: NllRegionVariableOrigin<'tcx>, to_region: RegionVid, ) -> BestBlame<'tcx>

Tries to find the best constraint to blame for the fact that R: from_region, where R is some region that meets target_test. This works by following the constraint graph, creating a constraint path that forces R to outlive from_region, and then finding the best choices within that path to blame.

pub(crate) fn universe_info( &self, universe: UniverseIndex, ) -> UniverseInfo<'tcx>

pub(crate) fn find_loop_terminator_location( &self, r: RegionVid, body: &Body<'_>, ) -> Option<Location>

Tries to find the terminator of the loop in which the region ‘r’ resides. Returns the location of the terminator if found.

pub(crate) fn constraint_sccs(&self) -> &Sccs<RegionVid, ConstraintSccIndex>

Access to the SCC constraint graph. This can be used to quickly under-approximate the regions which are equal to each other and their relative orderings.

pub(crate) fn liveness_constraints(&self) -> &LivenessValues

pub(crate) fn is_loan_live_at( &self, loan_idx: BorrowIndex, location: Location, ) -> bool

Returns whether the loan_idx is live at the given location: whether its issuing region is contained within the type of a variable that is live at this point. Note: for now, the sets of live loans is only available when using -Zpolonius=next.

Trait Implementations

impl<'tcx> Deref for RegionInferenceContext<'tcx>

type Target = RegionInferenceContextInner<'tcx>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 904 bytes