Struct rustc_typeck::check::upvar::InferBorrowKind

pub(in check::upvar) struct InferBorrowKind<'a, 'tcx> {
    fcx: &'a FnCtxt<'a, 'tcx>,
    closure_def_id: DefId,
    closure_span: Span,
    capture_clause: CaptureBy,
    current_closure_kind: ClosureKind,
    current_origin: Option<(Span, Symbol)>,
    capture_information: FxIndexMap<Place<'tcx>, CaptureInfo<'tcx>>,
}

Fields

fcx: &'a FnCtxt<'a, 'tcx>

closure_def_id: DefId

closure_span: Span

capture_clause: CaptureBy

current_closure_kind: ClosureKind

current_origin: Option<(Span, Symbol)>

capture_information: FxIndexMap<Place<'tcx>, CaptureInfo<'tcx>>

For each Place that is captured by the closure, we track the minimal kind of access we need (ref, ref mut, move, etc) and the expression that resulted in such access.

Consider closure where s.str1 is captured via an ImmutableBorrow and s.str2 via a MutableBorrow

struct SomeStruct { str1: String, str2: String }

// Assume that the HirId for the variable definition is `V1`
let mut s = SomeStruct { str1: format!("s1"), str2: format!("s2") }

let fix_s = |new_s2| {
    // Assume that the HirId for the expression `s.str1` is `E1`
    println!("Updating SomeStruct with str1=", s.str1);
    // Assume that the HirId for the expression `*s.str2` is `E2`
    s.str2 = new_s2;
};

For closure fix_s, (at a high level) the map contains

Place { V1, [ProjectionKind::Field(Index=0, Variant=0)] } : CaptureKind { E1, ImmutableBorrow } Place { V1, [ProjectionKind::Field(Index=1, Variant=0)] } : CaptureKind { E2, MutableBorrow }

Implementations

impl<'a, 'tcx> InferBorrowKind<'a, 'tcx>

pub(in check::upvar) fn adjust_upvar_borrow_kind_for_consume(
    &mut self,
    place_with_id: &PlaceWithHirId<'tcx>,
    diag_expr_id: HirId,
    mode: ConsumeMode
)

pub(in check::upvar) fn adjust_upvar_borrow_kind_for_mut(
    &mut self,
    place_with_id: &PlaceWithHirId<'tcx>,
    diag_expr_id: HirId
)

Indicates that place_with_id is being directly mutated (e.g., assigned to). If the place is based on a by-ref upvar, this implies that the upvar must be borrowed using an &mut borrow.

pub(in check::upvar) fn adjust_upvar_borrow_kind_for_unique(
    &mut self,
    place_with_id: &PlaceWithHirId<'tcx>,
    diag_expr_id: HirId
)

pub(in check::upvar) fn adjust_upvar_deref(
    &mut self,
    place_with_id: &PlaceWithHirId<'tcx>,
    diag_expr_id: HirId,
    borrow_kind: BorrowKind
)

pub(in check::upvar) fn adjust_upvar_borrow_kind(
    &mut self,
    place_with_id: &PlaceWithHirId<'tcx>,
    diag_expr_id: HirId,
    kind: BorrowKind
)

We infer the borrow_kind with which to borrow upvars in a stack closure. The borrow_kind basically follows a lattice of imm < unique-imm < mut, moving from left to right as needed (but never right to left). Here the argument mutbl is the borrow_kind that is required by some particular use.

pub(in check::upvar) fn adjust_closure_kind(
    &mut self,
    closure_id: LocalDefId,
    new_kind: ClosureKind,
    upvar_span: Span,
    var_name: Symbol
)

pub(in check::upvar) fn init_capture_info_for_place(
    &mut self,
    place_with_id: &PlaceWithHirId<'tcx>,
    diag_expr_id: HirId
)

Trait Implementations

impl<'a, 'tcx> Delegate<'tcx> for InferBorrowKind<'a, 'tcx>

pub fn consume(
    &mut self,
    place_with_id: &PlaceWithHirId<'tcx>,
    diag_expr_id: HirId,
    mode: ConsumeMode
)

pub fn borrow(
    &mut self,
    place_with_id: &PlaceWithHirId<'tcx>,
    diag_expr_id: HirId,
    bk: BorrowKind
)

pub fn mutate(
    &mut self,
    assignee_place: &PlaceWithHirId<'tcx>,
    diag_expr_id: HirId
)