Struct CapturedPlace

pub struct CapturedPlace<'tcx> {
    pub var_ident: Ident,
    pub place: Place<'tcx>,
    pub info: CaptureInfo,
    pub mutability: Mutability,
}

A composite describing a Place that is captured by a closure.

Fields

var_ident: Ident

Name and span where the binding happens.

place: Place<'tcx>

The Place that is captured.

info: CaptureInfo

CaptureKind and expression(s) that resulted in such capture of place.

mutability: Mutability

Represents if place can be mutated or not.

Implementations

impl<'tcx> CapturedPlace<'tcx>

pub fn to_string(&self, tcx: TyCtxt<'tcx>) -> String

pub fn to_symbol(&self) -> Symbol

Returns a symbol of the captured upvar, which looks like name__field1__field2.

pub fn get_root_variable(&self) -> HirId

Returns the hir-id of the root variable for the captured place. e.g., if a.b.c was captured, would return the hir-id for a.

pub fn get_closure_local_def_id(&self) -> LocalDefId

Returns the LocalDefId of the closure that captured this Place

pub fn get_path_span(&self, tcx: TyCtxt<'tcx>) -> Span

Return span pointing to use that resulted in selecting the captured path

pub fn get_capture_kind_span(&self, tcx: TyCtxt<'tcx>) -> Span

Return span pointing to use that resulted in selecting the current capture kind

pub fn is_by_ref(&self) -> bool

Trait Implementations

impl<'tcx> Clone for CapturedPlace<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for CapturedPlace<'tcx>

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

Formats the value using the given formatter.

impl<'tcx, __D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<__D> for CapturedPlace<'tcx>

fn decode(__decoder: &mut __D) -> Self

impl<'tcx, __E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<__E> for CapturedPlace<'tcx>

fn encode(&self, __encoder: &mut __E)

impl<'tcx> Hash for CapturedPlace<'tcx>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for CapturedPlace<'tcx>

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher, )

impl<'tcx> PartialEq for CapturedPlace<'tcx>

fn eq(&self, other: &CapturedPlace<'tcx>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for CapturedPlace<'tcx>

fn try_fold_with<__F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, __folder: &mut __F, ) -> Result<Self, __F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for CapturedPlace<'tcx>

fn visit_with<__V: TypeVisitor<TyCtxt<'tcx>>>( &self, __visitor: &mut __V, ) -> __V::Result

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'tcx> Eq for CapturedPlace<'tcx>

impl<'tcx> StructuralPartialEq for CapturedPlace<'tcx>

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