Struct ClosureData 

pub struct ClosureData {
    pub min_captures: FxIndexMap<BindingId, Vec<CapturedPlace>>,
    pub fake_reads: Box<[(Place, FakeReadCause, SmallVec<[CaptureSourceStack; 2]>)]>,
    pub liberated_sig: StoredFnSig,
}

Fields

min_captures: FxIndexMap<BindingId, Vec<CapturedPlace>>

Tracks the minimum captures required for a closure; see MinCaptureInformationMap for more details.

fake_reads: Box<[(Place, FakeReadCause, SmallVec<[CaptureSourceStack; 2]>)]>

Tracks the fake reads required for a closure and the reason for the fake read. When performing pattern matching for closures, there are times we don’t end up reading places that are mentioned in a closure (because of _ patterns). However, to ensure the places are initialized, we introduce fake reads. Consider these two examples:

let x: u8;
let c = || match x { _ => () };

In this example, we don’t need to actually read/borrow x in c, and so we don’t want to capture it. However, we do still want an error here, because x should have to be initialized at the point where c is created. Therefore, we add a “fake read” instead.

let c = || {
    let (t1, t2) = t;
}

In the second example, we capture the disjoint fields of t (t.0 & t.1), but we never capture t. This becomes an issue when we build MIR as we require information on t in order to create place t.0 and t.1. We can solve this issue by fake reading t.

liberated_sig: StoredFnSig

For each fn, records the “liberated” types of its arguments and return type. Liberated means that all bound regions (including late-bound regions) are replaced with free equivalents. This table is not used in codegen (since regions are erased there) and hence is not serialized to metadata.

This table also contains the “revealed” values for any impl Trait that appear in the signature and whose values are being inferred by this function.

Example

fn foo(x: &u32) -> impl Debug { *x }

The function signature here would be:

for<'a> fn(&'a u32) -> Foo

where Foo is an opaque type created for this function.

The liberated form of this would be

fn(&'a u32) -> u32

Note that 'a is not bound (it would be an ReLateParam) and that the Foo opaque type is replaced by its hidden type.

Trait Implementations

impl Clone for ClosureData

fn clone(&self) -> ClosureData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ClosureData

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

Formats the value using the given formatter.

impl Eq for ClosureData

impl PartialEq for ClosureData

fn eq(&self, other: &ClosureData) -> 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 StructuralPartialEq for ClosureData