Struct rustc_borrowck::constraints::OutlivesConstraintSet

pub(crate) struct OutlivesConstraintSet<'tcx> {
    outlives: IndexVec<OutlivesConstraintIndex, OutlivesConstraint<'tcx>>,
}

A set of NLL region constraints. These include “outlives” constraints of the form R1: R2. Each constraint is identified by a unique OutlivesConstraintIndex and you can index into the set (constraint_set[i]) to access the constraint details.

Fields

outlives: IndexVec<OutlivesConstraintIndex, OutlivesConstraint<'tcx>>

Implementations

impl<'tcx> OutlivesConstraintSet<'tcx>

pub(crate) fn push(&mut self, constraint: OutlivesConstraint<'tcx>)

pub(crate) fn graph(&self, num_region_vars: usize) -> ConstraintGraph<Normal>

Constructs a “normal” graph from the constraint set; the graph makes it easy to find the constraints affecting a particular region.

N.B., this graph contains a “frozen” view of the current constraints. Any new constraints added to the OutlivesConstraintSet after the graph is built will not be present in the graph.

pub(crate) fn reverse_graph( &self, num_region_vars: usize, ) -> ConstraintGraph<Reverse>

Like graph, but constraints a reverse graph where R1: R2 represents an edge R2 -> R1.

pub(crate) fn outlives( &self, ) -> &IndexSlice<OutlivesConstraintIndex, OutlivesConstraint<'tcx>>

pub(crate) fn compute_sccs( &self, static_region: RegionVid, definitions: &IndexVec<RegionVid, RegionDefinition<'tcx>>, ) -> Sccs<RegionVid, ConstraintSccIndex, RegionTracker>

Computes cycles (SCCs) in the graph of regions. In particular, find all regions R1, R2 such that R1: R2 and R2: R1 and group them into an SCC, and find the relationships between SCCs.

pub(crate) fn add_outlives_static( &mut self, universal_regions: &UniversalRegions<'tcx>, definitions: &IndexVec<RegionVid, RegionDefinition<'tcx>>, ) -> Sccs<RegionVid, ConstraintSccIndex, RegionTracker>

This method handles Universe errors by rewriting the constraint graph. For each strongly connected component in the constraint graph such that there is a series of constraints A: B: C: … : X where A’s universe is smaller than X’s and A is a placeholder, add a constraint that A: ’static. This is a safe upper bound in the face of borrow checker/trait solver limitations that will eventually go away.

For a more precise definition, see the documentation for RegionTracker::has_incompatible_universes().

This edge case used to be handled during constraint propagation by iterating over the strongly connected components in the constraint graph while maintaining a set of bookkeeping mappings similar to what is stored in RegionTracker and manually adding ’sttaic as needed.

It was rewritten as part of the Polonius project with the goal of moving higher-kindedness concerns out of the path of the borrow checker, for two reasons:

1. Implementing Polonius is difficult enough without also handling them.
2. The long-term goal is to handle higher-kinded concerns in the trait solver, where they belong. This avoids logic duplication and allows future trait solvers to compute better bounds than for example our “must outlive ’static” here.

This code is a stop-gap measure in preparation for the future trait solver.

Every constraint added by this method is an internal IllegalUniverse constraint.

Trait Implementations

impl<'tcx> Clone for OutlivesConstraintSet<'tcx>

fn clone(&self) -> OutlivesConstraintSet<'tcx>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'tcx> Debug for OutlivesConstraintSet<'tcx>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'tcx> Default for OutlivesConstraintSet<'tcx>

fn default() -> OutlivesConstraintSet<'tcx>

Returns the “default value” for a type.

impl<'tcx> Index<OutlivesConstraintIndex> for OutlivesConstraintSet<'tcx>

type Output = OutlivesConstraint<'tcx>

The returned type after indexing.

fn index(&self, i: OutlivesConstraintIndex) -> &Self::Output

Performs the indexing (container[index]) operation.

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: 24 bytes