Struct RegionInferenceContextInner 

pub struct RegionInferenceContextInner<'tcx> {
    pub(crate) definitions: Frozen<IndexVec<RegionVid, RegionDefinition<'tcx>>>,
    pub(super) liveness_constraints: LivenessValues,
    pub(super) constraints: Frozen<OutlivesConstraintSet<'tcx>>,
    pub(super) constraint_graph: Frozen<ConstraintGraph<Normal>>,
    pub(super) constraint_sccs: Sccs<RegionVid, ConstraintSccIndex>,
    pub(super) scc_annotations: IndexVec<ConstraintSccIndex, RegionTracker>,
    pub(super) universe_causes: FxIndexMap<UniverseIndex, UniverseInfo<'tcx>>,
    pub(super) scc_values: RegionValues<'tcx, ConstraintSccIndex>,
    pub(super) universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
}

Contains the data for RegionInferenceContext and UnsolvedRegionInferenceContext.

Fields

definitions: Frozen<IndexVec<RegionVid, RegionDefinition<'tcx>>>

Contains the definition for every region variable. Region variables are identified by their index (RegionVid). The definition contains information about where the region came from as well as its final inferred value.

liveness_constraints: LivenessValues

The liveness constraints added to each region. For most regions, these start out empty and steadily grow, though for each universally quantified region R they start out containing the entire CFG and end(R).

constraints: Frozen<OutlivesConstraintSet<'tcx>>

The outlives constraints computed by the type-check.

constraint_graph: Frozen<ConstraintGraph<Normal>>

The constraint-set, but in graph form, making it easy to traverse the constraints adjacent to a particular region. Used to construct the SCC (see constraint_sccs) and for error reporting.

constraint_sccs: Sccs<RegionVid, ConstraintSccIndex>

The SCC computed from constraints and the constraint graph. We have an edge from SCC A to SCC B if A: B. Used to compute the values of each region.

scc_annotations: IndexVec<ConstraintSccIndex, RegionTracker>

universe_causes: FxIndexMap<UniverseIndex, UniverseInfo<'tcx>>

Map universe indexes to information on why we created it.

scc_values: RegionValues<'tcx, ConstraintSccIndex>

The final inferred values of the region variables; we compute one value per SCC. To get the value for any given region, you first find which scc it is a part of.

universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>

Information about how the universally quantified regions in scope on this function relate to one another.

Implementations

impl<'tcx> 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.

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