| borrowck_assign_due_to_use_closure = |
| assignment occurs due to use in closure |
| |
| borrowck_assign_due_to_use_coroutine = |
| assign occurs due to use in coroutine |
| |
| borrowck_assign_part_due_to_use_closure = |
| assignment to part occurs due to use in closure |
| |
| borrowck_assign_part_due_to_use_coroutine = |
| assign to part occurs due to use in coroutine |
| |
| borrowck_borrow_due_to_use_closure = |
| borrow occurs due to use in closure |
| |
| borrowck_borrow_due_to_use_coroutine = |
| borrow occurs due to use in coroutine |
| |
| borrowck_calling_operator_moves = |
| calling this operator moves the value |
| |
| borrowck_calling_operator_moves_lhs = |
| calling this operator moves the left-hand side |
| |
| borrowck_cannot_move_when_borrowed = |
| cannot move out of {$place -> |
| [value] value |
| *[other] {$place} |
| } because it is borrowed |
| .label = borrow of {$borrow_place -> |
| [value] value |
| *[other] {$borrow_place} |
| } occurs here |
| .move_label = move out of {$value_place -> |
| [value] value |
| *[other] {$value_place} |
| } occurs here |
| |
| borrowck_capture_immute = |
| capture is immutable because of use here |
| |
| borrowck_capture_move = |
| capture is moved because of use here |
| |
| borrowck_capture_mut = |
| capture is mutable because of use here |
| |
| borrowck_closure_inferred_mut = inferred to be a `FnMut` closure |
| |
| borrowck_closure_invoked_twice = |
| closure cannot be invoked more than once because it moves the variable `{$place_name}` out of its environment |
| |
| borrowck_closure_moved_twice = |
| closure cannot be moved more than once as it is not `Copy` due to moving the variable `{$place_name}` out of its environment |
| |
| borrowck_consider_borrow_type_contents = |
| help: consider calling `.as_ref()` or `.as_mut()` to borrow the type's contents |
| |
| borrowck_could_not_normalize = |
| could not normalize `{$value}` |
| |
| borrowck_could_not_prove = |
| could not prove `{$predicate}` |
| |
| borrowck_dereference_suggestion = |
| dereference the return value |
| |
| borrowck_func_take_self_moved_place = |
| `{$func}` takes ownership of the receiver `self`, which moves {$place_name} |
| |
| borrowck_generic_does_not_live_long_enough = |
| `{$kind}` does not live long enough |
| |
| borrowck_higher_ranked_lifetime_error = |
| higher-ranked lifetime error |
| |
| borrowck_higher_ranked_subtype_error = |
| higher-ranked subtype error |
| |
| borrowck_implicit_static = |
| this has an implicit `'static` lifetime requirement |
| |
| borrowck_implicit_static_introduced = |
| calling this method introduces the `impl`'s `'static` requirement |
| |
| borrowck_implicit_static_relax = |
| consider relaxing the implicit `'static` requirement |
| |
| borrowck_lifetime_constraints_error = |
| lifetime may not live long enough |
| |
| borrowck_limitations_implies_static = |
| due to current limitations in the borrow checker, this implies a `'static` lifetime |
| |
| borrowck_move_closure_suggestion = |
| consider adding 'move' keyword before the nested closure |
| |
| borrowck_move_out_place_here = |
| {$place} is moved here |
| |
| borrowck_move_unsized = |
| cannot move a value of type `{$ty}` |
| .label = the size of `{$ty}` cannot be statically determined |
| |
| borrowck_moved_a_fn_once_in_call = |
| this value implements `FnOnce`, which causes it to be moved when called |
| |
| borrowck_moved_a_fn_once_in_call_call = |
| `FnOnce` closures can only be called once |
| |
| borrowck_moved_a_fn_once_in_call_def = |
| `{$ty}` is made to be an `FnOnce` closure here |
| |
| borrowck_moved_due_to_await = |
| {$place_name} {$is_partial -> |
| [true] partially moved |
| *[false] moved |
| } due to this {$is_loop_message -> |
| [true] await, in previous iteration of loop |
| *[false] await |
| } |
| |
| borrowck_moved_due_to_call = |
| {$place_name} {$is_partial -> |
| [true] partially moved |
| *[false] moved |
| } due to this {$is_loop_message -> |
| [true] call, in previous iteration of loop |
| *[false] call |
| } |
| |
| borrowck_moved_due_to_implicit_into_iter_call = |
| {$place_name} {$is_partial -> |
| [true] partially moved |
| *[false] moved |
| } due to this implicit call to {$is_loop_message -> |
| [true] `.into_iter()`, in previous iteration of loop |
| *[false] `.into_iter()` |
| } |
| |
| borrowck_moved_due_to_method_call = |
| {$place_name} {$is_partial -> |
| [true] partially moved |
| *[false] moved |
| } due to this method {$is_loop_message -> |
| [true] call, in previous iteration of loop |
| *[false] call |
| } |
| |
| borrowck_moved_due_to_usage_in_operator = |
| {$place_name} {$is_partial -> |
| [true] partially moved |
| *[false] moved |
| } due to usage in {$is_loop_message -> |
| [true] operator, in previous iteration of loop |
| *[false] operator |
| } |
| |
| borrowck_opaque_type_lifetime_mismatch = |
| opaque type used twice with different lifetimes |
| .label = lifetime `{$arg}` used here |
| .prev_lifetime_label = lifetime `{$prev}` previously used here |
| .note = if all non-lifetime generic parameters are the same, but the lifetime parameters differ, it is not possible to differentiate the opaque types |
| |
| borrowck_opaque_type_non_generic_param = |
| expected generic {$kind} parameter, found `{$ty}` |
| .label = {STREQ($ty, "'static") -> |
| [true] cannot use static lifetime; use a bound lifetime instead or remove the lifetime parameter from the opaque type |
| *[other] this generic parameter must be used with a generic {$kind} parameter |
| } |
| |
| borrowck_partial_var_move_by_use_in_closure = |
| variable {$is_partial -> |
| [true] partially moved |
| *[false] moved |
| } due to use in closure |
| |
| borrowck_partial_var_move_by_use_in_coroutine = |
| variable {$is_partial -> |
| [true] partially moved |
| *[false] moved |
| } due to use in coroutine |
| |
| borrowck_restrict_to_static = |
| consider restricting the type parameter to the `'static` lifetime |
| |
| borrowck_returned_async_block_escaped = |
| returns an `async` block that contains a reference to a captured variable, which then escapes the closure body |
| |
| borrowck_returned_closure_escaped = |
| returns a closure that contains a reference to a captured variable, which then escapes the closure body |
| |
| borrowck_returned_lifetime_short = |
| {$category_desc}requires that `{$free_region_name}` must outlive `{$outlived_fr_name}` |
| |
| borrowck_returned_lifetime_wrong = |
| {$mir_def_name} was supposed to return data with lifetime `{$outlived_fr_name}` but it is returning data with lifetime `{$fr_name}` |
| |
| borrowck_returned_ref_escaped = |
| returns a reference to a captured variable which escapes the closure body |
| |
| borrowck_simd_intrinsic_arg_const = |
| {$arg -> |
| [1] 1st |
| [2] 2nd |
| [3] 3rd |
| *[other] {$arg}th |
| } argument of `{$intrinsic}` is required to be a `const` item |
| |
| borrowck_suggest_create_fresh_reborrow = |
| consider reborrowing the `Pin` instead of moving it |
| |
| borrowck_suggest_iterate_over_slice = |
| consider iterating over a slice of the `{$ty}`'s content to avoid moving into the `for` loop |
| |
| borrowck_ty_no_impl_copy = |
| {$is_partial_move -> |
| [true] partial move |
| *[false] move |
| } occurs because {$place} has type `{$ty}`, which does not implement the `Copy` trait |
| |
| borrowck_use_due_to_use_closure = |
| use occurs due to use in closure |
| |
| borrowck_use_due_to_use_coroutine = |
| use occurs due to use in coroutine |
| |
| borrowck_used_impl_require_static = |
| the used `impl` has a `'static` requirement |
| |
| borrowck_value_capture_here = |
| value captured {$is_within -> |
| [true] here by coroutine |
| *[false] here |
| } |
| |
| borrowck_value_moved_here = |
| value {$is_partial -> |
| [true] partially moved |
| *[false] moved |
| } {$is_move_msg -> |
| [true] into closure here |
| *[false] here |
| }{$is_loop_message -> |
| [true] , in previous iteration of loop |
| *[false] {""} |
| } |
| |
| borrowck_var_borrow_by_use_in_closure = |
| borrow occurs due to use in closure |
| |
| borrowck_var_borrow_by_use_in_coroutine = |
| borrow occurs due to use in coroutine |
| |
| borrowck_var_borrow_by_use_place_in_closure = |
| {$is_single_var -> |
| *[true] borrow occurs |
| [false] borrows occur |
| } due to use of {$place} in closure |
| |
| borrowck_var_borrow_by_use_place_in_coroutine = |
| {$is_single_var -> |
| *[true] borrow occurs |
| [false] borrows occur |
| } due to use of {$place} in coroutine |
| |
| borrowck_var_cannot_escape_closure = |
| captured variable cannot escape `FnMut` closure body |
| .note = `FnMut` closures only have access to their captured variables while they are executing... |
| .cannot_escape = ...therefore, they cannot allow references to captured variables to escape |
| |
| borrowck_var_does_not_need_mut = |
| variable does not need to be mutable |
| .suggestion = remove this `mut` |
| |
| borrowck_var_first_borrow_by_use_place_in_closure = |
| first borrow occurs due to use of {$place} in closure |
| |
| borrowck_var_first_borrow_by_use_place_in_coroutine = |
| first borrow occurs due to use of {$place} in coroutine |
| |
| borrowck_var_here_captured = variable captured here |
| |
| borrowck_var_here_defined = variable defined here |
| |
| borrowck_var_move_by_use_in_closure = |
| move occurs due to use in closure |
| |
| borrowck_var_move_by_use_in_coroutine = |
| move occurs due to use in coroutine |
| |
| borrowck_var_mutable_borrow_by_use_place_in_closure = |
| mutable borrow occurs due to use of {$place} in closure |
| |
| borrowck_var_second_borrow_by_use_place_in_closure = |
| second borrow occurs due to use of {$place} in closure |
| |
| borrowck_var_second_borrow_by_use_place_in_coroutine = |
| second borrow occurs due to use of {$place} in coroutine |
