struct LexicalResolver<'cx, 'tcx> {
region_rels: &'cx RegionRelations<'cx, 'tcx>,
var_infos: VarInfos,
data: RegionConstraintData<'tcx>,
}
Fields§
§region_rels: &'cx RegionRelations<'cx, 'tcx>
§var_infos: VarInfos
§data: RegionConstraintData<'tcx>
Implementations§
source§impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx>
impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx>
fn tcx(&self) -> TyCtxt<'tcx>
fn infer_variable_values( &mut self, errors: &mut Vec<RegionResolutionError<'tcx>>, ) -> LexicalRegionResolutions<'tcx>
fn num_vars(&self) -> usize
sourcefn construct_var_data(&self) -> LexicalRegionResolutions<'tcx>
fn construct_var_data(&self) -> LexicalRegionResolutions<'tcx>
Initially, the value for all variables is set to 'empty
, the
empty region. The expansion
phase will grow this larger.
fn dump_constraints(&self)
fn expansion(&self, var_values: &mut LexicalRegionResolutions<'tcx>)
sourcefn expand_node(
&self,
a_region: Region<'tcx>,
b_vid: RegionVid,
b_data: &mut VarValue<'tcx>,
) -> bool
fn expand_node( &self, a_region: Region<'tcx>, b_vid: RegionVid, b_data: &mut VarValue<'tcx>, ) -> bool
Expands the value of the region represented with b_vid
with current
value b_data
to the lub of b_data
and a_region
. The corresponds
with the constraint '?b: 'a
('a <: '?b
), where 'a
is some known
region and '?b
is some region variable.
sourcefn sub_region_values(&self, a: VarValue<'tcx>, b: VarValue<'tcx>) -> bool
fn sub_region_values(&self, a: VarValue<'tcx>, b: VarValue<'tcx>) -> bool
True if a <= b
.
sourcefn sub_concrete_regions(&self, a: Region<'tcx>, b: Region<'tcx>) -> bool
fn sub_concrete_regions(&self, a: Region<'tcx>, b: Region<'tcx>) -> bool
True if a <= b
, but not defined over inference variables.
sourcefn lub_concrete_regions(&self, a: Region<'tcx>, b: Region<'tcx>) -> Region<'tcx>
fn lub_concrete_regions(&self, a: Region<'tcx>, b: Region<'tcx>) -> Region<'tcx>
Returns the least-upper-bound of a
and b
; i.e., the
smallest region c
such that a <= c
and b <= c
.
Neither a
nor b
may be an inference variable (hence the
term “concrete regions”).
sourcefn collect_errors(
&self,
var_data: &mut LexicalRegionResolutions<'tcx>,
errors: &mut Vec<RegionResolutionError<'tcx>>,
)
fn collect_errors( &self, var_data: &mut LexicalRegionResolutions<'tcx>, errors: &mut Vec<RegionResolutionError<'tcx>>, )
After expansion is complete, go and check upper bounds (i.e., cases where the region cannot grow larger than a fixed point) and check that they are satisfied.
sourcefn collect_var_errors(
&self,
var_data: &LexicalRegionResolutions<'tcx>,
errors: &mut Vec<RegionResolutionError<'tcx>>,
)
fn collect_var_errors( &self, var_data: &LexicalRegionResolutions<'tcx>, errors: &mut Vec<RegionResolutionError<'tcx>>, )
Go over the variables that were declared to be error variables
and create a RegionResolutionError
for each of them.
fn construct_graph(&self) -> Graph<(), Constraint<'tcx>>
fn collect_error_for_expanding_node( &self, graph: &Graph<(), Constraint<'tcx>>, dup_vec: &mut IndexSlice<RegionVid, Option<RegionVid>>, node_idx: RegionVid, errors: &mut Vec<RegionResolutionError<'tcx>>, )
sourcefn collect_bounding_regions(
&self,
graph: &Graph<(), Constraint<'tcx>>,
orig_node_idx: RegionVid,
dir: Direction,
dup_vec: Option<&mut IndexSlice<RegionVid, Option<RegionVid>>>,
) -> (Vec<RegionAndOrigin<'tcx>>, FxHashSet<RegionVid>, bool)
fn collect_bounding_regions( &self, graph: &Graph<(), Constraint<'tcx>>, orig_node_idx: RegionVid, dir: Direction, dup_vec: Option<&mut IndexSlice<RegionVid, Option<RegionVid>>>, ) -> (Vec<RegionAndOrigin<'tcx>>, FxHashSet<RegionVid>, bool)
Collects all regions that “bound” the variable orig_node_idx
in the
given direction.
If dup_vec
is Some
it’s used to track duplicates between successive
calls of this function.
The return tuple fields are:
- a list of all concrete regions bounding the given region.
- the set of all region variables bounding the given region.
- a
bool
that’s true if the returned region variables overlap with those returned by a previous call for another region.
fn bound_is_met( &self, bound: &VerifyBound<'tcx>, var_values: &LexicalRegionResolutions<'tcx>, generic_ty: Ty<'tcx>, min: Region<'tcx>, ) -> bool
Auto Trait Implementations§
impl<'cx, 'tcx> Freeze for LexicalResolver<'cx, 'tcx>
impl<'cx, 'tcx> !RefUnwindSafe for LexicalResolver<'cx, 'tcx>
impl<'cx, 'tcx> !Send for LexicalResolver<'cx, 'tcx>
impl<'cx, 'tcx> !Sync for LexicalResolver<'cx, 'tcx>
impl<'cx, 'tcx> Unpin for LexicalResolver<'cx, 'tcx>
impl<'cx, 'tcx> !UnwindSafe for LexicalResolver<'cx, 'tcx>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
source§impl<T> Filterable for T
impl<T> Filterable for T
source§fn filterable(
self,
filter_name: &'static str,
) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
fn filterable( self, filter_name: &'static str, ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§impl<P> IntoQueryParam<P> for P
impl<P> IntoQueryParam<P> for P
fn into_query_param(self) -> P
source§impl<T> MaybeResult<T> for T
impl<T> MaybeResult<T> for T
source§impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
source§impl<I, T> UpcastFrom<I, T> for T
impl<I, T> UpcastFrom<I, T> for T
fn upcast_from(from: T, _tcx: I) -> T
source§impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T
source§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
source§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
source§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
impl<T> ErasedDestructor for Twhere
T: 'static,
impl<T> MaybeSendSync for T
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: 104 bytes