pub(crate) struct MirBorrowckCtxt<'cx, 'tcx> {
Show 22 fields pub(crate) infcx: &'cx InferCtxt<'tcx>, pub(crate) param_env: ParamEnv<'tcx>, pub(crate) body: &'cx Body<'tcx>, pub(crate) move_data: &'cx MoveData<'tcx>, pub(crate) location_table: &'cx LocationTable, pub(crate) movable_generator: bool, pub(crate) locals_are_invalidated_at_exit: bool, pub(crate) access_place_error_reported: FxHashSet<(Place<'tcx>, Span)>, pub(crate) reservation_error_reported: FxHashSet<Place<'tcx>>, pub(crate) fn_self_span_reported: FxHashSet<Span>, pub(crate) uninitialized_error_reported: FxHashSet<PlaceRef<'tcx>>, pub(crate) used_mut: FxHashSet<Local>, pub(crate) used_mut_upvars: SmallVec<[Field; 8]>, pub(crate) regioncx: Rc<RegionInferenceContext<'tcx>>, pub(crate) borrow_set: Rc<BorrowSet<'tcx>>, pub(crate) dominators: OnceCell<Dominators<BasicBlock>>, pub(crate) upvars: Vec<Upvar<'tcx>>, pub(crate) local_names: IndexVec<Local, Option<Symbol>>, pub(crate) region_names: RefCell<FxHashMap<RegionVid, RegionName>>, pub(crate) next_region_name: RefCell<usize>, pub(crate) polonius_output: Option<Rc<PoloniusOutput>>, pub(crate) errors: BorrowckErrors<'tcx>,
}

Fields§

§infcx: &'cx InferCtxt<'tcx>§param_env: ParamEnv<'tcx>§body: &'cx Body<'tcx>§move_data: &'cx MoveData<'tcx>§location_table: &'cx LocationTable

Map from MIR Location to LocationIndex; created when MIR borrowck begins.

§movable_generator: bool§locals_are_invalidated_at_exit: bool

This keeps track of whether local variables are free-ed when the function exits even without a StorageDead, which appears to be the case for constants.

I’m not sure this is the right approach - @eddyb could you try and figure this out?

§access_place_error_reported: FxHashSet<(Place<'tcx>, Span)>

This field keeps track of when borrow errors are reported in the access_place function so that there is no duplicate reporting. This field cannot also be used for the conflicting borrow errors that is handled by the reservation_error_reported field as the inclusion of the Span type (while required to mute some errors) stops the muting of the reservation errors.

§reservation_error_reported: FxHashSet<Place<'tcx>>

This field keeps track of when borrow conflict errors are reported for reservations, so that we don’t report seemingly duplicate errors for corresponding activations.

§fn_self_span_reported: FxHashSet<Span>

This fields keeps track of the Spans that we have used to report extra information for FnSelfUse, to avoid unnecessarily verbose errors.

§uninitialized_error_reported: FxHashSet<PlaceRef<'tcx>>

This field keeps track of errors reported in the checking of uninitialized variables, so that we don’t report seemingly duplicate errors.

§used_mut: FxHashSet<Local>

This field keeps track of all the local variables that are declared mut and are mutated. Used for the warning issued by an unused mutable local variable.

§used_mut_upvars: SmallVec<[Field; 8]>

If the function we’re checking is a closure, then we’ll need to report back the list of mutable upvars that have been used. This field keeps track of them.

§regioncx: Rc<RegionInferenceContext<'tcx>>

Region inference context. This contains the results from region inference and lets us e.g. find out which CFG points are contained in each borrow region.

§borrow_set: Rc<BorrowSet<'tcx>>

The set of borrows extracted from the MIR

§dominators: OnceCell<Dominators<BasicBlock>>

Dominators for MIR

§upvars: Vec<Upvar<'tcx>>

Information about upvars not necessarily preserved in types or MIR

§local_names: IndexVec<Local, Option<Symbol>>

Names of local (user) variables (extracted from var_debug_info).

§region_names: RefCell<FxHashMap<RegionVid, RegionName>>

Record the region names generated for each region in the given MIR def so that we can reuse them later in help/error messages.

§next_region_name: RefCell<usize>

The counter for generating new region names.

§polonius_output: Option<Rc<PoloniusOutput>>

Results of Polonius analysis.

§errors: BorrowckErrors<'tcx>

Implementations§

source§

impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx>

source

pub(crate) fn cannot_move_when_borrowed(
&self,
span: Span,
borrow_span: Span,
place: &str,
borrow_place: &str,
value_place: &str
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn cannot_use_when_mutably_borrowed(
&self,
span: Span,
desc: &str,
borrow_span: Span,
borrow_desc: &str
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn cannot_mutably_borrow_multiply(
&self,
new_loan_span: Span,
desc: &str,
opt_via: &str,
old_loan_span: Span,
old_opt_via: &str,
old_load_end_span: Option<Span>
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn cannot_uniquely_borrow_by_two_closures(
&self,
new_loan_span: Span,
desc: &str,
old_loan_span: Span,
old_load_end_span: Option<Span>
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn cannot_uniquely_borrow_by_one_closure(
&self,
new_loan_span: Span,
container_name: &str,
desc_new: &str,
opt_via: &str,
old_loan_span: Span,
noun_old: &str,
old_opt_via: &str,
previous_end_span: Option<Span>
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

pub(crate) fn cannot_reborrow_already_uniquely_borrowed(
&self,
new_loan_span: Span,
container_name: &str,
desc_new: &str,
opt_via: &str,
kind_new: &str,
old_loan_span: Span,
old_opt_via: &str,
previous_end_span: Option<Span>,
second_borrow_desc: &str
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

pub(crate) fn cannot_reborrow_already_borrowed(
&self,
span: Span,
desc_new: &str,
msg_new: &str,
kind_new: &str,
old_span: Span,
noun_old: &str,
kind_old: &str,
msg_old: &str,
old_load_end_span: Option<Span>
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

pub(crate) fn cannot_assign_to_borrowed(
&self,
span: Span,
borrow_span: Span,
desc: &str
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

pub(crate) fn cannot_reassign_immutable(
&self,
span: Span,
desc: &str,
is_arg: bool
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

pub(crate) fn cannot_assign(
&self,
span: Span,
desc: &str
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn cannot_move_out_of(
&self,
move_from_span: Span,
move_from_desc: &str
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

pub(crate) fn cannot_move_out_of_interior_noncopy(
&self,
move_from_span: Span,
ty: Ty<'_>,
is_index: Option<bool>
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

Signal an error due to an attempt to move out of the interior of an array or slice. is_index is None when error origin didn’t capture whether there was an indexing operation or not.

source

pub(crate) fn cannot_move_out_of_interior_of_drop(
&self,
move_from_span: Span,
container_ty: Ty<'_>
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

pub(crate) fn cannot_act_on_moved_value(
&self,
use_span: Span,
verb: &str,
optional_adverb_for_moved: &str,
moved_path: Option<String>
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn cannot_borrow_path_as_mutable_because(
&self,
span: Span,
path: &str,
reason: &str
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn cannot_mutate_in_immutable_section(
&self,
mutate_span: Span,
immutable_span: Span,
immutable_place: &str,
immutable_section: &str,
action: &str
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn cannot_borrow_across_generator_yield(
&self,
span: Span,
yield_span: Span
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn cannot_borrow_across_destructor(
&self,
borrow_span: Span
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn path_does_not_live_long_enough(
&self,
span: Span,
path: &str
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn cannot_return_reference_to_local(
&self,
span: Span,
return_kind: &str,
reference_desc: &str,
path_desc: &str
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn cannot_capture_in_long_lived_closure(
&self,
closure_span: Span,
closure_kind: &str,
borrowed_path: &str,
capture_span: Span,
scope: &str
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn thread_local_value_does_not_live_long_enough(
&self,
span: Span
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn temporary_value_borrowed_for_too_long(
&self,
span: Span
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source

pub(crate) fn struct_span_err_with_code<S: Into<MultiSpan>>(
&self,
sp: S,
msg: impl Into<DiagnosticMessage>,
code: DiagnosticId
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

source§

impl<'tcx> MirBorrowckCtxt<'_, 'tcx>

source

pub(crate) fn mir_def_id(&self) -> LocalDefId

source

pub(crate) fn mir_hir_id(&self) -> HirId

source

pub(crate) fn synthesize_region_name(&self) -> Symbol

Generate a synthetic region named 'N, where N is the next value of the counter. Then, increment the counter.

This is not idempotent. Call give_region_a_name when possible.

source

pub(crate) fn give_region_a_name(&self, fr: RegionVid) -> Option<RegionName>

Maps from an internal MIR region vid to something that we can report to the user. In some cases, the region vids will map directly to lifetimes that the user has a name for (e.g., 'static). But frequently they will not, in which case we have to find some way to identify the lifetime to the user. To that end, this function takes a “diagnostic” so that it can create auxiliary notes as needed.

The names are memoized, so this is both cheap to recompute and idempotent.

Example (function arguments):

Suppose we are trying to give a name to the lifetime of the reference x:

fn foo(x: &u32) { .. }

This function would create a label like this:

 | fn foo(x: &u32) { .. }
          ------- fully elaborated type of `x` is `&'1 u32`

and then return the name '1 for us to use.

source

fn give_name_from_error_region(&self, fr: RegionVid) -> Option<RegionName>

Checks for the case where fr maps to something that the user has a name for. In that case, we’ll be able to map fr to a Region<'tcx>, and that region will be one of named variants.

source

fn give_name_if_anonymous_region_appears_in_arguments(
&self,
fr: RegionVid
) -> Option<RegionName>

Finds an argument that contains fr and label it with a fully elaborated type, returning something like '1. Result looks like:

 | fn foo(x: &u32) { .. }
          ------- fully elaborated type of `x` is `&'1 u32`
source

fn get_argument_hir_ty_for_highlighting(
&self,
argument_index: usize
) -> Option<&Ty<'tcx>>

source

fn highlight_if_we_cannot_match_hir_ty(
&self,
needle_fr: RegionVid,
ty: Ty<'tcx>,
span: Span,
counter: usize
) -> RegionNameHighlight

Attempts to highlight the specific part of a type in an argument that has no type annotation. For example, we might produce an annotation like this:

 |     foo(|a, b| b)
 |          -  -
 |          |  |
 |          |  has type `&'1 u32`
 |          has type `&'2 u32`
source

fn highlight_if_we_can_match_hir_ty(
&self,
needle_fr: RegionVid,
ty: Ty<'tcx>,
hir_ty: &Ty<'_>
) -> Option<RegionNameHighlight>

Attempts to highlight the specific part of a type annotation that contains the anonymous reference we want to give a name to. For example, we might produce an annotation like this:

 | fn a<T>(items: &[T]) -> Box<dyn Iterator<Item = &T>> {
 |                - let's call the lifetime of this reference `'1`

the way this works is that we match up ty, which is a Ty<'tcx> (the internal form of the type) with hir_ty, a hir::Ty (the syntax of the type annotation). We are descending through the types stepwise, looking in to find the region needle_fr in the internal type. Once we find that, we can use the span of the hir::Ty to add the highlight.

This is a somewhat imperfect process, so along the way we also keep track of the closest type we’ve found. If we fail to find the exact & or '_ to highlight, then we may fall back to highlighting that closest type instead.

source

fn match_adt_and_segment<'hir>(
&self,
substs: SubstsRef<'tcx>,
needle_fr: RegionVid,
last_segment: &'hir PathSegment<'hir>,
search_stack: &mut Vec<(Ty<'tcx>, &'hir Ty<'hir>)>
) -> Option<RegionNameHighlight>

We’ve found an enum/struct/union type with the substitutions substs and – in the HIR – a path type with the final segment last_segment. Try to find a '_ to highlight in the generic args (or, if not, to produce new zipped pairs of types+hir to search through).

source

fn try_match_adt_and_generic_args<'hir>(
&self,
substs: SubstsRef<'tcx>,
needle_fr: RegionVid,
args: &'hir GenericArgs<'hir>,
search_stack: &mut Vec<(Ty<'tcx>, &'hir Ty<'hir>)>
) -> Option<&'hir Lifetime>

We’ve found an enum/struct/union type with the substitutions substs and – in the HIR – a path with the generic arguments args. If needle_fr appears in the args, return the hir::Lifetime that corresponds to it. If not, push onto search_stack the types+hir to search through.

source

fn give_name_if_anonymous_region_appears_in_upvars(
&self,
fr: RegionVid
) -> Option<RegionName>

Finds a closure upvar that contains fr and label it with a fully elaborated type, returning something like '1. Result looks like:

 | let x = Some(&22);
       - fully elaborated type of `x` is `Option<&'1 u32>`
source

fn give_name_if_anonymous_region_appears_in_output(
&self,
fr: RegionVid
) -> Option<RegionName>

Checks for arguments appearing in the (closure) return type. It must be a closure since, in a free fn, such an argument would have to either also appear in an argument (if using elision) or be early bound (named, not in argument).

source

fn get_future_inner_return_ty(&self, hir_ty: &'tcx Ty<'tcx>) -> &'tcx Ty<'tcx>

From the hir::Ty of an async function’s lowered return type, retrieve the hir::Ty representing the type the user originally wrote.

e.g. given the function:

async fn foo() -> i32 { 2 }

this function, given the lowered return type of foo, an OpaqueDef that implements Future<Output=i32>, returns the i32.

source

fn give_name_if_anonymous_region_appears_in_yield_ty(
&self,
fr: RegionVid
) -> Option<RegionName>

source

fn give_name_if_anonymous_region_appears_in_impl_signature(
&self,
fr: RegionVid
) -> Option<RegionName>

source

fn give_name_if_anonymous_region_appears_in_arg_position_impl_trait(
&self,
fr: RegionVid
) -> Option<RegionName>

source

fn any_param_predicate_mentions(
&self,
predicates: &[Predicate<'tcx>],
ty: Ty<'tcx>,
region: EarlyBoundRegion
) -> bool

source§

impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx>

source

pub(crate) fn report_use_of_moved_or_uninitialized(
&mut self,
location: Location,
desired_action: InitializationRequiringAction,
(moved_place, used_place, span): (PlaceRef<'tcx>, PlaceRef<'tcx>, Span),
mpi: MovePathIndex
)

source

fn suggest_ref_or_clone(
&mut self,
mpi: MovePathIndex,
move_span: Span,
err: &mut DiagnosticBuilder<'_, ErrorGuaranteed>,
in_pattern: &mut bool,
move_spans: UseSpans<'_>
)

source

fn report_use_of_uninitialized(
&self,
mpi: MovePathIndex,
used_place: PlaceRef<'tcx>,
moved_place: PlaceRef<'tcx>,
desired_action: InitializationRequiringAction,
span: Span,
use_spans: UseSpans<'tcx>
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

fn suggest_assign_value(
&self,
err: &mut Diagnostic,
moved_place: PlaceRef<'tcx>,
sugg_span: Span
)

source

fn suggest_borrow_fn_like(
&self,
err: &mut Diagnostic,
ty: Ty<'tcx>,
move_sites: &[MoveSite],
value_name: &str
) -> bool

source

fn suggest_cloning(&self, err: &mut Diagnostic, ty: Ty<'tcx>, span: Span)

source

fn suggest_adding_copy_bounds(
&self,
err: &mut Diagnostic,
ty: Ty<'tcx>,
span: Span
)

source

pub(crate) fn report_move_out_while_borrowed(
&mut self,
location: Location,
(place, span): (Place<'tcx>, Span),
borrow: &BorrowData<'tcx>
)

source

pub(crate) fn report_use_while_mutably_borrowed(
&mut self,
location: Location,
(place, _span): (Place<'tcx>, Span),
borrow: &BorrowData<'tcx>
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

pub(crate) fn report_conflicting_borrow(
&mut self,
location: Location,
(place, span): (Place<'tcx>, Span),
gen_borrow_kind: BorrowKind,
issued_borrow: &BorrowData<'tcx>
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

fn suggest_using_local_if_applicable(
&self,
err: &mut Diagnostic,
location: Location,
issued_borrow: &BorrowData<'tcx>,
explanation: BorrowExplanation<'tcx>
)

source

fn suggest_split_at_mut_if_applicable(
&self,
err: &mut Diagnostic,
place: Place<'tcx>,
borrowed_place: Place<'tcx>
)

source

fn suggest_binding_for_closure_capture_self(
&self,
err: &mut Diagnostic,
borrowed_place: Place<'tcx>,
issued_spans: &UseSpans<'tcx>
)

source

pub(crate) fn describe_place_for_conflicting_borrow(
&self,
first_borrowed_place: Place<'tcx>,
second_borrowed_place: Place<'tcx>
) -> (String, String, String, String)

Returns the description of the root place for a conflicting borrow and the full descriptions of the places that caused the conflict.

In the simplest case, where there are no unions involved, if a mutable borrow of x is attempted while a shared borrow is live, then this function will return:

("x", "", "")

In the simple union case, if a mutable borrow of a union field x.z is attempted while a shared borrow of another field x.y, then this function will return:

("x", "x.z", "x.y")

In the more complex union case, where the union is a field of a struct, then if a mutable borrow of a union field in a struct x.u.z is attempted while a shared borrow of another field x.u.y, then this function will return:

("x.u", "x.u.z", "x.u.y")

This is used when creating error messages like below:

cannot borrow `a.u` (via `a.u.z.c`) as immutable because it is also borrowed as
mutable (via `a.u.s.b`) [E0502]
source

pub(crate) fn report_borrowed_value_does_not_live_long_enough(
&mut self,
location: Location,
borrow: &BorrowData<'tcx>,
place_span: (Place<'tcx>, Span),
kind: Option<WriteKind>
)

Reports StorageDeadOrDrop of place conflicts with borrow.

This means that some data referenced by borrow needs to live past the point where the StorageDeadOrDrop of place occurs. This is usually interpreted as meaning that place has too short a lifetime. (But sometimes it is more useful to report it as a more direct conflict between the execution of a Drop::drop with an aliasing borrow.)

source

fn report_local_value_does_not_live_long_enough(
&mut self,
location: Location,
name: &str,
borrow: &BorrowData<'tcx>,
drop_span: Span,
borrow_spans: UseSpans<'tcx>,
explanation: BorrowExplanation<'tcx>
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

fn report_borrow_conflicts_with_destructor(
&mut self,
location: Location,
borrow: &BorrowData<'tcx>,
(place, drop_span): (Place<'tcx>, Span),
kind: Option<WriteKind>,
dropped_ty: Ty<'tcx>
)

source

fn report_thread_local_value_does_not_live_long_enough(
&mut self,
drop_span: Span,
borrow_span: Span
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

fn report_temporary_value_does_not_live_long_enough(
&mut self,
location: Location,
borrow: &BorrowData<'tcx>,
drop_span: Span,
borrow_spans: UseSpans<'tcx>,
proper_span: Span,
explanation: BorrowExplanation<'tcx>
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

fn try_report_cannot_return_reference_to_local(
&self,
borrow: &BorrowData<'tcx>,
borrow_span: Span,
return_span: Span,
category: ConstraintCategory<'tcx>,
opt_place_desc: Option<&String>
) -> Option<DiagnosticBuilder<'cx, ErrorGuaranteed>>

source

fn report_escaping_closure_capture(
&mut self,
use_span: UseSpans<'tcx>,
var_span: Span,
fr_name: &RegionName,
category: ConstraintCategory<'tcx>,
constraint_span: Span,
captured_var: &str,
scope: &str
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

fn report_escaping_data(
&mut self,
borrow_span: Span,
name: &Option<String>,
upvar_span: Span,
upvar_name: Symbol,
escape_span: Span
) -> DiagnosticBuilder<'cx, ErrorGuaranteed>

source

fn get_moved_indexes(
&mut self,
location: Location,
mpi: MovePathIndex
) -> (Vec<MoveSite>, Vec<Location>)

source

pub(crate) fn report_illegal_mutation_of_borrowed(
&mut self,
location: Location,
(place, span): (Place<'tcx>, Span),
loan: &BorrowData<'tcx>
)

source

fn explain_deref_coercion(
&mut self,
loan: &BorrowData<'tcx>,
err: &mut Diagnostic
)

source

pub(crate) fn report_illegal_reassignment(
&mut self,
_location: Location,
(place, span): (Place<'tcx>, Span),
assigned_span: Span,
err_place: Place<'tcx>
)

Reports an illegal reassignment; for example, an assignment to (part of) a non-mut local that occurs potentially after that local has already been initialized. place is the path being assigned; err_place is a place providing a reason why place is not mutable (e.g., the non-mut local x in an assignment to x.f).

source

fn classify_drop_access_kind(
&self,
place: PlaceRef<'tcx>
) -> StorageDeadOrDrop<'tcx>

source

fn classify_immutable_section(&self, place: Place<'tcx>) -> Option<&'static str>

Describe the reason for the fake borrow that was assigned to place.

source

fn annotate_argument_and_return_for_borrow(
&self,
borrow: &BorrowData<'tcx>
) -> Option<AnnotatedBorrowFnSignature<'tcx>>

Annotate argument and return type of function and closure with (synthesized) lifetime for borrow of local value that does not live long enough.

source

fn annotate_fn_sig(
&self,
did: LocalDefId,
sig: PolyFnSig<'tcx>
) -> Option<AnnotatedBorrowFnSignature<'tcx>>

Annotate the first argument and return type of a function signature if they are references.

source§

impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx>

source

fn free_region_constraint_info(
&self,
borrow_region: RegionVid,
outlived_region: RegionVid
) -> (ConstraintCategory<'tcx>, bool, Span, Option<RegionName>, Vec<ExtraConstraintInfo>)

source

pub(crate) fn explain_why_borrow_contains_point(
&self,
location: Location,
borrow: &BorrowData<'tcx>,
kind_place: Option<(WriteKind, Place<'tcx>)>
) -> BorrowExplanation<'tcx>

Returns structured explanation for why the borrow contains the point from location. This is key for the “3-point errors” described in the NLL RFC.

Parameters
  • borrow: the borrow in question
  • location: where the borrow occurs
  • kind_place: if Some, this describes the statement that triggered the error.
    • first half is the kind of write, if any, being performed
    • second half is the place being accessed
source

fn later_use_kind(
&self,
borrow: &BorrowData<'tcx>,
use_spans: UseSpans<'tcx>,
location: Location
) -> (LaterUseKind, Span, Option<Span>)

Determine how the borrow was later used. First span returned points to the location of the conflicting use Second span if Some is returned in the case of closures and points to the use of the path

source

fn was_captured_by_trait_object(&self, borrow: &BorrowData<'tcx>) -> bool

Checks if a borrowed value was captured by a trait object. We do this by looking forward in the MIR from the reserve location and checking if we see an unsized cast to a trait object on our data.

source§

impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx>

source

pub(crate) fn report_move_errors(
&mut self,
move_errors: Vec<(Place<'tcx>, MoveError<'tcx>)>
)

source

fn group_move_errors(
&self,
errors: Vec<(Place<'tcx>, MoveError<'tcx>)>
) -> Vec<GroupedMoveError<'tcx>>

source

fn append_to_grouped_errors(
&self,
grouped_errors: &mut Vec<GroupedMoveError<'tcx>>,
original_path: Place<'tcx>,
error: MoveError<'tcx>
)

source

fn append_binding_error(
&self,
grouped_errors: &mut Vec<GroupedMoveError<'tcx>>,
kind: IllegalMoveOriginKind<'tcx>,
original_path: Place<'tcx>,
move_from: Place<'tcx>,
bind_to: Local,
match_place: Option<Place<'tcx>>,
match_span: Span,
statement_span: Span
)

source

fn report(&mut self, error: GroupedMoveError<'tcx>)

source

fn report_cannot_move_from_static(
&mut self,
place: Place<'tcx>,
span: Span
) -> DiagnosticBuilder<'a, ErrorGuaranteed>

source

fn report_cannot_move_from_borrowed_content(
&mut self,
move_place: Place<'tcx>,
deref_target_place: Place<'tcx>,
span: Span,
use_spans: Option<UseSpans<'tcx>>
) -> DiagnosticBuilder<'a, ErrorGuaranteed>

source

fn add_move_hints(
&self,
error: GroupedMoveError<'tcx>,
err: &mut Diagnostic,
span: Span
)

source

fn add_borrow_suggestions(&self, err: &mut Diagnostic, span: Span)

source

fn add_move_error_suggestions(&self, err: &mut Diagnostic, binds_to: &[Local])

source

fn add_move_error_details(&self, err: &mut Diagnostic, binds_to: &[Local])

source§

impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx>

source

pub(crate) fn report_mutability_error(
&mut self,
access_place: Place<'tcx>,
span: Span,
the_place_err: PlaceRef<'tcx>,
error_access: AccessKind,
location: Location
)

source

fn suggest_map_index_mut_alternatives(
&self,
ty: Ty<'tcx>,
err: &mut Diagnostic,
span: Span
)

source

fn is_error_in_trait(&self, local: Local) -> (bool, Option<Span>)

User cannot make signature of a trait mutable without changing the trait. So we find if this error belongs to a trait and if so we move suggestion to the trait or disable it if it is out of scope of this crate

source

fn show_mutating_upvar(
&self,
tcx: TyCtxt<'_>,
closure_local_def_id: LocalDefId,
the_place_err: PlaceRef<'tcx>,
err: &mut Diagnostic
)

source

fn suggest_similar_mut_method_for_for_loop(&self, err: &mut Diagnostic)

source

fn expected_fn_found_fn_mut_call(&self, err: &mut Diagnostic, sp: Span, act: &str)

Targeted error when encountering an FnMut closure where an Fn closure was expected.

source§

impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx>

source

pub(super) fn to_error_region(&self, r: RegionVid) -> Option<Region<'tcx>>

Converts a region inference variable into a ty::Region that we can use for error reporting. If r is universally bound, then we use the name that we have on record for it. If r is existentially bound, then we check its inferred value and try to find a good name from that. Returns None if we can’t find one (e.g., this is just some random part of the CFG).

source

pub(super) fn to_error_region_vid(&self, r: RegionVid) -> Option<RegionVid>

Returns the RegionVid corresponding to the region returned by to_error_region.

source

fn is_closure_fn_mut(&self, fr: RegionVid) -> bool

Returns true if a closure is inferred to be an FnMut closure.

source

fn suggest_static_lifetime_for_gat_from_hrtb(
&self,
diag: &mut DiagnosticBuilder<'_, ErrorGuaranteed>,
lower_bound: RegionVid
)

source

pub(crate) fn report_region_errors(&mut self, nll_errors: RegionErrors<'tcx>)

Produces nice borrowck error diagnostics for all the errors collected in nll_errors.

source

pub(crate) fn report_region_error(
&mut self,
fr: RegionVid,
fr_origin: NllRegionVariableOrigin,
outlived_fr: RegionVid,
outlives_suggestion: &mut OutlivesSuggestionBuilder
)

Report an error because the universal region fr was required to outlive outlived_fr but it is not known to do so. For example:

fn foo<'a, 'b>(x: &'a u32) -> &'b u32 { x }

Here we would be invoked with fr = 'a and outlived_fr = ’b`.

source

fn report_fnmut_error(
&self,
errci: &ErrorConstraintInfo<'tcx>,
kind: ReturnConstraint
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

Report a specialized error when FnMut closures return a reference to a captured variable. This function expects fr to be local and outlived_fr to not be local.

error: captured variable cannot escape `FnMut` closure body
  --> $DIR/issue-53040.rs:15:8
   |
LL |     || &mut v;
   |     -- ^^^^^^ creates a reference to a captured variable which escapes the closure body
   |     |
   |     inferred to be a `FnMut` closure
   |
   = note: `FnMut` closures only have access to their captured variables while they are
           executing...
   = note: ...therefore, returned references to captured variables will escape the closure
source

fn report_escaping_data_error(
&self,
errci: &ErrorConstraintInfo<'tcx>
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

Reports an error specifically for when data is escaping a closure.

error: borrowed data escapes outside of function
  --> $DIR/lifetime-bound-will-change-warning.rs:44:5
   |
LL | fn test2<'a>(x: &'a Box<Fn()+'a>) {
   |              - `x` is a reference that is only valid in the function body
LL |     // but ref_obj will not, so warn.
LL |     ref_obj(x)
   |     ^^^^^^^^^^ `x` escapes the function body here
source

fn report_general_error(
&self,
errci: &ErrorConstraintInfo<'tcx>
) -> DiagnosticBuilder<'tcx, ErrorGuaranteed>

Reports a region inference error for the general case with named/synthesized lifetimes to explain what is happening.

error: unsatisfied lifetime constraints
  --> $DIR/regions-creating-enums3.rs:17:5
   |
LL | fn mk_add_bad1<'a,'b>(x: &'a ast<'a>, y: &'b ast<'b>) -> ast<'a> {
   |                -- -- lifetime `'b` defined here
   |                |
   |                lifetime `'a` defined here
LL |     ast::add(x, y)
   |     ^^^^^^^^^^^^^^ function was supposed to return data with lifetime `'a` but it
   |                    is returning data with lifetime `'b`
source

fn add_static_impl_trait_suggestion(
&self,
diag: &mut Diagnostic,
fr: RegionVid,
fr_name: RegionName,
outlived_fr: RegionVid
)

Adds a suggestion to errors where an impl Trait is returned.

help: to allow this `impl Trait` to capture borrowed data with lifetime `'1`, add `'_` as
      a constraint
   |
LL |     fn iter_values_anon(&self) -> impl Iterator<Item=u32> + 'a {
   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
source

fn maybe_suggest_constrain_dyn_trait_impl(
&self,
diag: &mut Diagnostic,
f: Region<'tcx>,
o: Region<'tcx>,
category: &ConstraintCategory<'tcx>
)

source

fn suggest_constrain_dyn_trait_in_impl(
&self,
err: &mut Diagnostic,
found_dids: &FxIndexSet<DefId>,
ident: Ident,
self_ty: &Ty<'_>
) -> bool

source

fn suggest_adding_lifetime_params(
&self,
diag: &mut Diagnostic,
sub: RegionVid,
sup: RegionVid
)

source

fn suggest_move_on_borrowing_closure(&self, diag: &mut Diagnostic)

source§

impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx>

source

pub(crate) fn add_moved_or_invoked_closure_note(
&self,
location: Location,
place: PlaceRef<'tcx>,
diag: &mut Diagnostic
) -> bool

Adds a suggestion when a closure is invoked twice with a moved variable or when a closure is moved after being invoked.

note: closure cannot be invoked more than once because it moves the variable `dict` out of
      its environment
  --> $DIR/issue-42065.rs:16:29
   |
LL |         for (key, value) in dict {
   |                             ^^^^
source

pub(crate) fn describe_any_place(&self, place_ref: PlaceRef<'tcx>) -> String

End-user visible description of place if one can be found. If the place is a temporary for instance, "value" will be returned.

source

pub(crate) fn describe_place(&self, place_ref: PlaceRef<'tcx>) -> Option<String>

End-user visible description of place if one can be found. If the place is a temporary for instance, None will be returned.

source

pub(crate) fn describe_place_with_options(
&self,
place: PlaceRef<'tcx>,
opt: DescribePlaceOpt
) -> Option<String>

End-user visible description of place if one can be found. If the place is a temporary for instance, None will be returned. IncludingDowncast parameter makes the function return None if ProjectionElem is Downcast and IncludingDowncast is true

source

fn describe_name(&self, place: PlaceRef<'tcx>) -> Option<Symbol>

source

fn append_local_to_string(&self, local: Local, buf: &mut String) -> Result<(), ()>

Appends end-user visible description of the local place to buf. If local doesn’t have a name, or its name was generated by the compiler, then Err is returned

source

fn describe_field(
&self,
place: PlaceRef<'tcx>,
field: Field,
including_tuple_field: IncludingTupleField
) -> Option<String>

End-user visible description of the fieldnth field of base

source

fn describe_field_from_ty(
&self,
ty: Ty<'_>,
field: Field,
variant_index: Option<VariantIdx>,
including_tuple_field: IncludingTupleField
) -> Option<String>

End-user visible description of the field_indexnth field of ty

source

pub(crate) fn note_type_does_not_implement_copy(
&self,
err: &mut Diagnostic,
place_desc: &str,
ty: Ty<'tcx>,
span: Option<Span>,
move_prefix: &str
)

Add a note that a type does not implement Copy

source

pub(crate) fn borrowed_content_source(
&self,
deref_base: PlaceRef<'tcx>
) -> BorrowedContentSource<'tcx>

source

pub(crate) fn get_name_for_ty(&self, ty: Ty<'tcx>, counter: usize) -> String

Return the name of the provided Ty (that must be a reference) with a synthesized lifetime name where required.

source

pub(crate) fn get_region_name_for_ty(
&self,
ty: Ty<'tcx>,
counter: usize
) -> String

Returns the name of the provided Ty (that must be a reference)’s region with a synthesized lifetime name where required.

source§

impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx>

source

pub(crate) fn move_spans(
&self,
moved_place: PlaceRef<'tcx>,
location: Location
) -> UseSpans<'tcx>

Finds the spans associated to a move or copy of move_place at location.

source

pub(crate) fn borrow_spans(
&self,
use_span: Span,
location: Location
) -> UseSpans<'tcx>

Finds the span of arguments of a closure (within maybe_closure_span) and its usage of the local assigned at location. This is done by searching in statements succeeding location and originating from maybe_closure_span.

source

fn closure_span(
&self,
def_id: LocalDefId,
target_place: PlaceRef<'tcx>,
places: &[Operand<'tcx>]
) -> Option<(Span, Option<GeneratorKind>, Span, Span)>

Finds the spans of a captured place within a closure or generator. The first span is the location of the use resulting in the capture kind of the capture The second span is the location the use resulting in the captured path of the capture

source

pub(crate) fn retrieve_borrow_spans(
&self,
borrow: &BorrowData<'_>
) -> UseSpans<'tcx>

Helper to retrieve span(s) of given borrow from the current MIR representation

source

fn explain_captures(
&mut self,
err: &mut Diagnostic,
span: Span,
move_span: Span,
move_spans: UseSpans<'tcx>,
moved_place: Place<'tcx>,
partially_str: &str,
loop_message: &str,
move_msg: &str,
is_loop_move: bool,
maybe_reinitialized_locations_is_empty: bool
)

source§

impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx>

source

pub(crate) fn prefixes(
&self,
place_ref: PlaceRef<'tcx>,
kind: PrefixSet
) -> Prefixes<'cx, 'tcx>

Returns an iterator over the prefixes of place (inclusive) from longest to smallest, potentially terminating the iteration early based on kind.

source§

impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx>

source

pub(crate) fn gather_used_muts(
&mut self,
temporary_used_locals: FxHashSet<Local>,
never_initialized_mut_locals: FxHashSet<Local>
)

Walks the MIR adding to the set of used_mut locals that will be ignored for the purposes of the unused_mut lint.

temporary_used_locals should contain locals that were found to be temporary, mutable and used from borrow checking. This function looks for assignments into these locals from user-declared locals and adds those user-defined locals to the used_mut set. This can occur due to a rare case involving upvars in closures.

never_initialized_mut_locals should contain the set of user-declared mutable locals (not arguments) that have not already been marked as being used. This function then looks for assignments from statements or the terminator into the locals from this set and removes them from the set. This leaves only those locals that have not been assigned to - this set is used as a proxy for locals that were not initialized due to unreachable code. These locals are then considered “used” to silence the lint for them. See #55344 for context.

source§

impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx>

source

pub fn buffer_error(&mut self, t: DiagnosticBuilder<'_, ErrorGuaranteed>)

source

pub fn buffer_non_error_diag(&mut self, t: DiagnosticBuilder<'_, ()>)

source

pub fn buffer_move_error(
&mut self,
move_out_indices: Vec<MoveOutIndex>,
place_and_err: (PlaceRef<'tcx>, DiagnosticBuilder<'tcx, ErrorGuaranteed>)
) -> bool

source

pub fn get_buffered_mut_error(
&mut self,
span: Span
) -> Option<(DiagnosticBuilder<'tcx, ErrorGuaranteed>, usize)>

source

pub fn buffer_mut_error(
&mut self,
span: Span,
t: DiagnosticBuilder<'tcx, ErrorGuaranteed>,
count: usize
)

source

pub fn emit_errors(&mut self) -> Option<ErrorGuaranteed>

source

pub fn has_buffered_errors(&self) -> bool

source

pub fn has_move_error(
&self,
move_out_indices: &[MoveOutIndex]
) -> Option<&(PlaceRef<'tcx>, DiagnosticBuilder<'cx, ErrorGuaranteed>)>

source§

impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx>

source

pub(crate) fn body(&self) -> &'cx Body<'tcx>

source

pub(crate) fn access_place(
&mut self,
location: Location,
place_span: (Place<'tcx>, Span),
kind: (AccessDepth, ReadOrWrite),
is_local_mutation_allowed: LocalMutationIsAllowed,
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>
)

Checks an access to the given place to see if it is allowed. Examines the set of borrows that are in scope, as well as which paths have been initialized, to ensure that (a) the place is initialized and (b) it is not borrowed in some way that would prevent this access.

Returns true if an error is reported.

source

pub(crate) fn check_access_for_conflict(
&mut self,
location: Location,
place_span: (Place<'tcx>, Span),
sd: AccessDepth,
rw: ReadOrWrite,
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>
) -> bool

source

pub(crate) fn mutate_place(
&mut self,
location: Location,
place_span: (Place<'tcx>, Span),
kind: AccessDepth,
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>
)

source

pub(crate) fn consume_rvalue(
&mut self,
location: Location,
(rvalue, span): (&'cx Rvalue<'tcx>, Span),
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>
)

source

pub(crate) fn propagate_closure_used_mut_upvar(
&mut self,
operand: &Operand<'tcx>
)

source

pub(crate) fn consume_operand(
&mut self,
location: Location,
(operand, span): (&'cx Operand<'tcx>, Span),
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>
)

source

pub(crate) fn check_for_invalidation_at_exit(
&mut self,
location: Location,
borrow: &BorrowData<'tcx>,
span: Span
)

Checks whether a borrow of this place is invalidated when the function exits

source

pub(crate) fn check_for_local_borrow(
&mut self,
borrow: &BorrowData<'tcx>,
yield_span: Span
)

Reports an error if this is a borrow of local data. This is called for all Yield expressions on movable generators

source

pub(crate) fn check_activations(
&mut self,
location: Location,
span: Span,
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>
)

source

pub(crate) fn check_if_full_path_is_moved(
&mut self,
location: Location,
desired_action: InitializationRequiringAction,
place_span: (PlaceRef<'tcx>, Span),
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>
)

source

pub(crate) fn check_if_subslice_element_is_moved(
&mut self,
location: Location,
desired_action: InitializationRequiringAction,
place_span: (PlaceRef<'tcx>, Span),
maybe_uninits: &ChunkedBitSet<MovePathIndex>,
from: u64,
to: u64
)

Subslices correspond to multiple move paths, so we iterate through the elements of the base array. For each element we check

  • Does this element overlap with our slice.
  • Is any part of it uninitialized.
source

pub(crate) fn check_if_path_or_subpath_is_moved(
&mut self,
location: Location,
desired_action: InitializationRequiringAction,
place_span: (PlaceRef<'tcx>, Span),
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>
)

source

pub(crate) fn move_path_closest_to(
&mut self,
place: PlaceRef<'tcx>
) -> (PlaceRef<'tcx>, MovePathIndex)

Currently MoveData does not store entries for all places in the input MIR. For example it will currently filter out places that are Copy; thus we do not track places of shared reference type. This routine will walk up a place along its prefixes, searching for a foundational place that is tracked in the MoveData.

An Err result includes a tag indicated why the search failed. Currently this can only occur if the place is built off of a static variable, as we do not track those in the MoveData.

source

pub(crate) fn move_path_for_place(
&mut self,
place: PlaceRef<'tcx>
) -> Option<MovePathIndex>

source

pub(crate) fn check_if_assigned_path_is_moved(
&mut self,
location: Location,
(place, span): (Place<'tcx>, Span),
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>
)

source

pub(crate) fn check_access_permissions(
&mut self,
(place, span): (Place<'tcx>, Span),
kind: ReadOrWrite,
is_local_mutation_allowed: LocalMutationIsAllowed,
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>,
location: Location
) -> bool

Checks the permissions for the given place and read or write kind

Returns true if an error is reported.

source

pub(crate) fn is_local_ever_initialized(
&self,
local: Local,
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>
) -> Option<InitIndex>

source

pub(crate) fn add_used_mut(
&mut self,
root_place: RootPlace<'tcx>,
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>
)

Adds the place into the used mutable variables set

source

pub(crate) fn is_mutable(
&self,
place: PlaceRef<'tcx>,
is_local_mutation_allowed: LocalMutationIsAllowed
) -> Result<RootPlace<'tcx>, PlaceRef<'tcx>>

Whether this value can be written or borrowed mutably. Returns the root place if the place passed in is a projection.

source

pub(crate) fn is_upvar_field_projection(
&self,
place_ref: PlaceRef<'tcx>
) -> Option<Field>

If place is a field projection, and the field is being projected from a closure type, then returns the index of the field being projected. Note that this closure will always be self in the current MIR, because that is the only time we directly access the fields of a closure type.

source

pub(crate) fn dominators(&self) -> &Dominators<BasicBlock>

Trait Implementations§

source§

impl<'cx, 'tcx> ResultsVisitor<'cx, 'tcx> for MirBorrowckCtxt<'cx, 'tcx>

§

type FlowState = BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>

source§

fn visit_statement_before_primary_effect(
&mut self,
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>,
stmt: &'cx Statement<'tcx>,
location: Location
)

Called with the before_statement_effect of the given statement applied to state but not its statement_effect.
source§

fn visit_terminator_before_primary_effect(
&mut self,
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>,
term: &'cx Terminator<'tcx>,
loc: Location
)

Called with the before_terminator_effect of the given terminator applied to state but not its terminator_effect.
source§

fn visit_terminator_after_primary_effect(
&mut self,
flow_state: &BorrowckAnalyses<BitSet<BorrowIndex>, ChunkedBitSet<MovePathIndex>, ChunkedBitSet<InitIndex>>,
term: &'cx Terminator<'tcx>,
loc: Location
)

Called with both the before_terminator_effect and the terminator_effect of the given terminator applied to state. Read more
source§

fn visit_block_start(
&mut self,
_state: &Self::FlowState,
_block_data: &'mir BasicBlockData<'tcx>,
_block: BasicBlock
)

source§

fn visit_statement_after_primary_effect(
&mut self,
_state: &Self::FlowState,
_statement: &'mir Statement<'tcx>,
_location: Location
)

Called with both the before_statement_effect and the statement_effect of the given statement applied to state.
source§

fn visit_block_end(
&mut self,
_state: &Self::FlowState,
_block_data: &'mir BasicBlockData<'tcx>,
_block: BasicBlock
)

Auto Trait Implementations§

§

impl<'cx, 'tcx> !RefUnwindSafe for MirBorrowckCtxt<'cx, 'tcx>

§

impl<'cx, 'tcx> !Send for MirBorrowckCtxt<'cx, 'tcx>

§

impl<'cx, 'tcx> !Sync for MirBorrowckCtxt<'cx, 'tcx>

§

impl<'cx, 'tcx> Unpin for MirBorrowckCtxt<'cx, 'tcx>where
'tcx: 'cx,

§

impl<'cx, 'tcx> !UnwindSafe for MirBorrowckCtxt<'cx, 'tcx>

Blanket Implementations§

source§

impl<T> Any for Twhere
T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

const: unstable · source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere
U: From<T>,

const: unstable · source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
const: unstable · source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

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