does not contain version number driver_impl_rlink_encoding_version_mismatch = .rlink file was produced with encoding version `{$version_array}`, but the current version is `{$rlink_version}` driver_impl_rlink_no_a_file = rlink must be a file driver_impl_rlink_rustc_version_mismatch = .rlink file was produced by rustc version `{$rustc_version}`, but the current version is `{$current_version}` driver_impl_rlink_unable_to_read = failed to read rlink file: `{$err}` driver_impl_rlink_wrong_file_type = The input does not look like a .rlink file driver_impl_unstable_feature_usage = cannot dump feature usage metrics: {$error} ast_lowering_abi_specified_multiple_times = `{$prev_name}` ABI specified multiple times .label = previously specified here .note = these ABIs are equivalent on the current target ast_lowering_arbitrary_expression_in_pattern = arbitrary expressions aren't allowed in patterns .pattern_from_macro_note = the `expr` fragment specifier forces the metavariable's content to be an expression ast_lowering_argument = argument ast_lowering_assoc_ty_binding_in_dyn = associated type bounds are not allowed in `dyn` types .suggestion = use `impl Trait` to introduce a type instead ast_lowering_assoc_ty_parentheses = parenthesized generic arguments cannot be used in associated type constraints ast_lowering_async_bound_not_on_trait = `async` bound modifier only allowed on trait, not `{$descr}` ast_lowering_async_bound_only_for_fn_traits = `async` bound modifier only allowed on `Fn`/`FnMut`/`FnOnce` traits ast_lowering_async_coroutines_not_supported = `async` coroutines are not yet supported ast_lowering_att_syntax_only_x86 = the `att_syntax` option is only supported on x86 ast_lowering_await_only_in_async_fn_and_blocks = `await` is only allowed inside `async` functions and blocks .label = only allowed inside `async` functions and blocks ast_lowering_bad_return_type_notation_inputs = argument types not allowed with return type notation .suggestion = remove the input types ast_lowering_bad_return_type_notation_needs_dots = return type notation arguments must be elided with `..` .suggestion = use the correct syntax by adding `..` to the arguments ast_lowering_bad_return_type_notation_output = return type not allowed with return type notation ast_lowering_bad_return_type_notation_output_suggestion = use the right argument notation and remove the return type ast_lowering_bad_return_type_notation_position = return type notation not allowed in this position yet ast_lowering_clobber_abi_not_supported = `clobber_abi` is not supported on this target ast_lowering_closure_cannot_be_static = closures cannot be static ast_lowering_coroutine_too_many_parameters = too many parameters for a coroutine (expected 0 or 1 parameters) ast_lowering_default_field_in_tuple = default fields are not supported in tuple structs .label = default fields are only supported on structs ast_lowering_does_not_support_modifiers = the `{$class_name}` register class does not support template modifiers ast_lowering_extra_double_dot = `..` can only be used once per {$ctx} pattern .label = can only be used once per {$ctx} pattern ast_lowering_functional_record_update_destructuring_assignment = functional record updates are not allowed in destructuring assignments .suggestion = consider removing the trailing pattern ast_lowering_generic_param_default_in_binder = defaults for generic parameters are not allowed in `for<...>` binders ast_lowering_generic_type_with_parentheses = parenthesized type parameters may only be used with a `Fn` trait .label = only `Fn` traits may use parentheses ast_lowering_inclusive_range_with_no_end = inclusive range with no end ast_lowering_inline_asm_unsupported_target = inline assembly is unsupported on this target ast_lowering_invalid_abi = invalid ABI: found `{$abi}` .label = invalid ABI .note = invoke `{$command}` for a full list of supported calling conventions ast_lowering_invalid_abi_clobber_abi = invalid ABI for `clobber_abi` .note = the following ABIs are supported on this target: {$supported_abis} ast_lowering_invalid_abi_suggestion = there's a similarly named valid ABI `{$suggestion}` ast_lowering_invalid_asm_template_modifier_const = asm template modifiers are not allowed for `const` arguments ast_lowering_invalid_asm_template_modifier_label = asm template modifiers are not allowed for `label` arguments ast_lowering_invalid_asm_template_modifier_reg_class = invalid asm template modifier for this register class ast_lowering_invalid_asm_template_modifier_sym = asm template modifiers are not allowed for `sym` arguments ast_lowering_invalid_legacy_const_generic_arg = invalid argument to a legacy const generic: cannot have const blocks, closures, async blocks or items ast_lowering_invalid_legacy_const_generic_arg_suggestion = try using a const generic argument instead ast_lowering_invalid_register = invalid register `{$reg}`: {$error} ast_lowering_invalid_register_class = invalid register class `{$reg_class}`: unknown register class .note = the following register classes are supported on this target: {$supported_register_classes} ast_lowering_match_arm_with_no_body = `match` arm with no body .suggestion = add a body after the pattern ast_lowering_misplaced_double_dot = `..` patterns are not allowed here .note = only allowed in tuple, tuple struct, and slice patterns ast_lowering_misplaced_impl_trait = `impl Trait` is not allowed in {$position} .note = `impl Trait` is only allowed in arguments and return types of functions and methods ast_lowering_misplaced_relax_trait_bound = `?Trait` bounds are only permitted at the point where a type parameter is declared ast_lowering_never_pattern_with_body = a never pattern is always unreachable .label = this will never be executed .suggestion = remove this expression ast_lowering_never_pattern_with_guard = a guard on a never pattern will never be run .suggestion = remove this guard ast_lowering_no_precise_captures_on_apit = `use<...>` precise capturing syntax not allowed in argument-position `impl Trait` ast_lowering_previously_used_here = previously used here ast_lowering_register1 = register `{$reg1_name}` ast_lowering_register2 = register `{$reg2_name}` ast_lowering_register_class_only_clobber = register class `{$reg_class_name}` can only be used as a clobber, not as an input or output ast_lowering_register_class_only_clobber_stable = register class `{$reg_class_name}` can only be used as a clobber in stable ast_lowering_register_conflict = register `{$reg1_name}` conflicts with register `{$reg2_name}` .help = use `lateout` instead of `out` to avoid conflict ast_lowering_remove_parentheses = remove these parentheses ast_lowering_sub_tuple_binding = `{$ident_name} @` is not allowed in a {$ctx} .label = this is only allowed in slice patterns .help = remove this and bind each tuple field independently ast_lowering_sub_tuple_binding_suggestion = if you don't need to use the contents of {$ident}, discard the tuple's remaining fields ast_lowering_support_modifiers = the `{$class_name}` register class supports the following template modifiers: {$modifiers} ast_lowering_template_modifier = template modifier ast_lowering_this_not_async = this is not `async` ast_lowering_underscore_array_length_unstable = using `_` for array lengths is unstable ast_lowering_underscore_expr_lhs_assign = in expressions, `_` can only be used on the left-hand side of an assignment .label = `_` not allowed here ast_lowering_unstable_inline_assembly = inline assembly is not stable yet on this architecture ast_lowering_unstable_inline_assembly_label_operand_with_outputs = using both label and output operands for inline assembly is unstable ast_lowering_unstable_may_unwind = the `may_unwind` option is unstable ast_lowering_use_angle_brackets = use angle brackets instead ast_lowering_yield = yield syntax is experimental ast_lowering_yield_in_closure = `yield` can only be used in `#[coroutine]` closures, or `gen` blocks .suggestion = use `#[coroutine]` to make this closure a coroutine ast_passes_assoc_const_without_body = associated constant in `impl` without body .suggestion = provide a definition for the constant ast_passes_assoc_fn_without_body = associated function in `impl` without body .suggestion = provide a definition for the function ast_passes_assoc_type_without_body = associated type in `impl` without body .suggestion = provide a definition for the type ast_passes_at_least_one_trait = at least one trait must be specified ast_passes_auto_generic = auto traits cannot have generic parameters .label = auto trait cannot have generic parameters .suggestion = remove the parameters ast_passes_auto_items = auto traits cannot have associated items .label = {ast_passes_auto_items} .suggestion = remove these associated items ast_passes_auto_super_lifetime = auto traits cannot have super traits or lifetime bounds .label = {ast_passes_auto_super_lifetime} .suggestion = remove the super traits or lifetime bounds ast_passes_bad_c_variadic = only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg ast_passes_bare_fn_invalid_safety = function pointers cannot be declared with `safe` safety qualifier .suggestion = remove safe from this item ast_passes_body_in_extern = incorrect `{$kind}` inside `extern` block .cannot_have = cannot have a body .invalid = the invalid body .existing = `extern` blocks define existing foreign {$kind}s and {$kind}s inside of them cannot have a body ast_passes_bound_in_context = bounds on `type`s in {$ctx} have no effect ast_passes_const_and_c_variadic = functions cannot be both `const` and C-variadic .const = `const` because of this .variadic = C-variadic because of this ast_passes_const_and_coroutine = functions cannot be both `const` and `{$coroutine_kind}` .const = `const` because of this .coroutine = `{$coroutine_kind}` because of this .label = {""} ast_passes_const_bound_trait_object = const trait bounds are not allowed in trait object types ast_passes_const_without_body = free constant item without body .suggestion = provide a definition for the constant ast_passes_constraint_on_negative_bound = associated type constraints not allowed on negative bounds ast_passes_equality_in_where = equality constraints are not yet supported in `where` clauses .label = not supported .suggestion = if `{$ident}` is an associated type you're trying to set, use the associated type binding syntax .suggestion_path = if `{$trait_segment}::{$potential_assoc}` is an associated type you're trying to set, use the associated type binding syntax .note = see issue #20041 for more information ast_passes_extern_block_suggestion = if you meant to declare an externally defined function, use an `extern` block ast_passes_extern_fn_qualifiers = functions in `extern` blocks cannot have `{$kw}` qualifier .label = in this `extern` block .suggestion = remove the `{$kw}` qualifier ast_passes_extern_invalid_safety = items in `extern` blocks without an `unsafe` qualifier cannot have safety qualifiers .suggestion = add `unsafe` to this `extern` block ast_passes_extern_item_ascii = items in `extern` blocks cannot use non-ascii identifiers .label = in this `extern` block .note = this limitation may be lifted in the future; see issue #83942 for more information ast_passes_extern_keyword_link = for more information, visit https://doc.rust-lang.org/std/keyword.extern.html ast_passes_extern_types_cannot = `type`s inside `extern` blocks cannot have {$descr} .suggestion = remove the {$remove_descr} .label = `extern` block begins here ast_passes_extern_without_abi = `extern` declarations without an explicit ABI are disallowed .suggestion = specify an ABI .help = prior to Rust 2024, a default ABI was inferred ast_passes_feature_on_non_nightly = `#![feature]` may not be used on the {$channel} release channel .suggestion = remove the attribute .stable_since = the feature `{$name}` has been stable since `{$since}` and no longer requires an attribute to enable ast_passes_fieldless_union = unions cannot have zero fields ast_passes_fn_body_extern = incorrect function inside `extern` block .cannot_have = cannot have a body .suggestion = remove the invalid body .help = you might have meant to write a function accessible through FFI, which can be done by writing `extern fn` outside of the `extern` block .label = `extern` blocks define existing foreign functions and functions inside of them cannot have a body ast_passes_fn_param_c_var_args_not_last = `...` must be the last argument of a C-variadic function ast_passes_fn_param_doc_comment = documentation comments cannot be applied to function parameters .label = doc comments are not allowed here ast_passes_fn_param_forbidden_attr = allow, cfg, cfg_attr, deny, expect, forbid, and warn are the only allowed built-in attributes in function parameters ast_passes_fn_param_forbidden_self = `self` parameter is only allowed in associated functions .label = not semantically valid as function parameter .note = associated functions are those in `impl` or `trait` definitions ast_passes_fn_param_too_many = function can not have more than {$max_num_args} arguments ast_passes_fn_without_body = free function without a body .suggestion = provide a definition for the function ast_passes_forbidden_bound = bounds cannot be used in this context ast_passes_forbidden_const_param = late-bound const parameters cannot be used currently ast_passes_forbidden_default = `default` is only allowed on items in trait impls .label = `default` because of this ast_passes_forbidden_non_lifetime_param = only lifetime parameters can be used in this context ast_passes_generic_before_constraints = generic arguments must come before the first constraint .constraints = {$constraint_len -> [one] constraint *[other] constraints } .args = generic {$args_len -> [one] argument *[other] arguments } .empty_string = {""}, .suggestion = move the {$constraint_len -> [one] constraint *[other] constraints } after the generic {$args_len -> [one] argument *[other] arguments } ast_passes_generic_default_trailing = generic parameters with a default must be trailing ast_passes_incompatible_features = `{$f1}` and `{$f2}` are incompatible, using them at the same time is not allowed .help = remove one of these features ast_passes_inherent_cannot_be = inherent impls cannot be {$annotation} .because = {$annotation} because of this .type = inherent impl for this type .only_trait = only trait implementations may be annotated with {$annotation} ast_passes_item_invalid_safety = items outside of `unsafe extern {"{ }"}` cannot be declared with `safe` safety qualifier .suggestion = remove safe from this item ast_passes_item_underscore = `{$kind}` items in this context need a name .label = `_` is not a valid name for this `{$kind}` item ast_passes_match_arm_with_no_body = `match` arm with no body .suggestion = add a body after the pattern ast_passes_missing_unsafe_on_extern = extern blocks must be unsafe ast_passes_module_nonascii = trying to load file for module `{$name}` with non-ascii identifier name .help = consider using the `#[path]` attribute to specify filesystem path ast_passes_negative_bound_not_supported = negative bounds are not supported ast_passes_negative_bound_with_parenthetical_notation = parenthetical notation may not be used for negative bounds ast_passes_nested_impl_trait = nested `impl Trait` is not allowed .outer = outer `impl Trait` .inner = nested `impl Trait` here ast_passes_nested_lifetimes = nested quantification of lifetimes ast_passes_nomangle_ascii = `#[no_mangle]` requires ASCII identifier ast_passes_obsolete_auto = `impl Trait for .. {"{}"}` is an obsolete syntax .help = use `auto trait Trait {"{}"}` instead ast_passes_optional_trait_object = `?Trait` is not permitted in trait object types ast_passes_optional_trait_supertrait = `?Trait` is not permitted in supertraits .note = traits are `?{$path_str}` by default ast_passes_out_of_order_params = {$param_ord} parameters must be declared prior to {$max_param} parameters .suggestion = reorder the parameters: lifetimes, then consts and types ast_passes_pattern_in_bodiless = patterns aren't allowed in functions without bodies .label = pattern not allowed in function without body ast_passes_pattern_in_fn_pointer = patterns aren't allowed in function pointer types ast_passes_pattern_in_foreign = patterns aren't allowed in foreign function declarations .label = pattern not allowed in foreign function ast_passes_precise_capturing_duplicated = duplicate `use<...>` precise capturing syntax .label = second `use<...>` here ast_passes_precise_capturing_not_allowed_here = `use<...>` precise capturing syntax not allowed in {$loc} ast_passes_static_without_body = free static item without body .suggestion = provide a definition for the static ast_passes_tilde_const_disallowed = `~const` is not allowed here .closure = closures cannot have `~const` trait bounds .function = this function is not `const`, so it cannot have `~const` trait bounds .trait = this trait is not a `#[const_trait]`, so it cannot have `~const` trait bounds .trait_impl = this impl is not `const`, so it cannot have `~const` trait bounds .impl = inherent impls cannot have `~const` trait bounds .trait_assoc_ty = associated types in non-`#[const_trait]` traits cannot have `~const` trait bounds .trait_impl_assoc_ty = associated types in non-const impls cannot have `~const` trait bounds .inherent_assoc_ty = inherent associated types cannot have `~const` trait bounds .object = trait objects cannot have `~const` trait bounds .item = this item cannot have `~const` trait bounds ast_passes_trait_fn_const = functions in {$in_impl -> [true] trait impls *[false] traits } cannot be declared const .label = functions in {$in_impl -> [true] trait impls *[false] traits } cannot be const .const_context_label = this declares all associated functions implicitly const .remove_const_sugg = remove the `const`{$requires_multiple_changes -> [true] {" ..."} *[false] {""} } .make_impl_const_sugg = ... and declare the impl to be const instead .make_trait_const_sugg = ... and declare the trait to be a `#[const_trait]` instead ast_passes_trait_object_single_bound = only a single explicit lifetime bound is permitted ast_passes_ty_alias_without_body = free type alias without body .suggestion = provide a definition for the type ast_passes_unsafe_item = {$kind} cannot be declared unsafe ast_passes_unsafe_negative_impl = negative impls cannot be unsafe .negative = negative because of this .unsafe = unsafe because of this ast_passes_unsafe_static = static items cannot be declared with `unsafe` safety qualifier outside of `extern` block ast_passes_visibility_not_permitted = visibility qualifiers are not permitted here .enum_variant = enum variants and their fields always share the visibility of the enum they are in .trait_impl = trait items always share the visibility of their trait .individual_impl_items = place qualifiers on individual impl items instead .individual_foreign_items = place qualifiers on individual foreign items instead .remove_qualifier_sugg = remove the qualifier ast_passes_where_clause_after_type_alias = where clauses are not allowed after the type for type aliases .note = see issue #112792 for more information .help = add `#![feature(lazy_type_alias)]` to the crate attributes to enable ast_passes_where_clause_before_type_alias = where clauses are not allowed before the type for type aliases .note = see issue #89122 for more information .remove_suggestion = remove this `where` .move_suggestion = move it to the end of the type declaration attr_parsing_cfg_predicate_identifier = `cfg` predicate key must be an identifier attr_parsing_deprecated_item_suggestion = suggestions on deprecated items are unstable .help = add `#![feature(deprecated_suggestion)]` to the crate root .note = see #94785 for more details attr_parsing_empty_confusables = expected at least one confusable name attr_parsing_expected_one_cfg_pattern = expected 1 cfg-pattern attr_parsing_expected_single_version_literal = expected single version literal attr_parsing_expected_version_literal = expected a version literal attr_parsing_expects_feature_list = `{$name}` expects a list of feature names attr_parsing_expects_features = `{$name}` expects feature names attr_parsing_incorrect_meta_item = expected a quoted string literal attr_parsing_incorrect_meta_item_suggestion = consider surrounding this with quotes attr_parsing_incorrect_repr_format_align_one_arg = incorrect `repr(align)` attribute format: `align` takes exactly one argument in parentheses attr_parsing_incorrect_repr_format_expect_literal_integer = incorrect `repr(align)` attribute format: `align` expects a literal integer as argument attr_parsing_incorrect_repr_format_generic = incorrect `repr({$repr_arg})` attribute format .suggestion = use parentheses instead attr_parsing_incorrect_repr_format_packed_expect_integer = incorrect `repr(packed)` attribute format: `packed` expects a literal integer as argument attr_parsing_incorrect_repr_format_packed_one_or_zero_arg = incorrect `repr(packed)` attribute format: `packed` takes exactly one parenthesized argument, or no parentheses at all attr_parsing_invalid_issue_string = `issue` must be a non-zero numeric string or "none" .must_not_be_zero = `issue` must not be "0", use "none" instead .empty = cannot parse integer from empty string .invalid_digit = invalid digit found in string .pos_overflow = number too large to fit in target type .neg_overflow = number too small to fit in target type attr_parsing_invalid_predicate = invalid predicate `{$predicate}` attr_parsing_invalid_repr_align_need_arg = invalid `repr(align)` attribute: `align` needs an argument .suggestion = supply an argument here attr_parsing_invalid_repr_generic = invalid `repr({$repr_arg})` attribute: {$error_part} attr_parsing_invalid_repr_hint_no_paren = invalid representation hint: `{$name}` does not take a parenthesized argument list attr_parsing_invalid_repr_hint_no_value = invalid representation hint: `{$name}` does not take a value attr_parsing_invalid_since = 'since' must be a Rust version number, such as "1.31.0" attr_parsing_missing_feature = missing 'feature' attr_parsing_missing_issue = missing 'issue' attr_parsing_missing_note = missing 'note' attr_parsing_missing_since = missing 'since' attr_parsing_multiple_item = multiple '{$item}' items attr_parsing_multiple_stability_levels = multiple stability levels attr_parsing_non_ident_feature = 'feature' is not an identifier attr_parsing_repr_ident = meta item in `repr` must be an identifier attr_parsing_rustc_allowed_unstable_pairing = `rustc_allowed_through_unstable_modules` attribute must be paired with a `stable` attribute attr_parsing_rustc_promotable_pairing = `rustc_promotable` attribute must be paired with either a `rustc_const_unstable` or a `rustc_const_stable` attribute attr_parsing_soft_no_args = `soft` should not have any arguments attr_parsing_stability_outside_std = stability attributes may not be used outside of the standard library attr_parsing_unknown_meta_item = unknown meta item '{$item}' .label = expected one of {$expected} attr_parsing_unknown_version_literal = unknown version literal format, assuming it refers to a future version attr_parsing_unrecognized_repr_hint = unrecognized representation hint .help = valid reprs are `Rust` (default), `C`, `align`, `packed`, `transparent`, `simd`, `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize` attr_parsing_unstable_cfg_target_compact = compact `cfg(target(..))` is experimental and subject to change attr_parsing_unsupported_literal_cfg_boolean = literal in `cfg` predicate value must be a boolean attr_parsing_unsupported_literal_cfg_string = literal in `cfg` predicate value must be a string attr_parsing_unsupported_literal_deprecated_kv_pair = item in `deprecated` must be a key/value pair attr_parsing_unsupported_literal_deprecated_string = literal in `deprecated` value must be a string attr_parsing_unsupported_literal_generic = unsupported literal attr_parsing_unsupported_literal_suggestion = consider removing the prefix attr_parsing_unused_multiple = multiple `{$name}` attributes .suggestion = remove this attribute .note = attribute also specified here 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_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_tail_expr_drop_order = relative drop order changing in Rust 2024 .label = this temporary value will be dropped at the end of the block .note = consider using a `let` binding to ensure the value will live long enough 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 builtin_macros_alloc_error_must_be_fn = alloc_error_handler must be a function builtin_macros_alloc_must_statics = allocators must be statics builtin_macros_asm_clobber_abi = clobber_abi builtin_macros_asm_clobber_no_reg = asm with `clobber_abi` must specify explicit registers for outputs builtin_macros_asm_clobber_outputs = generic outputs builtin_macros_asm_duplicate_arg = duplicate argument named `{$name}` .label = previously here .arg = duplicate argument builtin_macros_asm_expected_comma = expected token: `,` .label = expected `,` builtin_macros_asm_expected_other = expected operand, {$is_inline_asm -> [false] options *[true] clobber_abi, options }, or additional template string builtin_macros_asm_expected_string_literal = expected string literal .label = not a string literal builtin_macros_asm_explicit_register_name = explicit register arguments cannot have names builtin_macros_asm_mayunwind = asm labels are not allowed with the `may_unwind` option builtin_macros_asm_modifier_invalid = asm template modifier must be a single character builtin_macros_asm_mutually_exclusive = the `{$opt1}` and `{$opt2}` options are mutually exclusive builtin_macros_asm_no_matched_argument_name = there is no argument named `{$name}` builtin_macros_asm_noreturn = asm outputs are not allowed with the `noreturn` option builtin_macros_asm_opt_already_provided = the `{$symbol}` option was already provided .label = this option was already provided .suggestion = remove this option builtin_macros_asm_pos_after = positional arguments cannot follow named arguments or explicit register arguments .pos = positional argument .named = named argument .explicit = explicit register argument builtin_macros_asm_pure_combine = the `pure` option must be combined with either `nomem` or `readonly` builtin_macros_asm_pure_no_output = asm with the `pure` option must have at least one output builtin_macros_asm_requires_template = requires at least a template string argument builtin_macros_asm_sym_no_path = expected a path for argument to `sym` builtin_macros_asm_underscore_input = _ cannot be used for input operands builtin_macros_asm_unsupported_clobber_abi = `clobber_abi` cannot be used with `{$macro_name}!` builtin_macros_asm_unsupported_operand = the `{$symbol}` operand cannot be used with `{$macro_name}!` .label = the `{$symbol}` operand is not meaningful for global-scoped inline assembly, remove it builtin_macros_asm_unsupported_option = the `{$symbol}` option cannot be used with `{$macro_name}!` .label = the `{$symbol}` option is not meaningful for global-scoped inline assembly .suggestion = remove this option builtin_macros_assert_missing_comma = unexpected string literal .suggestion = try adding a comma builtin_macros_assert_requires_boolean = macro requires a boolean expression as an argument .label = boolean expression required builtin_macros_assert_requires_expression = macro requires an expression as an argument .suggestion = try removing semicolon builtin_macros_autodiff = autodiff must be applied to function builtin_macros_autodiff_missing_config = autodiff requires at least a name and mode builtin_macros_autodiff_mode = unknown Mode: `{$mode}`. Use `Forward` or `Reverse` builtin_macros_autodiff_mode_activity = {$act} can not be used in {$mode} Mode builtin_macros_autodiff_not_build = this rustc version does not support autodiff builtin_macros_autodiff_number_activities = expected {$expected} activities, but found {$found} builtin_macros_autodiff_ret_activity = invalid return activity {$act} in {$mode} Mode builtin_macros_autodiff_ty_activity = {$act} can not be used for this type builtin_macros_autodiff_unknown_activity = did not recognize Activity: `{$act}` builtin_macros_autodiff_width = autodiff width must fit u32, but is {$width} builtin_macros_bad_derive_target = `derive` may only be applied to `struct`s, `enum`s and `union`s .label = not applicable here .label2 = not a `struct`, `enum` or `union` builtin_macros_bench_sig = functions used as benches must have signature `fn(&mut Bencher) -> impl Termination` builtin_macros_cannot_derive_union = this trait cannot be derived for unions builtin_macros_cfg_accessible_has_args = `cfg_accessible` path cannot accept arguments builtin_macros_cfg_accessible_indeterminate = cannot determine whether the path is accessible or not builtin_macros_cfg_accessible_literal_path = `cfg_accessible` path cannot be a literal builtin_macros_cfg_accessible_multiple_paths = multiple `cfg_accessible` paths are specified builtin_macros_cfg_accessible_unspecified_path = `cfg_accessible` path is not specified builtin_macros_coerce_pointee_requires_maybe_sized = `derive(CoercePointee)` requires `{$name}` to be marked `?Sized` builtin_macros_coerce_pointee_requires_one_field = `CoercePointee` can only be derived on `struct`s with at least one field builtin_macros_coerce_pointee_requires_one_generic = `CoercePointee` can only be derived on `struct`s that are generic over at least one type builtin_macros_coerce_pointee_requires_one_pointee = exactly one generic type parameter must be marked as `#[pointee]` to derive `CoercePointee` traits builtin_macros_coerce_pointee_requires_transparent = `CoercePointee` can only be derived on `struct`s with `#[repr(transparent)]` builtin_macros_coerce_pointee_too_many_pointees = only one type parameter can be marked as `#[pointee]` when deriving `CoercePointee` traits .label = here another type parameter is marked as `#[pointee]` builtin_macros_concat_bytes_array = cannot concatenate doubly nested array .note = byte strings are treated as arrays of bytes .help = try flattening the array builtin_macros_concat_bytes_bad_repeat = repeat count is not a positive number builtin_macros_concat_bytes_invalid = cannot concatenate {$lit_kind} literals .byte_char = try using a byte character .byte_str = try using a byte string .number_array = try wrapping the number in an array builtin_macros_concat_bytes_missing_literal = expected a byte literal .note = only byte literals (like `b"foo"`, `b's'` and `[3, 4, 5]`) can be passed to `concat_bytes!()` builtin_macros_concat_bytes_non_u8 = numeric literal is not a `u8` builtin_macros_concat_bytes_oob = numeric literal is out of bounds builtin_macros_concat_bytestr = cannot concatenate a byte string literal builtin_macros_concat_c_str_lit = cannot concatenate a C string literal builtin_macros_concat_idents_ident_args = `concat_idents!()` requires ident args builtin_macros_concat_idents_missing_args = `concat_idents!()` takes 1 or more arguments builtin_macros_concat_idents_missing_comma = `concat_idents!()` expecting comma builtin_macros_concat_missing_literal = expected a literal .note = only literals (like `"foo"`, `-42` and `3.14`) can be passed to `concat!()` builtin_macros_default_arg = `#[default]` attribute does not accept a value .suggestion = try using `#[default]` builtin_macros_derive_macro_call = `derive` cannot be used on items with type macros builtin_macros_derive_path_args_list = traits in `#[derive(...)]` don't accept arguments .suggestion = remove the arguments builtin_macros_derive_path_args_value = traits in `#[derive(...)]` don't accept values .suggestion = remove the value builtin_macros_env_not_defined = environment variable `{$var}` not defined at compile time .cargo = Cargo sets build script variables at run time. Use `std::env::var({$var_expr})` instead .custom = use `std::env::var({$var_expr})` to read the variable at run time builtin_macros_env_not_unicode = environment variable `{$var}` is not a valid Unicode string builtin_macros_env_takes_args = `env!()` takes 1 or 2 arguments builtin_macros_expected_comma_in_list = expected token: `,` builtin_macros_expected_one_cfg_pattern = expected 1 cfg-pattern builtin_macros_expected_register_class_or_explicit_register = expected register class or explicit register builtin_macros_export_macro_rules = cannot export macro_rules! macros from a `proc-macro` crate type currently builtin_macros_format_duplicate_arg = duplicate argument named `{$ident}` .label1 = previously here .label2 = duplicate argument builtin_macros_format_no_arg_named = there is no argument named `{$name}` .note = did you intend to capture a variable `{$name}` from the surrounding scope? .note2 = to avoid ambiguity, `format_args!` cannot capture variables when the format string is expanded from a macro builtin_macros_format_pos_mismatch = {$n} positional {$n -> [one] argument *[more] arguments } in format string, but {$desc} builtin_macros_format_positional_after_named = positional arguments cannot follow named arguments .label = positional arguments must be before named arguments .named_args = named argument builtin_macros_format_redundant_args = redundant {$n -> [one] argument *[more] arguments } .help = {$n -> [one] the formatting string already captures the binding directly, it doesn't need to be included in the argument list *[more] the formatting strings already captures the bindings directly, they don't need to be included in the argument list } .note = {$n -> [one] the formatting specifier is referencing the binding already *[more] the formatting specifiers are referencing the bindings already } .suggestion = this can be removed builtin_macros_format_remove_raw_ident = remove the `r#` builtin_macros_format_reorder_format_parameter = did you mean `{$replacement}`? builtin_macros_format_requires_string = requires at least a format string argument builtin_macros_format_string_invalid = invalid format string: {$desc} .label = {$label1} in format string .note = {$note} .second_label = {$label} builtin_macros_format_unknown_trait = unknown format trait `{$ty}` .note = the only appropriate formatting traits are: - ``, which uses the `Display` trait - `?`, which uses the `Debug` trait - `e`, which uses the `LowerExp` trait - `E`, which uses the `UpperExp` trait - `o`, which uses the `Octal` trait - `p`, which uses the `Pointer` trait - `b`, which uses the `Binary` trait - `x`, which uses the `LowerHex` trait - `X`, which uses the `UpperHex` trait .suggestion = use the `{$trait_name}` trait builtin_macros_format_unused_arg = {$named -> [true] named argument *[false] argument } never used builtin_macros_format_unused_args = multiple unused formatting arguments .label = multiple missing formatting specifiers builtin_macros_format_use_positional = consider using a positional formatting argument instead builtin_macros_multiple_default_attrs = multiple `#[default]` attributes .note = only one `#[default]` attribute is needed .label = `#[default]` used here .label_again = `#[default]` used again here .help = try removing {$only_one -> [true] this *[false] these } builtin_macros_multiple_defaults = multiple declared defaults .label = first default .additional = additional default .note = only one variant can be default .suggestion = make `{$ident}` default builtin_macros_naked_functions_testing_attribute = cannot use `#[unsafe(naked)]` with testing attributes .label = function marked with testing attribute here .naked_attribute = `#[unsafe(naked)]` is incompatible with testing attributes builtin_macros_no_default_variant = `#[derive(Default)]` on enum with no `#[default]` .label = this enum needs a unit variant marked with `#[default]` .suggestion = make this unit variant default by placing `#[default]` on it builtin_macros_non_abi = at least one abi must be provided as an argument to `clobber_abi` builtin_macros_non_exhaustive_default = default variant must be exhaustive .label = declared `#[non_exhaustive]` here .help = consider a manual implementation of `Default` builtin_macros_non_generic_pointee = the `#[pointee]` attribute may only be used on generic parameters builtin_macros_non_unit_default = the `#[default]` attribute may only be used on unit enum variants{$post} .help = consider a manual implementation of `Default` builtin_macros_only_one_argument = {$name} takes 1 argument builtin_macros_proc_macro = `proc-macro` crate types currently cannot export any items other than functions tagged with `#[proc_macro]`, `#[proc_macro_derive]`, or `#[proc_macro_attribute]` builtin_macros_proc_macro_attribute_only_be_used_on_bare_functions = the `#[{$path}]` attribute may only be used on bare functions builtin_macros_proc_macro_attribute_only_usable_with_crate_type = the `#[{$path}]` attribute is only usable with crates of the `proc-macro` crate type builtin_macros_requires_cfg_pattern = macro requires a cfg-pattern as an argument .label = cfg-pattern required builtin_macros_source_uitls_expected_item = expected item, found `{$token}` builtin_macros_takes_no_arguments = {$name} takes no arguments builtin_macros_test_bad_fn = {$kind} functions cannot be used for tests .label = `{$kind}` because of this builtin_macros_test_case_non_item = `#[test_case]` attribute is only allowed on items builtin_macros_test_runner_invalid = `test_runner` argument must be a path builtin_macros_test_runner_nargs = `#![test_runner(..)]` accepts exactly 1 argument builtin_macros_tests_not_support = building tests with panic=abort is not supported without `-Zpanic_abort_tests` builtin_macros_trace_macros = trace_macros! accepts only `true` or `false` builtin_macros_unexpected_lit = expected path to a trait, found literal .label = not a trait .str_lit = try using `#[derive({$sym})]` .other = for example, write `#[derive(Debug)]` for `Debug` codegen_ssa_L4Bender_exporting_symbols_unimplemented = exporting symbols not implemented yet for L4Bender codegen_ssa_add_native_library = failed to add native library {$library_path}: {$error} codegen_ssa_aix_strip_not_used = using host's `strip` binary to cross-compile to AIX which is not guaranteed to work codegen_ssa_archive_build_failure = failed to build archive at `{$path}`: {$error} codegen_ssa_atomic_compare_exchange = Atomic compare-exchange intrinsic missing failure memory ordering codegen_ssa_autodiff_without_lto = using the autodiff feature requires using fat-lto codegen_ssa_bare_instruction_set = `#[instruction_set]` requires an argument codegen_ssa_binary_output_to_tty = option `-o` or `--emit` is used to write binary output type `{$shorthand}` to stdout, but stdout is a tty codegen_ssa_cgu_not_recorded = CGU-reuse for `{$cgu_user_name}` is (mangled: `{$cgu_name}`) was not recorded codegen_ssa_check_installed_visual_studio = please ensure that Visual Studio 2017 or later, or Build Tools for Visual Studio were installed with the Visual C++ option. codegen_ssa_compiler_builtins_cannot_call = `compiler_builtins` cannot call functions through upstream monomorphizations; encountered invalid call from `{$caller}` to `{$callee}` codegen_ssa_copy_path = could not copy {$from} to {$to}: {$error} codegen_ssa_copy_path_buf = unable to copy {$source_file} to {$output_path}: {$error} codegen_ssa_cpu_required = target requires explicitly specifying a cpu with `-C target-cpu` codegen_ssa_create_temp_dir = couldn't create a temp dir: {$error} codegen_ssa_dlltool_fail_import_library = Dlltool could not create import library with {$dlltool_path} {$dlltool_args}: {$stdout} {$stderr} codegen_ssa_error_calling_dlltool = Error calling dlltool '{$dlltool_path}': {$error} codegen_ssa_error_creating_import_library = Error creating import library for {$lib_name}: {$error} codegen_ssa_error_creating_remark_dir = failed to create remark directory: {$error} codegen_ssa_error_writing_def_file = Error writing .DEF file: {$error} codegen_ssa_expected_name_value_pair = expected name value pair codegen_ssa_expected_one_argument = expected one argument codegen_ssa_expected_used_symbol = expected `used`, `used(compiler)` or `used(linker)` codegen_ssa_extern_funcs_not_found = some `extern` functions couldn't be found; some native libraries may need to be installed or have their path specified codegen_ssa_extract_bundled_libs_archive_member = failed to get data from archive member '{$rlib}': {$error} codegen_ssa_extract_bundled_libs_convert_name = failed to convert name '{$rlib}': {$error} codegen_ssa_extract_bundled_libs_mmap_file = failed to mmap file '{$rlib}': {$error} codegen_ssa_extract_bundled_libs_open_file = failed to open file '{$rlib}': {$error} codegen_ssa_extract_bundled_libs_parse_archive = failed to parse archive '{$rlib}': {$error} codegen_ssa_extract_bundled_libs_read_entry = failed to read entry '{$rlib}': {$error} codegen_ssa_extract_bundled_libs_write_file = failed to write file '{$rlib}': {$error} codegen_ssa_failed_to_get_layout = failed to get layout for {$ty}: {$err} codegen_ssa_failed_to_write = failed to write {$path}: {$error} codegen_ssa_field_associated_value_expected = associated value expected for `{$name}` codegen_ssa_forbidden_target_feature_attr = target feature `{$feature}` cannot be enabled with `#[target_feature]`: {$reason} codegen_ssa_ignoring_emit_path = ignoring emit path because multiple .{$extension} files were produced codegen_ssa_ignoring_output = ignoring -o because multiple .{$extension} files were produced codegen_ssa_illegal_link_ordinal_format = illegal ordinal format in `link_ordinal` .note = an unsuffixed integer value, e.g., `1`, is expected codegen_ssa_incorrect_cgu_reuse_type = CGU-reuse for `{$cgu_user_name}` is `{$actual_reuse}` but should be {$at_least -> [one] {"at least "} *[other] {""} }`{$expected_reuse}` codegen_ssa_insufficient_vs_code_product = VS Code is a different product, and is not sufficient. codegen_ssa_invalid_argument = invalid argument .help = valid inline arguments are `always` and `never` codegen_ssa_invalid_instruction_set = invalid instruction set specified codegen_ssa_invalid_link_ordinal_nargs = incorrect number of arguments to `#[link_ordinal]` .note = the attribute requires exactly one argument codegen_ssa_invalid_literal_value = invalid literal value .label = value must be an integer between `0` and `255` codegen_ssa_invalid_monomorphization_basic_float_type = invalid monomorphization of `{$name}` intrinsic: expected basic float type, found `{$ty}` codegen_ssa_invalid_monomorphization_basic_integer_type = invalid monomorphization of `{$name}` intrinsic: expected basic integer type, found `{$ty}` codegen_ssa_invalid_monomorphization_cannot_return = invalid monomorphization of `{$name}` intrinsic: cannot return `{$ret_ty}`, expected `u{$expected_int_bits}` or `[u8; {$expected_bytes}]` codegen_ssa_invalid_monomorphization_cast_wide_pointer = invalid monomorphization of `{$name}` intrinsic: cannot cast wide pointer `{$ty}` codegen_ssa_invalid_monomorphization_expected_element_type = invalid monomorphization of `{$name}` intrinsic: expected element type `{$expected_element}` of second argument `{$second_arg}` to be a pointer to the element type `{$in_elem}` of the first argument `{$in_ty}`, found `{$expected_element}` != `{$mutability} {$in_elem}` codegen_ssa_invalid_monomorphization_expected_pointer = invalid monomorphization of `{$name}` intrinsic: expected pointer, got `{$ty}` codegen_ssa_invalid_monomorphization_expected_return_type = invalid monomorphization of `{$name}` intrinsic: expected return type `{$in_ty}`, found `{$ret_ty}` codegen_ssa_invalid_monomorphization_expected_usize = invalid monomorphization of `{$name}` intrinsic: expected `usize`, got `{$ty}` codegen_ssa_invalid_monomorphization_expected_vector_element_type = invalid monomorphization of `{$name}` intrinsic: expected element type `{$expected_element}` of vector type `{$vector_type}` to be a signed or unsigned integer type codegen_ssa_invalid_monomorphization_float_to_int_unchecked = invalid monomorphization of `float_to_int_unchecked` intrinsic: expected basic float type, found `{$ty}` codegen_ssa_invalid_monomorphization_floating_point_type = invalid monomorphization of `{$name}` intrinsic: `{$in_ty}` is not a floating-point type codegen_ssa_invalid_monomorphization_floating_point_vector = invalid monomorphization of `{$name}` intrinsic: unsupported element type `{$f_ty}` of floating-point vector `{$in_ty}` codegen_ssa_invalid_monomorphization_inserted_type = invalid monomorphization of `{$name}` intrinsic: expected inserted type `{$in_elem}` (element of input `{$in_ty}`), found `{$out_ty}` codegen_ssa_invalid_monomorphization_invalid_bitmask = invalid monomorphization of `{$name}` intrinsic: invalid bitmask `{$mask_ty}`, expected `u{$expected_int_bits}` or `[u8; {$expected_bytes}]` codegen_ssa_invalid_monomorphization_mask_wrong_element_type = invalid monomorphization of `{$name}` intrinsic: expected mask element type to be an integer, found `{$ty}` codegen_ssa_invalid_monomorphization_mismatched_lengths = invalid monomorphization of `{$name}` intrinsic: mismatched lengths: mask length `{$m_len}` != other vector length `{$v_len}` codegen_ssa_invalid_monomorphization_return_element = invalid monomorphization of `{$name}` intrinsic: expected return element type `{$in_elem}` (element of input `{$in_ty}`), found `{$ret_ty}` with element type `{$out_ty}` codegen_ssa_invalid_monomorphization_return_integer_type = invalid monomorphization of `{$name}` intrinsic: expected return type with integer elements, found `{$ret_ty}` with non-integer `{$out_ty}` codegen_ssa_invalid_monomorphization_return_length = invalid monomorphization of `{$name}` intrinsic: expected return type of length {$in_len}, found `{$ret_ty}` with length {$out_len} codegen_ssa_invalid_monomorphization_return_length_input_type = invalid monomorphization of `{$name}` intrinsic: expected return type with length {$in_len} (same as input type `{$in_ty}`), found `{$ret_ty}` with length {$out_len} codegen_ssa_invalid_monomorphization_return_type = invalid monomorphization of `{$name}` intrinsic: expected return type `{$in_elem}` (element of input `{$in_ty}`), found `{$ret_ty}` codegen_ssa_invalid_monomorphization_second_argument_length = invalid monomorphization of `{$name}` intrinsic: expected second argument with length {$in_len} (same as input type `{$in_ty}`), found `{$arg_ty}` with length {$out_len} codegen_ssa_invalid_monomorphization_simd_argument = invalid monomorphization of `{$name}` intrinsic: expected SIMD argument type, found non-SIMD `{$ty}` codegen_ssa_invalid_monomorphization_simd_first = invalid monomorphization of `{$name}` intrinsic: expected SIMD first type, found non-SIMD `{$ty}` codegen_ssa_invalid_monomorphization_simd_index_out_of_bounds = invalid monomorphization of `{$name}` intrinsic: SIMD index #{$arg_idx} is out of bounds (limit {$total_len}) codegen_ssa_invalid_monomorphization_simd_input = invalid monomorphization of `{$name}` intrinsic: expected SIMD input type, found non-SIMD `{$ty}` codegen_ssa_invalid_monomorphization_simd_return = invalid monomorphization of `{$name}` intrinsic: expected SIMD return type, found non-SIMD `{$ty}` codegen_ssa_invalid_monomorphization_simd_second = invalid monomorphization of `{$name}` intrinsic: expected SIMD second type, found non-SIMD `{$ty}` codegen_ssa_invalid_monomorphization_simd_shuffle = invalid monomorphization of `{$name}` intrinsic: simd_shuffle index must be a SIMD vector of `u32`, got `{$ty}` codegen_ssa_invalid_monomorphization_simd_third = invalid monomorphization of `{$name}` intrinsic: expected SIMD third type, found non-SIMD `{$ty}` codegen_ssa_invalid_monomorphization_third_argument_length = invalid monomorphization of `{$name}` intrinsic: expected third argument with length {$in_len} (same as input type `{$in_ty}`), found `{$arg_ty}` with length {$out_len} codegen_ssa_invalid_monomorphization_unrecognized_intrinsic = invalid monomorphization of `{$name}` intrinsic: unrecognized intrinsic `{$name}` codegen_ssa_invalid_monomorphization_unsupported_cast = invalid monomorphization of `{$name}` intrinsic: unsupported cast from `{$in_ty}` with element `{$in_elem}` to `{$ret_ty}` with element `{$out_elem}` codegen_ssa_invalid_monomorphization_unsupported_operation = invalid monomorphization of `{$name}` intrinsic: unsupported operation on `{$in_ty}` with element `{$in_elem}` codegen_ssa_invalid_monomorphization_unsupported_symbol = invalid monomorphization of `{$name}` intrinsic: unsupported {$symbol} from `{$in_ty}` with element `{$in_elem}` to `{$ret_ty}` codegen_ssa_invalid_monomorphization_unsupported_symbol_of_size = invalid monomorphization of `{$name}` intrinsic: unsupported {$symbol} from `{$in_ty}` with element `{$in_elem}` of size `{$size}` to `{$ret_ty}` codegen_ssa_invalid_no_sanitize = invalid argument for `no_sanitize` .note = expected one of: `address`, `cfi`, `hwaddress`, `kcfi`, `memory`, `memtag`, `shadow-call-stack`, or `thread` codegen_ssa_invalid_windows_subsystem = invalid windows subsystem `{$subsystem}`, only `windows` and `console` are allowed codegen_ssa_ld64_unimplemented_modifier = `as-needed` modifier not implemented yet for ld64 codegen_ssa_lib_def_write_failure = failed to write lib.def file: {$error} codegen_ssa_link_exe_unexpected_error = `link.exe` returned an unexpected error codegen_ssa_link_script_unavailable = can only use link script when linking with GNU-like linker codegen_ssa_link_script_write_failure = failed to write link script to {$path}: {$error} codegen_ssa_linker_file_stem = couldn't extract file stem from specified linker codegen_ssa_linker_not_found = linker `{$linker_path}` not found .note = {$error} codegen_ssa_linker_output = {$inner} codegen_ssa_linker_unsupported_modifier = `as-needed` modifier not supported for current linker codegen_ssa_linking_failed = linking with `{$linker_path}` failed: {$exit_status} codegen_ssa_malformed_cgu_name = found malformed codegen unit name `{$user_path}`. codegen units names must always start with the name of the crate (`{$crate_name}` in this case). codegen_ssa_metadata_object_file_write = error writing metadata object file: {$error} codegen_ssa_missing_cpp_build_tool_component = or a necessary component may be missing from the "C++ build tools" workload codegen_ssa_missing_features = add the missing features in a `target_feature` attribute codegen_ssa_missing_memory_ordering = Atomic intrinsic missing memory ordering codegen_ssa_missing_query_depgraph = found CGU-reuse attribute but `-Zquery-dep-graph` was not specified codegen_ssa_mixed_export_name_and_no_mangle = `{$no_mangle_attr}` attribute may not be used in combination with `#[export_name]` .label = `{$no_mangle_attr}` is ignored .note = `#[export_name]` takes precedence .suggestion = remove the `{$no_mangle_attr}` attribute codegen_ssa_msvc_missing_linker = the msvc targets depend on the msvc linker but `link.exe` was not found codegen_ssa_multiple_external_func_decl = multiple declarations of external function `{$function}` from library `{$library_name}` have different calling conventions codegen_ssa_multiple_instruction_set = cannot specify more than one instruction set codegen_ssa_multiple_main_functions = entry symbol `main` declared multiple times .help = did you use `#[no_mangle]` on `fn main`? Use `#![no_main]` to suppress the usual Rust-generated entry point codegen_ssa_no_field = no field `{$name}` codegen_ssa_no_module_named = no module named `{$user_path}` (mangled: {$cgu_name}). available modules: {$cgu_names} codegen_ssa_no_natvis_directory = error enumerating natvis directory: {$error} codegen_ssa_no_saved_object_file = cached cgu {$cgu_name} should have an object file, but doesn't codegen_ssa_null_on_export = `export_name` may not contain null characters codegen_ssa_out_of_range_integer = integer value out of range .label = value must be between `0` and `255` codegen_ssa_processing_dymutil_failed = processing debug info with `dsymutil` failed: {$status} .note = {$output} codegen_ssa_read_file = failed to read file: {$message} codegen_ssa_repair_vs_build_tools = the Visual Studio build tools may need to be repaired using the Visual Studio installer codegen_ssa_requires_rust_abi = `#[track_caller]` requires Rust ABI codegen_ssa_rlib_archive_build_failure = failed to build archive from rlib at `{$path}`: {$error} codegen_ssa_rlib_incompatible_dependency_formats = `{$ty1}` and `{$ty2}` do not have equivalent dependency formats (`{$list1}` vs `{$list2}`) codegen_ssa_rlib_missing_format = could not find formats for rlibs codegen_ssa_rlib_not_found = could not find rlib for: `{$crate_name}` codegen_ssa_rlib_only_rmeta_found = could not find rlib for: `{$crate_name}`, found rmeta (metadata) file codegen_ssa_select_cpp_build_tool_workload = in the Visual Studio installer, ensure the "C++ build tools" workload is selected codegen_ssa_self_contained_linker_missing = the self-contained linker was requested, but it wasn't found in the target's sysroot, or in rustc's sysroot codegen_ssa_shuffle_indices_evaluation = could not evaluate shuffle_indices at compile time codegen_ssa_specify_libraries_to_link = use the `-l` flag to specify native libraries to link codegen_ssa_static_library_native_artifacts = Link against the following native artifacts when linking against this static library. The order and any duplication can be significant on some platforms. codegen_ssa_static_library_native_artifacts_to_file = Native artifacts to link against have been written to {$path}. The order and any duplication can be significant on some platforms. codegen_ssa_stripping_debug_info_failed = stripping debug info with `{$util}` failed: {$status} .note = {$output} codegen_ssa_symbol_file_write_failure = failed to write symbols file: {$error} codegen_ssa_target_feature_disable_or_enable = the target features {$features} must all be either enabled or disabled together codegen_ssa_target_feature_safe_trait = `#[target_feature(..)]` cannot be applied to safe trait method .label = cannot be applied to safe trait method .label_def = not an `unsafe` function codegen_ssa_thorin_decompress_data = failed to decompress compressed section codegen_ssa_thorin_duplicate_unit = duplicate split compilation unit ({$unit}) codegen_ssa_thorin_empty_unit = unit {$unit} in input DWARF object with no data codegen_ssa_thorin_gimli_read = {$error} codegen_ssa_thorin_gimli_write = {$error} codegen_ssa_thorin_incompatible_index_version = incompatible `{$section}` index version: found version {$actual}, expected version {$format} codegen_ssa_thorin_invalid_input_kind = input is not an archive or elf object codegen_ssa_thorin_io = {$error} codegen_ssa_thorin_missing_dwo_name = missing path attribute to DWARF object ({$id}) codegen_ssa_thorin_missing_referenced_unit = unit {$unit} referenced by executable was not found codegen_ssa_thorin_missing_required_section = input object missing required section `{$section}` codegen_ssa_thorin_mixed_input_encodings = input objects haved mixed encodings codegen_ssa_thorin_multiple_debug_info_section = multiple `.debug_info.dwo` sections codegen_ssa_thorin_multiple_debug_types_section = multiple `.debug_types.dwo` sections in a package codegen_ssa_thorin_multiple_relocations = multiple relocations for section `{$section}` at offset {$offset} codegen_ssa_thorin_no_compilation_units = input object has no compilation units codegen_ssa_thorin_no_die = no top-level debugging information entry in compilation/type unit codegen_ssa_thorin_not_output_object_created = no output object was created from inputs codegen_ssa_thorin_not_split_unit = regular compilation unit in object (missing dwo identifier) codegen_ssa_thorin_object_read = {$error} codegen_ssa_thorin_object_write = {$error} codegen_ssa_thorin_offset_at_index = read offset at index {$index} of `.debug_str_offsets.dwo` section codegen_ssa_thorin_parse_archive_member = failed to parse archive member codegen_ssa_thorin_parse_index = failed to parse `{$section}` index section codegen_ssa_thorin_parse_input_archive_file = failed to parse input archive file codegen_ssa_thorin_parse_input_file_kind = failed to parse input file kind codegen_ssa_thorin_parse_input_object_file = failed to parse input object file codegen_ssa_thorin_parse_unit = failed to parse unit codegen_ssa_thorin_parse_unit_abbreviations = failed to parse unit abbreviations codegen_ssa_thorin_parse_unit_attribute = failed to parse unit attribute codegen_ssa_thorin_parse_unit_header = failed to parse unit header codegen_ssa_thorin_read_input_failure = failed to read input file codegen_ssa_thorin_relocation_with_invalid_symbol = relocation with invalid symbol for section `{$section}` at offset {$offset} codegen_ssa_thorin_row_not_in_index = row {$row} found in index's hash table not present in index codegen_ssa_thorin_section_not_in_row = section not found in unit's row in index codegen_ssa_thorin_section_without_name = section without name at offset {$offset} codegen_ssa_thorin_str_at_offset = read string at offset {$offset} of `.debug_str.dwo` section codegen_ssa_thorin_top_level_die_not_unit = top-level debugging information entry is not a compilation/type unit codegen_ssa_thorin_unit_not_in_index = unit {$unit} from input package is not in its index codegen_ssa_thorin_unsupported_relocation = unsupported relocation for section {$section} at offset {$offset} codegen_ssa_unable_to_exe_linker = could not exec the linker `{$linker_path}` .note = {$error} .command_note = {$command_formatted} codegen_ssa_unable_to_run = unable to run `{$util}`: {$error} codegen_ssa_unable_to_run_dsymutil = unable to run `dsymutil`: {$error} codegen_ssa_unable_to_write_debugger_visualizer = Unable to write debugger visualizer file `{$path}`: {$error} codegen_ssa_unexpected_parameter_name = unexpected parameter name .label = expected `{$prefix_nops}` or `{$entry_nops}` codegen_ssa_unknown_archive_kind = Don't know how to build archive of type: {$kind} codegen_ssa_unknown_atomic_operation = unknown atomic operation codegen_ssa_unknown_atomic_ordering = unknown ordering in atomic intrinsic codegen_ssa_unknown_reuse_kind = unknown cgu-reuse-kind `{$kind}` specified codegen_ssa_unsupported_instruction_set = target does not support `#[instruction_set]` codegen_ssa_unsupported_link_self_contained = option `-C link-self-contained` is not supported on this target codegen_ssa_use_cargo_directive = use the `cargo:rustc-link-lib` directive to specify the native libraries to link with Cargo (see https://doc.rust-lang.org/cargo/reference/build-scripts.html#rustc-link-lib) codegen_ssa_version_script_write_failure = failed to write version script: {$error} codegen_ssa_visual_studio_not_installed = you may need to install Visual Studio build tools with the "C++ build tools" workload codegen_ssa_xcrun_command_line_tools_insufficient = when compiling for iOS, tvOS, visionOS or watchOS, you need a full installation of Xcode codegen_ssa_xcrun_failed_invoking = invoking `{$command_formatted}` to find {$sdk_name}.sdk failed: {$error} codegen_ssa_xcrun_found_developer_dir = found active developer directory at "{$developer_dir}" # `xcrun` already outputs a message about missing Xcode installation, so we only augment it with details about env vars. codegen_ssa_xcrun_no_developer_dir = pass the path of an Xcode installation via the DEVELOPER_DIR environment variable, or an SDK with the SDKROOT environment variable codegen_ssa_xcrun_sdk_path_warning = output of `xcrun` while finding {$sdk_name}.sdk .note = {$stderr} codegen_ssa_xcrun_unsuccessful = failed running `{$command_formatted}` to find {$sdk_name}.sdk .note = {$stdout}{$stderr} const_eval_address_space_full = there are no more free addresses in the address space const_eval_alignment_check_failed = {$msg -> [AccessedPtr] accessing memory *[other] accessing memory based on pointer } with alignment {$has}, but alignment {$required} is required const_eval_already_reported = an error has already been reported elsewhere (this should not usually be printed) const_eval_assume_false = `assume` called with `false` const_eval_bad_pointer_op = {$operation -> [MemoryAccess] memory access failed [InboundsPointerArithmetic] in-bounds pointer arithmetic failed *[Dereferenceable] pointer not dereferenceable } const_eval_bad_pointer_op_attempting = {const_eval_bad_pointer_op}: {$operation -> [MemoryAccess] attempting to access {$inbounds_size -> [1] 1 byte *[x] {$inbounds_size} bytes } [InboundsPointerArithmetic] attempting to offset pointer by {$inbounds_size -> [1] 1 byte *[x] {$inbounds_size} bytes } *[Dereferenceable] pointer must {$inbounds_size -> [0] point to some allocation [1] be dereferenceable for 1 byte *[x] be dereferenceable for {$inbounds_size} bytes } } const_eval_bounds_check_failed = indexing out of bounds: the len is {$len} but the index is {$index} const_eval_call_nonzero_intrinsic = `{$name}` called on 0 const_eval_closure_call = closures need an RFC before allowed to be called in {const_eval_const_context}s const_eval_closure_fndef_not_const = function defined here, but it is not `const` const_eval_consider_dereferencing = consider dereferencing here const_eval_const_accesses_mut_global = constant accesses mutable global memory const_eval_const_context = {$kind -> [const] constant [static] static [const_fn] constant function *[other] {""} } const_eval_copy_nonoverlapping_overlapping = `copy_nonoverlapping` called on overlapping ranges const_eval_dangling_int_pointer = {const_eval_bad_pointer_op_attempting}, but got {$pointer} which is a dangling pointer (it has no provenance) const_eval_dangling_null_pointer = {const_eval_bad_pointer_op_attempting}, but got null pointer const_eval_dangling_ptr_in_final = encountered dangling pointer in final value of {const_eval_intern_kind} const_eval_dead_local = accessing a dead local variable const_eval_dealloc_immutable = deallocating immutable allocation {$alloc} const_eval_dealloc_incorrect_layout = incorrect layout on deallocation: {$alloc} has size {$size} and alignment {$align}, but gave size {$size_found} and alignment {$align_found} const_eval_dealloc_kind_mismatch = deallocating {$alloc}, which is {$alloc_kind} memory, using {$kind} deallocation operation const_eval_deref_function_pointer = accessing {$allocation} which contains a function const_eval_deref_vtable_pointer = accessing {$allocation} which contains a vtable const_eval_division_by_zero = dividing by zero const_eval_division_overflow = overflow in signed division (dividing MIN by -1) const_eval_dyn_call_not_a_method = `dyn` call trying to call something that is not a method const_eval_error = {$error_kind -> [static] could not evaluate static initializer [const] evaluation of constant value failed [const_with_path] evaluation of `{$instance}` failed *[other] {""} } const_eval_exact_div_has_remainder = exact_div: {$a} cannot be divided by {$b} without remainder const_eval_extern_static = cannot access extern static `{$did}` const_eval_extern_type_field = `extern type` field does not have a known offset const_eval_fn_ptr_call = function pointers need an RFC before allowed to be called in {const_eval_const_context}s const_eval_frame_note = {$times -> [0] {const_eval_frame_note_inner} *[other] [... {$times} additional calls {const_eval_frame_note_inner} ...] } const_eval_frame_note_inner = inside {$where_ -> [closure] closure [instance] `{$instance}` *[other] {""} } const_eval_frame_note_last = the failure occurred here const_eval_incompatible_calling_conventions = calling a function with calling convention {$callee_conv} using calling convention {$caller_conv} const_eval_incompatible_return_types = calling a function with return type {$callee_ty} passing return place of type {$caller_ty} const_eval_incompatible_types = calling a function with argument of type {$callee_ty} passing data of type {$caller_ty} const_eval_interior_mutable_ref_escaping = {const_eval_const_context}s cannot refer to interior mutable data .label = this borrow of an interior mutable value may end up in the final value .help = to fix this, the value can be extracted to a separate `static` item and then referenced .teach_note = References that escape into the final value of a constant or static must be immutable. This is to avoid accidentally creating shared mutable state. If you really want global mutable state, try using an interior mutable `static` or a `static mut`. const_eval_intern_kind = {$kind -> [static] static [static_mut] mutable static [const] constant [promoted] promoted *[other] {""} } const_eval_interrupted = compilation was interrupted const_eval_invalid_align_details = invalid align passed to `{$name}`: {$align} is {$err_kind -> [not_power_of_two] not a power of 2 [too_large] too large *[other] {""} } const_eval_invalid_bool = interpreting an invalid 8-bit value as a bool: 0x{$value} const_eval_invalid_char = interpreting an invalid 32-bit value as a char: 0x{$value} const_eval_invalid_dealloc = deallocating {$alloc_id}, which is {$kind -> [fn] a function [vtable] a vtable [static_mem] static memory *[other] {""} } const_eval_invalid_function_pointer = using {$pointer} as function pointer but it does not point to a function const_eval_invalid_meta = invalid metadata in wide pointer: total size is bigger than largest supported object const_eval_invalid_meta_slice = invalid metadata in wide pointer: slice is bigger than largest supported object const_eval_invalid_niched_enum_variant_written = trying to set discriminant of a {$ty} to the niched variant, but the value does not match const_eval_invalid_str = this string is not valid UTF-8: {$err} const_eval_invalid_tag = enum value has invalid tag: {$tag} const_eval_invalid_transmute = transmuting from {$src_bytes}-byte type to {$dest_bytes}-byte type: `{$src}` -> `{$dest}` const_eval_invalid_uninit_bytes = reading memory at {$alloc}{$access}, but memory is uninitialized at {$uninit}, and this operation requires initialized memory const_eval_invalid_uninit_bytes_unknown = using uninitialized data, but this operation requires initialized memory const_eval_invalid_vtable_pointer = using {$pointer} as vtable pointer but it does not point to a vtable const_eval_invalid_vtable_trait = using vtable for `{$vtable_dyn_type}` but `{$expected_dyn_type}` was expected const_eval_lazy_lock = consider wrapping this expression in `std::sync::LazyLock::new(|| ...)` const_eval_live_drop = destructor of `{$dropped_ty}` cannot be evaluated at compile-time .label = the destructor for this type cannot be evaluated in {const_eval_const_context}s .dropped_at_label = value is dropped here const_eval_long_running = constant evaluation is taking a long time .note = this lint makes sure the compiler doesn't get stuck due to infinite loops in const eval. If your compilation actually takes a long time, you can safely allow the lint. .label = the const evaluator is currently interpreting this expression .help = the constant being evaluated const_eval_max_num_nodes_in_const = maximum number of nodes exceeded in constant {$global_const_id} const_eval_memory_exhausted = tried to allocate more memory than available to compiler const_eval_modified_global = modifying a static's initial value from another static's initializer const_eval_mutable_ptr_in_final = encountered mutable pointer in final value of {const_eval_intern_kind} const_eval_mutable_raw_escaping = raw mutable pointers are not allowed in the final value of {const_eval_const_context}s .teach_note = Pointers that escape into the final value of a constant or static must be immutable. This is to avoid accidentally creating shared mutable state. If you really want global mutable state, try using an interior mutable `static` or a `static mut`. const_eval_mutable_ref_escaping = mutable references are not allowed in the final value of {const_eval_const_context}s .teach_note = References that escape into the final value of a constant or static must be immutable. This is to avoid accidentally creating shared mutable state. If you really want global mutable state, try using an interior mutable `static` or a `static mut`. const_eval_nested_static_in_thread_local = #[thread_local] does not support implicit nested statics, please create explicit static items and refer to them instead const_eval_non_const_await = cannot convert `{$ty}` into a future in {const_eval_const_context}s const_eval_non_const_closure = cannot call {$non_or_conditionally}-const closure in {const_eval_const_context}s const_eval_non_const_deref_coercion = cannot perform {$non_or_conditionally}-const deref coercion on `{$ty}` in {const_eval_const_context}s .note = attempting to deref into `{$target_ty}` .target_note = deref defined here const_eval_non_const_fmt_macro_call = cannot call {$non_or_conditionally}-const formatting macro in {const_eval_const_context}s const_eval_non_const_fn_call = cannot call {$non_or_conditionally}-const {$def_descr} `{$def_path_str}` in {const_eval_const_context}s const_eval_non_const_for_loop_into_iter = cannot use `for` loop on `{$ty}` in {const_eval_const_context}s const_eval_non_const_impl = impl defined here, but it is not `const` const_eval_non_const_intrinsic = cannot call non-const intrinsic `{$name}` in {const_eval_const_context}s const_eval_non_const_match_eq = cannot match on `{$ty}` in {const_eval_const_context}s .note = `{$ty}` cannot be compared in compile-time, and therefore cannot be used in `match`es const_eval_non_const_operator = cannot call {$non_or_conditionally}-const operator in {const_eval_const_context}s const_eval_non_const_question_branch = `?` is not allowed on `{$ty}` in {const_eval_const_context}s const_eval_non_const_question_from_residual = `?` is not allowed on `{$ty}` in {const_eval_const_context}s const_eval_non_const_try_block_from_output = `try` block cannot convert `{$ty}` to the result in {const_eval_const_context}s const_eval_not_enough_caller_args = calling a function with fewer arguments than it requires const_eval_nullary_intrinsic_fail = could not evaluate nullary intrinsic const_eval_offset_from_different_allocations = `{$name}` called on two different pointers that are not both derived from the same allocation const_eval_offset_from_out_of_bounds = `{$name}` called on two different pointers where the memory range between them is not in-bounds of an allocation const_eval_offset_from_overflow = `{$name}` called when first pointer is too far ahead of second const_eval_offset_from_underflow = `{$name}` called when first pointer is too far before second const_eval_offset_from_unsigned_overflow = `ptr_offset_from_unsigned` called when first pointer has smaller {$is_addr -> [true] address *[false] offset } than second: {$a_offset} < {$b_offset} const_eval_overflow_arith = arithmetic overflow in `{$intrinsic}` const_eval_overflow_shift = overflowing shift by {$shift_amount} in `{$intrinsic}` const_eval_panic = evaluation panicked: {$msg} const_eval_panic_non_str = argument to `panic!()` in a const context must have type `&str` const_eval_partial_pointer_copy = unable to copy parts of a pointer from memory at {$ptr} const_eval_partial_pointer_overwrite = unable to overwrite parts of a pointer in memory at {$ptr} const_eval_pointer_arithmetic_overflow = overflowing pointer arithmetic: the total offset in bytes does not fit in an `isize` const_eval_pointer_out_of_bounds = {const_eval_bad_pointer_op_attempting}, but got {$pointer} which {$inbounds_size_is_neg -> [false] {$alloc_size_minus_ptr_offset -> [0] is at or beyond the end of the allocation of size {$alloc_size -> [1] 1 byte *[x] {$alloc_size} bytes } [1] is only 1 byte from the end of the allocation *[x] is only {$alloc_size_minus_ptr_offset} bytes from the end of the allocation } *[true] {$ptr_offset_abs -> [0] is at the beginning of the allocation *[other] is only {$ptr_offset_abs} bytes from the beginning of the allocation } } const_eval_pointer_use_after_free = {const_eval_bad_pointer_op}: {$alloc_id} has been freed, so this pointer is dangling const_eval_ptr_as_bytes_1 = this code performed an operation that depends on the underlying bytes representing a pointer const_eval_ptr_as_bytes_2 = the absolute address of a pointer is not known at compile-time, so such operations are not supported const_eval_range = in the range {$lo}..={$hi} const_eval_range_lower = greater or equal to {$lo} const_eval_range_singular = equal to {$lo} const_eval_range_upper = less or equal to {$hi} const_eval_range_wrapping = less or equal to {$hi}, or greater or equal to {$lo} const_eval_raw_bytes = the raw bytes of the constant (size: {$size}, align: {$align}) {"{"}{$bytes}{"}"} const_eval_raw_ptr_comparison = pointers cannot be reliably compared during const eval .note = see issue #53020 for more information const_eval_raw_ptr_to_int = pointers cannot be cast to integers during const eval .note = at compile-time, pointers do not have an integer value .note2 = avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior const_eval_read_pointer_as_int = unable to turn pointer into integer const_eval_realloc_or_alloc_with_offset = {$kind -> [dealloc] deallocating [realloc] reallocating *[other] {""} } {$ptr} which does not point to the beginning of an object const_eval_recursive_static = encountered static that tried to initialize itself with itself const_eval_remainder_by_zero = calculating the remainder with a divisor of zero const_eval_remainder_overflow = overflow in signed remainder (dividing MIN by -1) const_eval_scalar_size_mismatch = scalar size mismatch: expected {$target_size} bytes but got {$data_size} bytes instead const_eval_size_overflow = overflow computing total size of `{$name}` const_eval_stack_frame_limit_reached = reached the configured maximum number of stack frames const_eval_thread_local_access = thread-local statics cannot be accessed at compile-time const_eval_thread_local_static = cannot access thread local static `{$did}` const_eval_too_generic = encountered overly generic constant const_eval_too_many_caller_args = calling a function with more arguments than it expected const_eval_unallowed_fn_pointer_call = function pointer calls are not allowed in {const_eval_const_context}s const_eval_unallowed_heap_allocations = allocations are not allowed in {const_eval_const_context}s .label = allocation not allowed in {const_eval_const_context}s .teach_note = The runtime heap is not yet available at compile-time, so no runtime heap allocations can be created. const_eval_unallowed_inline_asm = inline assembly is not allowed in {const_eval_const_context}s const_eval_unallowed_op_in_const_context = {$msg} const_eval_uninhabited_enum_variant_read = read discriminant of an uninhabited enum variant const_eval_uninhabited_enum_variant_written = writing discriminant of an uninhabited enum variant const_eval_unmarked_const_item_exposed = `{$def_path}` cannot be (indirectly) exposed to stable .help = either mark the callee as `#[rustc_const_stable_indirect]`, or the caller as `#[rustc_const_unstable]` const_eval_unmarked_intrinsic_exposed = intrinsic `{$def_path}` cannot be (indirectly) exposed to stable .help = mark the caller as `#[rustc_const_unstable]`, or mark the intrinsic `#[rustc_intrinsic_const_stable_indirect]` (but this requires team approval) const_eval_unreachable = entering unreachable code const_eval_unreachable_unwind = unwinding past a stack frame that does not allow unwinding const_eval_unsized_local = unsized locals are not supported const_eval_unstable_const_fn = `{$def_path}` is not yet stable as a const fn const_eval_unstable_const_trait = `{$def_path}` is not yet stable as a const trait const_eval_unstable_in_stable_exposed = const function that might be (indirectly) exposed to stable cannot use `#[feature({$gate})]` .is_function_call = mark the callee as `#[rustc_const_stable_indirect]` if it does not itself require any unstable features .unstable_sugg = if the {$is_function_call2 -> [true] caller *[false] function } is not (yet) meant to be exposed to stable, add `#[rustc_const_unstable]` (this is what you probably want to do) .bypass_sugg = otherwise, as a last resort `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks (this requires team approval) const_eval_unstable_intrinsic = `{$name}` is not yet stable as a const intrinsic const_eval_unstable_intrinsic_suggestion = add `#![feature({$feature})]` to the crate attributes to enable const_eval_unterminated_c_string = reading a null-terminated string starting at {$pointer} with no null found before end of allocation const_eval_unwind_past_top = unwinding past the topmost frame of the stack ## The `front_matter`s here refer to either `const_eval_front_matter_invalid_value` or `const_eval_front_matter_invalid_value_with_path`. ## (We'd love to sort this differently to make that more clear but tidy won't let us...) const_eval_validation_box_to_uninhabited = {$front_matter}: encountered a box pointing to uninhabited type {$ty} const_eval_validation_const_ref_to_extern = {$front_matter}: encountered reference to `extern` static in `const` const_eval_validation_const_ref_to_mutable = {$front_matter}: encountered reference to mutable memory in `const` const_eval_validation_dangling_box_no_provenance = {$front_matter}: encountered a dangling box ({$pointer} has no provenance) const_eval_validation_dangling_box_out_of_bounds = {$front_matter}: encountered a dangling box (going beyond the bounds of its allocation) const_eval_validation_dangling_box_use_after_free = {$front_matter}: encountered a dangling box (use-after-free) const_eval_validation_dangling_ref_no_provenance = {$front_matter}: encountered a dangling reference ({$pointer} has no provenance) const_eval_validation_dangling_ref_out_of_bounds = {$front_matter}: encountered a dangling reference (going beyond the bounds of its allocation) const_eval_validation_dangling_ref_use_after_free = {$front_matter}: encountered a dangling reference (use-after-free) const_eval_validation_expected_bool = expected a boolean const_eval_validation_expected_box = expected a box const_eval_validation_expected_char = expected a unicode scalar value const_eval_validation_expected_enum_tag = expected a valid enum tag const_eval_validation_expected_float = expected a floating point number const_eval_validation_expected_fn_ptr = expected a function pointer const_eval_validation_expected_init_scalar = expected initialized scalar value const_eval_validation_expected_int = expected an integer const_eval_validation_expected_raw_ptr = expected a raw pointer const_eval_validation_expected_ref = expected a reference const_eval_validation_expected_str = expected a string const_eval_validation_failure = it is undefined behavior to use this value const_eval_validation_failure_note = The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. const_eval_validation_front_matter_invalid_value = constructing invalid value const_eval_validation_front_matter_invalid_value_with_path = constructing invalid value at {$path} const_eval_validation_invalid_bool = {$front_matter}: encountered {$value}, but expected a boolean const_eval_validation_invalid_box_meta = {$front_matter}: encountered invalid box metadata: total size is bigger than largest supported object const_eval_validation_invalid_box_slice_meta = {$front_matter}: encountered invalid box metadata: slice is bigger than largest supported object const_eval_validation_invalid_char = {$front_matter}: encountered {$value}, but expected a valid unicode scalar value (in `0..=0x10FFFF` but not in `0xD800..=0xDFFF`) const_eval_validation_invalid_enum_tag = {$front_matter}: encountered {$value}, but expected a valid enum tag const_eval_validation_invalid_fn_ptr = {$front_matter}: encountered {$value}, but expected a function pointer const_eval_validation_invalid_ref_meta = {$front_matter}: encountered invalid reference metadata: total size is bigger than largest supported object const_eval_validation_invalid_ref_slice_meta = {$front_matter}: encountered invalid reference metadata: slice is bigger than largest supported object const_eval_validation_invalid_vtable_ptr = {$front_matter}: encountered {$value}, but expected a vtable pointer const_eval_validation_invalid_vtable_trait = {$front_matter}: wrong trait in wide pointer vtable: expected `{$expected_dyn_type}`, but encountered `{$vtable_dyn_type}` const_eval_validation_mutable_ref_to_immutable = {$front_matter}: encountered mutable reference or box pointing to read-only memory const_eval_validation_never_val = {$front_matter}: encountered a value of the never type `!` const_eval_validation_null_box = {$front_matter}: encountered a null box const_eval_validation_null_fn_ptr = {$front_matter}: encountered a null function pointer const_eval_validation_null_ref = {$front_matter}: encountered a null reference const_eval_validation_nullable_ptr_out_of_range = {$front_matter}: encountered a potentially null pointer, but expected something that cannot possibly fail to be {$in_range} const_eval_validation_out_of_range = {$front_matter}: encountered {$value}, but expected something {$in_range} const_eval_validation_partial_pointer = {$front_matter}: encountered a partial pointer or a mix of pointers const_eval_validation_pointer_as_int = {$front_matter}: encountered a pointer, but {$expected} const_eval_validation_ptr_out_of_range = {$front_matter}: encountered a pointer, but expected something that cannot possibly fail to be {$in_range} const_eval_validation_ref_to_uninhabited = {$front_matter}: encountered a reference pointing to uninhabited type {$ty} const_eval_validation_unaligned_box = {$front_matter}: encountered an unaligned box (required {$required_bytes} byte alignment but found {$found_bytes}) const_eval_validation_unaligned_ref = {$front_matter}: encountered an unaligned reference (required {$required_bytes} byte alignment but found {$found_bytes}) const_eval_validation_uninhabited_enum_variant = {$front_matter}: encountered an uninhabited enum variant const_eval_validation_uninhabited_val = {$front_matter}: encountered a value of uninhabited type `{$ty}` const_eval_validation_uninit = {$front_matter}: encountered uninitialized memory, but {$expected} const_eval_validation_unsafe_cell = {$front_matter}: encountered `UnsafeCell` in read-only memory const_eval_write_through_immutable_pointer = writing through a pointer that was derived from a shared (immutable) reference const_eval_write_to_read_only = writing to {$allocation} which is read-only errors_delayed_at_with_newline = delayed at {$emitted_at} {$note} errors_delayed_at_without_newline = delayed at {$emitted_at} - {$note} errors_expected_lifetime_parameter = expected lifetime {$count -> [1] parameter *[other] parameters } errors_indicate_anonymous_lifetime = indicate the anonymous {$count -> [1] lifetime *[other] lifetimes } errors_invalid_flushed_delayed_diagnostic_level = `flushed_delayed` got diagnostic with level {$level}, instead of the expected `DelayedBug` errors_target_inconsistent_architecture = inconsistent target specification: "data-layout" claims architecture is {$dl}-endian, while "target-endian" is `{$target}` errors_target_inconsistent_pointer_width = inconsistent target specification: "data-layout" claims pointers are {$pointer_size}-bit, while "target-pointer-width" is `{$target}` errors_target_invalid_address_space = invalid address space `{$addr_space}` for `{$cause}` in "data-layout": {$err} errors_target_invalid_alignment = invalid alignment for `{$cause}` in "data-layout": `{$align}` is {$err_kind -> [not_power_of_two] not a power of 2 [too_large] too large *[other] {""} } errors_target_invalid_bits = invalid {$kind} `{$bit}` for `{$cause}` in "data-layout": {$err} errors_target_invalid_bits_size = {$err} errors_target_missing_alignment = missing alignment for `{$cause}` in "data-layout" expand_arg_not_attributes = second argument must be `attributes` expand_attr_no_arguments = attribute must have either one or two arguments expand_attribute_meta_item = attribute must be a meta item, not a literal expand_attribute_single_word = attribute must only be a single word expand_attributes_on_expressions_experimental = attributes on expressions are experimental .help_outer_doc = `///` is used for outer documentation comments; for a plain comment, use `//` .help_inner_doc = `//!` is used for inner documentation comments; for a plain comment, use `//` by removing the `!` or inserting a space in between them: `// !` expand_attributes_wrong_form = attribute must be of form: `attributes(foo, bar)` expand_cannot_be_name_of_macro = `{$trait_ident}` cannot be a name of {$macro_type} macro expand_collapse_debuginfo_illegal = illegal value for attribute #[collapse_debuginfo(no|external|yes)] expand_count_repetition_misplaced = `count` can not be placed inside the innermost repetition expand_crate_name_in_cfg_attr = `crate_name` within an `#![cfg_attr]` attribute is forbidden expand_crate_type_in_cfg_attr = `crate_type` within an `#![cfg_attr]` attribute is forbidden expand_custom_attribute_panicked = custom attribute panicked .help = message: {$message} expand_duplicate_matcher_binding = duplicate matcher binding .label = duplicate binding .label2 = previous binding expand_empty_delegation_mac = empty {$kind} delegation is not supported expand_expected_paren_or_brace = expected `(` or `{"{"}`, found `{$token}` expand_explain_doc_comment_inner = inner doc comments expand to `#![doc = "..."]`, which is what this macro attempted to match expand_explain_doc_comment_outer = outer doc comments expand to `#[doc = "..."]`, which is what this macro attempted to match expand_expr_repeat_no_syntax_vars = attempted to repeat an expression containing no syntax variables matched as repeating at this depth expand_feature_not_allowed = the feature `{$name}` is not in the list of allowed features expand_feature_removed = feature has been removed .label = feature has been removed .reason = {$reason} expand_glob_delegation_outside_impls = glob delegation is only supported in impls expand_glob_delegation_traitless_qpath = qualified path without a trait in glob delegation expand_helper_attribute_name_invalid = `{$name}` cannot be a name of derive helper attribute expand_incomplete_parse = macro expansion ignores {$descr} and any tokens following .label = caused by the macro expansion here .note = the usage of `{$macro_path}!` is likely invalid in {$kind_name} context .suggestion_add_semi = you might be missing a semicolon here expand_invalid_cfg_expected_syntax = expected syntax is expand_invalid_cfg_multiple_predicates = multiple `cfg` predicates are specified expand_invalid_cfg_no_parens = `cfg` is not followed by parentheses expand_invalid_cfg_no_predicate = `cfg` predicate is not specified expand_invalid_cfg_predicate_literal = `cfg` predicate key cannot be a literal expand_invalid_fragment_specifier = invalid fragment specifier `{$fragment}` .help = {$help} expand_macro_body_stability = macros cannot have body stability attributes .label = invalid body stability attribute .label2 = body stability attribute affects this macro expand_macro_const_stability = macros cannot have const stability attributes .label = invalid const stability attribute .label2 = const stability attribute affects this macro expand_macro_expands_to_match_arm = macros cannot expand to match arms expand_malformed_feature_attribute = malformed `feature` attribute input .expected = expected just one word expand_meta_var_dif_seq_matchers = {$msg} expand_meta_var_expr_unrecognized_var = variable `{$key}` is not recognized in meta-variable expression expand_missing_fragment_specifier = missing fragment specifier .note = fragment specifiers must be specified in the 2024 edition .suggestion_add_fragspec = try adding a specifier here .valid = {$valid} expand_module_circular = circular modules: {$modules} expand_module_file_not_found = file not found for module `{$name}` .help = to create the module `{$name}`, create file "{$default_path}" or "{$secondary_path}" .note = if there is a `mod {$name}` elsewhere in the crate already, import it with `use crate::...` instead expand_module_in_block = cannot declare a non-inline module inside a block unless it has a path attribute .note = maybe `use` the module `{$name}` instead of redeclaring it expand_module_multiple_candidates = file for module `{$name}` found at both "{$default_path}" and "{$secondary_path}" .help = delete or rename one of them to remove the ambiguity expand_must_repeat_once = this must repeat at least once expand_non_inline_modules_in_proc_macro_input_are_unstable = non-inline modules in proc macro input are unstable expand_not_a_meta_item = not a meta item expand_only_one_word = must only be one word expand_proc_macro_back_compat = using an old version of `{$crate_name}` .note = older versions of the `{$crate_name}` crate no longer compile; please update to `{$crate_name}` v{$fixed_version}, or switch to one of the `{$crate_name}` alternatives expand_proc_macro_derive_panicked = proc-macro derive panicked .help = message: {$message} expand_proc_macro_derive_tokens = proc-macro derive produced unparsable tokens expand_proc_macro_panicked = proc macro panicked .help = message: {$message} expand_recursion_limit_reached = recursion limit reached while expanding `{$descr}` .help = consider increasing the recursion limit by adding a `#![recursion_limit = "{$suggested_limit}"]` attribute to your crate (`{$crate_name}`) expand_remove_expr_not_supported = removing an expression is not supported in this position expand_remove_node_not_supported = removing {$descr} is not supported in this position expand_resolve_relative_path = cannot resolve relative path in non-file source `{$path}` expand_trace_macro = trace_macro expand_unsupported_key_value = key-value macro attributes are not supported expand_var_still_repeating = variable `{$ident}` is still repeating at this depth expand_wrong_fragment_kind = non-{$kind} macro in {$kind} position: {$name} hir_analysis_ambiguous_assoc_item = ambiguous associated {$assoc_kind} `{$assoc_ident}` in bounds of `{$qself}` .label = ambiguous associated {$assoc_kind} `{$assoc_ident}` hir_analysis_ambiguous_lifetime_bound = ambiguous lifetime bound, explicit lifetime bound required hir_analysis_assoc_item_constraints_not_allowed_here = associated item constraints are not allowed here .label = associated item constraint not allowed here hir_analysis_assoc_item_is_private = {$kind} `{$name}` is private .label = private {$kind} .defined_here_label = the {$kind} is defined here hir_analysis_assoc_item_not_found = associated {$assoc_kind} `{$assoc_ident}` not found for `{$qself}` hir_analysis_assoc_item_not_found_found_in_other_trait_label = there is {$identically_named -> [true] an *[false] a similarly named } associated {$assoc_kind} `{$suggested_name}` in the trait `{$trait_name}` hir_analysis_assoc_item_not_found_label = associated {$assoc_kind} `{$assoc_ident}` not found hir_analysis_assoc_item_not_found_other_sugg = `{$qself}` has the following associated {$assoc_kind} hir_analysis_assoc_item_not_found_similar_in_other_trait_qpath_sugg = consider fully qualifying{$identically_named -> [true] {""} *[false] {" "}and renaming } the associated {$assoc_kind} hir_analysis_assoc_item_not_found_similar_in_other_trait_sugg = change the associated {$assoc_kind} name to use `{$suggested_name}` from `{$trait_name}` hir_analysis_assoc_item_not_found_similar_in_other_trait_with_bound_sugg = ...and changing the associated {$assoc_kind} name hir_analysis_assoc_item_not_found_similar_sugg = there is an associated {$assoc_kind} with a similar name hir_analysis_assoc_kind_mismatch = expected {$expected}, found {$got} .label = unexpected {$got} .expected_because_label = expected a {$expected} because of this associated {$expected} .note = the associated {$assoc_kind} is defined here .bound_on_assoc_const_label = bounds are not allowed on associated constants hir_analysis_assoc_kind_mismatch_wrap_in_braces_sugg = consider adding braces here hir_analysis_associated_type_trait_uninferred_generic_params = cannot use the associated {$what} of a trait with uninferred generic parameters .suggestion = use a fully qualified path with inferred lifetimes hir_analysis_associated_type_trait_uninferred_generic_params_multipart_suggestion = use a fully qualified path with explicit lifetimes hir_analysis_auto_deref_reached_recursion_limit = reached the recursion limit while auto-dereferencing `{$ty}` .label = deref recursion limit reached .help = consider increasing the recursion limit by adding a `#![recursion_limit = "{$suggested_limit}"]` attribute to your crate (`{$crate_name}`) hir_analysis_bad_precise_capture = expected {$kind} parameter in `use<...>` precise captures list, found {$found} hir_analysis_bad_return_type_notation_position = return type notation not allowed in this position yet hir_analysis_cannot_capture_late_bound_const = cannot capture late-bound const parameter in {$what} .label = parameter defined here hir_analysis_cannot_capture_late_bound_lifetime = cannot capture late-bound lifetime in {$what} .label = lifetime defined here hir_analysis_cannot_capture_late_bound_ty = cannot capture late-bound type parameter in {$what} .label = parameter defined here hir_analysis_closure_implicit_hrtb = implicit types in closure signatures are forbidden when `for<...>` is present .label = `for<...>` is here hir_analysis_cmse_call_generic = function pointers with the `"C-cmse-nonsecure-call"` ABI cannot contain generics in their type hir_analysis_cmse_entry_generic = functions with the `"C-cmse-nonsecure-entry"` ABI cannot contain generics in their type hir_analysis_cmse_inputs_stack_spill = arguments for `{$abi}` function too large to pass via registers .label = {$plural -> [false] this argument doesn't *[true] these arguments don't } fit in the available registers .note = functions with the `{$abi}` ABI must pass all their arguments via the 4 32-bit available argument registers hir_analysis_cmse_output_stack_spill = return value of `{$abi}` function too large to pass via registers .label = this type doesn't fit in the available registers .note1 = functions with the `{$abi}` ABI must pass their result via the available return registers .note2 = the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size hir_analysis_coerce_multi = implementing `{$trait_name}` does not allow multiple fields to be coerced .note = the trait `{$trait_name}` may only be implemented when a single field is being coerced .label = these fields must be coerced for `{$trait_name}` to be valid hir_analysis_coerce_pointee_no_field = `CoercePointee` can only be derived on `struct`s with at least one field hir_analysis_coerce_pointee_no_user_validity_assertion = asserting applicability of `derive(CoercePointee)` on a target data is forbidden hir_analysis_coerce_pointee_not_concrete_ty = `derive(CoercePointee)` is only applicable to `struct` hir_analysis_coerce_pointee_not_struct = `derive(CoercePointee)` is only applicable to `struct`, instead of `{$kind}` hir_analysis_coerce_pointee_not_transparent = `derive(CoercePointee)` is only applicable to `struct` with `repr(transparent)` layout hir_analysis_coerce_unsized_field_validity = for `{$ty}` to have a valid implementation of `{$trait_name}`, it must be possible to coerce the field of type `{$field_ty}` .label = `{$field_ty}` must be a pointer, reference, or smart pointer that is allowed to be unsized hir_analysis_coerce_unsized_may = the trait `{$trait_name}` may only be implemented for a coercion between structures hir_analysis_coerce_zero = implementing `{$trait_name}` requires a field to be coerced hir_analysis_coercion_between_struct_same_note = expected coercion between the same definition; expected `{$source_path}`, found `{$target_path}` hir_analysis_coercion_between_struct_single_note = expected a single field to be coerced, none found hir_analysis_const_bound_for_non_const_trait = `{$modifier}` can only be applied to `#[const_trait]` traits .label = can't be applied to `{$trait_name}` .note = `{$trait_name}` can't be used with `{$modifier}` because it isn't annotated with `#[const_trait]` .suggestion = {$suggestion_pre}mark `{$trait_name}` as `#[const_trait]` to allow it to have `const` implementations hir_analysis_const_impl_for_non_const_trait = const `impl` for trait `{$trait_name}` which is not marked with `#[const_trait]` .label = this trait is not `const` .suggestion = {$suggestion_pre}mark `{$trait_name}` as `#[const_trait]` to allow it to have `const` implementations .note = marking a trait with `#[const_trait]` ensures all default method bodies are `const` .adding = adding a non-const method body in the future would be a breaking change hir_analysis_const_param_ty_impl_on_non_adt = the trait `ConstParamTy` may not be implemented for this type .label = type is not a structure or enumeration hir_analysis_const_param_ty_impl_on_unsized = the trait `ConstParamTy` may not be implemented for this type .label = type is not `Sized` hir_analysis_copy_impl_on_non_adt = the trait `Copy` cannot be implemented for this type .label = type is not a structure or enumeration hir_analysis_copy_impl_on_type_with_dtor = the trait `Copy` cannot be implemented for this type; the type has a destructor .label = `Copy` not allowed on types with destructors hir_analysis_cross_crate_traits = cross-crate traits with a default impl, like `{$traits}`, can only be implemented for a struct/enum type, not `{$self_ty}` .label = can't implement cross-crate trait with a default impl for non-struct/enum type hir_analysis_cross_crate_traits_defined = cross-crate traits with a default impl, like `{$traits}`, can only be implemented for a struct/enum type defined in the current crate .label = can't implement cross-crate trait for type in another crate hir_analysis_dispatch_from_dyn_repr = structs implementing `DispatchFromDyn` may not have `#[repr(packed)]` or `#[repr(C)]` hir_analysis_dispatch_from_dyn_zst = the trait `DispatchFromDyn` may only be implemented for structs containing the field being coerced, ZST fields with 1 byte alignment that don't mention type/const generics, and nothing else .note = extra field `{$name}` of type `{$ty}` is not allowed hir_analysis_drop_impl_negative = negative `Drop` impls are not supported hir_analysis_drop_impl_on_wrong_item = the `Drop` trait may only be implemented for local structs, enums, and unions .label = must be a struct, enum, or union in the current crate hir_analysis_drop_impl_reservation = reservation `Drop` impls are not supported hir_analysis_duplicate_precise_capture = cannot capture parameter `{$name}` twice .label = parameter captured again here hir_analysis_empty_specialization = specialization impl does not specialize any associated items .note = impl is a specialization of this impl hir_analysis_enum_discriminant_overflowed = enum discriminant overflowed .label = overflowed on value after {$discr} .note = explicitly set `{$item_name} = {$wrapped_discr}` if that is desired outcome hir_analysis_escaping_bound_var_in_ty_of_assoc_const_binding = the type of the associated constant `{$assoc_const}` cannot capture late-bound generic parameters .label = its type cannot capture the late-bound {$var_def_kind} `{$var_name}` .var_defined_here_label = the late-bound {$var_def_kind} `{$var_name}` is defined here hir_analysis_field_already_declared = field `{$field_name}` is already declared .label = field already declared .previous_decl_label = `{$field_name}` first declared here hir_analysis_field_already_declared_both_nested = field `{$field_name}` is already declared .label = field `{$field_name}` declared in this unnamed field .nested_field_decl_note = field `{$field_name}` declared here .previous_decl_label = `{$field_name}` first declared here in this unnamed field .previous_nested_field_decl_note = field `{$field_name}` first declared here hir_analysis_field_already_declared_current_nested = field `{$field_name}` is already declared .label = field `{$field_name}` declared in this unnamed field .nested_field_decl_note = field `{$field_name}` declared here .previous_decl_label = `{$field_name}` first declared here hir_analysis_field_already_declared_nested_help = fields from the type of this unnamed field are considered fields of the outer type hir_analysis_field_already_declared_previous_nested = field `{$field_name}` is already declared .label = field already declared .previous_decl_label = `{$field_name}` first declared here in this unnamed field .previous_nested_field_decl_note = field `{$field_name}` first declared here hir_analysis_function_not_found_in_trait = function not found in this trait hir_analysis_function_not_have_default_implementation = function doesn't have a default implementation .note = required by this annotation hir_analysis_functions_names_duplicated = functions names are duplicated .note = all `#[rustc_must_implement_one_of]` arguments must be unique hir_analysis_generic_args_on_overridden_impl = could not resolve generic parameters on overridden impl hir_analysis_impl_not_marked_default = `{$ident}` specializes an item from a parent `impl`, but that item is not marked `default` .label = cannot specialize default item `{$ident}` .ok_label = parent `impl` is here .note = to specialize, `{$ident}` in the parent `impl` must be marked `default` hir_analysis_impl_not_marked_default_err = `{$ident}` specializes an item from a parent `impl`, but that item is not marked `default` .note = parent implementation is in crate `{$cname}` hir_analysis_inherent_dyn = cannot define inherent `impl` for a dyn auto trait .label = impl requires at least one non-auto trait .note = define and implement a new trait or type instead hir_analysis_inherent_nominal = no nominal type found for inherent implementation .label = impl requires a nominal type .note = either implement a trait on it or create a newtype to wrap it instead hir_analysis_inherent_primitive_ty = cannot define inherent `impl` for primitive types .help = consider using an extension trait instead hir_analysis_inherent_primitive_ty_note = you could also try moving the reference to uses of `{$subty}` (such as `self`) within the implementation hir_analysis_inherent_ty_outside = cannot define inherent `impl` for a type outside of the crate where the type is defined .help = consider moving this inherent impl into the crate defining the type if possible .span_help = alternatively add `#[rustc_has_incoherent_inherent_impls]` to the type and `#[rustc_allow_incoherent_impl]` to the relevant impl items hir_analysis_inherent_ty_outside_new = cannot define inherent `impl` for a type outside of the crate where the type is defined .label = impl for type defined outside of crate .note = define and implement a trait or new type instead hir_analysis_inherent_ty_outside_primitive = cannot define inherent `impl` for primitive types outside of `core` .help = consider moving this inherent impl into `core` if possible .span_help = alternatively add `#[rustc_allow_incoherent_impl]` to the relevant impl items hir_analysis_inherent_ty_outside_relevant = cannot define inherent `impl` for a type outside of the crate where the type is defined .help = consider moving this inherent impl into the crate defining the type if possible .span_help = alternatively add `#[rustc_allow_incoherent_impl]` to the relevant impl items hir_analysis_invalid_generic_receiver_ty = invalid generic `self` parameter type: `{$receiver_ty}` .note = type of `self` must not be a method generic parameter type hir_analysis_invalid_generic_receiver_ty_help = use a concrete type such as `self`, `&self`, `&mut self`, `self: Box`, `self: Rc`, `self: Arc`, or `self: Pin

` (where P is one of the previous types except `Self`) hir_analysis_invalid_receiver_ty = invalid `self` parameter type: `{$receiver_ty}` .note = type of `self` must be `Self` or some type implementing `Receiver` hir_analysis_invalid_receiver_ty_help = consider changing to `self`, `&self`, `&mut self`, or a type implementing `Receiver` such as `self: Box`, `self: Rc`, or `self: Arc` hir_analysis_invalid_receiver_ty_help_no_arbitrary_self_types = consider changing to `self`, `&self`, `&mut self`, `self: Box`, `self: Rc`, `self: Arc`, or `self: Pin

` (where P is one of the previous types except `Self`) hir_analysis_invalid_receiver_ty_help_nonnull_note = `NonNull` does not implement `Receiver` because it has methods that may shadow the referent; consider wrapping your `NonNull` in a newtype wrapper for which you implement `Receiver` hir_analysis_invalid_receiver_ty_help_weak_note = `Weak` does not implement `Receiver` because it has methods that may shadow the referent; consider wrapping your `Weak` in a newtype wrapper for which you implement `Receiver` hir_analysis_invalid_receiver_ty_no_arbitrary_self_types = invalid `self` parameter type: `{$receiver_ty}` .note = type of `self` must be `Self` or a type that dereferences to it hir_analysis_invalid_union_field = field must implement `Copy` or be wrapped in `ManuallyDrop<...>` to be used in a union .note = union fields must not have drop side-effects, which is currently enforced via either `Copy` or `ManuallyDrop<...>` hir_analysis_invalid_union_field_sugg = wrap the field type in `ManuallyDrop<...>` hir_analysis_late_bound_const_in_apit = `impl Trait` can only mention const parameters from an fn or impl .label = const parameter declared here hir_analysis_late_bound_lifetime_in_apit = `impl Trait` can only mention lifetimes from an fn or impl .label = lifetime declared here hir_analysis_late_bound_type_in_apit = `impl Trait` can only mention type parameters from an fn or impl .label = type parameter declared here hir_analysis_lifetime_implicitly_captured = `impl Trait` captures lifetime parameter, but it is not mentioned in `use<...>` precise captures list .param_label = all lifetime parameters originating from a trait are captured implicitly hir_analysis_lifetime_must_be_first = lifetime parameter `{$name}` must be listed before non-lifetime parameters .label = move the lifetime before this parameter hir_analysis_lifetime_not_captured = `impl Trait` captures lifetime parameter, but it is not mentioned in `use<...>` precise captures list .label = lifetime captured due to being mentioned in the bounds of the `impl Trait` .param_label = this lifetime parameter is captured hir_analysis_lifetimes_or_bounds_mismatch_on_trait = lifetime parameters or bounds on {$item_kind} `{$ident}` do not match the trait declaration .label = lifetimes do not match {$item_kind} in trait .generics_label = lifetimes in impl do not match this {$item_kind} in trait .where_label = this `where` clause might not match the one in the trait .bounds_label = this bound might be missing in the impl hir_analysis_linkage_type = invalid type for variable with `#[linkage]` attribute hir_analysis_main_function_async = `main` function is not allowed to be `async` .label = `main` function is not allowed to be `async` hir_analysis_main_function_generic_parameters = `main` function is not allowed to have generic parameters .label = `main` cannot have generic parameters hir_analysis_main_function_return_type_generic = `main` function return type is not allowed to have generic parameters hir_analysis_manual_implementation = manual implementations of `{$trait_name}` are experimental .label = manual implementations of `{$trait_name}` are experimental .help = add `#![feature(unboxed_closures)]` to the crate attributes to enable hir_analysis_method_should_return_future = method should be `async` or return a future, but it is synchronous .note = this method is `async` so it expects a future to be returned hir_analysis_missing_one_of_trait_item = not all trait items implemented, missing one of: `{$missing_items_msg}` .label = missing one of `{$missing_items_msg}` in implementation .note = required because of this annotation hir_analysis_missing_trait_item = not all trait items implemented, missing: `{$missing_items_msg}` .label = missing `{$missing_items_msg}` in implementation hir_analysis_missing_trait_item_label = `{$item}` from trait hir_analysis_missing_trait_item_suggestion = implement the missing item: `{$snippet}` hir_analysis_missing_trait_item_unstable = not all trait items implemented, missing: `{$missing_item_name}` .note = default implementation of `{$missing_item_name}` is unstable .some_note = use of unstable library feature `{$feature}`: {$reason} .none_note = use of unstable library feature `{$feature}` hir_analysis_missing_type_params = the type {$parameterCount -> [one] parameter *[other] parameters } {$parameters} must be explicitly specified .label = type {$parameterCount -> [one] parameter *[other] parameters } {$parameters} must be specified for this .suggestion = set the type {$parameterCount -> [one] parameter *[other] parameters } to the desired {$parameterCount -> [one] type *[other] types } .no_suggestion_label = missing {$parameterCount -> [one] reference *[other] references } to {$parameters} .note = because the parameter {$parameterCount -> [one] default references *[other] defaults reference } `Self`, the {$parameterCount -> [one] parameter *[other] parameters } must be specified on the object type hir_analysis_multiple_relaxed_default_bounds = type parameter has more than one relaxed default bound, only one is supported hir_analysis_must_be_name_of_associated_function = must be a name of an associated function hir_analysis_must_implement_not_function = not a function hir_analysis_must_implement_not_function_note = all `#[rustc_must_implement_one_of]` arguments must be associated function names hir_analysis_must_implement_not_function_span_note = required by this annotation hir_analysis_must_implement_one_of_attribute = the `#[rustc_must_implement_one_of]` attribute must be used with at least 2 args hir_analysis_no_variant_named = no variant named `{$ident}` found for enum `{$ty}` hir_analysis_not_supported_delegation = {$descr} .label = callee defined here hir_analysis_only_current_traits_adt = `{$name}` is not defined in the current crate hir_analysis_only_current_traits_arbitrary = only traits defined in the current crate can be implemented for arbitrary types hir_analysis_only_current_traits_foreign = this is not defined in the current crate because this is a foreign trait hir_analysis_only_current_traits_name = this is not defined in the current crate because {$name} are always foreign hir_analysis_only_current_traits_note = define and implement a trait or new type instead hir_analysis_only_current_traits_note_more_info = for more information see https://doc.rust-lang.org/reference/items/implementations.html#orphan-rules hir_analysis_only_current_traits_note_uncovered = impl doesn't have any local type before any uncovered type parameters hir_analysis_only_current_traits_opaque = type alias impl trait is treated as if it were foreign, because its hidden type could be from a foreign crate hir_analysis_only_current_traits_outside = only traits defined in the current crate can be implemented for types defined outside of the crate hir_analysis_only_current_traits_pointer = `{$pointer}` is not defined in the current crate because raw pointers are always foreign hir_analysis_only_current_traits_pointer_sugg = consider introducing a new wrapper type hir_analysis_only_current_traits_primitive = only traits defined in the current crate can be implemented for primitive types hir_analysis_only_current_traits_ty = `{$ty}` is not defined in the current crate hir_analysis_opaque_captures_higher_ranked_lifetime = `impl Trait` cannot capture {$bad_place} .label = `impl Trait` implicitly captures all lifetimes in scope .note = lifetime declared here hir_analysis_param_in_ty_of_assoc_const_binding = the type of the associated constant `{$assoc_const}` must not depend on {$param_category -> [self] `Self` [synthetic] `impl Trait` *[normal] generic parameters } .label = its type must not depend on {$param_category -> [self] `Self` [synthetic] `impl Trait` *[normal] the {$param_def_kind} `{$param_name}` } .param_defined_here_label = {$param_category -> [synthetic] the `impl Trait` is specified here *[normal] the {$param_def_kind} `{$param_name}` is defined here } hir_analysis_param_not_captured = `impl Trait` must mention all {$kind} parameters in scope in `use<...>` .label = {$kind} parameter is implicitly captured by this `impl Trait` .note = currently, all {$kind} parameters are required to be mentioned in the precise captures list hir_analysis_paren_sugar_attribute = the `#[rustc_paren_sugar]` attribute is a temporary means of controlling which traits can use parenthetical notation .help = add `#![feature(unboxed_closures)]` to the crate attributes to use it hir_analysis_parenthesized_fn_trait_expansion = parenthesized trait syntax expands to `{$expanded_type}` hir_analysis_placeholder_not_allowed_item_signatures = the placeholder `_` is not allowed within types on item signatures for {$kind} .label = not allowed in type signatures hir_analysis_precise_capture_self_alias = `Self` can't be captured in `use<...>` precise captures list, since it is an alias .label = `Self` is not a generic argument, but an alias to the type of the {$what} hir_analysis_recursive_generic_parameter = {$param_def_kind} `{$param_name}` is only used recursively .label = {$param_def_kind} must be used non-recursively in the definition .note = all type parameters must be used in a non-recursive way in order to constrain their variance hir_analysis_redundant_lifetime_args = unnecessary lifetime parameter `{$victim}` .note = you can use the `{$candidate}` lifetime directly, in place of `{$victim}` hir_analysis_requires_note = the `{$trait_name}` impl for `{$ty}` requires that `{$error_predicate}` hir_analysis_return_type_notation_equality_bound = return type notation is not allowed to use type equality hir_analysis_return_type_notation_illegal_param_const = return type notation is not allowed for functions that have const parameters .label = const parameter declared here hir_analysis_return_type_notation_illegal_param_type = return type notation is not allowed for functions that have type parameters .label = type parameter declared here hir_analysis_return_type_notation_on_non_rpitit = return type notation used on function that is not `async` and does not return `impl Trait` .note = function returns `{$ty}`, which is not compatible with associated type return bounds .label = this function must be `async` or return `impl Trait` hir_analysis_rpitit_refined = impl trait in impl method signature does not match trait method signature .suggestion = replace the return type so that it matches the trait .label = return type from trait method defined here .unmatched_bound_label = this bound is stronger than that defined on the trait .note = add `#[allow(refining_impl_trait)]` if it is intended for this to be part of the public API of this crate .feedback_note = we are soliciting feedback, see issue #121718 for more information hir_analysis_rpitit_refined_lifetimes = impl trait in impl method captures fewer lifetimes than in trait .suggestion = modify the `use<..>` bound to capture the same lifetimes that the trait does .note = add `#[allow(refining_impl_trait)]` if it is intended for this to be part of the public API of this crate .feedback_note = we are soliciting feedback, see issue #121718 for more information hir_analysis_self_in_impl_self = `Self` is not valid in the self type of an impl block .note = replace `Self` with a different type hir_analysis_self_in_type_alias = `Self` is not allowed in type aliases .label = `Self` is only available in impls, traits, and concrete type definitions hir_analysis_self_ty_not_captured = `impl Trait` must mention the `Self` type of the trait in `use<...>` .label = `Self` type parameter is implicitly captured by this `impl Trait` .note = currently, all type parameters are required to be mentioned in the precise captures list hir_analysis_simd_ffi_highly_experimental = use of SIMD type{$snip} in FFI is highly experimental and may result in invalid code .help = add `#![feature(simd_ffi)]` to the crate attributes to enable hir_analysis_specialization_trait = implementing `rustc_specialization_trait` traits is unstable .help = add `#![feature(min_specialization)]` to the crate attributes to enable hir_analysis_static_specialize = cannot specialize on `'static` lifetime hir_analysis_supertrait_item_multiple_shadowee = items from several supertraits are shadowed: {$traits} hir_analysis_supertrait_item_shadowee = item from `{$supertrait}` is shadowed by a subtrait item hir_analysis_supertrait_item_shadowing = trait item `{$item}` from `{$subtrait}` shadows identically named item from supertrait hir_analysis_tait_forward_compat2 = item does not constrain `{$opaque_type}` .note = consider removing `#[define_opaque]` or adding an empty `#[define_opaque()]` .opaque = this opaque type is supposed to be constrained hir_analysis_target_feature_on_main = `main` function is not allowed to have `#[target_feature]` hir_analysis_too_large_static = extern static is too large for the target architecture hir_analysis_track_caller_on_main = `main` function is not allowed to be `#[track_caller]` .suggestion = remove this annotation hir_analysis_trait_cannot_impl_for_ty = the trait `{$trait_name}` cannot be implemented for this type .label = this field does not implement `{$trait_name}` hir_analysis_trait_object_declared_with_no_traits = at least one trait is required for an object type .alias_span = this alias does not contain a trait hir_analysis_traits_with_defualt_impl = traits with a default impl, like `{$traits}`, cannot be implemented for {$problematic_kind} `{$self_ty}` .note = a trait object implements `{$traits}` if and only if `{$traits}` is one of the trait object's trait bounds hir_analysis_transparent_enum_variant = transparent enum needs exactly one variant, but has {$number} .label = needs exactly one variant, but has {$number} .many_label = too many variants in `{$path}` .multi_label = variant here hir_analysis_transparent_non_zero_sized = transparent {$desc} needs at most one field with non-trivial size or alignment, but has {$field_count} .label = needs at most one field with non-trivial size or alignment, but has {$field_count} .labels = this field has non-zero size or requires alignment hir_analysis_transparent_non_zero_sized_enum = the variant of a transparent {$desc} needs at most one field with non-trivial size or alignment, but has {$field_count} .label = needs at most one field with non-trivial size or alignment, but has {$field_count} .labels = this field has non-zero size or requires alignment hir_analysis_ty_of_assoc_const_binding_note = `{$assoc_const}` has type `{$ty}` hir_analysis_ty_param_first_local = type parameter `{$param}` must be covered by another type when it appears before the first local type (`{$local_type}`) .label = type parameter `{$param}` must be covered by another type when it appears before the first local type (`{$local_type}`) .note = implementing a foreign trait is only possible if at least one of the types for which it is implemented is local, and no uncovered type parameters appear before that first local type .case_note = in this case, 'before' refers to the following order: `impl<..> ForeignTrait for T0`, where `T0` is the first and `Tn` is the last hir_analysis_ty_param_some = type parameter `{$param}` must be used as the type parameter for some local type (e.g., `MyStruct<{$param}>`) .label = type parameter `{$param}` must be used as the type parameter for some local type .note = implementing a foreign trait is only possible if at least one of the types for which it is implemented is local .only_note = only traits defined in the current crate can be implemented for a type parameter hir_analysis_type_of = {$ty} hir_analysis_typeof_reserved_keyword_used = `typeof` is a reserved keyword but unimplemented .suggestion = consider replacing `typeof(...)` with an actual type .label = reserved keyword hir_analysis_unconstrained_generic_parameter = the {$param_def_kind} `{$param_name}` is not constrained by the impl trait, self type, or predicates .label = unconstrained {$param_def_kind} .const_param_note = expressions using a const parameter must map each value to a distinct output value .const_param_note2 = proving the result of expressions other than the parameter are unique is not supported hir_analysis_unconstrained_opaque_type = unconstrained opaque type .note = `{$name}` must be used in combination with a concrete type within the same {$what} hir_analysis_unrecognized_atomic_operation = unrecognized atomic operation function: `{$op}` .label = unrecognized atomic operation hir_analysis_unrecognized_intrinsic_function = unrecognized intrinsic function: `{$name}` .label = unrecognized intrinsic .help = if you're adding an intrinsic, be sure to update `check_intrinsic_type` hir_analysis_unused_associated_type_bounds = unnecessary associated type bound for dyn-incompatible associated type .note = this associated type has a `where Self: Sized` bound, and while the associated type can be specified, it cannot be used because trait objects are never `Sized` .suggestion = remove this bound hir_analysis_unused_generic_parameter = {$param_def_kind} `{$param_name}` is never used .label = unused {$param_def_kind} .const_param_help = if you intended `{$param_name}` to be a const parameter, use `const {$param_name}: /* Type */` instead .usage_spans = `{$param_name}` is named here, but is likely unused in the containing type hir_analysis_unused_generic_parameter_adt_help = consider removing `{$param_name}`, referring to it in a field, or using a marker such as `{$phantom_data}` hir_analysis_unused_generic_parameter_adt_no_phantom_data_help = consider removing `{$param_name}` or referring to it in a field hir_analysis_unused_generic_parameter_ty_alias_help = consider removing `{$param_name}` or referring to it in the body of the type alias hir_analysis_useless_impl_item = this item cannot be used as its where bounds are not satisfied for the `Self` type hir_analysis_value_of_associated_struct_already_specified = the value of the associated type `{$item_name}` in trait `{$def_path}` is already specified .label = re-bound here .previous_bound_label = `{$item_name}` bound here first hir_analysis_variadic_function_compatible_convention = C-variadic function must have a compatible calling convention, like {$conventions} .label = C-variadic function must have a compatible calling convention hir_analysis_variances_of = {$variances} hir_analysis_where_clause_on_main = `main` function is not allowed to have a `where` clause .label = `main` cannot have a `where` clause hir_analysis_within_macro = due to this macro variable hir_analysis_wrong_number_of_generic_arguments_to_intrinsic = intrinsic has wrong number of {$descr} parameters: found {$found}, expected {$expected} .label = expected {$expected} {$descr} {$expected -> [one] parameter *[other] parameters } hir_typeck_add_missing_parentheses_in_range = you must surround the range in parentheses to call its `{$func_name}` function hir_typeck_add_return_type_add = try adding a return type hir_typeck_add_return_type_missing_here = a return type might be missing here hir_typeck_address_of_temporary_taken = cannot take address of a temporary .label = temporary value hir_typeck_arg_mismatch_indeterminate = argument type mismatch was detected, but rustc had trouble determining where .note = we would appreciate a bug report: https://github.com/rust-lang/rust/issues/new hir_typeck_as_deref_suggestion = consider using `as_deref` here hir_typeck_base_expression_double_dot = base expression required after `..` hir_typeck_base_expression_double_dot_add_expr = add a base expression here hir_typeck_base_expression_double_dot_enable_default_field_values = add `#![feature(default_field_values)]` to the crate attributes to enable default values on `struct` fields hir_typeck_base_expression_double_dot_remove = remove the `..` as all the fields are already present hir_typeck_candidate_trait_note = `{$trait_name}` defines an item `{$item_name}`{$action_or_ty -> [NONE] {""} [implement] , perhaps you need to implement it *[other] , perhaps you need to restrict type parameter `{$action_or_ty}` with it } hir_typeck_cannot_cast_to_bool = cannot cast `{$expr_ty}` as `bool` .suggestion = compare with zero instead .help = compare with zero instead .label = unsupported cast hir_typeck_cant_dereference = type `{$ty}` cannot be dereferenced hir_typeck_cant_dereference_label = can't be dereferenced hir_typeck_cast_enum_drop = cannot cast enum `{$expr_ty}` into integer `{$cast_ty}` because it implements `Drop` hir_typeck_cast_thin_pointer_to_wide_pointer = cannot cast thin pointer `{$expr_ty}` to wide pointer `{$cast_ty}` .teach_help = Thin pointers are "simple" pointers: they are purely a reference to a memory address. Wide pointers are pointers referencing "Dynamically Sized Types" (also called DST). DST don't have a statically known size, therefore they can only exist behind some kind of pointers that contain additional information. Slices and trait objects are DSTs. In the case of slices, the additional information the wide pointer holds is their size. To fix this error, don't try to cast directly between thin and wide pointers. For more information about casts, take a look at The Book: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions", hir_typeck_cast_unknown_pointer = cannot cast {$to -> [true] to *[false] from } a pointer of an unknown kind .label_to = needs more type information .note = the type information given here is insufficient to check whether the pointer cast is valid .label_from = the type information given here is insufficient to check whether the pointer cast is valid hir_typeck_const_select_must_be_const = this argument must be a `const fn` .help = consult the documentation on `const_eval_select` for more information hir_typeck_const_select_must_be_fn = this argument must be a function item .note = expected a function item, found {$ty} .help = consult the documentation on `const_eval_select` for more information hir_typeck_convert_to_str = try converting the passed type into a `&str` hir_typeck_convert_using_method = try using `{$sugg}` to convert `{$found}` to `{$expected}` hir_typeck_ctor_is_private = tuple struct constructor `{$def}` is private hir_typeck_dependency_on_unit_never_type_fallback = this function depends on never type fallback being `()` .note = in edition 2024, the requirement `{$obligation}` will fail .help = specify the types explicitly hir_typeck_deref_is_empty = this expression `Deref`s to `{$deref_ty}` which implements `is_empty` hir_typeck_expected_array_or_slice = expected an array or slice, found `{$ty}` hir_typeck_expected_array_or_slice_label = pattern cannot match with input type `{$ty}` hir_typeck_expected_default_return_type = expected `()` because of default return type hir_typeck_expected_return_type = expected `{$expected}` because of return type hir_typeck_explicit_destructor = explicit use of destructor method .label = explicit destructor calls not allowed .suggestion = consider using `drop` function hir_typeck_field_multiply_specified_in_initializer = field `{$ident}` specified more than once .label = used more than once .previous_use_label = first use of `{$ident}` hir_typeck_fn_item_to_variadic_function = can't pass a function item to a variadic function .suggestion = use a function pointer instead .help = a function item is zero-sized and needs to be cast into a function pointer to be used in FFI .note = for more information on function items, visit https://doc.rust-lang.org/reference/types/function-item.html hir_typeck_fru_expr = this expression does not end in a comma... hir_typeck_fru_expr2 = ... so this is interpreted as a `..` range expression, instead of functional record update syntax hir_typeck_fru_note = this expression may have been misinterpreted as a `..` range expression hir_typeck_fru_suggestion = to set the remaining fields{$expr -> [NONE]{""} *[other] {" "}from `{$expr}` }, separate the last named field with a comma hir_typeck_functional_record_update_on_non_struct = functional record update syntax requires a struct hir_typeck_help_set_edition_cargo = set `edition = "{$edition}"` in `Cargo.toml` hir_typeck_help_set_edition_standalone = pass `--edition {$edition}` to `rustc` hir_typeck_int_to_fat = cannot cast `{$expr_ty}` to a pointer that {$known_wide -> [true] is *[false] may be } wide hir_typeck_int_to_fat_label = creating a `{$cast_ty}` requires both an address and {$metadata} hir_typeck_int_to_fat_label_nightly = consider casting this expression to `*const ()`, then using `core::ptr::from_raw_parts` hir_typeck_invalid_callee = expected function, found {$found} hir_typeck_invalid_defined = `{$path}` defined here hir_typeck_invalid_defined_kind = {$kind} `{$path}` defined here hir_typeck_invalid_fn_defined = `{$func}` defined here returns `{$ty}` hir_typeck_invalid_local = `{$local_name}` has type `{$ty}` hir_typeck_lossy_provenance_int2ptr = strict provenance disallows casting integer `{$expr_ty}` to pointer `{$cast_ty}` .suggestion = use `.with_addr()` to adjust a valid pointer in the same allocation, to this address .help = if you can't comply with strict provenance and don't have a pointer with the correct provenance you can use `std::ptr::with_exposed_provenance()` instead hir_typeck_lossy_provenance_ptr2int = under strict provenance it is considered bad style to cast pointer `{$expr_ty}` to integer `{$cast_ty}` .suggestion = use `.addr()` to obtain the address of a pointer .help = if you can't comply with strict provenance and need to expose the pointer provenance you can use `.expose_provenance()` instead hir_typeck_missing_parentheses_in_range = can't call method `{$method_name}` on type `{$ty_str}` hir_typeck_never_type_fallback_flowing_into_unsafe_call = never type fallback affects this call to an `unsafe` function .help = specify the type explicitly hir_typeck_never_type_fallback_flowing_into_unsafe_deref = never type fallback affects this raw pointer dereference .help = specify the type explicitly hir_typeck_never_type_fallback_flowing_into_unsafe_method = never type fallback affects this call to an `unsafe` method .help = specify the type explicitly hir_typeck_never_type_fallback_flowing_into_unsafe_path = never type fallback affects this `unsafe` function .help = specify the type explicitly hir_typeck_never_type_fallback_flowing_into_unsafe_union_field = never type fallback affects this union access .help = specify the type explicitly hir_typeck_no_associated_item = no {$item_kind} named `{$item_ident}` found for {$ty_prefix} `{$ty_str}`{$trait_missing_method -> [true] {""} *[other] {" "}in the current scope } hir_typeck_no_field_on_type = no field `{$field}` on type `{$ty}` hir_typeck_no_field_on_variant = no field named `{$field}` on enum variant `{$container}::{$ident}` hir_typeck_no_field_on_variant_enum = this enum variant... hir_typeck_no_field_on_variant_field = ...does not have this field hir_typeck_note_caller_chooses_ty_for_ty_param = the caller chooses a type for `{$ty_param_name}` which can be different from `{$found_ty}` hir_typeck_note_edition_guide = for more on editions, read https://doc.rust-lang.org/edition-guide hir_typeck_option_result_asref = use `{$def_path}::as_ref` to convert `{$expected_ty}` to `{$expr_ty}` hir_typeck_option_result_cloned = use `{$def_path}::cloned` to clone the value inside the `{$def_path}` hir_typeck_option_result_copied = use `{$def_path}::copied` to copy the value inside the `{$def_path}` hir_typeck_pass_to_variadic_function = can't pass `{$ty}` to variadic function .suggestion = cast the value to `{$cast_ty}` .teach_help = certain types, like `{$ty}`, must be casted before passing them to a variadic function, because of arcane ABI rules dictated by the C standard hir_typeck_ptr_cast_add_auto_to_object = cannot add {$traits_len -> [1] auto trait {$traits} *[other] auto traits {$traits} } to dyn bound via pointer cast .note = this could allow UB elsewhere .help = use `transmute` if you're sure this is sound .label = unsupported cast hir_typeck_register_type_unstable = type `{$ty}` cannot be used with this register class in stable hir_typeck_remove_semi_for_coerce = you might have meant to return the `match` expression hir_typeck_remove_semi_for_coerce_expr = this could be implicitly returned but it is a statement, not a tail expression hir_typeck_remove_semi_for_coerce_ret = the `match` arms can conform to this return type hir_typeck_remove_semi_for_coerce_semi = the `match` is a statement because of this semicolon, consider removing it hir_typeck_remove_semi_for_coerce_suggestion = remove this semicolon hir_typeck_replace_comma_with_semicolon = replace the comma with a semicolon to create {$descr} hir_typeck_return_stmt_outside_of_fn_body = {$statement_kind} statement outside of function body .encl_body_label = the {$statement_kind} is part of this body... .encl_fn_label = ...not the enclosing function body hir_typeck_rpit_box_return_expr = if you change the return type to expect trait objects, box the returned expressions hir_typeck_rpit_change_return_type = you could change the return type to be a boxed trait object hir_typeck_rustcall_incorrect_args = functions with the "rust-call" ABI must take a single non-self tuple argument hir_typeck_self_ctor_from_outer_item = can't reference `Self` constructor from outer item .label = the inner item doesn't inherit generics from this impl, so `Self` is invalid to reference .suggestion = replace `Self` with the actual type hir_typeck_slicing_suggestion = consider slicing here hir_typeck_struct_expr_non_exhaustive = cannot create non-exhaustive {$what} using struct expression hir_typeck_suggest_boxing_note = for more on the distinction between the stack and the heap, read https://doc.rust-lang.org/book/ch15-01-box.html, https://doc.rust-lang.org/rust-by-example/std/box.html, and https://doc.rust-lang.org/std/boxed/index.html hir_typeck_suggest_boxing_when_appropriate = store this in the heap by calling `Box::new` hir_typeck_suggest_ptr_null_mut = consider using `core::ptr::null_mut` instead hir_typeck_supertrait_item_multiple_shadowee = items from several supertraits are shadowed: {$traits} hir_typeck_supertrait_item_shadowee = item from `{$supertrait}` is shadowed by a subtrait item hir_typeck_supertrait_item_shadower = item from `{$subtrait}` shadows a supertrait item hir_typeck_supertrait_item_shadowing = trait item `{$item}` from `{$subtrait}` shadows identically named item from supertrait hir_typeck_trivial_cast = trivial {$numeric -> [true] numeric cast *[false] cast }: `{$expr_ty}` as `{$cast_ty}` .help = cast can be replaced by coercion; this might require a temporary variable hir_typeck_union_pat_dotdot = `..` cannot be used in union patterns hir_typeck_union_pat_multiple_fields = union patterns should have exactly one field hir_typeck_use_is_empty = consider using the `is_empty` method on `{$expr_ty}` to determine if it contains anything hir_typeck_yield_expr_outside_of_coroutine = yield expression outside of coroutine literal incremental_assert_loaded = we asserted that an existing incremental cache directory should be successfully loaded, but it was not incremental_assert_not_loaded = we asserted that the incremental cache should not be loaded, but it was loaded incremental_assertion_auto = `except` specified DepNodes that can not be affected for "{$name}": "{$e}" incremental_associated_value_expected = expected an associated value incremental_associated_value_expected_for = associated value expected for `{$ident}` incremental_canonicalize_path = incremental compilation: error canonicalizing path `{$path}`: {$err} incremental_cargo_help_1 = incremental compilation can be disabled by setting the environment variable CARGO_INCREMENTAL=0 (see https://doc.rust-lang.org/cargo/reference/profiles.html#incremental) incremental_cargo_help_2 = the entire build directory can be changed to a different filesystem by setting the environment variable CARGO_TARGET_DIR to a different path (see https://doc.rust-lang.org/cargo/reference/config.html#buildtarget-dir) incremental_copy_workproduct_to_cache = error copying object file `{$from}` to incremental directory as `{$to}`: {$err} incremental_corrupt_file = corrupt incremental compilation artifact found at `{$path}`. This file will automatically be ignored and deleted. If you see this message repeatedly or can provoke it without manually manipulating the compiler's artifacts, please file an issue. The incremental compilation system relies on hardlinks and filesystem locks behaving correctly, and may not deal well with OS crashes, so whatever information you can provide about your filesystem or other state may be very relevant. incremental_create_dep_graph = failed to create dependency graph at `{$path}`: {$err} incremental_create_incr_comp_dir = could not create incremental compilation {$tag} directory `{$path}`: {$err} incremental_create_lock = incremental compilation: could not create session directory lock file: {$lock_err} incremental_create_new = failed to create {$name} at `{$path}`: {$err} incremental_delete_full = error deleting incremental compilation session directory `{$path}`: {$err} incremental_delete_incompatible = failed to delete invalidated or incompatible incremental compilation session directory contents `{$path}`: {$err} incremental_delete_lock = error deleting lock file for incremental compilation session directory `{$path}`: {$err} incremental_delete_old = unable to delete old {$name} at `{$path}`: {$err} incremental_delete_partial = failed to delete partly initialized session dir `{$path}`: {$err} incremental_delete_workproduct = file-system error deleting outdated file `{$path}`: {$err} incremental_finalize = error finalizing incremental compilation session directory `{$path}`: {$err} incremental_finalized_gc_failed = failed to garbage collect finalized incremental compilation session directory `{$path}`: {$err} incremental_hard_link_failed = hard linking files in the incremental compilation cache failed. copying files instead. consider moving the cache directory to a file system which supports hard linking in session dir `{$path}` incremental_invalid_gc_failed = failed to garbage collect invalid incremental compilation session directory `{$path}`: {$err} incremental_load_dep_graph = could not load dep-graph from `{$path}`: {$err} incremental_lock_unsupported = the filesystem for the incremental path at {$session_dir} does not appear to support locking, consider changing the incremental path to a filesystem that supports locking or disable incremental compilation incremental_missing_depnode = missing `DepNode` variant incremental_missing_if_this_changed = no `#[rustc_if_this_changed]` annotation detected incremental_move_dep_graph = failed to move dependency graph from `{$from}` to `{$to}`: {$err} incremental_no_cfg = no cfg attribute incremental_no_path = no path from `{$source}` to `{$target}` incremental_not_clean = `{$dep_node_str}` should be clean but is not incremental_not_dirty = `{$dep_node_str}` should be dirty but is not incremental_not_loaded = `{$dep_node_str}` should have been loaded from disk but it was not incremental_ok = OK incremental_repeated_depnode_label = dep-node label `{$label}` is repeated incremental_session_gc_failed = failed to garbage collect incremental compilation session directory `{$path}`: {$err} incremental_unchecked_clean = found unchecked `#[rustc_clean]` attribute incremental_undefined_clean_dirty_assertions = clean/dirty auto-assertions not yet defined for {$kind} incremental_undefined_clean_dirty_assertions_item = clean/dirty auto-assertions not yet defined for Node::Item.node={$kind} incremental_unknown_rustc_clean_argument = unknown `rustc_clean` argument incremental_unrecognized_depnode = unrecognized `DepNode` variant: {$name} incremental_unrecognized_depnode_label = dep-node label `{$label}` not recognized incremental_write_new = failed to write {$name} to `{$path}`: {$err} infer_opaque_hidden_type = opaque type's hidden type cannot be another opaque type from the same scope .label = one of the two opaque types used here has to be outside its defining scope .opaque_type = opaque type whose hidden type is being assigned .hidden_type = opaque type being used as hidden type interface_abi_required_feature = target feature `{$feature}` must be {$enabled} to ensure that the ABI of the current target can be implemented correctly .note = this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! interface_abi_required_feature_issue = for more information, see issue #116344 interface_crate_name_does_not_match = `--crate-name` and `#[crate_name]` are required to match, but `{$crate_name}` != `{$attr_crate_name}` interface_crate_name_invalid = crate names cannot start with a `-`, but `{$crate_name}` has a leading hyphen interface_emoji_identifier = identifiers cannot contain emoji: `{$ident}` interface_error_writing_dependencies = error writing dependencies to `{$path}`: {$error} interface_failed_writing_file = failed to write file {$path}: {$error}" interface_ferris_identifier = Ferris cannot be used as an identifier .suggestion = try using their name instead interface_generated_file_conflicts_with_directory = the generated executable for the input file "{$input_path}" conflicts with the existing directory "{$dir_path}" interface_ignoring_extra_filename = ignoring -C extra-filename flag due to -o flag interface_ignoring_out_dir = ignoring --out-dir flag due to -o flag interface_input_file_would_be_overwritten = the input file "{$path}" would be overwritten by the generated executable interface_limit_invalid = `limit` must be a non-negative integer .label = {$error_str} interface_mixed_bin_crate = cannot mix `bin` crate type with others interface_mixed_proc_macro_crate = cannot mix `proc-macro` crate type with others interface_multiple_output_types_adaption = due to multiple output types requested, the explicitly specified output file name will be adapted for each output type interface_multiple_output_types_to_stdout = can't use option `-o` or `--emit` to write multiple output types to stdout interface_out_dir_error = failed to find or create the directory specified by `--out-dir` interface_proc_macro_crate_panic_abort = building proc macro crate with `panic=abort` may crash the compiler should the proc-macro panic interface_temps_dir_error = failed to find or create the directory specified by `--temps-dir` lint_abs_path_with_module = absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition .suggestion = use `crate` lint_ambiguous_glob_reexport = ambiguous glob re-exports .label_first_reexport = the name `{$name}` in the {$namespace} namespace is first re-exported here .label_duplicate_reexport = but the name `{$name}` in the {$namespace} namespace is also re-exported here lint_ambiguous_negative_literals = `-` has lower precedence than method calls, which might be unexpected .example = e.g. `-4.abs()` equals `-4`; while `(-4).abs()` equals `4` .negative_literal = add parentheses around the `-` and the literal to call the method on a negative literal .current_behavior = add parentheses around the literal and the method call to keep the current behavior lint_ambiguous_wide_pointer_comparisons = ambiguous wide pointer comparison, the comparison includes metadata which may not be expected .addr_metadata_suggestion = use explicit `std::ptr::eq` method to compare metadata and addresses .addr_suggestion = use `std::ptr::addr_eq` or untyped pointers to only compare their addresses lint_associated_const_elided_lifetime = {$elided -> [true] `&` without an explicit lifetime name cannot be used here *[false] `'_` cannot be used here } .suggestion = use the `'static` lifetime .note = cannot automatically infer `'static` because of other lifetimes in scope lint_async_fn_in_trait = use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified .note = you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future` .suggestion = you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change lint_atomic_ordering_fence = memory fences cannot have `Relaxed` ordering .help = consider using ordering modes `Acquire`, `Release`, `AcqRel` or `SeqCst` lint_atomic_ordering_invalid = `{$method}`'s failure ordering may not be `Release` or `AcqRel`, since a failed `{$method}` does not result in a write .label = invalid failure ordering .help = consider using `Acquire` or `Relaxed` failure ordering instead lint_atomic_ordering_load = atomic loads cannot have `Release` or `AcqRel` ordering .help = consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` lint_atomic_ordering_store = atomic stores cannot have `Acquire` or `AcqRel` ordering .help = consider using ordering modes `Release`, `SeqCst` or `Relaxed` lint_avoid_att_syntax = avoid using `.att_syntax`, prefer using `options(att_syntax)` instead lint_avoid_intel_syntax = avoid using `.intel_syntax`, Intel syntax is the default lint_bad_attribute_argument = bad attribute argument lint_bad_opt_access = {$msg} lint_break_with_label_and_loop = this labeled break expression is easy to confuse with an unlabeled break with a labeled value expression .suggestion = wrap this expression in parentheses lint_builtin_allow_internal_unsafe = `allow_internal_unsafe` allows defining macros using unsafe without triggering the `unsafe_code` lint at their call site lint_builtin_anonymous_params = anonymous parameters are deprecated and will be removed in the next edition .suggestion = try naming the parameter or explicitly ignoring it lint_builtin_clashing_extern_diff_name = `{$this}` redeclares `{$orig}` with a different signature .previous_decl_label = `{$orig}` previously declared here .mismatch_label = this signature doesn't match the previous declaration lint_builtin_clashing_extern_same_name = `{$this}` redeclared with a different signature .previous_decl_label = `{$orig}` previously declared here .mismatch_label = this signature doesn't match the previous declaration lint_builtin_const_no_mangle = const items should never be `#[no_mangle]` .suggestion = try a static value lint_builtin_decl_unsafe_fn = declaration of an `unsafe` function lint_builtin_decl_unsafe_method = declaration of an `unsafe` method lint_builtin_deprecated_attr_link = use of deprecated attribute `{$name}`: {$reason}. See {$link} .msg_suggestion = {$msg} .default_suggestion = remove this attribute lint_builtin_deref_nullptr = dereferencing a null pointer .label = this code causes undefined behavior when executed lint_builtin_double_negations = use of a double negation .note = the prefix `--` could be misinterpreted as a decrement operator which exists in other languages .note_decrement = use `-= 1` if you meant to decrement the value .add_parens_suggestion = add parentheses for clarity lint_builtin_ellipsis_inclusive_range_patterns = `...` range patterns are deprecated .suggestion = use `..=` for an inclusive range lint_builtin_explicit_outlives = outlives requirements can be inferred .suggestion = remove {$count -> [one] this bound *[other] these bounds } lint_builtin_export_name_fn = declaration of a function with `export_name` lint_builtin_export_name_method = declaration of a method with `export_name` lint_builtin_export_name_static = declaration of a static with `export_name` lint_builtin_global_asm = usage of `core::arch::global_asm` lint_builtin_global_macro_unsafety = using this macro is unsafe even though it does not need an `unsafe` block lint_builtin_impl_unsafe_method = implementation of an `unsafe` method lint_builtin_incomplete_features = the feature `{$name}` is incomplete and may not be safe to use and/or cause compiler crashes .note = see issue #{$n} for more information .help = consider using `min_{$name}` instead, which is more stable and complete lint_builtin_internal_features = the feature `{$name}` is internal to the compiler or standard library .note = using it is strongly discouraged lint_builtin_keyword_idents = `{$kw}` is a keyword in the {$next} edition .suggestion = you can use a raw identifier to stay compatible lint_builtin_link_section_fn = declaration of a function with `link_section` lint_builtin_link_section_static = declaration of a static with `link_section` lint_builtin_missing_copy_impl = type could implement `Copy`; consider adding `impl Copy` lint_builtin_missing_debug_impl = type does not implement `{$debug}`; consider adding `#[derive(Debug)]` or a manual implementation lint_builtin_missing_doc = missing documentation for {$article} {$desc} lint_builtin_mutable_transmutes = transmuting &T to &mut T is undefined behavior, even if the reference is unused, consider instead using an UnsafeCell lint_builtin_no_mangle_fn = declaration of a `no_mangle` function lint_builtin_no_mangle_generic = functions generic over types or consts must be mangled .suggestion = remove this attribute lint_builtin_no_mangle_method = declaration of a `no_mangle` method lint_builtin_no_mangle_static = declaration of a `no_mangle` static lint_builtin_non_shorthand_field_patterns = the `{$ident}:` in this pattern is redundant .suggestion = use shorthand field pattern lint_builtin_overridden_symbol_name = the linker's behavior with multiple libraries exporting duplicate symbol names is undefined and Rust cannot provide guarantees when you manually override them lint_builtin_overridden_symbol_section = the program's behavior with overridden link sections on items is unpredictable and Rust cannot provide guarantees when you manually override them lint_builtin_special_module_name_used_lib = found module declaration for lib.rs .note = lib.rs is the root of this crate's library target .help = to refer to it from other targets, use the library's name as the path lint_builtin_special_module_name_used_main = found module declaration for main.rs .note = a binary crate cannot be used as library lint_builtin_trivial_bounds = {$predicate_kind_name} bound {$predicate} does not depend on any type or lifetime parameters lint_builtin_type_alias_bounds_enable_feat_help = add `#![feature(lazy_type_alias)]` to the crate attributes to enable the desired semantics lint_builtin_type_alias_bounds_label = will not be checked at usage sites of the type alias lint_builtin_type_alias_bounds_limitation_note = this is a known limitation of the type checker that may be lifted in a future edition. see issue #112792 for more information lint_builtin_type_alias_bounds_param_bounds = bounds on generic parameters in type aliases are not enforced .suggestion = remove {$count -> [one] this bound *[other] these bounds } lint_builtin_type_alias_bounds_qualify_assoc_tys_sugg = fully qualify this associated type lint_builtin_type_alias_bounds_where_clause = where clauses on type aliases are not enforced .suggestion = remove this where clause lint_builtin_unpermitted_type_init_label = this code causes undefined behavior when executed lint_builtin_unpermitted_type_init_label_suggestion = help: use `MaybeUninit` instead, and only call `assume_init` after initialization is done lint_builtin_unpermitted_type_init_uninit = the type `{$ty}` does not permit being left uninitialized lint_builtin_unpermitted_type_init_zeroed = the type `{$ty}` does not permit zero-initialization lint_builtin_unreachable_pub = unreachable `pub` {$what} .suggestion = consider restricting its visibility .help = or consider exporting it for use by other crates lint_builtin_unsafe_block = usage of an `unsafe` block lint_builtin_unsafe_extern_block = usage of an `unsafe extern` block lint_builtin_unsafe_impl = implementation of an `unsafe` trait lint_builtin_unsafe_trait = declaration of an `unsafe` trait lint_builtin_unstable_features = use of an unstable feature lint_builtin_unused_doc_comment = unused doc comment .label = rustdoc does not generate documentation for {$kind} .plain_help = use `//` for a plain comment .block_help = use `/* */` for a plain comment lint_builtin_while_true = denote infinite loops with `loop {"{"} ... {"}"}` .suggestion = use `loop` lint_byte_slice_in_packed_struct_with_derive = {$ty} slice in a packed struct that derives a built-in trait .help = consider implementing the trait by hand, or remove the `packed` attribute lint_cfg_attr_no_attributes = `#[cfg_attr]` does not expand to any attributes lint_check_name_unknown_tool = unknown lint tool: `{$tool_name}` lint_closure_returning_async_block = closure returning async block can be made into an async closure .label = this async block can be removed, and the closure can be turned into an async closure .suggestion = turn this into an async closure lint_command_line_source = `forbid` lint level was set on command line lint_confusable_identifier_pair = found both `{$existing_sym}` and `{$sym}` as identifiers, which look alike .current_use = this identifier can be confused with `{$existing_sym}` .other_use = other identifier used here lint_custom_inner_attribute_unstable = custom inner attributes are unstable lint_dangling_pointers_from_temporaries = a dangling pointer will be produced because the temporary `{$ty}` will be dropped .label_ptr = this pointer will immediately be invalid .label_temporary = this `{$ty}` is deallocated at the end of the statement, bind it to a variable to extend its lifetime .note = pointers do not have a lifetime; when calling `{$callee}` the `{$ty}` will be deallocated at the end of the statement because nothing is referencing it as far as the type system is concerned .help_bind = you must make sure that the variable you bind the `{$ty}` to lives at least as long as the pointer returned by the call to `{$callee}` .help_returned = in particular, if this pointer is returned from the current function, binding the `{$ty}` inside the function will not suffice .help_visit = for more information, see lint_default_hash_types = prefer `{$preferred}` over `{$used}`, it has better performance .note = a `use rustc_data_structures::fx::{$preferred}` may be necessary lint_default_source = `forbid` lint level is the default for {$id} lint_deprecated_lint_name = lint name `{$name}` is deprecated and may not have an effect in the future .suggestion = change it to .help = change it to {$replace} lint_deprecated_where_clause_location = where clause not allowed here .note = see issue #89122 for more information .suggestion_move_to_end = move it to the end of the type declaration .suggestion_remove_where = remove this `where` lint_diag_out_of_impl = diagnostics should only be created in `Diagnostic`/`Subdiagnostic`/`LintDiagnostic` impls lint_drop_glue = types that do not implement `Drop` can still have drop glue, consider instead using `{$needs_drop}` to detect whether a type is trivially dropped lint_drop_trait_constraints = bounds on `{$predicate}` are most likely incorrect, consider instead using `{$needs_drop}` to detect whether a type can be trivially dropped lint_dropping_copy_types = calls to `std::mem::drop` with a value that implements `Copy` does nothing .label = argument has type `{$arg_ty}` lint_dropping_references = calls to `std::mem::drop` with a reference instead of an owned value does nothing .label = argument has type `{$arg_ty}` lint_duplicate_macro_attribute = duplicated attribute lint_duplicate_matcher_binding = duplicate matcher binding lint_elided_named_lifetime = elided lifetime has a name .label_elided = this elided lifetime gets resolved as `{$name}` .label_named = lifetime `{$name}` declared here .suggestion = consider specifying it explicitly lint_enum_intrinsics_mem_discriminant = the return value of `mem::discriminant` is unspecified when called with a non-enum type .note = the argument to `discriminant` should be a reference to an enum, but it was passed a reference to a `{$ty_param}`, which is not an enum lint_enum_intrinsics_mem_variant = the return value of `mem::variant_count` is unspecified when called with a non-enum type .note = the type parameter of `variant_count` should be an enum, but it was instantiated with the type `{$ty_param}`, which is not an enum lint_expectation = this lint expectation is unfulfilled .note = the `unfulfilled_lint_expectations` lint can't be expected and will always produce this message .rationale = {$rationale} lint_extern_crate_not_idiomatic = `extern crate` is not idiomatic in the new edition .suggestion = convert it to a `use` lint_extern_without_abi = `extern` declarations without an explicit ABI are deprecated .label = ABI should be specified here .suggestion = explicitly specify the {$default_abi} ABI lint_for_loops_over_fallibles = for loop over {$article} `{$ref_prefix}{$ty}`. This is more readably written as an `if let` statement .suggestion = consider using `if let` to clear intent .remove_next = to iterate over `{$recv_snip}` remove the call to `next` .use_while_let = to check pattern in a loop use `while let` .use_question_mark = consider unwrapping the `Result` with `?` to iterate over its contents lint_forgetting_copy_types = calls to `std::mem::forget` with a value that implements `Copy` does nothing .label = argument has type `{$arg_ty}` lint_forgetting_references = calls to `std::mem::forget` with a reference instead of an owned value does nothing .label = argument has type `{$arg_ty}` lint_hidden_glob_reexport = private item shadows public glob re-export .note_glob_reexport = the name `{$name}` in the {$namespace} namespace is supposed to be publicly re-exported here .note_private_item = but the private item here shadows it lint_hidden_lifetime_parameters = hidden lifetime parameters in types are deprecated lint_hidden_unicode_codepoints = unicode codepoint changing visible direction of text present in {$label} .label = this {$label} contains {$count -> [one] an invisible *[other] invisible } unicode text flow control {$count -> [one] codepoint *[other] codepoints } .note = these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen .suggestion_remove = if their presence wasn't intentional, you can remove them .suggestion_escape = if you want to keep them but make them visible in your source code, you can escape them .no_suggestion_note_escape = if you want to keep them but make them visible in your source code, you can escape them: {$escaped} lint_identifier_non_ascii_char = identifier contains non-ASCII characters lint_identifier_uncommon_codepoints = identifier contains {$codepoints_len -> [one] { $identifier_type -> [Exclusion] a character from an archaic script [Technical] a character that is for non-linguistic, specialized usage [Limited_Use] a character from a script in limited use [Not_NFKC] a non normalized (NFKC) character *[other] an uncommon character } *[other] { $identifier_type -> [Exclusion] {$codepoints_len} characters from archaic scripts [Technical] {$codepoints_len} characters that are for non-linguistic, specialized usage [Limited_Use] {$codepoints_len} characters from scripts in limited use [Not_NFKC] {$codepoints_len} non normalized (NFKC) characters *[other] uncommon characters } }: {$codepoints} .note = {$codepoints_len -> [one] this character is *[other] these characters are } included in the{$identifier_type -> [Restricted] {""} *[other] {" "}{$identifier_type} } Unicode general security profile lint_if_let_dtor = {$dtor_kind -> [dyn] value may invoke a custom destructor because it contains a trait object *[concrete] value invokes this custom destructor } lint_if_let_rescope = `if let` assigns a shorter lifetime since Edition 2024 .label = this value has a significant drop implementation which may observe a major change in drop order and requires your discretion .help = the value is now dropped here in Edition 2024 .suggestion = a `match` with a single arm can preserve the drop order up to Edition 2021 lint_ignored_unless_crate_specified = {$level}({$name}) is ignored unless specified at crate level lint_ill_formed_attribute_input = {$num_suggestions -> [1] attribute must be of the form {$suggestions} *[other] valid forms for the attribute are {$suggestions} } lint_impl_trait_overcaptures = `{$self_ty}` will capture more lifetimes than possibly intended in edition 2024 .note = specifically, {$num_captured -> [one] this lifetime is *[other] these lifetimes are } in scope but not mentioned in the type's bounds .note2 = all lifetimes in scope will be captured by `impl Trait`s in edition 2024 lint_impl_trait_redundant_captures = all possible in-scope parameters are already captured, so `use<...>` syntax is redundant .suggestion = remove the `use<...>` syntax lint_implicit_unsafe_autorefs = implicit autoref creates a reference to the dereference of a raw pointer .note = creating a reference requires the pointer target to be valid and imposes aliasing requirements .suggestion = try using a raw pointer method instead; or if this reference is intentional, make it explicit lint_improper_ctypes = `extern` {$desc} uses type `{$ty}`, which is not FFI-safe .label = not FFI-safe .note = the type is defined here lint_improper_ctypes_128bit = 128-bit integers don't currently have a known stable ABI lint_improper_ctypes_array_help = consider passing a pointer to the array lint_improper_ctypes_array_reason = passing raw arrays by value is not FFI-safe lint_improper_ctypes_box = box cannot be represented as a single pointer lint_improper_ctypes_char_help = consider using `u32` or `libc::wchar_t` instead lint_improper_ctypes_char_reason = the `char` type has no C equivalent lint_improper_ctypes_cstr_help = consider passing a `*const std::ffi::c_char` instead, and use `CStr::as_ptr()` lint_improper_ctypes_cstr_reason = `CStr`/`CString` do not have a guaranteed layout lint_improper_ctypes_dyn = trait objects have no C equivalent lint_improper_ctypes_enum_repr_help = consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum lint_improper_ctypes_enum_repr_reason = enum has no representation hint lint_improper_ctypes_fnptr_help = consider using an `extern fn(...) -> ...` function pointer instead lint_improper_ctypes_fnptr_reason = this function pointer has Rust-specific calling convention lint_improper_ctypes_non_exhaustive = this enum is non-exhaustive lint_improper_ctypes_non_exhaustive_variant = this enum has non-exhaustive variants lint_improper_ctypes_only_phantomdata = composed only of `PhantomData` lint_improper_ctypes_opaque = opaque types have no C equivalent lint_improper_ctypes_slice_help = consider using a raw pointer instead lint_improper_ctypes_slice_reason = slices have no C equivalent lint_improper_ctypes_str_help = consider using `*const u8` and a length instead lint_improper_ctypes_str_reason = string slices have no C equivalent lint_improper_ctypes_struct_fieldless_help = consider adding a member to this struct lint_improper_ctypes_struct_fieldless_reason = this struct has no fields lint_improper_ctypes_struct_layout_help = consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct lint_improper_ctypes_struct_layout_reason = this struct has unspecified layout lint_improper_ctypes_struct_non_exhaustive = this struct is non-exhaustive lint_improper_ctypes_struct_zst = this struct contains only zero-sized fields lint_improper_ctypes_tuple_help = consider using a struct instead lint_improper_ctypes_tuple_reason = tuples have unspecified layout lint_improper_ctypes_union_fieldless_help = consider adding a member to this union lint_improper_ctypes_union_fieldless_reason = this union has no fields lint_improper_ctypes_union_layout_help = consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this union lint_improper_ctypes_union_layout_reason = this union has unspecified layout lint_improper_ctypes_union_non_exhaustive = this union is non-exhaustive lint_incomplete_include = include macro expected single expression in source lint_inner_macro_attribute_unstable = inner macro attributes are unstable lint_invalid_asm_label_binary = avoid using labels containing only the digits `0` and `1` in inline assembly .label = use a different label that doesn't start with `0` or `1` .help = start numbering with `2` instead .note1 = an LLVM bug makes these labels ambiguous with a binary literal number on x86 .note2 = see for more information lint_invalid_asm_label_format_arg = avoid using named labels in inline assembly .help = only local labels of the form `:` should be used in inline asm .note1 = format arguments may expand to a non-numeric value .note2 = see the asm section of Rust By Example for more information lint_invalid_asm_label_named = avoid using named labels in inline assembly .help = only local labels of the form `:` should be used in inline asm .note = see the asm section of Rust By Example for more information lint_invalid_asm_label_no_span = the label may be declared in the expansion of a macro lint_invalid_crate_type_value = invalid `crate_type` value .suggestion = did you mean # FIXME: we should ordinalize $valid_up_to when we add support for doing so lint_invalid_from_utf8_checked = calls to `{$method}` with an invalid literal always return an error .label = the literal was valid UTF-8 up to the {$valid_up_to} bytes # FIXME: we should ordinalize $valid_up_to when we add support for doing so lint_invalid_from_utf8_unchecked = calls to `{$method}` with an invalid literal are undefined behavior .label = the literal was valid UTF-8 up to the {$valid_up_to} bytes lint_invalid_nan_comparisons_eq_ne = incorrect NaN comparison, NaN cannot be directly compared to itself .suggestion = use `f32::is_nan()` or `f64::is_nan()` instead lint_invalid_nan_comparisons_lt_le_gt_ge = incorrect NaN comparison, NaN is not orderable lint_invalid_null_arguments = calling this function with a null pointer is undefined behavior, even if the result of the function is unused .origin = null pointer originates from here .doc = for more information, visit and lint_invalid_reference_casting_assign_to_ref = assigning to `&T` is undefined behavior, consider using an `UnsafeCell` .label = casting happened here lint_invalid_reference_casting_bigger_layout = casting references to a bigger memory layout than the backing allocation is undefined behavior, even if the reference is unused .label = casting happened here .alloc = backing allocation comes from here .layout = casting from `{$from_ty}` ({$from_size} bytes) to `{$to_ty}` ({$to_size} bytes) lint_invalid_reference_casting_borrow_as_mut = casting `&T` to `&mut T` is undefined behavior, even if the reference is unused, consider instead using an `UnsafeCell` .label = casting happened here lint_invalid_reference_casting_note_book = for more information, visit lint_invalid_reference_casting_note_ty_has_interior_mutability = even for types with interior mutability, the only legal way to obtain a mutable pointer from a shared reference is through `UnsafeCell::get` lint_legacy_derive_helpers = derive helper attribute is used before it is introduced .label = the attribute is introduced here lint_lintpass_by_hand = implementing `LintPass` by hand .help = try using `declare_lint_pass!` or `impl_lint_pass!` instead lint_macro_expanded_macro_exports_accessed_by_absolute_paths = macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths .note = the macro is defined here lint_macro_expr_fragment_specifier_2024_migration = the `expr` fragment specifier will accept more expressions in the 2024 edition .suggestion = to keep the existing behavior, use the `expr_2021` fragment specifier lint_macro_is_private = macro `{$ident}` is private lint_macro_rule_never_used = rule #{$n} of macro `{$name}` is never used lint_macro_use_deprecated = applying the `#[macro_use]` attribute to an `extern crate` item is deprecated .help = remove it and import macros at use sites with a `use` item instead lint_malformed_attribute = malformed lint attribute input lint_map_unit_fn = `Iterator::map` call that discard the iterator's values .note = `Iterator::map`, like many of the methods on `Iterator`, gets executed lazily, meaning that its effects won't be visible until it is iterated .function_label = this function returns `()`, which is likely not what you wanted .argument_label = called `Iterator::map` with callable that returns `()` .map_label = after this call to map, the resulting iterator is `impl Iterator`, which means the only information carried by the iterator is the number of items .suggestion = you might have meant to use `Iterator::for_each` lint_metavariable_still_repeating = variable `{$name}` is still repeating at this depth lint_metavariable_wrong_operator = meta-variable repeats with different Kleene operator lint_missing_fragment_specifier = missing fragment specifier lint_missing_unsafe_on_extern = extern blocks should be unsafe .suggestion = needs `unsafe` before the extern keyword lint_mixed_script_confusables = the usage of Script Group `{$set}` in this crate consists solely of mixed script confusables .includes_note = the usage includes {$includes} .note = please recheck to make sure their usages are indeed what you want lint_multiple_supertrait_upcastable = `{$ident}` is dyn-compatible and has multiple supertraits lint_named_argument_used_positionally = named argument `{$named_arg_name}` is not used by name .label_named_arg = this named argument is referred to by position in formatting string .label_position_arg = this formatting argument uses named argument `{$named_arg_name}` by position .suggestion = use the named argument by name to avoid ambiguity lint_node_source = `forbid` level set here .note = {$reason} lint_non_binding_let_multi_drop_fn = consider immediately dropping the value using `drop(..)` after the `let` statement lint_non_binding_let_multi_suggestion = consider immediately dropping the value lint_non_binding_let_on_drop_type = non-binding let on a type that has a destructor lint_non_binding_let_on_sync_lock = non-binding let on a synchronization lock .label = this lock is not assigned to a binding and is immediately dropped lint_non_binding_let_suggestion = consider binding to an unused variable to avoid immediately dropping the value lint_non_camel_case_type = {$sort} `{$name}` should have an upper camel case name .suggestion = convert the identifier to upper camel case .label = should have an UpperCamelCase name lint_non_fmt_panic = panic message is not a string literal .note = this usage of `{$name}!()` is deprecated; it will be a hard error in Rust 2021 .more_info_note = for more information, see .supports_fmt_note = the `{$name}!()` macro supports formatting, so there's no need for the `format!()` macro here .supports_fmt_suggestion = remove the `format!(..)` macro call .display_suggestion = add a "{"{"}{"}"}" format string to `Display` the message .debug_suggestion = add a "{"{"}:?{"}"}" format string to use the `Debug` implementation of `{$ty}` .panic_suggestion = {$already_suggested -> [true] or use *[false] use } std::panic::panic_any instead lint_non_fmt_panic_braces = panic message contains {$count -> [one] a brace *[other] braces } .note = this message is not used as a format string, but will be in Rust 2021 .suggestion = add a "{"{"}{"}"}" format string to use the message literally lint_non_fmt_panic_unused = panic message contains {$count -> [one] an unused *[other] unused } formatting {$count -> [one] placeholder *[other] placeholders } .note = this message is not used as a format string when given without arguments, but will be in Rust 2021 .add_args_suggestion = add the missing {$count -> [one] argument *[other] arguments } .add_fmt_suggestion = or add a "{"{"}{"}"}" format string to use the message literally lint_non_glob_import_type_ir_inherent = non-glob import of `rustc_type_ir::inherent` .suggestion = try using a glob import instead lint_non_local_definitions_cargo_update = the {$macro_kind} `{$macro_name}` may come from an old version of the `{$crate_name}` crate, try updating your dependency with `cargo update -p {$crate_name}` lint_non_local_definitions_impl = non-local `impl` definition, `impl` blocks should be written at the same level as their item .non_local = an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl` .doctest = make this doc-test a standalone test with its own `fn main() {"{"} ... {"}"}` .exception = items in an anonymous const item (`const _: () = {"{"} ... {"}"}`) are treated as in the same scope as the anonymous const's declaration for the purpose of this lint .const_anon = use a const-anon item to suppress this lint .macro_to_change = the {$macro_kind} `{$macro_to_change}` defines the non-local `impl`, and may need to be changed lint_non_local_definitions_impl_move_help = move the `impl` block outside of this {$body_kind_descr} {$depth -> [one] `{$body_name}` *[other] `{$body_name}` and up {$depth} bodies } lint_non_local_definitions_macro_rules = non-local `macro_rules!` definition, `#[macro_export]` macro should be written at top level module .help = remove the `#[macro_export]` or move this `macro_rules!` outside the of the current {$body_kind_descr} {$depth -> [one] `{$body_name}` *[other] `{$body_name}` and up {$depth} bodies } .help_doctest = remove the `#[macro_export]` or make this doc-test a standalone test with its own `fn main() {"{"} ... {"}"}` .non_local = a `macro_rules!` definition is non-local if it is nested inside an item and has a `#[macro_export]` attribute lint_non_snake_case = {$sort} `{$name}` should have a snake case name .rename_or_convert_suggestion = rename the identifier or convert it to a snake case raw identifier .cannot_convert_note = `{$sc}` cannot be used as a raw identifier .rename_suggestion = rename the identifier .convert_suggestion = convert the identifier to snake case .help = convert the identifier to snake case: `{$sc}` .label = should have a snake_case name lint_non_upper_case_global = {$sort} `{$name}` should have an upper case name .suggestion = convert the identifier to upper case .label = should have an UPPER_CASE name lint_noop_method_call = call to `.{$method}()` on a reference in this situation does nothing .suggestion = remove this redundant call .note = the type `{$orig_ty}` does not implement `{$trait_}`, so calling `{$method}` on `&{$orig_ty}` copies the reference, which does not do anything and can be removed .derive_suggestion = if you meant to clone `{$orig_ty}`, implement `Clone` for it lint_only_cast_u8_to_char = only `u8` can be cast into `char` .suggestion = use a `char` literal instead lint_opaque_hidden_inferred_bound = opaque type `{$ty}` does not satisfy its associated type bounds .specifically = this associated type bound is unsatisfied for `{$proj_ty}` lint_opaque_hidden_inferred_bound_sugg = add this bound lint_or_patterns_back_compat = the meaning of the `pat` fragment specifier is changing in Rust 2021, which may affect this macro .suggestion = use pat_param to preserve semantics lint_out_of_scope_macro_calls = cannot find macro `{$path}` in the current scope when looking from {$location} .label = not found from {$location} .help = import `macro_rules` with `use` to make it callable above its definition lint_overflowing_bin_hex = literal out of range for `{$ty}` .negative_note = the literal `{$lit}` (decimal `{$dec}`) does not fit into the type `{$ty}` .negative_becomes_note = and the value `-{$lit}` will become `{$actually}{$ty}` .positive_note = the literal `{$lit}` (decimal `{$dec}`) does not fit into the type `{$ty}` and will become `{$actually}{$ty}` .suggestion = consider using the type `{$suggestion_ty}` instead .sign_bit_suggestion = to use as a negative number (decimal `{$negative_val}`), consider using the type `{$uint_ty}` for the literal and cast it to `{$int_ty}` .help = consider using the type `{$suggestion_ty}` instead lint_overflowing_int = literal out of range for `{$ty}` .note = the literal `{$lit}` does not fit into the type `{$ty}` whose range is `{$min}..={$max}` .help = consider using the type `{$suggestion_ty}` instead lint_overflowing_literal = literal out of range for `{$ty}` .note = the literal `{$lit}` does not fit into the type `{$ty}` and will be converted to `{$ty}::INFINITY` lint_overflowing_uint = literal out of range for `{$ty}` .note = the literal `{$lit}` does not fit into the type `{$ty}` whose range is `{$min}..={$max}` lint_overruled_attribute = {$lint_level}({$lint_source}) incompatible with previous forbid .label = overruled by previous forbid lint_pass_by_value = passing `{$ty}` by reference .suggestion = try passing by value lint_path_statement_drop = path statement drops value .suggestion = use `drop` to clarify the intent lint_path_statement_no_effect = path statement with no effect lint_pattern_in_bodiless = patterns aren't allowed in functions without bodies .label = pattern not allowed in function without body lint_pattern_in_foreign = patterns aren't allowed in foreign function declarations .label = pattern not allowed in foreign function lint_private_extern_crate_reexport = extern crate `{$ident}` is private and cannot be re-exported .suggestion = consider making the `extern crate` item publicly accessible lint_proc_macro_derive_resolution_fallback = cannot find {$ns} `{$ident}` in this scope .label = names from parent modules are not accessible without an explicit import lint_query_instability = using `{$query}` can result in unstable query results .note = if you believe this case to be fine, allow this lint and add a comment explaining your rationale lint_query_untracked = `{$method}` accesses information that is not tracked by the query system .note = if you believe this case to be fine, allow this lint and add a comment explaining your rationale lint_range_endpoint_out_of_range = range endpoint is out of range for `{$ty}` lint_range_use_inclusive_range = use an inclusive range instead lint_raw_prefix = prefix `'r` is reserved .label = reserved prefix .suggestion = insert whitespace here to avoid this being parsed as a prefix in Rust 2021 lint_reason_must_be_string_literal = reason must be a string literal lint_reason_must_come_last = reason in lint attribute must come last lint_redundant_import = the item `{$ident}` is imported redundantly .label_imported_here = the item `{$ident}` is already imported here .label_defined_here = the item `{$ident}` is already defined here .label_imported_prelude = the item `{$ident}` is already imported by the extern prelude .label_defined_prelude = the item `{$ident}` is already defined by the extern prelude lint_redundant_import_visibility = glob import doesn't reexport anything with visibility `{$import_vis}` because no imported item is public enough .note = the most public imported item is `{$max_vis}` .help = reduce the glob import's visibility or increase visibility of imported items lint_redundant_semicolons = unnecessary trailing {$multiple -> [true] semicolons *[false] semicolon } .suggestion = remove {$multiple -> [true] these semicolons *[false] this semicolon } lint_remove_mut_from_pattern = remove `mut` from the parameter lint_removed_lint = lint `{$name}` has been removed: {$reason} lint_renamed_lint = lint `{$name}` has been renamed to `{$replace}` .suggestion = use the new name .help = use the new name `{$replace}` lint_requested_level = requested on the command line with `{$level} {$lint_name}` lint_reserved_multihash = reserved token in Rust 2024 .suggestion = insert whitespace here to avoid this being parsed as a forbidden token in Rust 2024 lint_reserved_prefix = prefix `{$prefix}` is unknown .label = unknown prefix .suggestion = insert whitespace here to avoid this being parsed as a prefix in Rust 2021 lint_reserved_string = will be parsed as a guarded string in Rust 2024 .suggestion = insert whitespace here to avoid this being parsed as a guarded string in Rust 2024 lint_shadowed_into_iter = this method call resolves to `<&{$target} as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to `<{$target} as IntoIterator>::into_iter` in Rust {$edition} .use_iter_suggestion = use `.iter()` instead of `.into_iter()` to avoid ambiguity .remove_into_iter_suggestion = or remove `.into_iter()` to iterate by value .use_explicit_into_iter_suggestion = or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value lint_single_use_lifetime = lifetime parameter `{$ident}` only used once .label_param = this lifetime... .label_use = ...is used only here .suggestion = elide the single-use lifetime lint_span_use_eq_ctxt = use `.eq_ctxt()` instead of `.ctxt() == .ctxt()` lint_static_mut_refs_lint = creating a {$shared_label}reference to mutable static .label = {$shared_label}reference to mutable static .suggestion = use `&raw const` instead to create a raw pointer .suggestion_mut = use `&raw mut` instead to create a raw pointer .shared_note = shared references to mutable statics are dangerous; it's undefined behavior if the static is mutated or if a mutable reference is created for it while the shared reference lives .mut_note = mutable references to mutable statics are dangerous; it's undefined behavior if any other pointer to the static is used or if any other reference is created for the static while the mutable reference lives lint_supertrait_as_deref_target = this `Deref` implementation is covered by an implicit supertrait coercion .label = `{$self_ty}` implements `Deref` which conflicts with supertrait `{$supertrait_principal}` .label2 = target type is a supertrait of `{$self_ty}` .help = consider removing this implementation or replacing it with a method instead lint_suspicious_double_ref_clone = using `.clone()` on a double reference, which returns `{$ty}` instead of cloning the inner type lint_suspicious_double_ref_deref = using `.deref()` on a double reference, which returns `{$ty}` instead of dereferencing the inner type lint_symbol_intern_string_literal = using `Symbol::intern` on a string literal .help = consider adding the symbol to `compiler/rustc_span/src/symbol.rs` lint_trailing_semi_macro = trailing semicolon in macro used in expression position .note1 = macro invocations at the end of a block are treated as expressions .note2 = to ignore the value produced by the macro, add a semicolon after the invocation of `{$name}` lint_ty_qualified = usage of qualified `ty::{$ty}` .suggestion = try importing it and using it unqualified lint_tykind = usage of `ty::TyKind` .help = try using `Ty` instead lint_tykind_kind = usage of `ty::TyKind::` .suggestion = try using `ty::` directly lint_type_ir_inherent_usage = do not use `rustc_type_ir::inherent` unless you're inside of the trait solver .note = the method or struct you're looking for is likely defined somewhere else downstream in the compiler lint_type_ir_trait_usage = do not use `rustc_type_ir::Interner` or `rustc_type_ir::InferCtxtLike` unless you're inside of the trait solver .note = the method or struct you're looking for is likely defined somewhere else downstream in the compiler lint_undropped_manually_drops = calls to `std::mem::drop` with `std::mem::ManuallyDrop` instead of the inner value does nothing .label = argument has type `{$arg_ty}` .suggestion = use `std::mem::ManuallyDrop::into_inner` to get the inner value lint_unexpected_builtin_cfg = unexpected `--cfg {$cfg}` flag .controlled_by = config `{$cfg_name}` is only supposed to be controlled by `{$controlled_by}` .incoherent = manually setting a built-in cfg can and does create incoherent behaviors lint_unexpected_cfg_add_build_rs_println = or consider adding `{$build_rs_println}` to the top of the `build.rs` lint_unexpected_cfg_add_cargo_feature = consider using a Cargo feature instead lint_unexpected_cfg_add_cargo_toml_lint_cfg = or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:{$cargo_toml_lint_cfg} lint_unexpected_cfg_add_cmdline_arg = to expect this configuration use `{$cmdline_arg}` lint_unexpected_cfg_cargo_update = the {$macro_kind} `{$macro_name}` may come from an old version of the `{$crate_name}` crate, try updating your dependency with `cargo update -p {$crate_name}` lint_unexpected_cfg_define_features = consider defining some features in `Cargo.toml` lint_unexpected_cfg_doc_cargo = see for more information about checking conditional configuration lint_unexpected_cfg_doc_rustc = see for more information about checking conditional configuration lint_unexpected_cfg_from_external_macro_origin = using a cfg inside a {$macro_kind} will use the cfgs from the destination crate and not the ones from the defining crate lint_unexpected_cfg_from_external_macro_refer = try referring to `{$macro_name}` crate for guidance on how handle this unexpected cfg lint_unexpected_cfg_name = unexpected `cfg` condition name: `{$name}` lint_unexpected_cfg_name_expected_names = expected names are: {$possibilities}{$and_more -> [0] {""} *[other] {" "}and {$and_more} more } lint_unexpected_cfg_name_expected_values = expected values for `{$best_match}` are: {$possibilities} lint_unexpected_cfg_name_similar_name = there is a config with a similar name lint_unexpected_cfg_name_similar_name_different_values = there is a config with a similar name and different values lint_unexpected_cfg_name_similar_name_no_value = there is a config with a similar name and no value lint_unexpected_cfg_name_similar_name_value = there is a config with a similar name and value lint_unexpected_cfg_name_with_similar_value = found config with similar value lint_unexpected_cfg_value = unexpected `cfg` condition value: {$has_value -> [true] `{$value}` *[false] (none) } lint_unexpected_cfg_value_add_feature = consider adding `{$value}` as a feature in `Cargo.toml` lint_unexpected_cfg_value_expected_values = expected values for `{$name}` are: {$have_none_possibility -> [true] {"(none), "} *[false] {""} }{$possibilities}{$and_more -> [0] {""} *[other] {" "}and {$and_more} more } lint_unexpected_cfg_value_no_expected_value = no expected value for `{$name}` lint_unexpected_cfg_value_no_expected_values = no expected values for `{$name}` lint_unexpected_cfg_value_remove_condition = remove the condition lint_unexpected_cfg_value_remove_value = remove the value lint_unexpected_cfg_value_similar_name = there is a expected value with a similar name lint_unexpected_cfg_value_specify_value = specify a config value lint_ungated_async_fn_track_caller = `#[track_caller]` on async functions is a no-op .label = this function will not propagate the caller location lint_unicode_text_flow = unicode codepoint changing visible direction of text present in comment .label = {$num_codepoints -> [1] this comment contains an invisible unicode text flow control codepoint *[other] this comment contains invisible unicode text flow control codepoints } .note = these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen .suggestion = if their presence wasn't intentional, you can remove them .label_comment_char = {$c_debug} lint_unit_bindings = binding has unit type `()` .label = this pattern is inferred to be the unit type `()` lint_unknown_diagnostic_attribute = unknown diagnostic attribute lint_unknown_diagnostic_attribute_typo_sugg = an attribute with a similar name exists lint_unknown_gated_lint = unknown lint: `{$name}` .note = the `{$name}` lint is unstable lint_unknown_lint = unknown lint: `{$name}` .suggestion = {$from_rustc -> [true] a lint with a similar name exists in `rustc` lints *[false] did you mean } .help = {$from_rustc -> [true] a lint with a similar name exists in `rustc` lints: `{$replace}` *[false] did you mean: `{$replace}` } lint_unknown_macro_variable = unknown macro variable `{$name}` lint_unknown_tool_in_scoped_lint = unknown tool name `{$tool_name}` found in scoped lint: `{$tool_name}::{$lint_name}` .help = add `#![register_tool({$tool_name})]` to the crate root lint_unnameable_test_items = cannot test inner items lint_unnecessary_qualification = unnecessary qualification .suggestion = remove the unnecessary path segments lint_unpredictable_fn_pointer_comparisons = function pointer comparisons do not produce meaningful results since their addresses are not guaranteed to be unique .note_duplicated_fn = the address of the same function can vary between different codegen units .note_deduplicated_fn = furthermore, different functions could have the same address after being merged together .note_visit_fn_addr_eq = for more information visit .fn_addr_eq_suggestion = refactor your code, or use `std::ptr::fn_addr_eq` to suppress the lint lint_unqualified_local_imports = `use` of a local item without leading `self::`, `super::`, or `crate::` lint_unsafe_attr_outside_unsafe = unsafe attribute used without unsafe .label = usage of unsafe attribute lint_unsafe_attr_outside_unsafe_suggestion = wrap the attribute in `unsafe(...)` lint_unsupported_group = `{$lint_group}` lint group is not supported with ´--force-warn´ lint_untranslatable_diag = diagnostics should be created using translatable messages lint_unused_allocation = unnecessary allocation, use `&` instead lint_unused_allocation_mut = unnecessary allocation, use `&mut` instead lint_unused_builtin_attribute = unused attribute `{$attr_name}` .note = the built-in attribute `{$attr_name}` will be ignored, since it's applied to the macro invocation `{$macro_name}` lint_unused_closure = unused {$pre}{$count -> [one] closure *[other] closures }{$post} that must be used .note = closures are lazy and do nothing unless called lint_unused_comparisons = comparison is useless due to type limits lint_unused_coroutine = unused {$pre}{$count -> [one] coroutine *[other] coroutine }{$post} that must be used .note = coroutines are lazy and do nothing unless resumed lint_unused_crate_dependency = extern crate `{$extern_crate}` is unused in crate `{$local_crate}` .help = remove the dependency or add `use {$extern_crate} as _;` to the crate root lint_unused_def = unused {$pre}`{$def}`{$post} that must be used .suggestion = use `let _ = ...` to ignore the resulting value lint_unused_delim = unnecessary {$delim} around {$item} .suggestion = remove these {$delim} lint_unused_doc_comment = unused doc comment .label = rustdoc does not generate documentation for macro invocations .help = to document an item produced by a macro, the macro must produce the documentation as part of its expansion lint_unused_extern_crate = unused extern crate .suggestion = remove it lint_unused_import_braces = braces around {$node} is unnecessary lint_unused_imports = {$num_snippets -> [one] unused import: {$span_snippets} *[other] unused imports: {$span_snippets} } .suggestion_remove_whole_use = remove the whole `use` item .suggestion_remove_imports = {$num_to_remove -> [one] remove the unused import *[other] remove the unused imports } .help = if this is a test module, consider adding a `#[cfg(test)]` to the containing module lint_unused_label = unused label lint_unused_lifetime = lifetime parameter `{$ident}` never used .suggestion = elide the unused lifetime lint_unused_macro_definition = unused macro definition: `{$name}` lint_unused_macro_use = unused `#[macro_use]` import lint_unused_op = unused {$op} that must be used .label = the {$op} produces a value .suggestion = use `let _ = ...` to ignore the resulting value lint_unused_result = unused result of type `{$ty}` lint_use_let_underscore_ignore_suggestion = use `let _ = ...` to ignore the expression or result lint_useless_ptr_null_checks_fn_ptr = function pointers are not nullable, so checking them for null will always return false .help = wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value .label = expression has type `{$orig_ty}` lint_useless_ptr_null_checks_fn_ret = returned pointer of `{$fn_name}` call is never null, so checking it for null will always return false lint_useless_ptr_null_checks_ref = references are not nullable, so checking them for null will always return false .label = expression has type `{$orig_ty}` lint_uses_power_alignment = repr(C) does not follow the power alignment rule. This may affect platform C ABI compatibility for this type lint_variant_size_differences = enum variant is more than three times larger ({$largest} bytes) than the next largest metadata_as_needed_compatibility = linking modifier `as-needed` is only compatible with `dylib` and `framework` linking kinds metadata_bad_panic_strategy = the linked panic runtime `{$runtime}` is not compiled with this crate's panic strategy `{$strategy}` metadata_binary_output_to_tty = option `-o` or `--emit` is used to write binary output type `metadata` to stdout, but stdout is a tty metadata_bundle_needs_static = linking modifier `bundle` is only compatible with `static` linking kind metadata_cannot_find_crate = can't find crate for `{$crate_name}`{$add_info} metadata_cant_find_crate = can't find crate metadata_compiler_missing_profiler = the compiler may have been built without the profiler runtime metadata_conflicting_alloc_error_handler = the `#[alloc_error_handler]` in {$other_crate_name} conflicts with allocation error handler in: {$crate_name} metadata_conflicting_global_alloc = the `#[global_allocator]` in {$other_crate_name} conflicts with global allocator in: {$crate_name} metadata_consider_adding_std = consider adding the standard library to the sysroot with `x build library --target {$locator_triple}` metadata_consider_building_std = consider building the standard library from source with `cargo build -Zbuild-std` metadata_consider_downloading_target = consider downloading the target with `rustup target add {$locator_triple}` metadata_crate_dep_multiple = cannot satisfy dependencies so `{$crate_name}` only shows up once .help = having upstream crates all available in one format will likely make this go away metadata_crate_dep_not_static = `{$crate_name}` was unavailable as a static crate, preventing fully static linking metadata_crate_dep_rustc_driver = `feature(rustc_private)` is needed to link to the compiler's `rustc_driver` library metadata_crate_location_unknown_type = extern location for {$crate_name} is of an unknown type: {$path} metadata_crate_not_compiler_builtins = the crate `{$crate_name}` resolved as `compiler_builtins` but is not `#![compiler_builtins]` metadata_crate_not_panic_runtime = the crate `{$crate_name}` is not a panic runtime metadata_dl_error = {$path}{$err} metadata_empty_link_name = link name must not be empty .label = empty link name metadata_empty_renaming_target = an empty renaming target was specified for library `{$lib_name}` metadata_extern_location_not_exist = extern location for {$crate_name} does not exist: {$location} metadata_extern_location_not_file = extern location for {$crate_name} is not a file: {$location} metadata_fail_create_file_encoder = failed to create file encoder: {$err} metadata_fail_write_file = failed to write to `{$path}`: {$err} metadata_failed_copy_to_stdout = failed to copy {$filename} to stdout: {$err} metadata_failed_create_encoded_metadata = failed to create encoded metadata from file: {$err} metadata_failed_create_file = failed to create the file {$filename}: {$err} metadata_failed_create_tempdir = couldn't create a temp dir: {$err} metadata_failed_write_error = failed to write {$filename}: {$err} metadata_found_crate_versions = the following crate versions were found:{$found_crates} metadata_found_staticlib = found staticlib `{$crate_name}` instead of rlib or dylib{$add_info} .help = please recompile that crate using --crate-type lib metadata_full_metadata_not_found = only metadata stub found for `{$flavor}` dependency `{$crate_name}` please provide path to the corresponding .rmeta file with full metadata metadata_global_alloc_required = no global memory allocator found but one is required; link to std or add `#[global_allocator]` to a static item that implements the GlobalAlloc trait metadata_import_name_type_form = import name type must be of the form `import_name_type = "string"` metadata_import_name_type_raw = import name type can only be used with link kind `raw-dylib` metadata_import_name_type_x86 = import name type is only supported on x86 metadata_incompatible_panic_in_drop_strategy = the crate `{$crate_name}` is compiled with the panic-in-drop strategy `{$found_strategy}` which is incompatible with this crate's strategy of `{$desired_strategy}` metadata_incompatible_rustc = found crate `{$crate_name}` compiled by an incompatible version of rustc{$add_info} .help = please recompile that crate using this compiler ({$rustc_version}) (consider running `cargo clean` first) metadata_incompatible_target_modifiers = mixing `{$flag_name_prefixed}` will cause an ABI mismatch in crate `{$local_crate}` .note = `{$flag_name_prefixed}={$local_value}` in this crate is incompatible with `{$flag_name_prefixed}={$extern_value}` in dependency `{$extern_crate}` .help = the `{$flag_name_prefixed}` flag modifies the ABI so Rust crates compiled with different values of this flag cannot be used together safely metadata_incompatible_target_modifiers_help_allow = if you are sure this will not cause problems, you may use `-Cunsafe-allow-abi-mismatch={$flag_name}` to silence this error metadata_incompatible_target_modifiers_help_fix = set `{$flag_name_prefixed}={$extern_value}` in this crate or `{$flag_name_prefixed}={$local_value}` in `{$extern_crate}` metadata_incompatible_target_modifiers_help_fix_l_missed = set `{$flag_name_prefixed}={$extern_value}` in this crate or unset `{$flag_name_prefixed}` in `{$extern_crate}` metadata_incompatible_target_modifiers_help_fix_r_missed = unset `{$flag_name_prefixed}` in this crate or set `{$flag_name_prefixed}={$local_value}` in `{$extern_crate}` metadata_incompatible_target_modifiers_l_missed = mixing `{$flag_name_prefixed}` will cause an ABI mismatch in crate `{$local_crate}` .note = unset `{$flag_name_prefixed}` in this crate is incompatible with `{$flag_name_prefixed}={$extern_value}` in dependency `{$extern_crate}` .help = the `{$flag_name_prefixed}` flag modifies the ABI so Rust crates compiled with different values of this flag cannot be used together safely metadata_incompatible_target_modifiers_r_missed = mixing `{$flag_name_prefixed}` will cause an ABI mismatch in crate `{$local_crate}` .note = `{$flag_name_prefixed}={$local_value}` in this crate is incompatible with unset `{$flag_name_prefixed}` in dependency `{$extern_crate}` .help = the `{$flag_name_prefixed}` flag modifies the ABI so Rust crates compiled with different values of this flag cannot be used together safely metadata_incompatible_wasm_link = `wasm_import_module` is incompatible with other arguments in `#[link]` attributes metadata_install_missing_components = maybe you need to install the missing components with: `rustup component add rust-src rustc-dev llvm-tools-preview` metadata_invalid_link_modifier = invalid linking modifier syntax, expected '+' or '-' prefix before one of: bundle, verbatim, whole-archive, as-needed metadata_invalid_meta_files = found invalid metadata files for crate `{$crate_name}`{$add_info} metadata_lib_filename_form = file name should be lib*.rlib or {$dll_prefix}*{$dll_suffix} metadata_lib_framework_apple = library kind `framework` is only supported on Apple targets metadata_lib_required = crate `{$crate_name}` required to be available in {$kind} format, but was not found in this form metadata_link_arg_unstable = link kind `link-arg` is unstable metadata_link_cfg_form = link cfg must be of the form `cfg(/* predicate */)` metadata_link_cfg_single_predicate = link cfg must have a single predicate argument metadata_link_cfg_unstable = link cfg is unstable metadata_link_framework_apple = link kind `framework` is only supported on Apple targets metadata_link_kind_form = link kind must be of the form `kind = "string"` metadata_link_modifiers_form = link modifiers must be of the form `modifiers = "string"` metadata_link_name_form = link name must be of the form `name = "string"` metadata_link_ordinal_raw_dylib = `#[link_ordinal]` is only supported if link kind is `raw-dylib` metadata_link_requires_name = `#[link]` attribute requires a `name = "string"` argument .label = missing `name` argument metadata_missing_native_library = could not find native static library `{$libname}`, perhaps an -L flag is missing? metadata_multiple_candidates = multiple candidates for `{$flavor}` dependency `{$crate_name}` found metadata_multiple_cfgs = multiple `cfg` arguments in a single `#[link]` attribute metadata_multiple_import_name_type = multiple `import_name_type` arguments in a single `#[link]` attribute metadata_multiple_kinds_in_link = multiple `kind` arguments in a single `#[link]` attribute metadata_multiple_link_modifiers = multiple `modifiers` arguments in a single `#[link]` attribute metadata_multiple_modifiers = multiple `{$modifier}` modifiers in a single `modifiers` argument metadata_multiple_names_in_link = multiple `name` arguments in a single `#[link]` attribute metadata_multiple_renamings = multiple renamings were specified for library `{$lib_name}` metadata_multiple_wasm_import = multiple `wasm_import_module` arguments in a single `#[link]` attribute metadata_newer_crate_version = found possibly newer version of crate `{$crate_name}`{$add_info} .note = perhaps that crate needs to be recompiled? metadata_no_crate_with_triple = couldn't find crate `{$crate_name}` with expected target triple {$locator_triple}{$add_info} metadata_no_link_mod_override = overriding linking modifiers from command line is not supported metadata_no_multiple_alloc_error_handler = cannot define multiple allocation error handlers .label = cannot define a new allocation error handler metadata_no_multiple_global_alloc = cannot define multiple global allocators .label = cannot define a new global allocator metadata_no_panic_strategy = the crate `{$crate_name}` does not have the panic strategy `{$strategy}` metadata_no_transitive_needs_dep = the crate `{$crate_name}` cannot depend on a crate that needs {$needs_crate_name}, but it depends on `{$deps_crate_name}` metadata_non_ascii_name = cannot load a crate with a non-ascii name `{$crate_name}` metadata_not_profiler_runtime = the crate `{$crate_name}` is not a profiler runtime metadata_only_provide_library_name = only provide the library name `{$suggested_name}`, not the full filename metadata_prev_alloc_error_handler = previous allocation error handler defined here metadata_prev_global_alloc = previous global allocator defined here metadata_raw_dylib_elf_unstable = link kind `raw-dylib` is unstable on ELF platforms metadata_raw_dylib_no_nul = link name must not contain NUL characters if link kind is `raw-dylib` metadata_raw_dylib_only_windows = link kind `raw-dylib` is only supported on Windows targets metadata_renaming_no_link = renaming of the library `{$lib_name}` was specified, however this crate contains no `#[link(...)]` attributes referencing this library metadata_required_panic_strategy = the crate `{$crate_name}` requires panic strategy `{$found_strategy}` which is incompatible with this crate's strategy of `{$desired_strategy}` metadata_rlib_required = crate `{$crate_name}` required to be available in rlib format, but was not found in this form metadata_rustc_lib_required = crate `{$crate_name}` required to be available in {$kind} format, but was not found in this form .note = only .rmeta files are distributed for `rustc_private` crates other than `rustc_driver` .help = try adding `extern crate rustc_driver;` at the top level of this crate metadata_stable_crate_id_collision = found crates (`{$crate_name0}` and `{$crate_name1}`) with colliding StableCrateId values metadata_std_required = `std` is required by `{$current_crate}` because it does not declare `#![no_std]` metadata_symbol_conflicts_current = the current crate is indistinguishable from one of its dependencies: it has the same crate-name `{$crate_name}` and was compiled with the same `-C metadata` arguments, so this will result in symbol conflicts between the two metadata_target_no_std_support = the `{$locator_triple}` target may not support the standard library metadata_target_not_installed = the `{$locator_triple}` target may not be installed metadata_two_panic_runtimes = cannot link together two panic runtimes: {$prev_name} and {$cur_name} metadata_unexpected_link_arg = unexpected `#[link]` argument, expected one of: name, kind, modifiers, cfg, wasm_import_module, import_name_type metadata_unknown_import_name_type = unknown import name type `{$import_name_type}`, expected one of: decorated, noprefix, undecorated metadata_unknown_link_kind = unknown link kind `{$kind}`, expected one of: static, dylib, framework, raw-dylib, link-arg .label = unknown link kind metadata_unknown_link_modifier = unknown linking modifier `{$modifier}`, expected one of: bundle, verbatim, whole-archive, as-needed metadata_unknown_target_modifier_unsafe_allowed = unknown target modifier `{$flag_name}`, requested by `-Cunsafe-allow-abi-mismatch={$flag_name}` metadata_unsupported_abi = ABI not supported by `#[link(kind = "raw-dylib")]` on this architecture metadata_unsupported_abi_i686 = ABI not supported by `#[link(kind = "raw-dylib")]` on i686 metadata_wasm_c_abi = older versions of the `wasm-bindgen` crate are incompatible with current versions of Rust; please update to `wasm-bindgen` v0.2.88 metadata_wasm_import_form = wasm import module must be of the form `wasm_import_module = "string"` metadata_whole_archive_needs_static = linking modifier `whole-archive` is only compatible with `static` linking kind middle_assert_async_resume_after_drop = `async fn` resumed after async drop middle_assert_async_resume_after_panic = `async fn` resumed after panicking middle_assert_async_resume_after_return = `async fn` resumed after completion middle_assert_coroutine_resume_after_drop = coroutine resumed after async drop middle_assert_coroutine_resume_after_panic = coroutine resumed after panicking middle_assert_coroutine_resume_after_return = coroutine resumed after completion middle_assert_divide_by_zero = attempt to divide `{$val}` by zero middle_assert_gen_resume_after_drop = `gen` fn or block cannot be further iterated on after it async dropped middle_assert_gen_resume_after_panic = `gen` fn or block cannot be further iterated on after it panicked middle_assert_misaligned_ptr_deref = misaligned pointer dereference: address must be a multiple of {$required} but is {$found} middle_assert_null_ptr_deref = null pointer dereference occurred middle_assert_op_overflow = attempt to compute `{$left} {$op} {$right}`, which would overflow middle_assert_overflow_neg = attempt to negate `{$val}`, which would overflow middle_assert_remainder_by_zero = attempt to calculate the remainder of `{$val}` with a divisor of zero middle_assert_shl_overflow = attempt to shift left by `{$val}`, which would overflow middle_assert_shr_overflow = attempt to shift right by `{$val}`, which would overflow middle_autodiff_unsafe_inner_const_ref = reading from a `Duplicated` const {$ty} is unsafe middle_bounds_check = index out of bounds: the length is {$len} but the index is {$index} middle_conflict_types = this expression supplies two conflicting concrete types for the same opaque type middle_consider_type_length_limit = consider adding a `#![type_length_limit="{$type_length}"]` attribute to your crate middle_const_eval_non_int = constant evaluation of enum discriminant resulted in non-integer middle_const_not_used_in_type_alias = const parameter `{$ct}` is part of concrete type but not used in parameter list for the `impl Trait` type alias middle_deprecated = use of deprecated {$kind} `{$path}`{$has_note -> [true] : {$note} *[other] {""} } middle_deprecated_in_future = use of {$kind} `{$path}` that will be deprecated in a future Rust version{$has_note -> [true] : {$note} *[other] {""} } middle_deprecated_in_version = use of {$kind} `{$path}` that will be deprecated in future version {$version}{$has_note -> [true] : {$note} *[other] {""} } middle_deprecated_suggestion = replace the use of the deprecated {$kind} middle_drop_check_overflow = overflow while adding drop-check rules for `{$ty}` .note = overflowed on `{$overflow_ty}` middle_erroneous_constant = erroneous constant encountered middle_failed_writing_file = failed to write file {$path}: {$error}" middle_layout_cycle = a cycle occurred during layout computation middle_layout_normalization_failure = unable to determine layout for `{$ty}` because `{$failure_ty}` cannot be normalized middle_layout_references_error = the type has an unknown layout middle_layout_size_overflow = values of the type `{$ty}` are too big for the target architecture middle_layout_too_generic = the type `{$ty}` does not have a fixed layout middle_layout_unknown = the type `{$ty}` has an unknown layout middle_opaque_hidden_type_mismatch = concrete type differs from previous defining opaque type use .label = expected `{$self_ty}`, got `{$other_ty}` middle_previous_use_here = previous use here middle_recursion_limit_reached = reached the recursion limit finding the struct tail for `{$ty}` .help = consider increasing the recursion limit by adding a `#![recursion_limit = "{$suggested_limit}"]` middle_requires_lang_item = requires `{$name}` lang_item middle_strict_coherence_needs_negative_coherence = to use `strict_coherence` on this trait, the `with_negative_coherence` feature must be enabled .label = due to this attribute middle_type_length_limit = reached the type-length limit while instantiating `{$shrunk}` middle_unsupported_union = we don't support unions yet: '{$ty_name}' middle_written_to_path = the full type name has been written to '{$path}' mir_build_adt_defined_here = `{$ty}` defined here mir_build_already_borrowed = cannot borrow value as mutable because it is also borrowed as immutable mir_build_already_mut_borrowed = cannot borrow value as immutable because it is also borrowed as mutable mir_build_bindings_with_variant_name = pattern binding `{$name}` is named the same as one of the variants of the type `{$ty_path}` .suggestion = to match on the variant, qualify the path mir_build_borrow = value is borrowed by `{$name}` here mir_build_borrow_of_layout_constrained_field_requires_unsafe = borrow of layout constrained field with interior mutability is unsafe and requires unsafe block .note = references to fields of layout constrained fields lose the constraints. Coupled with interior mutability, the field can be changed to invalid values .label = borrow of layout constrained field with interior mutability mir_build_borrow_of_layout_constrained_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = borrow of layout constrained field with interior mutability is unsafe and requires unsafe function or block .note = references to fields of layout constrained fields lose the constraints. Coupled with interior mutability, the field can be changed to invalid values .label = borrow of layout constrained field with interior mutability mir_build_borrow_of_moved_value = borrow of moved value .label = value moved into `{$name}` here .occurs_because_label = move occurs because `{$name}` has type `{$ty}`, which does not implement the `Copy` trait .value_borrowed_label = value borrowed here after move .suggestion = borrow this binding in the pattern to avoid moving the value mir_build_call_to_deprecated_safe_fn_requires_unsafe = call to deprecated safe function `{$function}` is unsafe and requires unsafe block .note = consult the function's documentation for information on how to avoid undefined behavior .label = call to unsafe function .suggestion = you can wrap the call in an `unsafe` block if you can guarantee {$guarantee} mir_build_call_to_fn_with_requires_unsafe = call to function `{$function}` with `#[target_feature]` is unsafe and requires unsafe block .help = in order for the call to be safe, the context requires the following additional target {$missing_target_features_count -> [1] feature *[count] features }: {$missing_target_features} .note = the {$build_target_features} target {$build_target_features_count -> [1] feature *[count] features } being enabled in the build configuration does not remove the requirement to list {$build_target_features_count -> [1] it *[count] them } in `#[target_feature]` .label = call to function with `#[target_feature]` mir_build_call_to_fn_with_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = call to function `{$function}` with `#[target_feature]` is unsafe and requires unsafe function or block .help = in order for the call to be safe, the context requires the following additional target {$missing_target_features_count -> [1] feature *[count] features }: {$missing_target_features} .note = the {$build_target_features} target {$build_target_features_count -> [1] feature *[count] features } being enabled in the build configuration does not remove the requirement to list {$build_target_features_count -> [1] it *[count] them } in `#[target_feature]` .label = call to function with `#[target_feature]` mir_build_call_to_unsafe_fn_requires_unsafe = call to unsafe function `{$function}` is unsafe and requires unsafe block .note = consult the function's documentation for information on how to avoid undefined behavior .label = call to unsafe function mir_build_call_to_unsafe_fn_requires_unsafe_nameless = call to unsafe function is unsafe and requires unsafe block .note = consult the function's documentation for information on how to avoid undefined behavior .label = call to unsafe function mir_build_call_to_unsafe_fn_requires_unsafe_nameless_unsafe_op_in_unsafe_fn_allowed = call to unsafe function is unsafe and requires unsafe function or block .note = consult the function's documentation for information on how to avoid undefined behavior .label = call to unsafe function mir_build_call_to_unsafe_fn_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = call to unsafe function `{$function}` is unsafe and requires unsafe function or block .note = consult the function's documentation for information on how to avoid undefined behavior .label = call to unsafe function mir_build_confused = missing patterns are not covered because `{$variable}` is interpreted as a constant pattern, not a new variable mir_build_const_defined_here = constant defined here mir_build_const_param_in_pattern = constant parameters cannot be referenced in patterns .label = can't be used in patterns mir_build_const_param_in_pattern_def = constant defined here mir_build_const_pattern_depends_on_generic_parameter = constant pattern cannot depend on generic parameters .label = `const` depends on a generic parameter mir_build_could_not_eval_const_pattern = could not evaluate constant pattern .label = could not evaluate constant mir_build_deref_raw_pointer_requires_unsafe = dereference of raw pointer is unsafe and requires unsafe block .note = raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior .label = dereference of raw pointer mir_build_deref_raw_pointer_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = dereference of raw pointer is unsafe and requires unsafe function or block .note = raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior .label = dereference of raw pointer mir_build_exceeds_mcdc_condition_limit = number of conditions in decision ({$num_conditions}) exceeds limit ({$max_conditions}), so MC/DC analysis will not count this expression mir_build_extern_static_requires_unsafe = use of extern static is unsafe and requires unsafe block .note = extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior .label = use of extern static mir_build_extern_static_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = use of extern static is unsafe and requires unsafe function or block .note = extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior .label = use of extern static mir_build_inform_irrefutable = `let` bindings require an "irrefutable pattern", like a `struct` or an `enum` with only one variant mir_build_initializing_type_with_requires_unsafe = initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe block .note = initializing a layout restricted type's field with a value outside the valid range is undefined behavior .label = initializing type with `rustc_layout_scalar_valid_range` attr mir_build_initializing_type_with_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe function or block .note = initializing a layout restricted type's field with a value outside the valid range is undefined behavior .label = initializing type with `rustc_layout_scalar_valid_range` attr mir_build_initializing_type_with_unsafe_field_requires_unsafe = initializing type with an unsafe field is unsafe and requires unsafe block .note = unsafe fields may carry library invariants .label = initialization of struct with unsafe field mir_build_initializing_type_with_unsafe_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = initializing type with an unsafe field is unsafe and requires unsafe block .note = unsafe fields may carry library invariants .label = initialization of struct with unsafe field mir_build_inline_assembly_requires_unsafe = use of inline assembly is unsafe and requires unsafe block .note = inline assembly is entirely unchecked and can cause undefined behavior .label = use of inline assembly mir_build_inline_assembly_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = use of inline assembly is unsafe and requires unsafe function or block .note = inline assembly is entirely unchecked and can cause undefined behavior .label = use of inline assembly mir_build_interpreted_as_const = introduce a variable instead mir_build_invalid_pattern = {$prefix} `{$non_sm_ty}` cannot be used in patterns .label = {$prefix} can't be used in patterns mir_build_irrefutable_let_patterns_if_let = irrefutable `if let` {$count -> [one] pattern *[other] patterns } .note = {$count -> [one] this pattern *[other] these patterns } will always match, so the `if let` is useless .help = consider replacing the `if let` with a `let` mir_build_irrefutable_let_patterns_if_let_guard = irrefutable `if let` guard {$count -> [one] pattern *[other] patterns } .note = {$count -> [one] this pattern *[other] these patterns } will always match, so the guard is useless .help = consider removing the guard and adding a `let` inside the match arm mir_build_irrefutable_let_patterns_let_else = irrefutable `let...else` {$count -> [one] pattern *[other] patterns } .note = {$count -> [one] this pattern *[other] these patterns } will always match, so the `else` clause is useless .help = consider removing the `else` clause mir_build_irrefutable_let_patterns_while_let = irrefutable `while let` {$count -> [one] pattern *[other] patterns } .note = {$count -> [one] this pattern *[other] these patterns } will always match, so the loop will never exit .help = consider instead using a `loop {"{"} ... {"}"}` with a `let` inside it mir_build_leading_irrefutable_let_patterns = leading irrefutable {$count -> [one] pattern *[other] patterns } in let chain .note = {$count -> [one] this pattern *[other] these patterns } will always match .help = consider moving {$count -> [one] it *[other] them } outside of the construct mir_build_literal_in_range_out_of_bounds = literal out of range for `{$ty}` .label = this value does not fit into the type `{$ty}` whose range is `{$min}..={$max}` mir_build_lower_range_bound_must_be_less_than_or_equal_to_upper = lower range bound must be less than or equal to upper .label = lower bound larger than upper bound .teach_note = When matching against a range, the compiler verifies that the range is non-empty. Range patterns include both end-points, so this is equivalent to requiring the start of the range to be less than or equal to the end of the range. mir_build_lower_range_bound_must_be_less_than_upper = lower range bound must be less than upper mir_build_more_information = for more information, visit https://doc.rust-lang.org/book/ch19-02-refutability.html mir_build_moved = value is moved into `{$name}` here mir_build_moved_while_borrowed = cannot move out of value because it is borrowed mir_build_multiple_mut_borrows = cannot borrow value as mutable more than once at a time mir_build_mutable_borrow = value is mutably borrowed by `{$name}` here mir_build_mutable_static_requires_unsafe = use of mutable static is unsafe and requires unsafe block .note = mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior .label = use of mutable static mir_build_mutable_static_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = use of mutable static is unsafe and requires unsafe function or block .note = mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior .label = use of mutable static mir_build_mutation_of_layout_constrained_field_requires_unsafe = mutation of layout constrained field is unsafe and requires unsafe block .note = mutating layout constrained fields cannot statically be checked for valid values .label = mutation of layout constrained field mir_build_mutation_of_layout_constrained_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = mutation of layout constrained field is unsafe and requires unsafe function or block .note = mutating layout constrained fields cannot statically be checked for valid values .label = mutation of layout constrained field mir_build_nan_pattern = cannot use NaN in patterns .label = evaluates to `NaN`, which is not allowed in patterns .note = NaNs compare inequal to everything, even themselves, so this pattern would never match .help = try using the `is_nan` method instead mir_build_non_const_path = runtime values cannot be referenced in patterns .label = references a runtime value mir_build_non_empty_never_pattern = mismatched types .label = a never pattern must be used on an uninhabited type .note = the matched value is of type `{$ty}` mir_build_non_exhaustive_match_all_arms_guarded = match arms with guards don't count towards exhaustivity mir_build_non_exhaustive_patterns_type_not_empty = non-exhaustive patterns: type `{$ty}` is non-empty .def_note = `{$peeled_ty}` defined here .type_note = the matched value is of type `{$ty}` .non_exhaustive_type_note = the matched value is of type `{$ty}`, which is marked as non-exhaustive .reference_note = references are always considered inhabited .suggestion = ensure that all possible cases are being handled by adding a match arm with a wildcard pattern as shown .help = ensure that all possible cases are being handled by adding a match arm with a wildcard pattern mir_build_non_partial_eq_match = constant of non-structural type `{$ty}` in a pattern .label = constant of non-structural type mir_build_pattern_not_covered = refutable pattern in {$origin} .pattern_ty = the matched value is of type `{$pattern_ty}` mir_build_pointer_pattern = function pointers and raw pointers not derived from integers in patterns behave unpredictably and should not be relied upon .label = can't be used in patterns .note = see https://github.com/rust-lang/rust/issues/70861 for details mir_build_privately_uninhabited = pattern `{$witness_1}` is currently uninhabited, but this variant contains private fields which may become inhabited in the future mir_build_rust_2024_incompatible_pat = {$bad_modifiers -> *[true] binding modifiers{$bad_ref_pats -> *[true] {" "}and reference patterns [false] {""} } [false] reference patterns } may only be written when the default binding mode is `move`{$is_hard_error -> *[true] {""} [false] {" "}in Rust 2024 } mir_build_static_in_pattern = statics cannot be referenced in patterns .label = can't be used in patterns mir_build_static_in_pattern_def = `static` defined here mir_build_suggest_attempted_int_lit = alternatively, you could prepend the pattern with an underscore to define a new named variable; identifiers cannot begin with digits mir_build_suggest_if_let = you might want to use `if let` to ignore the {$count -> [one] variant that isn't *[other] variants that aren't } matched mir_build_suggest_let_else = you might want to use `let else` to handle the {$count -> [one] variant that isn't *[other] variants that aren't } matched mir_build_trailing_irrefutable_let_patterns = trailing irrefutable {$count -> [one] pattern *[other] patterns } in let chain .note = {$count -> [one] this pattern *[other] these patterns } will always match .help = consider moving {$count -> [one] it *[other] them } into the body mir_build_type_not_structural = constant of non-structural type `{$ty}` in a pattern .label = constant of non-structural type mir_build_type_not_structural_def = `{$ty}` must be annotated with `#[derive(PartialEq)]` to be usable in patterns mir_build_type_not_structural_more_info = see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details mir_build_type_not_structural_tip = the `PartialEq` trait must be derived, manual `impl`s are not sufficient; see https://doc.rust-lang.org/stable/std/marker/trait.StructuralPartialEq.html for details mir_build_union_field_requires_unsafe = access to union field is unsafe and requires unsafe block .note = the field may not be properly initialized: using uninitialized data will cause undefined behavior .label = access to union field mir_build_union_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = access to union field is unsafe and requires unsafe function or block .note = the field may not be properly initialized: using uninitialized data will cause undefined behavior .label = access to union field mir_build_union_pattern = cannot use unions in constant patterns .label = can't use a `union` here mir_build_unreachable_making_this_unreachable = collectively making this unreachable mir_build_unreachable_making_this_unreachable_n_more = ...and {$covered_by_many_n_more_count} other patterns collectively make this unreachable mir_build_unreachable_matches_same_values = matches some of the same values mir_build_unreachable_pattern = unreachable pattern .label = no value can reach this .unreachable_matches_no_values = matches no values because `{$matches_no_values_ty}` is uninhabited .unreachable_uninhabited_note = to learn more about uninhabited types, see https://doc.rust-lang.org/nomicon/exotic-sizes.html#empty-types .unreachable_covered_by_catchall = matches any value .unreachable_covered_by_one = matches all the relevant values .unreachable_covered_by_many = multiple earlier patterns match some of the same values .unreachable_pattern_const_reexport_accessible = there is a constant of the same name imported in another scope, which could have been used to pattern match against its value instead of introducing a new catch-all binding, but it needs to be imported in the pattern's scope .unreachable_pattern_wanted_const = you might have meant to pattern match against the value of {$is_typo -> [true] similarly named constant *[false] constant } `{$const_name}` instead of introducing a new catch-all binding .unreachable_pattern_const_inaccessible = there is a constant of the same name, which could have been used to pattern match against its value instead of introducing a new catch-all binding, but it is not accessible from this scope .unreachable_pattern_let_binding = there is a binding of the same name; if you meant to pattern match against the value of that binding, that is a feature of constants that is not available for `let` bindings .suggestion = remove the match arm mir_build_unsafe_binder_cast_requires_unsafe = unsafe binder cast is unsafe and requires unsafe block .label = unsafe binder cast .note = casting to or from an `unsafe<...>` binder type is unsafe since it erases lifetime information that may be required to uphold safety guarantees of a type mir_build_unsafe_binder_cast_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = unsafe binder cast is unsafe and requires unsafe block or unsafe fn .label = unsafe binder cast .note = casting to or from an `unsafe<...>` binder type is unsafe since it erases lifetime information that may be required to uphold safety guarantees of a type mir_build_unsafe_field_requires_unsafe = use of unsafe field is unsafe and requires unsafe block .note = unsafe fields may carry library invariants .label = use of unsafe field mir_build_unsafe_field_requires_unsafe_unsafe_op_in_unsafe_fn_allowed = use of unsafe field is unsafe and requires unsafe block .note = unsafe fields may carry library invariants .label = use of unsafe field mir_build_unsafe_fn_safe_body = an unsafe function restricts its caller, but its body is safe by default mir_build_unsafe_not_inherited = items do not inherit unsafety from separate enclosing items mir_build_unsafe_op_in_unsafe_fn_borrow_of_layout_constrained_field_requires_unsafe = borrow of layout constrained field with interior mutability is unsafe and requires unsafe block .note = references to fields of layout constrained fields lose the constraints. Coupled with interior mutability, the field can be changed to invalid values .label = borrow of layout constrained field with interior mutability mir_build_unsafe_op_in_unsafe_fn_call_to_fn_with_requires_unsafe = call to function `{$function}` with `#[target_feature]` is unsafe and requires unsafe block .help = in order for the call to be safe, the context requires the following additional target {$missing_target_features_count -> [1] feature *[count] features }: {$missing_target_features} .note = the {$build_target_features} target {$build_target_features_count -> [1] feature *[count] features } being enabled in the build configuration does not remove the requirement to list {$build_target_features_count -> [1] it *[count] them } in `#[target_feature]` .label = call to function with `#[target_feature]` mir_build_unsafe_op_in_unsafe_fn_call_to_unsafe_fn_requires_unsafe = call to unsafe function `{$function}` is unsafe and requires unsafe block .note = consult the function's documentation for information on how to avoid undefined behavior .label = call to unsafe function mir_build_unsafe_op_in_unsafe_fn_call_to_unsafe_fn_requires_unsafe_nameless = call to unsafe function is unsafe and requires unsafe block .note = consult the function's documentation for information on how to avoid undefined behavior .label = call to unsafe function mir_build_unsafe_op_in_unsafe_fn_deref_raw_pointer_requires_unsafe = dereference of raw pointer is unsafe and requires unsafe block .note = raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior .label = dereference of raw pointer mir_build_unsafe_op_in_unsafe_fn_extern_static_requires_unsafe = use of extern static is unsafe and requires unsafe block .note = extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior .label = use of extern static mir_build_unsafe_op_in_unsafe_fn_initializing_type_with_requires_unsafe = initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe block .note = initializing a layout restricted type's field with a value outside the valid range is undefined behavior .label = initializing type with `rustc_layout_scalar_valid_range` attr mir_build_unsafe_op_in_unsafe_fn_initializing_type_with_unsafe_field_requires_unsafe = initializing type with an unsafe field is unsafe and requires unsafe block .note = unsafe fields may carry library invariants .label = initialization of struct with unsafe field mir_build_unsafe_op_in_unsafe_fn_inline_assembly_requires_unsafe = use of inline assembly is unsafe and requires unsafe block .note = inline assembly is entirely unchecked and can cause undefined behavior .label = use of inline assembly mir_build_unsafe_op_in_unsafe_fn_mutable_static_requires_unsafe = use of mutable static is unsafe and requires unsafe block .note = mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior .label = use of mutable static mir_build_unsafe_op_in_unsafe_fn_mutation_of_layout_constrained_field_requires_unsafe = mutation of layout constrained field is unsafe and requires unsafe block .note = mutating layout constrained fields cannot statically be checked for valid values .label = mutation of layout constrained field mir_build_unsafe_op_in_unsafe_fn_union_field_requires_unsafe = access to union field is unsafe and requires unsafe block .note = the field may not be properly initialized: using uninitialized data will cause undefined behavior .label = access to union field mir_build_unsafe_op_in_unsafe_fn_unsafe_field_requires_unsafe = use of unsafe field is unsafe and requires unsafe block .note = unsafe fields may carry library invariants .label = use of unsafe field mir_build_unsized_pattern = cannot use unsized non-slice type `{$non_sm_ty}` in constant patterns mir_build_unused_unsafe = unnecessary `unsafe` block .label = unnecessary `unsafe` block mir_build_unused_unsafe_enclosing_block_label = because it's nested under this `unsafe` block mir_build_variant_defined_here = not covered mir_build_wrap_suggestion = consider wrapping the function body in an unsafe block mir_dataflow_duplicate_values_for = duplicate values for `{$name}` mir_dataflow_path_must_end_in_filename = path must end in a filename mir_dataflow_peek_argument_not_a_local = rustc_peek: argument was not a local mir_dataflow_peek_argument_untracked = rustc_peek: argument untracked mir_dataflow_peek_bit_not_set = rustc_peek: bit not set mir_dataflow_peek_must_be_not_temporary = dataflow::sanity_check cannot feed a non-temp to rustc_peek mir_dataflow_peek_must_be_place_or_ref_place = rustc_peek: argument expression must be either `place` or `&place` mir_dataflow_requires_an_argument = `{$name}` requires an argument mir_dataflow_stop_after_dataflow_ended_compilation = stop_after_dataflow ended compilation mir_dataflow_unknown_formatter = unknown formatter mir_transform_arithmetic_overflow = this arithmetic operation will overflow mir_transform_const_defined_here = `const` item defined here mir_transform_const_modify = attempting to modify a `const` item .note = each usage of a `const` item creates a new temporary; the original `const` item will not be modified mir_transform_const_mut_borrow = taking a mutable reference to a `const` item .note = each usage of a `const` item creates a new temporary .note2 = the mutable reference will refer to this temporary, not the original `const` item .note3 = mutable reference created due to call to this method mir_transform_exceeds_mcdc_test_vector_limit = number of total test vectors in one function will exceed limit ({$max_num_test_vectors}) if this decision is instrumented, so MC/DC analysis ignores it mir_transform_ffi_unwind_call = call to {$foreign -> [true] foreign function *[false] function pointer } with FFI-unwind ABI mir_transform_fn_item_ref = taking a reference to a function item does not give a function pointer .suggestion = cast `{$ident}` to obtain a function pointer mir_transform_force_inline = `{$callee}` could not be inlined into `{$caller}` but is required to be inlined .call = ...`{$callee}` called here .attr = inlining due to this annotation .caller = within `{$caller}`... .callee = `{$callee}` defined here .note = could not be inlined due to: {$reason} mir_transform_force_inline_attr = `{$callee}` is incompatible with `#[rustc_force_inline]` .attr = annotation here .callee = `{$callee}` defined here .note = incompatible due to: {$reason} mir_transform_force_inline_justification = `{$callee}` is required to be inlined to: {$sym} mir_transform_must_not_suspend = {$pre}`{$def_path}`{$post} held across a suspend point, but should not be .label = the value is held across this suspend point .note = {$reason} .help = consider using a block (`{"{ ... }"}`) to shrink the value's scope, ending before the suspend point mir_transform_operation_will_panic = this operation will panic at runtime mir_transform_tail_expr_drop_order = relative drop order changing in Rust 2024 .temporaries = in Rust 2024, this temporary value will be dropped first .observers = in Rust 2024, this local variable or temporary value will be dropped second .note_dtors = dropping the temporary value runs this custom `Drop` impl, which we could not prove to be side-effect free .note_observer_dtors = dropping the local runs this custom `Drop` impl, which we could not prove to be side-effect free .drop_location = now the temporary value is dropped here, before the local variables in the block or statement .note_epilogue = most of the time, changing drop order is harmless; inspect the `impl Drop`s for side effects like releasing locks or sending messages .label_local_epilogue = {$is_dropped_first_edition_2024 -> [true] up until Edition 2021 `{$name}` is dropped last but will be dropped earlier in Edition 2024 *[false] `{$name}` will be dropped later as of Edition 2024 } mir_transform_tail_expr_dtor = {$dtor_kind -> [dyn] `{$name}` may invoke a custom destructor because it contains a trait object *[concrete] `{$name}` invokes this custom destructor } mir_transform_tail_expr_local = {$is_generated_name -> [true] this value will be stored in a temporary; let us call it `{$name}` *[false] `{$name}` calls a custom destructor } mir_transform_unaligned_packed_ref = reference to packed field is unaligned .note = packed structs are only aligned by one byte, and many modern architectures penalize unaligned field accesses .note_ub = creating a misaligned reference is undefined behavior (even if that reference is never dereferenced) .help = copy the field contents to a local variable, or replace the reference with a raw pointer and use `read_unaligned`/`write_unaligned` (loads and stores via `*p` must be properly aligned even when using raw pointers) mir_transform_unconditional_recursion = function cannot return without recursing .label = cannot return without recursing .help = a `loop` may express intention better if this is on purpose mir_transform_unconditional_recursion_call_site_label = recursive call site mir_transform_undefined_transmute = pointers cannot be transmuted to integers during const eval .note = at compile-time, pointers do not have an integer value .note2 = avoiding this restriction via `union` or raw pointers leads to compile-time undefined behavior .help = for more information, see https://doc.rust-lang.org/std/mem/fn.transmute.html mir_transform_unknown_pass_name = MIR pass `{$name}` is unknown and will be ignored mir_transform_unnecessary_transmute = unnecessary transmute monomorphize_abi_error_disabled_vector_type = this function {$is_call -> [true] call *[false] definition } uses SIMD vector type `{$ty}` which (with the chosen ABI) requires the `{$required_feature}` target feature, which is not enabled{$is_call -> [true] {" "}in the caller *[false] {""} } .label = function {$is_call -> [true] called *[false] defined } here .help = consider enabling it globally (`-C target-feature=+{$required_feature}`) or locally (`#[target_feature(enable="{$required_feature}")]`) monomorphize_abi_error_unsupported_vector_type = this function {$is_call -> [true] call *[false] definition } uses SIMD vector type `{$ty}` which is not currently supported with the chosen ABI .label = function {$is_call -> [true] called *[false] defined } here monomorphize_abi_required_target_feature = this function {$is_call -> [true] call *[false] definition } uses ABI "{$abi}" which requires the `{$required_feature}` target feature, which is not enabled{$is_call -> [true] {" "}in the caller *[false] {""} } .label = function {$is_call -> [true] called *[false] defined } here .help = consider enabling it globally (`-C target-feature=+{$required_feature}`) or locally (`#[target_feature(enable="{$required_feature}")]`) monomorphize_couldnt_dump_mono_stats = unexpected error occurred while dumping monomorphization stats: {$error} monomorphize_encountered_error_while_instantiating = the above error was encountered while instantiating `{$formatted_item}` monomorphize_large_assignments = moving {$size} bytes .label = value moved from here .note = The current maximum size is {$limit}, but it can be customized with the move_size_limit attribute: `#![move_size_limit = "..."]` monomorphize_no_optimized_mir = missing optimized MIR for `{$instance}` in the crate `{$crate_name}` .note = missing optimized MIR for this item (was the crate `{$crate_name}` compiled with `--emit=metadata`?) monomorphize_recursion_limit = reached the recursion limit while instantiating `{$shrunk}` .note = `{$def_path_str}` defined here monomorphize_start_not_found = using `fn main` requires the standard library .help = use `#![no_main]` to bypass the Rust generated entrypoint and declare a platform specific entrypoint yourself, usually with `#[no_mangle]` monomorphize_symbol_already_defined = symbol `{$symbol}` is already defined monomorphize_unknown_cgu_collection_mode = unknown codegen-item collection mode '{$mode}', falling back to 'lazy' mode monomorphize_wasm_c_abi_transition = this function {$is_call -> [true] call *[false] definition } involves an argument of type `{$ty}` which is affected by the wasm ABI transition .help = the "C" ABI Rust uses on wasm32-unknown-unknown will change to align with the standard "C" ABI for this target monomorphize_written_to_path = the full type name has been written to '{$path}' parse_add_paren = try adding parentheses parse_ambiguous_range_pattern = the range pattern here has ambiguous interpretation parse_ambiguous_range_pattern_suggestion = add parentheses to clarify the precedence parse_array_brackets_instead_of_braces = this is a block expression, not an array .suggestion = to make an array, use square brackets instead of curly braces parse_array_index_offset_of = array indexing not supported in offset_of parse_assignment_else_not_allowed = ... else {"{"} ... {"}"} is not allowed parse_associated_static_item_not_allowed = associated `static` items are not allowed parse_async_block_in_2015 = `async` blocks are only allowed in Rust 2018 or later parse_async_bound_modifier_in_2015 = `async` trait bounds are only allowed in Rust 2018 or later parse_async_fn_in_2015 = `async fn` is not permitted in Rust 2015 .label = to use `async fn`, switch to Rust 2018 or later parse_async_impl = `async` trait implementations are unsupported parse_async_move_block_in_2015 = `async move` blocks are only allowed in Rust 2018 or later parse_async_move_order_incorrect = the order of `move` and `async` is incorrect .suggestion = try switching the order parse_async_use_block_in_2015 = `async use` blocks are only allowed in Rust 2018 or later parse_async_use_order_incorrect = the order of `use` and `async` is incorrect .suggestion = try switching the order parse_at_dot_dot_in_struct_pattern = `@ ..` is not supported in struct patterns .suggestion = bind to each field separately or, if you don't need them, just remove `{$ident} @` parse_at_in_struct_pattern = Unexpected `@` in struct pattern .note = struct patterns use `field: pattern` syntax to bind to fields .help = consider replacing `new_name @ field_name` with `field_name: new_name` if that is what you intended parse_attr_after_generic = trailing attribute after generic parameter .label = attributes must go before parameters parse_attr_without_generics = attribute without generic parameters .label = attributes are only permitted when preceding parameters parse_attribute_on_param_type = attributes cannot be applied to a function parameter's type .label = attributes are not allowed here parse_bad_assoc_type_bounds = bounds on associated types do not belong here .label = belongs in `where` clause parse_bad_item_kind = {$descr} is not supported in {$ctx} .help = consider moving the {$descr} out to a nearby module scope parse_bad_return_type_notation_output = return type not allowed with return type notation .suggestion = remove the return type parse_bare_cr = {$double_quotes -> [true] bare CR not allowed in string, use `\r` instead *[false] character constant must be escaped: `\r` } .escape = escape the character parse_bare_cr_in_raw_string = bare CR not allowed in raw string parse_binder_and_polarity = `for<...>` binder not allowed with `{$polarity}` trait polarity modifier .label = there is not a well-defined meaning for a higher-ranked `{$polarity}` trait parse_binder_before_modifiers = `for<...>` binder should be placed before trait bound modifiers .label = place the `for<...>` binder before any modifiers parse_bounds_not_allowed_on_trait_aliases = bounds are not allowed on trait aliases parse_box_not_pat = expected pattern, found {$descr} .note = `box` is a reserved keyword .suggestion = escape `box` to use it as an identifier parse_box_syntax_removed = `box_syntax` has been removed parse_box_syntax_removed_suggestion = use `Box::new()` instead parse_cannot_be_raw_ident = `{$ident}` cannot be a raw identifier parse_cannot_be_raw_lifetime = `{$ident}` cannot be a raw lifetime parse_catch_after_try = keyword `catch` cannot follow a `try` block .help = try using `match` on the result of the `try` block instead parse_cfg_attr_bad_delim = wrong `cfg_attr` delimiters parse_colon_as_semi = statements are terminated with a semicolon .suggestion = use a semicolon instead parse_comma_after_base_struct = cannot use a comma after the base struct .note = the base struct must always be the last field .suggestion = remove this comma parse_comparison_interpreted_as_generic = `<` is interpreted as a start of generic arguments for `{$type}`, not a comparison .label_args = interpreted as generic arguments .label_comparison = not interpreted as comparison .suggestion = try comparing the cast value parse_comparison_operators_cannot_be_chained = comparison operators cannot be chained .sugg_parentheses_for_function_args = or use `(...)` if you meant to specify fn arguments .sugg_split_comparison = split the comparison into two .sugg_parenthesize = parenthesize the comparison parse_compound_assignment_expression_in_let = can't reassign to an uninitialized variable .suggestion = initialize the variable .help = if you meant to overwrite, remove the `let` binding parse_const_generic_without_braces = expressions must be enclosed in braces to be used as const generic arguments .suggestion = enclose the `const` expression in braces parse_const_global_cannot_be_mutable = const globals cannot be mutable .label = cannot be mutable .suggestion = you might want to declare a static instead parse_const_let_mutually_exclusive = `const` and `let` are mutually exclusive .suggestion = remove `let` parse_cr_doc_comment = bare CR not allowed in {$block -> [true] block doc-comment *[false] doc-comment } parse_default_not_followed_by_item = `default` is not followed by an item .label = the `default` qualifier .note = only `fn`, `const`, `type`, or `impl` items may be prefixed by `default` parse_do_catch_syntax_removed = found removed `do catch` syntax .note = following RFC #2388, the new non-placeholder syntax is `try` .suggestion = replace with the new syntax parse_doc_comment_does_not_document_anything = found a documentation comment that doesn't document anything .help = doc comments must come before what they document, if a comment was intended use `//` .suggestion = missing comma here parse_doc_comment_on_param_type = documentation comments cannot be applied to a function parameter's type .label = doc comments are not allowed here parse_dot_dot_dot_for_remaining_fields = expected field pattern, found `{$token_str}` .suggestion = to omit remaining fields, use `..` parse_dot_dot_dot_range_to_pattern_not_allowed = range-to patterns with `...` are not allowed .suggestion = use `..=` instead parse_dot_dot_range_attribute = attributes are not allowed on range expressions starting with `..` parse_dotdotdot = unexpected token: `...` .suggest_exclusive_range = use `..` for an exclusive range .suggest_inclusive_range = or `..=` for an inclusive range parse_dotdotdot_rest_pattern = unexpected `...` .label = not a valid pattern .suggestion = for a rest pattern, use `..` instead of `...` parse_double_colon_in_bound = expected `:` followed by trait or lifetime .suggestion = use single colon parse_dyn_after_mut = `mut` must precede `dyn` .suggestion = place `mut` before `dyn` parse_empty_exponent_float = expected at least one digit in exponent parse_empty_unicode_escape = empty unicode escape .label = this escape must have at least 1 hex digit parse_enum_pattern_instead_of_identifier = expected identifier, found enum pattern parse_enum_struct_mutually_exclusive = `enum` and `struct` are mutually exclusive .suggestion = replace `enum struct` with parse_eq_field_init = expected `:`, found `=` .suggestion = replace equals symbol with a colon parse_escape_only_char = {$byte -> [true] byte *[false] character } constant must be escaped: `{$escaped_msg}` .escape = escape the character parse_expect_dotdot_not_dotdotdot = expected `..`, found `...` .suggestion = use `..` to fill in the rest of the fields parse_expect_eq_instead_of_eqeq = expected `=`, found `==` .suggestion = consider using `=` here parse_expect_label_found_ident = expected a label, found an identifier .suggestion = labels start with a tick parse_expect_path = expected a path parse_expected_binding_left_of_at = left-hand side of `@` must be a binding .label_lhs = interpreted as a pattern, not a binding .label_rhs = also a pattern .note = bindings are `x`, `mut x`, `ref x`, and `ref mut x` parse_expected_builtin_ident = expected identifier after `builtin #` parse_expected_comma_after_pattern_field = expected `,` parse_expected_else_block = expected `{"{"}`, found {$first_tok} .label = expected an `if` or a block after this `else` .suggestion = add an `if` if this is the condition of a chained `else if` statement parse_expected_expression_found_let = expected expression, found `let` statement .note = only supported directly in conditions of `if` and `while` expressions .not_supported_or = `||` operators are not supported in let chain expressions .not_supported_parentheses = `let`s wrapped in parentheses are not supported in a context with let chains parse_expected_fn_path_found_fn_keyword = expected identifier, found keyword `fn` .suggestion = use `Fn` to refer to the trait parse_expected_identifier = expected identifier parse_expected_identifier_found_doc_comment = expected identifier, found doc comment parse_expected_identifier_found_doc_comment_str = expected identifier, found doc comment `{$token}` parse_expected_identifier_found_keyword = expected identifier, found keyword parse_expected_identifier_found_keyword_str = expected identifier, found keyword `{$token}` parse_expected_identifier_found_metavar = expected identifier, found metavariable # This one deliberately doesn't print a token. parse_expected_identifier_found_metavar_str = expected identifier, found metavariable parse_expected_identifier_found_reserved_identifier = expected identifier, found reserved identifier parse_expected_identifier_found_reserved_identifier_str = expected identifier, found reserved identifier `{$token}` parse_expected_identifier_found_reserved_keyword = expected identifier, found reserved keyword parse_expected_identifier_found_reserved_keyword_str = expected identifier, found reserved keyword `{$token}` parse_expected_identifier_found_str = expected identifier, found `{$token}` parse_expected_mut_or_const_in_raw_pointer_type = expected `mut` or `const` keyword in raw pointer type .suggestion = add `mut` or `const` here parse_expected_semi_found_doc_comment_str = expected `;`, found doc comment `{$token}` parse_expected_semi_found_keyword_str = expected `;`, found keyword `{$token}` # This one deliberately doesn't print a token. parse_expected_semi_found_metavar_str = expected `;`, found metavariable parse_expected_semi_found_reserved_identifier_str = expected `;`, found reserved identifier `{$token}` parse_expected_semi_found_reserved_keyword_str = expected `;`, found reserved keyword `{$token}` parse_expected_semi_found_str = expected `;`, found `{$token}` parse_expected_statement_after_outer_attr = expected statement after outer attribute parse_expected_struct_field = expected one of `,`, `:`, or `{"}"}`, found `{$token}` .label = expected one of `,`, `:`, or `{"}"}` .ident_label = while parsing this struct field parse_expected_trait_in_trait_impl_found_type = expected a trait, found type parse_expr_rarrow_call = `->` is not valid syntax for field accesses and method calls .suggestion = try using `.` instead .help = the `.` operator will automatically dereference the value, except if the value is a raw pointer parse_extern_crate_name_with_dashes = crate name using dashes are not valid in `extern crate` statements .label = dash-separated idents are not valid .suggestion = if the original crate name uses dashes you need to use underscores in the code parse_extern_item_cannot_be_const = extern items cannot be `const` .suggestion = try using a static value .note = for more information, visit https://doc.rust-lang.org/std/keyword.extern.html parse_extra_if_in_let_else = remove the `if` if you meant to write a `let...else` statement parse_extra_impl_keyword_in_trait_impl = unexpected `impl` keyword .suggestion = remove the extra `impl` .note = this is parsed as an `impl Trait` type, but a trait is expected at this position parse_field_expression_with_generic = field expressions cannot have generic arguments parse_float_literal_requires_integer_part = float literals must have an integer part .suggestion = must have an integer part parse_float_literal_unsupported_base = {$base} float literal is not supported parse_fn_pointer_cannot_be_async = an `fn` pointer type cannot be `async` .label = `async` because of this .suggestion = remove the `async` qualifier parse_fn_pointer_cannot_be_const = an `fn` pointer type cannot be `const` .label = `const` because of this .suggestion = remove the `const` qualifier parse_fn_ptr_with_generics = function pointer types may not have generic parameters .suggestion = consider moving the lifetime {$arity -> [one] parameter *[other] parameters } to {$for_param_list_exists -> [true] the *[false] a } `for` parameter list parse_fn_trait_missing_paren = `Fn` bounds require arguments in parentheses .add_paren = add the missing parentheses parse_forgot_paren = perhaps you forgot parentheses? parse_found_expr_would_be_stmt = expected expression, found `{$token}` .label = expected expression parse_frontmatter_extra_characters_after_close = extra characters after frontmatter close are not allowed parse_frontmatter_invalid_close_preceding_whitespace = invalid preceding whitespace for frontmatter close .note = frontmatter close should not be preceded by whitespace parse_frontmatter_invalid_infostring = invalid infostring for frontmatter .note = frontmatter infostrings must be a single identifier immediately following the opening parse_frontmatter_invalid_opening_preceding_whitespace = invalid preceding whitespace for frontmatter opening .note = frontmatter opening should not be preceded by whitespace parse_frontmatter_length_mismatch = frontmatter close does not match the opening .label_opening = the opening here has {$len_opening} dashes... .label_close = ...while the close has {$len_close} dashes parse_frontmatter_unclosed = unclosed frontmatter .note = frontmatter opening here was not closed parse_function_body_equals_expr = function body cannot be `= expression;` .suggestion = surround the expression with `{"{"}` and `{"}"}` instead of `=` and `;` parse_generic_args_in_pat_require_turbofish_syntax = generic args in patterns require the turbofish syntax parse_generic_parameters_without_angle_brackets = generic parameters without surrounding angle brackets .suggestion = surround the type parameters with angle brackets parse_generics_in_path = unexpected generic arguments in path parse_help_set_edition_cargo = set `edition = "{$edition}"` in `Cargo.toml` parse_help_set_edition_standalone = pass `--edition {$edition}` to `rustc` parse_if_expression_missing_condition = missing condition for `if` expression .condition_label = expected condition here .block_label = if this block is the condition of the `if` expression, then it must be followed by another block parse_if_expression_missing_then_block = this `if` expression is missing a block after the condition .add_then_block = add a block here .condition_possibly_unfinished = this binary operation is possibly unfinished parse_in_in_typo = expected iterable, found keyword `in` .suggestion = remove the duplicated `in` parse_inappropriate_default = {$article} {$descr} cannot be `default` .label = `default` because of this .note = only associated `fn`, `const`, and `type` items can be `default` parse_inclusive_range_extra_equals = unexpected `=` after inclusive range .suggestion_remove_eq = use `..=` instead .note = inclusive ranges end with a single equals sign (`..=`) parse_inclusive_range_match_arrow = unexpected `>` after inclusive range .label = this is parsed as an inclusive range `..=` .suggestion = add a space between the pattern and `=>` parse_inclusive_range_no_end = inclusive range with no end .suggestion_open_range = use `..` instead .note = inclusive ranges must be bounded at the end (`..=b` or `a..=b`) parse_incorrect_parens_trait_bounds = incorrect parentheses around trait bounds parse_incorrect_parens_trait_bounds_sugg = fix the parentheses parse_incorrect_semicolon = expected item, found `;` .suggestion = remove this semicolon .help = {$name} declarations are not followed by a semicolon parse_incorrect_type_on_self = type not allowed for shorthand `self` parameter .suggestion = move the modifiers on `self` to the type parse_incorrect_use_of_await = incorrect use of `await` .parentheses_suggestion = `await` is not a method call, remove the parentheses parse_incorrect_use_of_await_postfix_suggestion = `await` is a postfix operation parse_incorrect_use_of_use = incorrect use of `use` .parentheses_suggestion = `use` is not a method call, try removing the parentheses parse_incorrect_visibility_restriction = incorrect visibility restriction .help = some possible visibility restrictions are: `pub(crate)`: visible only on the current crate `pub(super)`: visible only in the current module's parent `pub(in path::to::module)`: visible only on the specified path .suggestion = make this visible only to module `{$inner_str}` with `in` parse_inner_attr_explanation = inner attributes, like `#![no_std]`, annotate the item enclosing them, and are usually found at the beginning of source files parse_inner_attr_not_permitted = an inner attribute is not permitted in this context .label_does_not_annotate_this = {parse_label_inner_attr_does_not_annotate_this} .sugg_change_inner_to_outer = {parse_sugg_change_inner_attr_to_outer} parse_inner_attr_not_permitted_after_outer_attr = an inner attribute is not permitted following an outer attribute .label_attr = not permitted following an outer attribute .label_prev_attr = previous outer attribute .label_does_not_annotate_this = {parse_label_inner_attr_does_not_annotate_this} .sugg_change_inner_to_outer = {parse_sugg_change_inner_attr_to_outer} parse_inner_attr_not_permitted_after_outer_doc_comment = an inner attribute is not permitted following an outer doc comment .label_attr = not permitted following an outer doc comment .label_prev_doc_comment = previous doc comment .label_does_not_annotate_this = {parse_label_inner_attr_does_not_annotate_this} .sugg_change_inner_to_outer = {parse_sugg_change_inner_attr_to_outer} parse_inner_doc_comment_not_permitted = expected outer doc comment .note = inner doc comments like this (starting with `//!` or `/*!`) can only appear before items .suggestion = you might have meant to write a regular comment .label_does_not_annotate_this = the inner doc comment doesn't annotate this {$item} .sugg_change_inner_to_outer = to annotate the {$item}, change the doc comment from inner to outer style parse_invalid_attr_unsafe = `{$name}` is not an unsafe attribute .label = this is not an unsafe attribute .suggestion = remove the `unsafe(...)` .note = extraneous unsafe is not allowed in attributes parse_invalid_block_macro_segment = cannot use a `block` macro fragment here .label = the `block` fragment is within this context .suggestion = wrap this in another block parse_invalid_char_in_escape = {parse_invalid_char_in_escape_msg}: `{$ch}` .label = {parse_invalid_char_in_escape_msg} parse_invalid_char_in_escape_msg = invalid character in {$is_hex -> [true] numeric character *[false] unicode } escape parse_invalid_comparison_operator = invalid comparison operator `{$invalid}` .use_instead = `{$invalid}` is not a valid comparison operator, use `{$correct}` .spaceship_operator_invalid = `<=>` is not a valid comparison operator, use `std::cmp::Ordering` parse_invalid_curly_in_let_else = right curly brace `{"}"}` before `else` in a `let...else` statement not allowed parse_invalid_digit_literal = invalid digit for a base {$base} literal parse_invalid_dyn_keyword = invalid `dyn` keyword .help = `dyn` is only needed at the start of a trait `+`-separated list .suggestion = remove this keyword parse_invalid_expression_in_let_else = a `{$operator}` expression cannot be directly assigned in `let...else` parse_invalid_identifier_with_leading_number = identifiers cannot start with a number parse_invalid_label = invalid label name `{$name}` parse_invalid_literal_suffix_on_tuple_index = suffixes on a tuple index are invalid .label = invalid suffix `{$suffix}` .tuple_exception_line_1 = `{$suffix}` is *temporarily* accepted on tuple index fields as it was incorrectly accepted on stable for a few releases .tuple_exception_line_2 = on proc macros, you'll want to use `syn::Index::from` or `proc_macro::Literal::*_unsuffixed` for code that will desugar to tuple field access .tuple_exception_line_3 = see issue #60210 for more information parse_invalid_logical_operator = `{$incorrect}` is not a logical operator .note = unlike in e.g., Python and PHP, `&&` and `||` are used for logical operators .use_amp_amp_for_conjunction = use `&&` to perform logical conjunction .use_pipe_pipe_for_disjunction = use `||` to perform logical disjunction parse_invalid_meta_item = expected unsuffixed literal, found {$descr} .quote_ident_sugg = surround the identifier with quotation marks to make it into a string literal parse_invalid_offset_of = offset_of expects dot-separated field and variant names parse_invalid_path_sep_in_fn_definition = invalid path separator in function definition .suggestion = remove invalid path separator parse_invalid_unicode_escape = invalid unicode character escape .label = invalid escape .help = unicode escape must {$surrogate -> [true] not be a surrogate *[false] be at most 10FFFF } parse_invalid_variable_declaration = invalid variable declaration parse_keyword_lifetime = lifetimes cannot use keyword names parse_kw_bad_case = keyword `{$kw}` is written in the wrong case .suggestion = write it in the correct case parse_label_inner_attr_does_not_annotate_this = the inner attribute doesn't annotate this {$item} parse_label_unexpected_token = unexpected token parse_label_while_parsing_or_pattern_here = while parsing this or-pattern starting here parse_labeled_loop_in_break = parentheses are required around this expression to avoid confusion with a labeled break expression parse_leading_plus_not_supported = leading `+` is not supported .label = unexpected `+` .suggestion_remove_plus = try removing the `+` parse_leading_underscore_unicode_escape = {parse_leading_underscore_unicode_escape_label}: `_` parse_leading_underscore_unicode_escape_label = invalid start of unicode escape parse_left_arrow_operator = unexpected token: `<-` .suggestion = if you meant to write a comparison against a negative value, add a space in between `<` and `-` parse_lifetime_after_mut = lifetime must precede `mut` .suggestion = place the lifetime before `mut` parse_lifetime_in_borrow_expression = borrow expressions cannot be annotated with lifetimes .suggestion = remove the lifetime annotation .label = annotated with lifetime here parse_lifetime_in_eq_constraint = lifetimes are not permitted in this context .label = lifetime is not allowed here .context_label = this introduces an associated item binding .help = if you meant to specify a trait object, write `dyn /* Trait */ + {$lifetime}` .colon_sugg = you might have meant to write a bound here parse_lone_slash = invalid trailing slash in literal .label = {parse_lone_slash} parse_loop_else = `{$loop_kind}...else` loops are not supported .note = consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run .loop_keyword = `else` is attached to this loop parse_macro_expands_to_adt_field = macros cannot expand to {$adt_ty} fields parse_macro_expands_to_enum_variant = macros cannot expand to enum variants parse_macro_invocation_visibility = can't qualify macro invocation with `pub` .suggestion = remove the visibility .help = try adjusting the macro to put `{$vis}` inside the invocation parse_macro_invocation_with_qualified_path = macros cannot use qualified paths parse_macro_name_remove_bang = macro names aren't followed by a `!` .suggestion = remove the `!` parse_macro_rules_missing_bang = expected `!` after `macro_rules` .suggestion = add a `!` parse_macro_rules_visibility = can't qualify macro_rules invocation with `{$vis}` .suggestion = try exporting the macro parse_malformed_cfg_attr = malformed `cfg_attr` attribute input .suggestion = missing condition and attribute .note = for more information, visit parse_malformed_loop_label = malformed loop label .suggestion = use the correct loop label format parse_match_arm_body_without_braces = `match` arm body without braces .label_statements = {$num_statements -> [one] this statement is not surrounded by a body *[other] these statements are not surrounded by a body } .label_arrow = while parsing the `match` arm starting here .suggestion_add_braces = surround the {$num_statements -> [one] statement *[other] statements } with a body .suggestion_use_comma_not_semicolon = replace `;` with `,` to end a `match` arm expression parse_maybe_comparison = you might have meant to compare for equality parse_maybe_fn_typo_with_impl = you might have meant to write `impl` instead of `fn` .suggestion = replace `fn` with `impl` here parse_maybe_missing_let = you might have meant to continue the let-chain parse_maybe_recover_from_bad_qpath_stage_2 = missing angle brackets in associated item path .suggestion = types that don't start with an identifier need to be surrounded with angle brackets in qualified paths parse_maybe_recover_from_bad_type_plus = expected a path on the left-hand side of `+` parse_maybe_report_ambiguous_plus = ambiguous `+` in a type .suggestion = use parentheses to disambiguate parse_meta_bad_delim = wrong meta list delimiters parse_meta_bad_delim_suggestion = the delimiters should be `(` and `)` parse_mismatched_closing_delimiter = mismatched closing delimiter: `{$delimiter}` .label_unmatched = mismatched closing delimiter .label_opening_candidate = closing delimiter possibly meant for this .label_unclosed = unclosed delimiter parse_misplaced_return_type = place the return type after the function parameters parse_missing_comma_after_match_arm = expected `,` following `match` arm .suggestion = missing a comma here to end this `match` arm parse_missing_const_type = missing type for `{$kind}` item .suggestion = provide a type for the item parse_missing_enum_for_enum_definition = missing `enum` for enum definition .suggestion = add `enum` here to parse `{$ident}` as an enum parse_missing_enum_or_struct_for_item_definition = missing `enum` or `struct` for enum or struct definition parse_missing_expression_in_for_loop = missing expression to iterate on in `for` loop .suggestion = try adding an expression to the `for` loop parse_missing_fn_for_function_definition = missing `fn` for function definition .suggestion = add `fn` here to parse `{$ident}` as a function parse_missing_fn_for_method_definition = missing `fn` for method definition .suggestion = add `fn` here to parse `{$ident}` as a method parse_missing_fn_or_struct_for_item_definition = missing `fn` or `struct` for function or struct definition .suggestion = if you meant to call a macro, try .help = if you meant to call a macro, remove the `pub` and add a trailing `!` after the identifier parse_missing_fn_params = missing parameters for function definition .suggestion = add a parameter list parse_missing_for_in_trait_impl = missing `for` in a trait impl .suggestion = add `for` here parse_missing_in_in_for_loop = missing `in` in `for` loop .use_in_not_of = try using `in` here instead .add_in = try adding `in` here parse_missing_let_before_mut = missing keyword parse_missing_plus_in_bounds = expected `+` between lifetime and {$sym} .suggestion = add `+` parse_missing_semicolon_before_array = expected `;`, found `[` .suggestion = consider adding `;` here parse_missing_struct_for_struct_definition = missing `struct` for struct definition .suggestion = add `struct` here to parse `{$ident}` as a struct parse_missing_trait_in_trait_impl = missing trait in a trait impl .suggestion_add_trait = add a trait here .suggestion_remove_for = for an inherent impl, drop this `for` parse_misspelled_kw = {$is_incorrect_case -> [true] write keyword `{$similar_kw}` in lowercase *[false] there is a keyword `{$similar_kw}` with a similar name } parse_modifier_lifetime = `{$modifier}` may only modify trait bounds, not lifetime bounds .suggestion = remove the `{$modifier}` parse_modifiers_and_polarity = `{$modifiers_concatenated}` trait not allowed with `{$polarity}` trait polarity modifier .label = there is not a well-defined meaning for a `{$modifiers_concatenated} {$polarity}` trait parse_more_than_one_char = character literal may only contain one codepoint .followed_by = this `{$chr}` is followed by the combining {$len -> [one] mark *[other] marks } `{$escaped_marks}` .non_printing = there are non-printing characters, the full sequence is `{$escaped}` .consider_normalized = consider using the normalized form `{$ch}` of this character .remove_non = consider removing the non-printing characters .use_double_quotes = if you meant to write a {$is_byte -> [true] byte string *[false] string } literal, use double quotes parse_multiple_skipped_lines = multiple lines skipped by escaped newline .label = skipping everything up to and including this point parse_multiple_where_clauses = cannot define duplicate `where` clauses on an item .label = previous `where` clause starts here .suggestion = consider joining the two `where` clauses into one parse_mut_on_nested_ident_pattern = `mut` must be attached to each individual binding .suggestion = add `mut` to each binding parse_mut_on_non_ident_pattern = `mut` must be followed by a named binding .suggestion = remove the `mut` prefix parse_need_plus_after_trait_object_lifetime = lifetimes must be followed by `+` to form a trait object type .suggestion = consider adding a trait bound after the potential lifetime bound parse_nested_adt = `{$kw_str}` definition cannot be nested inside `{$keyword}` .suggestion = consider creating a new `{$kw_str}` definition instead of nesting parse_nested_c_variadic_type = C-variadic type `...` may not be nested inside another type parse_no_brace_unicode_escape = incorrect unicode escape sequence .label = {parse_no_brace_unicode_escape} .use_braces = format of unicode escape sequences uses braces .format_of_unicode = format of unicode escape sequences is `\u{"{...}"}` parse_no_digits_literal = no valid digits found for number parse_non_string_abi_literal = non-string ABI literal .suggestion = specify the ABI with a string literal parse_nonterminal_expected_ident = expected ident, found `{$token}` parse_nonterminal_expected_item_keyword = expected an item keyword parse_nonterminal_expected_lifetime = expected a lifetime, found `{$token}` parse_nonterminal_expected_statement = expected a statement parse_note_edition_guide = for more on editions, read https://doc.rust-lang.org/edition-guide parse_note_mut_pattern_usage = `mut` may be followed by `variable` and `variable @ pattern` parse_note_pattern_alternatives_use_single_vert = alternatives in or-patterns are separated with `|`, not `||` parse_nul_in_c_str = null characters in C string literals are not supported parse_or_in_let_chain = `||` operators are not supported in let chain conditions parse_or_pattern_not_allowed_in_fn_parameters = top-level or-patterns are not allowed in function parameters parse_or_pattern_not_allowed_in_let_binding = top-level or-patterns are not allowed in `let` bindings parse_out_of_range_hex_escape = out of range hex escape .label = must be a character in the range [\x00-\x7f] parse_outer_attr_explanation = outer attributes, like `#[test]`, annotate the item following them parse_outer_attribute_not_allowed_on_if_else = outer attributes are not allowed on `if` and `else` branches .branch_label = the attributes are attached to this branch .ctx_label = the branch belongs to this `{$ctx}` .suggestion = remove the attributes parse_overlong_unicode_escape = overlong unicode escape .label = must have at most 6 hex digits parse_parentheses_with_struct_fields = invalid `struct` delimiters or `fn` call arguments .suggestion_braces_for_struct = if `{$type}` is a struct, use braces as delimiters .suggestion_no_fields_for_fn = if `{$type}` is a function, use the arguments directly parse_parenthesized_lifetime = parenthesized lifetime bounds are not supported parse_parenthesized_lifetime_suggestion = remove the parentheses parse_path_double_colon = path separator must be a double colon .suggestion = use a double colon instead parse_path_found_attribute_in_params = `Trait(...)` syntax does not support attributes in parameters .suggestion = remove the attributes parse_path_found_c_variadic_params = `Trait(...)` syntax does not support c_variadic parameters .suggestion = remove the `...` parse_path_found_named_params = `Trait(...)` syntax does not support named parameters .suggestion = remove the parameter name parse_pattern_method_param_without_body = patterns aren't allowed in methods without bodies .suggestion = give this argument a name or use an underscore to ignore it parse_pattern_on_wrong_side_of_at = pattern on wrong side of `@` .label_pattern = pattern on the left, should be on the right .label_binding = binding on the right, should be on the left .suggestion = switch the order parse_question_mark_in_type = invalid `?` in type .label = `?` is only allowed on expressions, not types .suggestion = if you meant to express that the type might not contain a value, use the `Option` wrapper type parse_recover_import_as_use = expected item, found {$token_name} .suggestion = items are imported using the `use` keyword parse_remove_let = expected pattern, found `let` .suggestion = remove the unnecessary `let` keyword parse_repeated_mut_in_pattern = `mut` on a binding may not be repeated .suggestion = remove the additional `mut`s parse_require_colon_after_labeled_expression = labeled expression must be followed by `:` .note = labels are used before loops and blocks, allowing e.g., `break 'label` to them .label = the label .suggestion = add `:` after the label parse_reserved_multihash = reserved multi-hash token is forbidden .note = sequences of two or more # are reserved for future use since Rust 2024 .suggestion_whitespace = consider inserting whitespace here parse_reserved_string = invalid string literal .note = unprefixed guarded string literals are reserved for future use since Rust 2024 .suggestion_whitespace = consider inserting whitespace here parse_return_types_use_thin_arrow = return types are denoted using `->` .suggestion = use `->` instead parse_self_argument_pointer = cannot pass `self` by raw pointer .label = cannot pass `self` by raw pointer parse_self_param_not_first = unexpected `self` parameter in function .label = must be the first parameter of an associated function parse_shift_interpreted_as_generic = `<<` is interpreted as a start of generic arguments for `{$type}`, not a shift .label_args = interpreted as generic arguments .label_comparison = not interpreted as shift .suggestion = try shifting the cast value parse_single_colon_import_path = expected `::`, found `:` .suggestion = use double colon .note = import paths are delimited using `::` parse_static_with_generics = static items may not have generic parameters parse_struct_literal_body_without_path = struct literal body without path .suggestion = you might have forgotten to add the struct literal inside the block parse_struct_literal_not_allowed_here = struct literals are not allowed here .suggestion = surround the struct literal with parentheses parse_suffixed_literal_in_attribute = suffixed literals are not allowed in attributes .help = instead of using a suffixed literal (`1u8`, `1.0f32`, etc.), use an unsuffixed version (`1`, `1.0`, etc.) parse_sugg_add_let_for_stmt = you might have meant to introduce a new binding parse_sugg_add_semi = add `;` here parse_sugg_change_inner_attr_to_outer = to annotate the {$item}, change the attribute from inner to outer style parse_sugg_change_this_to_semi = change this to `;` parse_sugg_escape_identifier = escape `{$ident_name}` to use it as an identifier parse_sugg_remove_comma = remove this comma parse_sugg_remove_leading_vert_in_pattern = remove the `|` parse_sugg_turbofish_syntax = use `::<...>` instead of `<...>` to specify lifetime, type, or const arguments parse_sugg_wrap_expression_in_parentheses = wrap the expression in parentheses parse_sugg_wrap_macro_in_parentheses = use parentheses instead of braces for this macro parse_sugg_wrap_pattern_in_parens = wrap the pattern in parentheses parse_switch_mut_let_order = switch the order of `mut` and `let` parse_switch_ref_box_order = switch the order of `ref` and `box` .suggestion = swap them parse_ternary_operator = Rust has no ternary operator .help = use an `if-else` expression instead parse_tilde_is_not_unary_operator = `~` cannot be used as a unary operator .suggestion = use `!` to perform bitwise not parse_too_many_hashes = too many `#` symbols: raw strings may be delimited by up to 255 `#` symbols, but found {$num} parse_too_short_hex_escape = numeric character escape is too short parse_trailing_vert_not_allowed = a trailing `|` is not allowed in an or-pattern .suggestion = remove the `{$token}` parse_trait_alias_cannot_be_auto = trait aliases cannot be `auto` parse_trait_alias_cannot_be_unsafe = trait aliases cannot be `unsafe` parse_transpose_dyn_or_impl = `for<...>` expected after `{$kw}`, not before .suggestion = move `{$kw}` before the `for<...>` parse_unclosed_unicode_escape = unterminated unicode escape .label = missing a closing `{"}"}` .terminate = terminate the unicode escape parse_underscore_literal_suffix = underscore literal suffix is not allowed parse_unexpected_const_in_generic_param = expected lifetime, type, or constant, found keyword `const` .suggestion = the `const` keyword is only needed in the definition of the type parse_unexpected_const_param_declaration = unexpected `const` parameter declaration .label = expected a `const` expression, not a parameter declaration .suggestion = `const` parameters must be declared for the `impl` parse_unexpected_default_value_for_lifetime_in_generic_parameters = unexpected default lifetime parameter .label = lifetime parameters cannot have default values parse_unexpected_expr_in_pat = expected {$is_bound -> [true] a pattern range bound *[false] a pattern }, found an expression .label = not a pattern .note = arbitrary expressions are not allowed in patterns: parse_unexpected_expr_in_pat_const_sugg = consider extracting the expression into a `const` parse_unexpected_expr_in_pat_create_guard_sugg = consider moving the expression to a match arm guard parse_unexpected_expr_in_pat_update_guard_sugg = consider moving the expression to the match arm guard parse_unexpected_if_with_if = unexpected `if` in the condition expression .suggestion = remove the `if` parse_unexpected_lifetime_in_pattern = unexpected lifetime `{$symbol}` in pattern .suggestion = remove the lifetime parse_unexpected_paren_in_range_pat = range pattern bounds cannot have parentheses parse_unexpected_paren_in_range_pat_sugg = remove these parentheses parse_unexpected_parentheses_in_for_head = unexpected parentheses surrounding `for` loop head .suggestion = remove parentheses in `for` loop parse_unexpected_parentheses_in_match_arm_pattern = unexpected parentheses surrounding `match` arm pattern .suggestion = remove parentheses surrounding the pattern parse_unexpected_self_in_generic_parameters = unexpected keyword `Self` in generic parameters .note = you cannot use `Self` as a generic parameter because it is reserved for associated items parse_unexpected_token_after_dot = unexpected token: {$actual} parse_unexpected_token_after_label = expected `while`, `for`, `loop` or `{"{"}` after a label .suggestion_remove_label = consider removing the label .suggestion_enclose_in_block = consider enclosing expression in a block parse_unexpected_token_after_not = unexpected {$negated_desc} after identifier parse_unexpected_token_after_not_bitwise = use `!` to perform bitwise not parse_unexpected_token_after_not_default = use `!` to perform logical negation or bitwise not parse_unexpected_token_after_not_logical = use `!` to perform logical negation parse_unexpected_token_after_struct_name = expected `where`, `{"{"}`, `(`, or `;` after struct name parse_unexpected_token_after_struct_name_found_doc_comment = expected `where`, `{"{"}`, `(`, or `;` after struct name, found doc comment `{$token}` parse_unexpected_token_after_struct_name_found_keyword = expected `where`, `{"{"}`, `(`, or `;` after struct name, found keyword `{$token}` # This one deliberately doesn't print a token. parse_unexpected_token_after_struct_name_found_metavar = expected `where`, `{"{"}`, `(`, or `;` after struct name, found metavar parse_unexpected_token_after_struct_name_found_other = expected `where`, `{"{"}`, `(`, or `;` after struct name, found `{$token}` parse_unexpected_token_after_struct_name_found_reserved_identifier = expected `where`, `{"{"}`, `(`, or `;` after struct name, found reserved identifier `{$token}` parse_unexpected_token_after_struct_name_found_reserved_keyword = expected `where`, `{"{"}`, `(`, or `;` after struct name, found reserved keyword `{$token}` parse_unexpected_vert_vert_before_function_parameter = unexpected `||` before function parameter .suggestion = remove the `||` parse_unexpected_vert_vert_in_pattern = unexpected token `||` in pattern .suggestion = use a single `|` to separate multiple alternative patterns parse_unicode_escape_in_byte = unicode escape in byte string .label = {parse_unicode_escape_in_byte} .help = unicode escape sequences cannot be used as a byte or in a byte string parse_unknown_builtin_construct = unknown `builtin #` construct `{$name}` parse_unknown_prefix = prefix `{$prefix}` is unknown .label = unknown prefix .note = prefixed identifiers and literals are reserved since Rust 2021 .suggestion_br = use `br` for a raw byte string .suggestion_cr = use `cr` for a raw C-string .suggestion_str = if you meant to write a string literal, use double quotes .suggestion_whitespace = consider inserting whitespace here parse_unknown_start_of_token = unknown start of token: {$escaped} .sugg_quotes = Unicode characters '“' (Left Double Quotation Mark) and '”' (Right Double Quotation Mark) look like '{$ascii_str}' ({$ascii_name}), but are not .sugg_other = Unicode character '{$ch}' ({$u_name}) looks like '{$ascii_str}' ({$ascii_name}), but it is not .help_null = source files must contain UTF-8 encoded text, unexpected null bytes might occur when a different encoding is used .note_repeats = character appears {$repeats -> [one] once more *[other] {$repeats} more times } parse_unmatched_angle = unmatched angle {$plural -> [true] brackets *[false] bracket } .suggestion = remove extra angle {$plural -> [true] brackets *[false] bracket } parse_unmatched_angle_brackets = {$num_extra_brackets -> [one] unmatched angle bracket *[other] unmatched angle brackets } .suggestion = {$num_extra_brackets -> [one] remove extra angle bracket *[other] remove extra angle brackets } parse_unsafe_attr_outside_unsafe = unsafe attribute used without unsafe .label = usage of unsafe attribute parse_unsafe_attr_outside_unsafe_suggestion = wrap the attribute in `unsafe(...)` parse_unskipped_whitespace = whitespace symbol '{$ch}' is not skipped .label = {parse_unskipped_whitespace} parse_use_empty_block_not_semi = expected { "`{}`" }, found `;` .suggestion = try using { "`{}`" } instead parse_use_eq_instead = unexpected `==` .suggestion = try using `=` instead parse_use_let_not_auto = write `let` instead of `auto` to introduce a new variable parse_use_let_not_var = write `let` instead of `var` to introduce a new variable parse_visibility_not_followed_by_item = visibility `{$vis}` is not followed by an item .label = the visibility .help = you likely meant to define an item, e.g., `{$vis} fn foo() {"{}"}` parse_where_clause_before_const_body = where clauses are not allowed before const item bodies .label = unexpected where clause .name_label = while parsing this const item .body_label = the item body .suggestion = move the body before the where clause parse_where_clause_before_tuple_struct_body = where clauses are not allowed before tuple struct bodies .label = unexpected where clause .name_label = while parsing this tuple struct .body_label = the struct body .suggestion = move the body before the where clause parse_where_generics = generic parameters on `where` clauses are reserved for future use .label = currently unsupported parse_zero_chars = empty character literal .label = {parse_zero_chars} -passes_previously_accepted = this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! -passes_see_issue = see issue #{$issue} for more information passes_abi_invalid_attribute = `#[rustc_abi]` can only be applied to function items, type aliases, and associated functions passes_abi_ne = ABIs are not compatible left ABI = {$left} right ABI = {$right} passes_abi_of = fn_abi_of({$fn_name}) = {$fn_abi} passes_allow_incoherent_impl = `rustc_allow_incoherent_impl` attribute should be applied to impl items .label = the only currently supported targets are inherent methods passes_allow_internal_unstable = attribute should be applied to a macro .label = not a macro passes_attr_application_enum = attribute should be applied to an enum .label = not an enum passes_attr_application_struct = attribute should be applied to a struct .label = not a struct passes_attr_application_struct_enum_function_method_union = attribute should be applied to a struct, enum, function, associated function, or union .label = not a struct, enum, function, associated function, or union passes_attr_application_struct_enum_union = attribute should be applied to a struct, enum, or union .label = not a struct, enum, or union passes_attr_application_struct_union = attribute should be applied to a struct or union .label = not a struct or union passes_attr_crate_level = this attribute can only be applied at the crate level .suggestion = to apply to the crate, use an inner attribute .note = read for more information passes_attr_only_in_functions = `{$attr}` attribute can only be used on functions passes_autodiff_attr = `#[autodiff]` should be applied to a function .label = not a function passes_both_ffi_const_and_pure = `#[ffi_const]` function cannot be `#[ffi_pure]` passes_break_inside_closure = `{$name}` inside of a closure .label = cannot `{$name}` inside of a closure .closure_label = enclosing closure passes_break_inside_coroutine = `{$name}` inside `{$kind}` {$source} .label = cannot `{$name}` inside `{$kind}` {$source} .coroutine_label = enclosing `{$kind}` {$source} passes_break_non_loop = `break` with value from a `{$kind}` loop .label = can only break with a value inside `loop` or breakable block .label2 = you can't `break` with a value in a `{$kind}` loop .suggestion = use `break` on its own without a value inside this `{$kind}` loop .break_expr_suggestion = alternatively, you might have meant to use the available loop label passes_cannot_stabilize_deprecated = an API can't be stabilized after it is deprecated .label = invalid version .item = the stability attribute annotates this item passes_change_fields_to_be_of_unit_type = consider changing the { $num -> [one] field *[other] fields } to be of unit type to suppress this warning while preserving the field numbering, or remove the { $num -> [one] field *[other] fields } passes_cold = {passes_should_be_applied_to_fn} .warn = {-passes_previously_accepted} .label = {passes_should_be_applied_to_fn.label} passes_collapse_debuginfo = `collapse_debuginfo` attribute should be applied to macro definitions .label = not a macro definition passes_confusables = attribute should be applied to an inherent method .label = not an inherent method passes_const_stable_not_stable = attribute `#[rustc_const_stable]` can only be applied to functions that are declared `#[stable]` .label = attribute specified here passes_continue_labeled_block = `continue` pointing to a labeled block .label = labeled blocks cannot be `continue`'d .block_label = labeled block the `continue` points to passes_coroutine_on_non_closure = attribute should be applied to closures .label = not a closure passes_coverage_attribute_not_allowed = coverage attribute not allowed here .not_fn_impl_mod = not a function, impl block, or module .no_body = function has no body .help = coverage attribute can be applied to a function (with body), impl block, or module passes_dead_codes = { $multiple -> *[true] multiple {$descr}s are [false] { $num -> [one] {$descr} {$name_list} is *[other] {$descr}s {$name_list} are } } never {$participle} passes_debug_visualizer_invalid = invalid argument .note_1 = expected: `natvis_file = "..."` .note_2 = OR .note_3 = expected: `gdb_script_file = "..."` passes_debug_visualizer_placement = attribute should be applied to a module passes_debug_visualizer_unreadable = couldn't read {$file}: {$error} passes_deprecated = attribute is ignored here passes_deprecated_annotation_has_no_effect = this `#[deprecated]` annotation has no effect .suggestion = remove the unnecessary deprecation attribute passes_deprecated_attribute = deprecated attribute must be paired with either stable or unstable attribute passes_diagnostic_diagnostic_on_unimplemented_only_for_traits = `#[diagnostic::on_unimplemented]` can only be applied to trait definitions passes_diagnostic_item_first_defined = the diagnostic item is first defined here passes_doc_alias_bad_char = {$char_} character isn't allowed in {$attr_str} passes_doc_alias_bad_location = {$attr_str} isn't allowed on {$location} passes_doc_alias_duplicated = doc alias is duplicated .label = first defined here passes_doc_alias_empty = {$attr_str} attribute cannot have empty value passes_doc_alias_malformed = doc alias attribute expects a string `#[doc(alias = "a")]` or a list of strings `#[doc(alias("a", "b"))]` passes_doc_alias_not_an_alias = {$attr_str} is the same as the item's name passes_doc_alias_not_string_literal = `#[doc(alias("a"))]` expects string literals passes_doc_alias_start_end = {$attr_str} cannot start or end with ' ' passes_doc_attr_not_crate_level = `#![doc({$attr_name} = "...")]` isn't allowed as a crate-level attribute passes_doc_cfg_hide_takes_list = `#[doc(cfg_hide(...))]` takes a list of attributes passes_doc_expect_str = doc {$attr_name} attribute expects a string: #[doc({$attr_name} = "a")] passes_doc_fake_variadic_not_valid = `#[doc(fake_variadic)]` must be used on the first of a set of tuple or fn pointer trait impls with varying arity passes_doc_inline_conflict = conflicting doc inlining attributes .help = remove one of the conflicting attributes passes_doc_inline_conflict_first = this attribute... passes_doc_inline_conflict_second = {"."}..conflicts with this attribute passes_doc_inline_only_use = this attribute can only be applied to a `use` item .label = only applicable on `use` items .not_a_use_item_label = not a `use` item .note = read for more information passes_doc_invalid = invalid `doc` attribute passes_doc_keyword_empty_mod = `#[doc(keyword = "...")]` should be used on empty modules passes_doc_keyword_not_keyword = nonexistent keyword `{$keyword}` used in `#[doc(keyword = "...")]` .help = only existing keywords are allowed in core/std passes_doc_keyword_not_mod = `#[doc(keyword = "...")]` should be used on modules passes_doc_keyword_only_impl = `#[doc(keyword = "...")]` should be used on impl blocks passes_doc_masked_not_extern_crate_self = this attribute cannot be applied to an `extern crate self` item .label = not applicable on `extern crate self` items .extern_crate_self_label = `extern crate self` defined here passes_doc_masked_only_extern_crate = this attribute can only be applied to an `extern crate` item .label = only applicable on `extern crate` items .not_an_extern_crate_label = not an `extern crate` item .note = read for more information passes_doc_rust_logo = the `#[doc(rust_logo)]` attribute is used for Rust branding passes_doc_search_unbox_invalid = `#[doc(search_unbox)]` should be used on generic structs and enums passes_doc_test_literal = `#![doc(test(...)]` does not take a literal passes_doc_test_takes_list = `#[doc(test(...)]` takes a list of attributes passes_doc_test_unknown = unknown `doc(test)` attribute `{$path}` passes_doc_test_unknown_any = unknown `doc` attribute `{$path}` passes_doc_test_unknown_include = unknown `doc` attribute `{$path}` .suggestion = use `doc = include_str!` instead passes_doc_test_unknown_passes = unknown `doc` attribute `{$path}` .note = `doc` attribute `{$path}` no longer functions; see issue #44136 .label = no longer functions .help = you may want to use `doc(document_private_items)` .no_op_note = `doc({$path})` is now a no-op passes_doc_test_unknown_plugins = unknown `doc` attribute `{$path}` .note = `doc` attribute `{$path}` no longer functions; see issue #44136 and CVE-2018-1000622 .label = no longer functions .no_op_note = `doc({$path})` is now a no-op passes_doc_test_unknown_spotlight = unknown `doc` attribute `{$path}` .note = `doc(spotlight)` was renamed to `doc(notable_trait)` .suggestion = use `notable_trait` instead .no_op_note = `doc(spotlight)` is now a no-op passes_duplicate_diagnostic_item_in_crate = duplicate diagnostic item in crate `{$crate_name}`: `{$name}` .note = the diagnostic item is first defined in crate `{$orig_crate_name}` passes_duplicate_feature_err = the feature `{$feature}` has already been enabled passes_duplicate_lang_item = found duplicate lang item `{$lang_item_name}` .first_defined_span = the lang item is first defined here .first_defined_crate_depends = the lang item is first defined in crate `{$orig_crate_name}` (which `{$orig_dependency_of}` depends on) .first_defined_crate = the lang item is first defined in crate `{$orig_crate_name}` .first_definition_local = first definition in the local crate (`{$orig_crate_name}`) .second_definition_local = second definition in the local crate (`{$crate_name}`) .first_definition_path = first definition in `{$orig_crate_name}` loaded from {$orig_path} .second_definition_path = second definition in `{$crate_name}` loaded from {$path} passes_duplicate_lang_item_crate = duplicate lang item in crate `{$crate_name}`: `{$lang_item_name}` .first_defined_span = the lang item is first defined here .first_defined_crate_depends = the lang item is first defined in crate `{$orig_crate_name}` (which `{$orig_dependency_of}` depends on) .first_defined_crate = the lang item is first defined in crate `{$orig_crate_name}` .first_definition_local = first definition in the local crate (`{$orig_crate_name}`) .second_definition_local = second definition in the local crate (`{$crate_name}`) .first_definition_path = first definition in `{$orig_crate_name}` loaded from {$orig_path} .second_definition_path = second definition in `{$crate_name}` loaded from {$path} passes_duplicate_lang_item_crate_depends = duplicate lang item in crate `{$crate_name}` (which `{$dependency_of}` depends on): `{$lang_item_name}` .first_defined_span = the lang item is first defined here .first_defined_crate_depends = the lang item is first defined in crate `{$orig_crate_name}` (which `{$orig_dependency_of}` depends on) .first_defined_crate = the lang item is first defined in crate `{$orig_crate_name}` .first_definition_local = first definition in the local crate (`{$orig_crate_name}`) .second_definition_local = second definition in the local crate (`{$crate_name}`) .first_definition_path = first definition in `{$orig_crate_name}` loaded from {$orig_path} .second_definition_path = second definition in `{$crate_name}` loaded from {$path} passes_export_name = attribute should be applied to a free function, impl method or static .label = not a free function, impl method or static passes_extern_main = the `main` function cannot be declared in an `extern` block passes_feature_previously_declared = feature `{$feature}` is declared {$declared}, but was previously declared {$prev_declared} passes_feature_stable_twice = feature `{$feature}` is declared stable since {$since}, but was previously declared stable since {$prev_since} passes_ffi_const_invalid_target = `#[ffi_const]` may only be used on foreign functions passes_ffi_pure_invalid_target = `#[ffi_pure]` may only be used on foreign functions passes_has_incoherent_inherent_impl = `rustc_has_incoherent_inherent_impls` attribute should be applied to types or traits .label = only adts, extern types and traits are supported passes_ignored_attr = `#[{$sym}]` is ignored on struct fields and match arms .warn = {-passes_previously_accepted} .note = {-passes_see_issue(issue: "80564")} passes_ignored_attr_with_macro = `#[{$sym}]` is ignored on struct fields, match arms and macro defs .warn = {-passes_previously_accepted} .note = {-passes_see_issue(issue: "80564")} passes_ignored_derived_impls = `{$name}` has {$trait_list_len -> [one] a derived impl *[other] derived impls } for the {$trait_list_len -> [one] trait {$trait_list}, but this is *[other] traits {$trait_list}, but these are } intentionally ignored during dead code analysis passes_implied_feature_not_exist = feature `{$implied_by}` implying `{$feature}` does not exist passes_incorrect_crate_type = lang items are not allowed in stable dylibs passes_incorrect_do_not_recommend_args = `#[diagnostic::do_not_recommend]` does not expect any arguments passes_incorrect_do_not_recommend_location = `#[diagnostic::do_not_recommend]` can only be placed on trait implementations passes_incorrect_target = `{$name}` lang item must be applied to a {$kind} with {$at_least -> [true] at least {$num} *[false] {$num} } generic {$num -> [one] argument *[other] arguments } .label = this {$kind} has {$actual_num} generic {$actual_num -> [one] argument *[other] arguments } passes_ineffective_unstable_impl = an `#[unstable]` annotation here has no effect .note = see issue #55436 for more information passes_inline_ignored_constants = `#[inline]` is ignored on constants .warn = {-passes_previously_accepted} .note = {-passes_see_issue(issue: "65833")} passes_inline_ignored_for_exported = `#[inline]` is ignored on externally exported functions .help = externally exported functions are functions with `#[no_mangle]`, `#[export_name]`, or `#[linkage]` passes_inline_ignored_function_prototype = `#[inline]` is ignored on function prototypes passes_inline_not_fn_or_closure = attribute should be applied to function or closure .label = not a function or closure passes_inner_crate_level_attr = crate-level attribute should be in the root module passes_invalid_attr_at_crate_level = `{$name}` attribute cannot be used at crate level .suggestion = perhaps you meant to use an outer attribute passes_invalid_attr_at_crate_level_item = the inner attribute doesn't annotate this {$kind} passes_invalid_macro_export_arguments = invalid `#[macro_export]` argument passes_invalid_macro_export_arguments_too_many_items = `#[macro_export]` can only take 1 or 0 arguments passes_lang_item_fn = {$name -> [panic_impl] `#[panic_handler]` *[other] `{$name}` lang item } function passes_lang_item_fn_with_target_feature = {passes_lang_item_fn} is not allowed to have `#[target_feature]` .label = {passes_lang_item_fn} is not allowed to have `#[target_feature]` passes_lang_item_fn_with_track_caller = {passes_lang_item_fn} is not allowed to have `#[track_caller]` .label = {passes_lang_item_fn} is not allowed to have `#[track_caller]` passes_lang_item_on_incorrect_target = `{$name}` lang item must be applied to a {$expected_target} .label = attribute should be applied to a {$expected_target}, not a {$actual_target} passes_layout_abi = abi: {$abi} passes_layout_align = align: {$align} passes_layout_homogeneous_aggregate = homogeneous_aggregate: {$homogeneous_aggregate} passes_layout_invalid_attribute = `#[rustc_layout]` can only be applied to `struct`/`enum`/`union` declarations and type aliases passes_layout_of = layout_of({$normalized_ty}) = {$ty_layout} passes_layout_size = size: {$size} passes_link = attribute should be applied to an `extern` block with non-Rust ABI .warn = {-passes_previously_accepted} .label = not an `extern` block passes_link_name = attribute should be applied to a foreign function or static .warn = {-passes_previously_accepted} .label = not a foreign function or static .help = try `#[link(name = "{$value}")]` instead passes_link_ordinal = attribute should be applied to a foreign function or static .label = not a foreign function or static passes_link_section = attribute should be applied to a function or static .warn = {-passes_previously_accepted} .label = not a function or static passes_linkage = attribute should be applied to a function or static .label = not a function definition or static passes_macro_export = `#[macro_export]` only has an effect on macro definitions passes_macro_export_on_decl_macro = `#[macro_export]` has no effect on declarative macro definitions .note = declarative macros follow the same exporting rules as regular items passes_macro_use = `#[{$name}]` only has an effect on `extern crate` and modules passes_may_dangle = `#[may_dangle]` must be applied to a lifetime or type generic parameter in `Drop` impl passes_maybe_string_interpolation = you might have meant to use string interpolation in this string literal passes_missing_const_err = attributes `#[rustc_const_unstable]`, `#[rustc_const_stable]` and `#[rustc_const_stable_indirect]` require the function or method to be `const` .help = make the function or method const passes_missing_const_stab_attr = {$descr} has missing const stability attribute passes_missing_lang_item = lang item required, but not found: `{$name}` .note = this can occur when a binary crate with `#![no_std]` is compiled for a target where `{$name}` is defined in the standard library .help = you may be able to compile for a target that doesn't need `{$name}`, specify a target with `--target` or in `.cargo/config` passes_missing_panic_handler = `#[panic_handler]` function required, but not found passes_missing_stability_attr = {$descr} has missing stability attribute passes_multiple_rustc_main = multiple functions with a `#[rustc_main]` attribute .first = first `#[rustc_main]` function .additional = additional `#[rustc_main]` function passes_must_not_suspend = `must_not_suspend` attribute should be applied to a struct, enum, union, or trait .label = is not a struct, enum, union, or trait passes_must_use_no_effect = `#[must_use]` has no effect when applied to {$article} {$target} passes_naked_asm_outside_naked_fn = the `naked_asm!` macro can only be used in functions marked with `#[unsafe(naked)]` passes_naked_functions_asm_block = naked functions must contain a single `naked_asm!` invocation .label_multiple_asm = multiple `naked_asm!` invocations are not allowed in naked functions .label_non_asm = not allowed in naked functions passes_naked_functions_incompatible_attribute = attribute incompatible with `#[unsafe(naked)]` .label = the `{$attr}` attribute is incompatible with `#[unsafe(naked)]` .naked_attribute = function marked with `#[unsafe(naked)]` here passes_naked_functions_must_naked_asm = the `asm!` macro is not allowed in naked functions .label = consider using the `naked_asm!` macro instead passes_no_link = attribute should be applied to an `extern crate` item .label = not an `extern crate` item passes_no_main_function = `main` function not found in crate `{$crate_name}` .here_is_main = here is a function named `main` .one_or_more_possible_main = you have one or more functions named `main` not defined at the crate level .consider_moving_main = consider moving the `main` function definitions .main_must_be_defined_at_crate = the main function must be defined at the crate level{$has_filename -> [true] {" "}(in `{$filename}`) *[false] {""} } .consider_adding_main_to_file = consider adding a `main` function to `{$filename}` .consider_adding_main_at_crate = consider adding a `main` function at the crate level .teach_note = If you don't know the basics of Rust, you can go look to the Rust Book to get started: https://doc.rust-lang.org/book/ .non_function_main = non-function item at `crate::main` is found passes_no_mangle = attribute should be applied to a free function, impl method or static .warn = {-passes_previously_accepted} .label = not a free function, impl method or static passes_no_mangle_foreign = `#[no_mangle]` has no effect on a foreign {$foreign_item_kind} .warn = {-passes_previously_accepted} .label = foreign {$foreign_item_kind} .note = symbol names in extern blocks are not mangled .suggestion = remove this attribute passes_no_patterns = patterns not allowed in naked function parameters passes_no_sanitize = `#[no_sanitize({$attr_str})]` should be applied to {$accepted_kind} .label = not {$accepted_kind} passes_non_exaustive_with_default_field_values = `#[non_exhaustive]` can't be used to annotate items with default field values .label = this struct has default field values passes_non_exported_macro_invalid_attrs = attribute should be applied to function or closure .label = not a function or closure passes_object_lifetime_err = {$repr} passes_only_has_effect_on = `#[{$attr_name}]` only has an effect on {$target_name -> [function] functions [module] modules [implementation_block] implementation blocks *[unspecified] (unspecified--this is a compiler bug) } passes_optimize_invalid_target = attribute applied to an invalid target .label = invalid target passes_outer_crate_level_attr = crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]` passes_outside_loop = `{$name}` outside of a loop{$is_break -> [true] {" or labeled block"} *[false] {""} } .label = cannot `{$name}` outside of a loop{$is_break -> [true] {" or labeled block"} *[false] {""} } passes_outside_loop_suggestion = consider labeling this block to be able to break within it passes_panic_unwind_without_std = unwinding panics are not supported without std .note = since the core library is usually precompiled with panic="unwind", rebuilding your crate with panic="abort" may not be enough to fix the problem .help = using nightly cargo, use -Zbuild-std with panic="abort" to avoid unwinding passes_params_not_allowed = referencing function parameters is not allowed in naked functions .help = follow the calling convention in asm block to use parameters passes_parent_info = {$num -> [one] {$descr} *[other] {$descr}s } in this {$parent_descr} passes_pass_by_value = `pass_by_value` attribute should be applied to a struct, enum or type alias .label = is not a struct, enum or type alias passes_proc_macro_bad_sig = {$kind} has incorrect signature passes_remove_fields = consider removing { $num -> [one] this *[other] these } { $num -> [one] field *[other] fields } passes_repr_align_function = `repr(align)` attributes on functions are unstable passes_repr_align_greater_than_target_max = alignment must not be greater than `isize::MAX` bytes .note = `isize::MAX` is {$size} for the current target passes_repr_conflicting = conflicting representation hints passes_rustc_allow_const_fn_unstable = attribute should be applied to `const fn` .label = not a `const fn` passes_rustc_const_stable_indirect_pairing = `const_stable_indirect` attribute does not make sense on `rustc_const_stable` function, its behavior is already implied passes_rustc_dirty_clean = attribute requires -Z query-dep-graph to be enabled passes_rustc_force_inline = attribute should be applied to a function .label = not a function definition passes_rustc_force_inline_coro = attribute cannot be applied to a `async`, `gen` or `async gen` function .label = `async`, `gen` or `async gen` function passes_rustc_layout_scalar_valid_range_arg = expected exactly one integer literal argument passes_rustc_layout_scalar_valid_range_not_struct = attribute should be applied to a struct .label = not a struct passes_rustc_legacy_const_generics_index = #[rustc_legacy_const_generics] must have one index for each generic parameter .label = generic parameters passes_rustc_legacy_const_generics_index_exceed = index exceeds number of arguments .label = there {$arg_count -> [one] is *[other] are } only {$arg_count} {$arg_count -> [one] argument *[other] arguments } passes_rustc_legacy_const_generics_index_negative = arguments should be non-negative integers passes_rustc_legacy_const_generics_only = #[rustc_legacy_const_generics] functions must only have const generics .label = non-const generic parameter passes_rustc_lint_opt_deny_field_access = `#[rustc_lint_opt_deny_field_access]` should be applied to a field .label = not a field passes_rustc_lint_opt_ty = `#[rustc_lint_opt_ty]` should be applied to a struct .label = not a struct passes_rustc_pub_transparent = attribute should be applied to `#[repr(transparent)]` types .label = not a `#[repr(transparent)]` type passes_rustc_std_internal_symbol = attribute should be applied to functions or statics .label = not a function or static passes_should_be_applied_to_fn = attribute should be applied to a function definition .label = {$on_crate -> [true] cannot be applied to crates *[false] not a function definition } passes_should_be_applied_to_static = attribute should be applied to a static .label = not a static passes_should_be_applied_to_struct_enum = attribute should be applied to a struct or enum .label = not a struct or enum passes_should_be_applied_to_trait = attribute should be applied to a trait .label = not a trait passes_stability_promotable = attribute cannot be applied to an expression passes_string_interpolation_only_works = string interpolation only works in `format!` invocations passes_target_feature_on_statement = {passes_should_be_applied_to_fn} .warn = {-passes_previously_accepted} .label = {passes_should_be_applied_to_fn.label} passes_trait_impl_const_stability_mismatch = const stability on the impl does not match the const stability on the trait passes_trait_impl_const_stability_mismatch_impl_stable = this impl is (implicitly) stable... passes_trait_impl_const_stability_mismatch_impl_unstable = this impl is unstable... passes_trait_impl_const_stability_mismatch_trait_stable = ...but the trait is stable passes_trait_impl_const_stability_mismatch_trait_unstable = ...but the trait is unstable passes_trait_impl_const_stable = trait implementations cannot be const stable yet .note = see issue #67792 for more information passes_transparent_incompatible = transparent {$target} cannot have other repr hints passes_unexportable_adt_with_private_fields = ADT types with private fields are not exportable .note = `{$field_name}` is private passes_unexportable_fn_abi = only functions with "C" ABI are exportable passes_unexportable_generic_fn = generic functions are not exportable passes_unexportable_item = {$descr}'s are not exportable passes_unexportable_priv_item = private items are not exportable .note = is only usable at visibility `{$vis_descr}` passes_unexportable_type_in_interface = {$desc} with `#[export_stable]` attribute uses type `{$ty}`, which is not exportable .label = not exportable passes_unexportable_type_repr = types with unstable layout are not exportable passes_unknown_external_lang_item = unknown external lang item: `{$lang_item}` passes_unknown_feature = unknown feature `{$feature}` passes_unknown_lang_item = definition of an unknown lang item: `{$name}` .label = definition of unknown lang item `{$name}` passes_unlabeled_cf_in_while_condition = `break` or `continue` with no label in the condition of a `while` loop .label = unlabeled `{$cf_type}` in the condition of a `while` loop passes_unlabeled_in_labeled_block = unlabeled `{$cf_type}` inside of a labeled block .label = `{$cf_type}` statements that would diverge to or through a labeled block need to bear a label passes_unnecessary_partial_stable_feature = the feature `{$feature}` has been partially stabilized since {$since} and is succeeded by the feature `{$implies}` .suggestion = if you are using features which are still unstable, change to using `{$implies}` .suggestion_remove = if you are using features which are now stable, remove this line passes_unnecessary_stable_feature = the feature `{$feature}` has been stable since {$since} and no longer requires an attribute to enable passes_unreachable_due_to_uninhabited = unreachable {$descr} .label = unreachable {$descr} .label_orig = any code following this expression is unreachable .note = this expression has type `{$ty}`, which is uninhabited passes_unrecognized_argument = unrecognized argument passes_unstable_attr_for_already_stable_feature = can't mark as unstable using an already stable feature .label = this feature is already stable .item = the stability attribute annotates this item .help = consider removing the attribute passes_unsupported_attributes_in_where = most attributes are not supported in `where` clauses .help = only `#[cfg]` and `#[cfg_attr]` are supported passes_unused = unused attribute .suggestion = remove this attribute passes_unused_assign = value assigned to `{$name}` is never read .help = maybe it is overwritten before being read? passes_unused_assign_passed = value passed to `{$name}` is never read .help = maybe it is overwritten before being read? passes_unused_assign_suggestion = you might have meant to mutate the pointed at value being passed in, instead of changing the reference in the local binding passes_unused_capture_maybe_capture_ref = value captured by `{$name}` is never read .help = did you mean to capture by reference instead? passes_unused_default_method_body_const_note = `default_method_body_is_const` has been replaced with `#[const_trait]` on traits passes_unused_duplicate = unused attribute .suggestion = remove this attribute .note = attribute also specified here .warn = {-passes_previously_accepted} passes_unused_empty_lints_note = attribute `{$name}` with an empty list has no effect passes_unused_linker_messages_note = the `linker_messages` lint can only be controlled at the root of a crate that needs to be linked passes_unused_multiple = multiple `{$name}` attributes .suggestion = remove this attribute .note = attribute also specified here passes_unused_no_lints_note = attribute `{$name}` without any lints has no effect passes_unused_var_assigned_only = variable `{$name}` is assigned to, but never used .note = consider using `_{$name}` instead passes_unused_var_maybe_capture_ref = unused variable: `{$name}` .help = did you mean to capture by reference instead? passes_unused_var_remove_field = unused variable: `{$name}` passes_unused_var_remove_field_suggestion = try removing the field passes_unused_variable_args_in_macro = `{$name}` is captured in macro and introduced a unused variable passes_unused_variable_try_ignore = unused variable: `{$name}` .suggestion = try ignoring the field passes_unused_variable_try_prefix = unused variable: `{$name}` .label = unused variable .suggestion = if this is intentional, prefix it with an underscore passes_used_compiler_linker = `used(compiler)` and `used(linker)` can't be used together passes_used_static = attribute must be applied to a `static` variable .label = but this is a {$target} passes_useless_assignment = useless assignment of {$is_field_assign -> [true] field *[false] variable } of type `{$ty}` to itself passes_useless_stability = this stability annotation is useless .label = useless stability annotation .item = the stability attribute annotates this item pattern_analysis_excluside_range_missing_gap = multiple ranges are one apart .label = this range doesn't match `{$gap}` because `..` is an exclusive range .suggestion = use an inclusive range instead pattern_analysis_excluside_range_missing_max = exclusive range missing `{$max}` .label = this range doesn't match `{$max}` because `..` is an exclusive range .suggestion = use an inclusive range instead pattern_analysis_mixed_deref_pattern_constructors = mix of deref patterns and normal constructors .deref_pattern_label = matches on the result of dereferencing `{$smart_pointer_ty}` .normal_constructor_label = matches directly on `{$smart_pointer_ty}` pattern_analysis_non_exhaustive_omitted_pattern = some variants are not matched explicitly .help = ensure that all variants are matched explicitly by adding the suggested match arms .note = the matched value is of type `{$scrut_ty}` and the `non_exhaustive_omitted_patterns` attribute was found pattern_analysis_non_exhaustive_omitted_pattern_lint_on_arm = the lint level must be set on the whole match .help = it no longer has any effect to set the lint level on an individual match arm .label = remove this attribute .suggestion = set the lint level on the whole match pattern_analysis_overlapping_range_endpoints = multiple patterns overlap on their endpoints .label = ... with this range .note = you likely meant to write mutually exclusive ranges pattern_analysis_uncovered = {$count -> [1] pattern `{$witness_1}` [2] patterns `{$witness_1}` and `{$witness_2}` [3] patterns `{$witness_1}`, `{$witness_2}` and `{$witness_3}` *[other] patterns `{$witness_1}`, `{$witness_2}`, `{$witness_3}` and {$remainder} more } not covered privacy_field_is_private = {$len -> [1] field *[other] fields } {$field_names} of {$variant_descr} `{$def_path_str}` {$len -> [1] is *[other] are } private .label = in this type privacy_field_is_private_is_update_syntax_label = {$rest_len -> [1] field *[other] fields } {$rest_field_names} {$rest_len -> [1] is *[other] are } private privacy_field_is_private_label = private field privacy_from_private_dep_in_public_interface = {$kind} `{$descr}` from private dependency '{$krate}' in public interface privacy_in_public_interface = {$vis_descr} {$kind} `{$descr}` in public interface .label = can't leak {$vis_descr} {$kind} .visibility_label = `{$descr}` declared as {$vis_descr} privacy_item_is_private = {$kind} `{$descr}` is private .label = private {$kind} privacy_private_interface_or_bounds_lint = {$ty_kind} `{$ty_descr}` is more private than the item `{$item_descr}` .item_label = {$item_kind} `{$item_descr}` is reachable at visibility `{$item_vis_descr}` .ty_note = but {$ty_kind} `{$ty_descr}` is only usable at visibility `{$ty_vis_descr}` privacy_report_effective_visibility = {$descr} privacy_unnameable_types_lint = {$kind} `{$descr}` is reachable but cannot be named .label = reachable at visibility `{$reachable_vis}`, but can only be named at visibility `{$reexported_vis}` privacy_unnamed_item_is_private = {$kind} is private .label = private {$kind} query_system_cycle = cycle detected when {$stack_bottom} .note = see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information query_system_cycle_recursive_trait_alias = trait aliases cannot be recursive query_system_cycle_recursive_ty_alias = type aliases cannot be recursive query_system_cycle_recursive_ty_alias_help1 = consider using a struct, enum, or union instead to break the cycle query_system_cycle_recursive_ty_alias_help2 = see for more information query_system_cycle_stack_middle = ...which requires {$desc}... query_system_cycle_stack_multiple = ...which again requires {$stack_bottom}, completing the cycle query_system_cycle_stack_single = ...which immediately requires {$stack_bottom} again query_system_cycle_usage = cycle used when {$usage} query_system_increment_compilation = internal compiler error: encountered incremental compilation error with {$dep_node} .help = This is a known issue with the compiler. Run {$run_cmd} to allow your project to compile query_system_increment_compilation_note1 = Please follow the instructions below to create a bug report with the provided information query_system_increment_compilation_note2 = See for more information query_system_overflow_note = query depth increased by {$depth} when {$desc} query_system_query_overflow = queries overflow the depth limit! .help = consider increasing the recursion limit by adding a `#![recursion_limit = "{$suggested_limit}"]` attribute to your crate (`{$crate_name}`) query_system_reentrant = internal compiler error: reentrant incremental verify failure, suppressing message resolve_accessible_unsure = not sure whether the path is accessible or not .note = the type may have associated items, but we are currently not checking them resolve_add_as_non_derive = add as non-Derive macro `#[{$macro_path}]` resolve_added_macro_use = have you added the `#[macro_use]` on the module/import? resolve_ancestor_only = visibilities can only be restricted to ancestor modules resolve_anonymous_lifetime_non_gat_report_error = in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type .label = this lifetime must come from the implemented type resolve_arguments_macro_use_not_allowed = arguments to `macro_use` are not allowed here resolve_associated_const_with_similar_name_exists = there is an associated constant with a similar name resolve_associated_fn_with_similar_name_exists = there is an associated function with a similar name resolve_associated_type_with_similar_name_exists = there is an associated type with a similar name resolve_attempt_to_use_non_constant_value_in_constant = attempt to use a non-constant value in a constant resolve_attempt_to_use_non_constant_value_in_constant_label_with_suggestion = non-constant value resolve_attempt_to_use_non_constant_value_in_constant_with_suggestion = consider using `{$suggestion}` instead of `{$current}` resolve_attempt_to_use_non_constant_value_in_constant_without_suggestion = this would need to be a `{$suggestion}` resolve_attributes_starting_with_rustc_are_reserved = attributes starting with `rustc` are reserved for use by the `rustc` compiler resolve_bad_macro_import = bad macro import resolve_binding_in_never_pattern = never patterns cannot contain variable bindings .suggestion = use a wildcard `_` instead resolve_binding_shadows_something_unacceptable = {$shadowing_binding}s cannot shadow {$shadowed_binding}s .label = cannot be named the same as {$article} {$shadowed_binding} .label_shadowed_binding = the {$shadowed_binding} `{$name}` is {$participle} here resolve_binding_shadows_something_unacceptable_suggestion = try specify the pattern arguments resolve_cannot_be_reexported_crate_public = `{$ident}` is only public within the crate, and cannot be re-exported outside resolve_cannot_be_reexported_private = `{$ident}` is private, and cannot be re-exported resolve_cannot_capture_dynamic_environment_in_fn_item = can't capture dynamic environment in a fn item .help = use the `|| {"{"} ... {"}"}` closure form instead resolve_cannot_determine_import_resolution = cannot determine resolution for the import .note = import resolution is stuck, try simplifying other imports resolve_cannot_determine_macro_resolution = cannot determine resolution for the {$kind} `{$path}` .note = import resolution is stuck, try simplifying macro imports resolve_cannot_find_builtin_macro_with_name = cannot find a built-in macro with name `{$ident}` resolve_cannot_find_ident_in_this_scope = cannot find {$expected} `{$ident}` in this scope resolve_cannot_glob_import_possible_crates = cannot glob-import all possible crates resolve_cannot_use_through_an_import = cannot use {$article} {$descr} through an import .note = the {$descr} imported here resolve_change_import_binding = you can use `as` to change the binding name of the import resolve_consider_adding_a_derive = consider adding a derive resolve_consider_adding_macro_export = consider adding a `#[macro_export]` to the macro in the imported module resolve_consider_declaring_with_pub = consider declaring type or module `{$ident}` with `pub` resolve_consider_making_the_field_public = { $number_of_fields -> [one] consider making the field publicly accessible *[other] consider making the fields publicly accessible } resolve_consider_marking_as_pub = consider marking `{$ident}` as `pub` in the imported module resolve_consider_move_macro_position = consider moving the definition of `{$ident}` before this call resolve_const_not_member_of_trait = const `{$const_}` is not a member of trait `{$trait_}` .label = not a member of trait `{$trait_}` resolve_const_param_in_enum_discriminant = const parameters may not be used in enum discriminant values resolve_const_param_in_non_trivial_anon_const = const parameters may only be used as standalone arguments, i.e. `{$name}` resolve_constructor_private_if_any_field_private = a constructor is private if any of the fields is private resolve_elided_anonymous_lifetime_report_error = `&` without an explicit lifetime name cannot be used here .label = explicit lifetime name needed here resolve_elided_anonymous_lifetime_report_error_suggestion = consider introducing a higher-ranked lifetime here resolve_expected_module_found = expected module, found {$res} `{$path_str}` .label = not a module resolve_explicit_anonymous_lifetime_report_error = `'_` cannot be used here .label = `'_` is a reserved lifetime name resolve_explicit_unsafe_traits = unsafe traits like `{$ident}` should be implemented explicitly resolve_extern_crate_loading_macro_not_at_crate_root = an `extern crate` loading macros must be at the crate root resolve_extern_crate_self_requires_renaming = `extern crate self;` requires renaming .suggestion = rename the `self` crate to be able to import it resolve_forward_declared_generic_in_const_param_ty = const parameter types cannot reference parameters before they are declared .label = const parameter type cannot reference `{$param}` before it is declared resolve_forward_declared_generic_param = generic parameter defaults cannot reference parameters before they are declared .label = cannot reference `{$param}` before it is declared resolve_found_an_item_configured_out = found an item that was configured out resolve_generic_arguments_in_macro_path = generic arguments in macro path resolve_generic_params_from_outer_item = can't use {$is_self -> [true] `Self` *[false] generic parameters } from outer item .label = use of {$is_self -> [true] `Self` *[false] generic parameter } from outer item .refer_to_type_directly = refer to the type directly here instead .suggestion = try introducing a local generic parameter here resolve_generic_params_from_outer_item_const = a `const` is a separate item from the item that contains it resolve_generic_params_from_outer_item_const_param = const parameter from outer item resolve_generic_params_from_outer_item_self_ty_alias = `Self` type implicitly declared here, by this `impl` resolve_generic_params_from_outer_item_self_ty_param = can't use `Self` here resolve_generic_params_from_outer_item_static = a `static` is a separate item from the item that contains it resolve_generic_params_from_outer_item_ty_param = type parameter from outer item resolve_ident_bound_more_than_once_in_parameter_list = identifier `{$identifier}` is bound more than once in this parameter list .label = used as parameter more than once resolve_ident_bound_more_than_once_in_same_pattern = identifier `{$identifier}` is bound more than once in the same pattern .label = used in a pattern more than once resolve_ident_imported_here_but_it_is_desc = `{$imported_ident}` is imported here, but it is {$imported_ident_desc} resolve_ident_in_scope_but_it_is_desc = `{$imported_ident}` is in scope, but it is {$imported_ident_desc} resolve_implicit_elided_lifetimes_not_allowed_here = implicit elided lifetime not allowed here resolve_imported_crate = `$crate` may not be imported resolve_imported_macro_not_found = imported macro not found resolve_imports_cannot_refer_to = imports cannot refer to {$what} resolve_indeterminate = cannot determine resolution for the visibility resolve_invalid_asm_sym = invalid `sym` operand .label = is a local variable .help = `sym` operands must refer to either a function or a static resolve_is_private = {$ident_descr} `{$ident}` is private .label = private {$ident_descr} resolve_item_was_behind_feature = the item is gated behind the `{$feature}` feature resolve_item_was_cfg_out = the item is gated here resolve_label_with_similar_name_reachable = a label with a similar name is reachable resolve_lending_iterator_report_error = associated type `Iterator::Item` is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type .note = you can't create an `Iterator` that borrows each `Item` from itself, but you can instead create a new type that borrows your existing type and implement `Iterator` for that new type resolve_lifetime_param_in_enum_discriminant = lifetime parameters may not be used in enum discriminant values resolve_lifetime_param_in_non_trivial_anon_const = lifetime parameters may not be used in const expressions resolve_lowercase_self = attempt to use a non-constant value in a constant .suggestion = try using `Self` resolve_macro_cannot_use_as_attr = `{$ident}` exists, but a declarative macro cannot be used as an attribute macro resolve_macro_cannot_use_as_derive = `{$ident}` exists, but a declarative macro cannot be used as a derive macro resolve_macro_defined_later = a macro with the same name exists, but it appears later resolve_macro_expanded_extern_crate_cannot_shadow_extern_arguments = macro-expanded `extern crate` items cannot shadow names passed with `--extern` resolve_macro_expected_found = expected {$expected}, found {$found} `{$macro_path}` .label = not {$article} {$expected} resolve_macro_extern_deprecated = `#[macro_escape]` is a deprecated synonym for `#[macro_use]` .help = try an outer attribute: `#[macro_use]` resolve_macro_use_extern_crate_self = `#[macro_use]` is not supported on `extern crate self` resolve_macro_use_name_already_in_use = `{$name}` is already in scope .note = macro-expanded `#[macro_use]`s may not shadow existing macros (see RFC 1560) resolve_method_not_member_of_trait = method `{$method}` is not a member of trait `{$trait_}` .label = not a member of trait `{$trait_}` resolve_missing_macro_rules_name = maybe you have forgotten to define a name for this `macro_rules!` resolve_module_only = visibility must resolve to a module resolve_name_defined_multiple_time = the name `{$name}` is defined multiple times .note = `{$name}` must be defined only once in the {$descr} namespace of this {$container} resolve_name_defined_multiple_time_old_binding_definition = previous definition of the {$old_kind} `{$name}` here resolve_name_defined_multiple_time_old_binding_import = previous import of the {$old_kind} `{$name}` here resolve_name_defined_multiple_time_redefined = `{$name}` redefined here resolve_name_defined_multiple_time_reimported = `{$name}` reimported here resolve_name_is_already_used_as_generic_parameter = the name `{$name}` is already used for a generic parameter in this item's generic parameters .label = already used .first_use_of_name = first use of `{$name}` resolve_name_reserved_in_attribute_namespace = name `{$ident}` is reserved in attribute namespace resolve_note_and_refers_to_the_item_defined_here = {$first -> [true] {$dots -> [true] the {$binding_descr} `{$binding_name}` is defined here... *[false] the {$binding_descr} `{$binding_name}` is defined here } *[false] {$dots -> [true] ...and refers to the {$binding_descr} `{$binding_name}` which is defined here... *[false] ...and refers to the {$binding_descr} `{$binding_name}` which is defined here } } resolve_outer_ident_is_not_publicly_reexported = {$outer_ident_descr} `{$outer_ident}` is not publicly re-exported resolve_param_in_enum_discriminant = generic parameters may not be used in enum discriminant values .label = cannot perform const operation using `{$name}` resolve_param_in_non_trivial_anon_const = generic parameters may not be used in const operations .label = cannot perform const operation using `{$name}` resolve_param_in_non_trivial_anon_const_help = add `#![feature(generic_const_exprs)]` to allow generic const expressions resolve_param_in_ty_of_const_param = the type of const parameters must not depend on other generic parameters .label = the type must not depend on the parameter `{$name}` resolve_pattern_doesnt_bind_name = pattern doesn't bind `{$name}` resolve_proc_macro_same_crate = can't use a procedural macro from the same crate that defines it .help = you can define integration tests in a directory named `tests` resolve_reexport_of_crate_public = re-export of crate public `{$ident}` resolve_reexport_of_private = re-export of private `{$ident}` resolve_relative_2018 = relative paths are not supported in visibilities in 2018 edition or later .suggestion = try resolve_remove_surrounding_derive = remove from the surrounding `derive()` resolve_remove_unnecessary_import = remove unnecessary import resolve_self_import_can_only_appear_once_in_the_list = `self` import can only appear once in an import list .label = can only appear once in an import list resolve_self_import_only_in_import_list_with_non_empty_prefix = `self` import can only appear in an import list with a non-empty prefix .label = can only appear in an import list with a non-empty prefix resolve_self_imports_only_allowed_within = `self` imports are only allowed within a {"{"} {"}"} list resolve_self_imports_only_allowed_within_multipart_suggestion = alternatively, use the multi-path `use` syntax to import `self` resolve_self_imports_only_allowed_within_suggestion = consider importing the module directly resolve_self_in_const_generic_ty = cannot use `Self` in const parameter type resolve_self_in_generic_param_default = generic parameters cannot use `Self` in their defaults resolve_similarly_named_defined_here = similarly named {$candidate_descr} `{$candidate}` defined here resolve_single_item_defined_here = {$candidate_descr} `{$candidate}` defined here resolve_static_lifetime_is_reserved = invalid lifetime parameter name: `{$lifetime}` .label = 'static is a reserved lifetime name resolve_suggestion_import_ident_directly = import `{$ident}` directly resolve_suggestion_import_ident_through_reexport = import `{$ident}` through the re-export resolve_tool_module_imported = cannot use a tool module through an import .note = the tool module imported here resolve_tool_only_accepts_identifiers = `{$tool}` only accepts identifiers .label = not an identifier resolve_tool_was_already_registered = tool `{$tool}` was already registered .label = already registered here resolve_trait_impl_duplicate = duplicate definitions with name `{$name}`: .label = duplicate definition .old_span_label = previous definition here .trait_item_span = item in trait resolve_trait_impl_mismatch = item `{$name}` is an associated {$kind}, which doesn't match its trait `{$trait_path}` .label = does not match trait .trait_impl_mismatch_label_item = item in trait resolve_try_using_similarly_named_label = try using similarly named label resolve_type_not_member_of_trait = type `{$type_}` is not a member of trait `{$trait_}` .label = not a member of trait `{$trait_}` resolve_type_param_in_enum_discriminant = type parameters may not be used in enum discriminant values resolve_type_param_in_non_trivial_anon_const = type parameters may not be used in const expressions resolve_undeclared_label = use of undeclared label `{$name}` .label = undeclared label `{$name}` resolve_underscore_lifetime_is_reserved = `'_` cannot be used here .label = `'_` is a reserved lifetime name resolve_unexpected_res_change_ty_to_const_param_sugg = you might have meant to write a const parameter here resolve_unexpected_res_use_at_op_in_slice_pat_with_range_sugg = if you meant to collect the rest of the slice in `{$ident}`, use the at operator resolve_unnamed_crate_root_import = crate root imports need to be explicitly named: `use crate as name;` resolve_unreachable_label = use of unreachable label `{$name}` .label = unreachable label `{$name}` .label_definition_span = unreachable label defined here .note = labels are unreachable through functions, closures, async blocks and modules resolve_unreachable_label_similar_name_reachable = a label with a similar name is reachable resolve_unreachable_label_similar_name_unreachable = a label with a similar name exists but is also unreachable resolve_unreachable_label_suggestion_use_similarly_named = try using similarly named label resolve_unreachable_label_with_similar_name_exists = a label with a similar name exists but is unreachable resolve_variable_bound_with_different_mode = variable `{$variable_name}` is bound inconsistently across alternatives separated by `|` .label = bound in different ways .first_binding_span = first binding resolve_variable_is_not_bound_in_all_patterns = variable `{$name}` is not bound in all patterns resolve_variable_not_in_all_patterns = variable not in all patterns session_apple_deployment_target_invalid = failed to parse deployment target specified in {$env_var}: {$error} session_apple_deployment_target_too_low = deployment target in {$env_var} was set to {$version}, but the minimum supported by `rustc` is {$os_min} session_binary_float_literal_not_supported = binary float literal is not supported session_branch_protection_requires_aarch64 = `-Zbranch-protection` is only supported on aarch64 session_cannot_enable_crt_static_linux = sanitizer is incompatible with statically linked libc, disable it using `-C target-feature=-crt-static` session_cannot_mix_and_match_sanitizers = `-Zsanitizer={$first}` is incompatible with `-Zsanitizer={$second}` session_cli_feature_diagnostic_help = add `-Zcrate-attr="feature({$feature})"` to the command-line options to enable session_crate_name_empty = crate name must not be empty session_embed_source_insufficient_dwarf_version = `-Zembed-source=y` requires at least `-Z dwarf-version=5` but DWARF version is {$dwarf_version} session_embed_source_requires_debug_info = `-Zembed-source=y` requires debug information to be enabled session_expr_parentheses_needed = parentheses are required to parse this as an expression session_failed_to_create_profiler = failed to create profiler: {$err} session_feature_diagnostic_for_issue = see issue #{$n} for more information session_feature_diagnostic_help = add `#![feature({$feature})]` to the crate attributes to enable session_feature_diagnostic_suggestion = add `#![feature({$feature})]` to the crate attributes to enable session_feature_suggest_upgrade_compiler = this compiler was built on {$date}; consider upgrading it if it is out of date session_file_is_not_writeable = output file {$file} is not writeable -- check its permissions session_file_write_fail = failed to write `{$path}` due to error `{$err}` session_function_return_requires_x86_or_x86_64 = `-Zfunction-return` (except `keep`) is only supported on x86 and x86_64 session_function_return_thunk_extern_requires_non_large_code_model = `-Zfunction-return=thunk-extern` is only supported on non-large code models session_hexadecimal_float_literal_not_supported = hexadecimal float literal is not supported session_incompatible_linker_flavor = linker flavor `{$flavor}` is incompatible with the current target .note = compatible flavors are: {$compatible_list} session_instrumentation_not_supported = {$us} instrumentation is not supported for this target session_int_literal_too_large = integer literal is too large .note = value exceeds limit of `{$limit}` session_invalid_character_in_crate_name = invalid character {$character} in crate name: `{$crate_name}` .help = you can either pass `--crate-name` on the command line or add `#![crate_name = "…"]` to set the crate name session_invalid_float_literal_suffix = invalid suffix `{$suffix}` for float literal .label = invalid suffix `{$suffix}` .help = valid suffixes are `f32` and `f64` session_invalid_float_literal_width = invalid width `{$width}` for float literal .help = valid widths are 32 and 64 session_invalid_int_literal_width = invalid width `{$width}` for integer literal .help = valid widths are 8, 16, 32, 64 and 128 session_invalid_literal_suffix = suffixes on {$kind} literals are invalid .label = invalid suffix `{$suffix}` session_invalid_num_literal_base_prefix = invalid base prefix for number literal .note = base prefixes (`0xff`, `0b1010`, `0o755`) are lowercase .suggestion = try making the prefix lowercase session_invalid_num_literal_suffix = invalid suffix `{$suffix}` for number literal .label = invalid suffix `{$suffix}` .help = the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.) session_linker_plugin_lto_windows_not_supported = linker plugin based LTO is not supported together with `-C prefer-dynamic` when targeting Windows-like targets session_not_circumvent_feature = `-Zunleash-the-miri-inside-of-you` may not be used to circumvent feature gates, except when testing error paths in the CTFE engine session_not_supported = not supported session_octal_float_literal_not_supported = octal float literal is not supported session_profile_sample_use_file_does_not_exist = file `{$path}` passed to `-C profile-sample-use` does not exist session_profile_use_file_does_not_exist = file `{$path}` passed to `-C profile-use` does not exist session_sanitizer_cfi_canonical_jump_tables_requires_cfi = `-Zsanitizer-cfi-canonical-jump-tables` requires `-Zsanitizer=cfi` session_sanitizer_cfi_generalize_pointers_requires_cfi = `-Zsanitizer-cfi-generalize-pointers` requires `-Zsanitizer=cfi` or `-Zsanitizer=kcfi` session_sanitizer_cfi_normalize_integers_requires_cfi = `-Zsanitizer-cfi-normalize-integers` requires `-Zsanitizer=cfi` or `-Zsanitizer=kcfi` session_sanitizer_cfi_requires_lto = `-Zsanitizer=cfi` requires `-Clto` or `-Clinker-plugin-lto` session_sanitizer_cfi_requires_single_codegen_unit = `-Zsanitizer=cfi` with `-Clto` requires `-Ccodegen-units=1` session_sanitizer_kcfi_arity_requires_kcfi = `-Zsanitizer-kcfi-arity` requires `-Zsanitizer=kcfi` session_sanitizer_kcfi_requires_panic_abort = `-Z sanitizer=kcfi` requires `-C panic=abort` session_sanitizer_not_supported = {$us} sanitizer is not supported for this target session_sanitizers_not_supported = {$us} sanitizers are not supported for this target session_skipping_const_checks = skipping const checks session_soft_float_deprecated = `-Csoft-float` is unsound and deprecated; use a corresponding *eabi target instead .note = it will be removed or ignored in a future version of Rust session_soft_float_deprecated_issue = see issue #129893 for more information session_soft_float_ignored = `-Csoft-float` is ignored on this target; it only has an effect on *eabihf targets .note = this may become a hard error in a future version of Rust session_split_debuginfo_unstable_platform = `-Csplit-debuginfo={$debuginfo}` is unstable on this platform session_split_lto_unit_requires_lto = `-Zsplit-lto-unit` requires `-Clto`, `-Clto=thin`, or `-Clinker-plugin-lto` session_target_requires_unwind_tables = target requires unwind tables, they cannot be disabled with `-C force-unwind-tables=no` session_target_small_data_threshold_not_supported = `-Z small-data-threshold` is not supported for target {$target_triple} and will be ignored session_target_stack_protector_not_supported = `-Z stack-protector={$stack_protector}` is not supported for target {$target_triple} and will be ignored session_unleashed_feature_help_named = skipping check for `{$gate}` feature session_unleashed_feature_help_unnamed = skipping check that does not even have a feature gate session_unstable_virtual_function_elimination = `-Zvirtual-function-elimination` requires `-Clto` session_unsupported_crate_type_for_target = dropping unsupported crate type `{$crate_type}` for target `{$target_triple}` session_unsupported_dwarf_version = requested DWARF version {$dwarf_version} is not supported session_unsupported_dwarf_version_help = supported DWARF versions are 2, 3, 4 and 5 session_unsupported_reg_struct_return_arch = `-Zreg-struct-return` is only supported on x86 session_unsupported_regparm = `-Zregparm={$regparm}` is unsupported (valid values 0-3) session_unsupported_regparm_arch = `-Zregparm=N` is only supported on x86 trait_selection_actual_impl_expl_but_actually_implemented_for_ty = ...but `{$trait_path}` is actually implemented for the type `{$ty}`{$has_lifetime -> [true] , for some specific lifetime `'{$lifetime}` *[false] {""} } trait_selection_actual_impl_expl_but_actually_implements_trait = ...but it actually implements `{$trait_path}`{$has_lifetime -> [true] , for some specific lifetime `'{$lifetime}` *[false] {""} } trait_selection_actual_impl_expl_but_actually_ty_implements = ...but `{$ty}` actually implements `{$trait_path}`{$has_lifetime -> [true] , for some specific lifetime `'{$lifetime}` *[false] {""} } trait_selection_actual_impl_expl_expected_other_any = {$leading_ellipsis -> [true] ... *[false] {""} }`{$ty_or_sig}` must implement `{$trait_path}`, for any lifetime `'{$lifetime_1}`... trait_selection_actual_impl_expl_expected_other_nothing = {$leading_ellipsis -> [true] ... *[false] {""} }`{$ty_or_sig}` must implement `{$trait_path}` trait_selection_actual_impl_expl_expected_other_some = {$leading_ellipsis -> [true] ... *[false] {""} }`{$ty_or_sig}` must implement `{$trait_path}`, for some specific lifetime `'{$lifetime_1}`... trait_selection_actual_impl_expl_expected_other_two = {$leading_ellipsis -> [true] ... *[false] {""} }`{$ty_or_sig}` must implement `{$trait_path}`, for any two lifetimes `'{$lifetime_1}` and `'{$lifetime_2}`... trait_selection_actual_impl_expl_expected_passive_any = {$leading_ellipsis -> [true] ... *[false] {""} }`{$trait_path}` would have to be implemented for the type `{$ty_or_sig}`, for any lifetime `'{$lifetime_1}`... trait_selection_actual_impl_expl_expected_passive_nothing = {$leading_ellipsis -> [true] ... *[false] {""} }`{$trait_path}` would have to be implemented for the type `{$ty_or_sig}` trait_selection_actual_impl_expl_expected_passive_some = {$leading_ellipsis -> [true] ... *[false] {""} }`{$trait_path}` would have to be implemented for the type `{$ty_or_sig}`, for some specific lifetime `'{$lifetime_1}`... trait_selection_actual_impl_expl_expected_passive_two = {$leading_ellipsis -> [true] ... *[false] {""} }`{$trait_path}` would have to be implemented for the type `{$ty_or_sig}`, for any two lifetimes `'{$lifetime_1}` and `'{$lifetime_2}`... trait_selection_actual_impl_expl_expected_signature_any = {$leading_ellipsis -> [true] ... *[false] {""} }closure with signature `{$ty_or_sig}` must implement `{$trait_path}`, for any lifetime `'{$lifetime_1}`... trait_selection_actual_impl_expl_expected_signature_nothing = {$leading_ellipsis -> [true] ... *[false] {""} }closure with signature `{$ty_or_sig}` must implement `{$trait_path}` trait_selection_actual_impl_expl_expected_signature_some = {$leading_ellipsis -> [true] ... *[false] {""} }closure with signature `{$ty_or_sig}` must implement `{$trait_path}`, for some specific lifetime `'{$lifetime_1}`... trait_selection_actual_impl_expl_expected_signature_two = {$leading_ellipsis -> [true] ... *[false] {""} }closure with signature `{$ty_or_sig}` must implement `{$trait_path}`, for any two lifetimes `'{$lifetime_1}` and `'{$lifetime_2}`... trait_selection_adjust_signature_borrow = consider adjusting the signature so it borrows its {$len -> [one] argument *[other] arguments } trait_selection_adjust_signature_remove_borrow = consider adjusting the signature so it does not borrow its {$len -> [one] argument *[other] arguments } trait_selection_ascribe_user_type_prove_predicate = ...so that the where clause holds trait_selection_async_closure_not_fn = async closure does not implement `{$kind}` because it captures state from its environment trait_selection_await_both_futures = consider `await`ing on both `Future`s trait_selection_await_future = consider `await`ing on the `Future` trait_selection_await_note = calling an async function returns a future trait_selection_but_calling_introduces = {$has_param_name -> [true] `{$param_name}` *[false] `fn` parameter } has {$lifetime_kind -> [true] lifetime `{$lifetime}` *[false] an anonymous lifetime `'_` } but calling `{$assoc_item}` introduces an implicit `'static` lifetime requirement .label1 = {$has_lifetime -> [true] lifetime `{$lifetime}` *[false] an anonymous lifetime `'_` } .label2 = ...is used and required to live as long as `'static` here because of an implicit lifetime bound on the {$has_impl_path -> [true] `impl` of `{$impl_path}` *[false] inherent `impl` } trait_selection_but_needs_to_satisfy = {$has_param_name -> [true] `{$param_name}` *[false] `fn` parameter } has {$has_lifetime -> [true] lifetime `{$lifetime}` *[false] an anonymous lifetime `'_` } but it needs to satisfy a `'static` lifetime requirement .influencer = this data with {$has_lifetime -> [true] lifetime `{$lifetime}` *[false] an anonymous lifetime `'_` }... .require = {$spans_empty -> *[true] ...is used and required to live as long as `'static` here [false] ...and is required to live as long as `'static` here } .used_here = ...is used here... .introduced_by_bound = `'static` lifetime requirement introduced by this bound trait_selection_closure_fn_mut_label = closure is `{$trait_prefix}FnMut` because it mutates the variable `{$place}` here trait_selection_closure_fn_once_label = closure is `{$trait_prefix}FnOnce` because it moves the variable `{$place}` out of its environment trait_selection_closure_kind_mismatch = expected a closure that implements the `{$trait_prefix}{$expected}` trait, but this closure only implements `{$trait_prefix}{$found}` .label = this closure implements `{$trait_prefix}{$found}`, not `{$trait_prefix}{$expected}` trait_selection_closure_kind_requirement = the requirement to implement `{$trait_prefix}{$expected}` derives from here trait_selection_compare_impl_item_obligation = ...so that the definition in impl matches the definition from the trait trait_selection_consider_specifying_length = consider specifying the actual array length trait_selection_data_flows = ...but data{$label_var1_exists -> [true] {" "}from `{$label_var1}` *[false] {""} } flows{$label_var2_exists -> [true] {" "}into `{$label_var2}` *[false] {""} } here trait_selection_data_lifetime_flow = ...but data with one lifetime flows into the other here trait_selection_data_returned = ...but data{$label_var1_exists -> [true] {" "}from `{$label_var1}` *[false] {""} } is returned here trait_selection_declared_different = this parameter and the return type are declared with different lifetimes... trait_selection_declared_multiple = this type is declared with multiple lifetimes... trait_selection_disallowed_positional_argument = positional format arguments are not allowed here .help = only named format arguments with the name of one of the generic types are allowed in this context trait_selection_does_not_outlive_static_from_impl = ...does not necessarily outlive the static lifetime introduced by the compatible `impl` trait_selection_dtcs_has_lifetime_req_label = this has an implicit `'static` lifetime requirement trait_selection_dtcs_has_req_note = the used `impl` has a `'static` requirement trait_selection_dtcs_introduces_requirement = calling this method introduces the `impl`'s `'static` requirement trait_selection_dtcs_suggestion = consider relaxing the implicit `'static` requirement trait_selection_explicit_lifetime_required_sugg_with_ident = add explicit lifetime `{$named}` to the type of `{$simple_ident}` trait_selection_explicit_lifetime_required_sugg_with_param_type = add explicit lifetime `{$named}` to type trait_selection_explicit_lifetime_required_with_ident = explicit lifetime required in the type of `{$simple_ident}` .label = lifetime `{$named}` required trait_selection_explicit_lifetime_required_with_param_type = explicit lifetime required in parameter type .label = lifetime `{$named}` required trait_selection_fn_consider_casting = consider casting the fn item to a fn pointer: `{$casting}` trait_selection_fn_consider_casting_both = consider casting both fn items to fn pointers using `as {$sig}` trait_selection_fn_uniq_types = different fn items have unique types, even if their signatures are the same trait_selection_fps_cast = consider casting to a fn pointer trait_selection_fps_cast_both = consider casting both fn items to fn pointers using `as {$expected_sig}` trait_selection_fps_items_are_distinct = fn items are distinct from fn pointers trait_selection_fps_remove_ref = consider removing the reference trait_selection_fps_use_ref = consider using a reference trait_selection_fulfill_req_lifetime = the type `{$ty}` does not fulfill the required lifetime trait_selection_full_type_written = the full type name has been written to '{$path}' trait_selection_ignored_diagnostic_option = `{$option_name}` is ignored due to previous definition of `{$option_name}` .other_label = `{$option_name}` is first declared here .label = `{$option_name}` is already declared here trait_selection_implicit_static_lifetime_note = this has an implicit `'static` lifetime requirement trait_selection_implicit_static_lifetime_suggestion = consider relaxing the implicit `'static` requirement trait_selection_inherent_projection_normalization_overflow = overflow evaluating associated type `{$ty}` trait_selection_invalid_format_specifier = invalid format specifier .help = no format specifier are supported in this position trait_selection_label_bad = {$bad_kind -> *[other] cannot infer type [more_info] cannot infer {$prefix_kind -> *[type] type for {$prefix} [const_with_param] the value of const parameter [const] the value of the constant } `{$name}`{$has_parent -> [true] {" "}declared on the {$parent_prefix} `{$parent_name}` *[false] {""} } } trait_selection_lf_bound_not_satisfied = lifetime bound not satisfied trait_selection_lifetime_mismatch = lifetime mismatch trait_selection_lifetime_param_suggestion = consider {$is_reuse -> [true] reusing *[false] introducing } a named lifetime parameter{$is_impl -> [true] {" "}and update trait if needed *[false] {""} } trait_selection_lifetime_param_suggestion_elided = each elided lifetime in input position becomes a distinct lifetime trait_selection_malformed_on_unimplemented_attr = malformed `on_unimplemented` attribute .help = only `message`, `note` and `label` are allowed as options .label = invalid option found here trait_selection_meant_byte_literal = if you meant to write a byte literal, prefix with `b` trait_selection_meant_char_literal = if you meant to write a `char` literal, use single quotes trait_selection_meant_str_literal = if you meant to write a string literal, use double quotes trait_selection_mismatched_static_lifetime = incompatible lifetime on type trait_selection_missing_options_for_on_unimplemented_attr = missing options for `on_unimplemented` attribute .help = at least one of the `message`, `note` and `label` options are expected trait_selection_msl_introduces_static = introduces a `'static` lifetime requirement trait_selection_msl_unmet_req = because this has an unmet lifetime requirement trait_selection_negative_positive_conflict = found both positive and negative implementation of trait `{$trait_desc}`{$self_desc -> [none] {""} *[default] {" "}for type `{$self_desc}` }: .negative_implementation_here = negative implementation here .negative_implementation_in_crate = negative implementation in crate `{$negative_impl_cname}` .positive_implementation_here = positive implementation here .positive_implementation_in_crate = positive implementation in crate `{$positive_impl_cname}` trait_selection_nothing = {""} trait_selection_oc_cant_coerce_force_inline = cannot coerce functions which must be inlined to function pointers trait_selection_oc_cant_coerce_intrinsic = cannot coerce intrinsics to function pointers trait_selection_oc_closure_selfref = closure/coroutine type that references itself trait_selection_oc_const_compat = const not compatible with trait trait_selection_oc_fn_lang_correct_type = {$lang_item_name -> [panic_impl] `#[panic_handler]` *[lang_item_name] lang item `{$lang_item_name}` } function has wrong type trait_selection_oc_fn_main_correct_type = `main` function has wrong type trait_selection_oc_generic = mismatched types trait_selection_oc_if_else_different = `if` and `else` have incompatible types trait_selection_oc_intrinsic_correct_type = intrinsic has wrong type trait_selection_oc_match_compat = `match` arms have incompatible types trait_selection_oc_method_compat = method not compatible with trait trait_selection_oc_method_correct_type = mismatched `self` parameter type trait_selection_oc_no_diverge = `else` clause of `let...else` does not diverge trait_selection_oc_no_else = `if` may be missing an `else` clause trait_selection_oc_try_compat = `?` operator has incompatible types trait_selection_oc_type_compat = type not compatible with trait trait_selection_opaque_captures_lifetime = hidden type for `{$opaque_ty}` captures lifetime that does not appear in bounds .label = opaque type defined here trait_selection_opaque_type_non_generic_param = expected generic {$kind} parameter, found `{$arg}` .label = {STREQ($arg, "'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 } trait_selection_outlives_bound = lifetime of the source pointer does not outlive lifetime bound of the object type trait_selection_outlives_content = lifetime of reference outlives lifetime of borrowed content... trait_selection_precise_capturing_existing = add `{$new_lifetime}` to the `use<...>` bound to explicitly capture it trait_selection_precise_capturing_new = add a `use<...>` bound to explicitly capture `{$new_lifetime}` trait_selection_precise_capturing_new_but_apit = add a `use<...>` bound to explicitly capture `{$new_lifetime}` after turning all argument-position `impl Trait` into type parameters, noting that this possibly affects the API of this crate trait_selection_precise_capturing_overcaptures = use the precise capturing `use<...>` syntax to make the captures explicit trait_selection_prlf_defined_with_sub = the lifetime `{$sub_symbol}` defined here... trait_selection_prlf_defined_without_sub = the lifetime defined here... trait_selection_prlf_known_limitation = this is a known limitation that will be removed in the future (see issue #100013 for more information) trait_selection_prlf_must_outlive_with_sup = ...must outlive the lifetime `{$sup_symbol}` defined here trait_selection_prlf_must_outlive_without_sup = ...must outlive the lifetime defined here trait_selection_reborrow = ...so that reference does not outlive borrowed content trait_selection_ref_longer_than_data = in type `{$ty}`, reference has a longer lifetime than the data it references trait_selection_reference_outlives_referent = ...so that the reference type `{$name}` does not outlive the data it points at trait_selection_region_explanation = {$pref_kind -> *[should_not_happen] [{$pref_kind}] [ref_valid_for] ...the reference is valid for [content_valid_for] ...but the borrowed content is only valid for [type_obj_valid_for] object type is valid for [source_pointer_valid_for] source pointer is only valid for [type_satisfy] type must satisfy [type_outlive] type must outlive [lf_param_instantiated_with] lifetime parameter instantiated with [lf_param_must_outlive] but lifetime parameter must outlive [lf_instantiated_with] lifetime instantiated with [lf_must_outlive] but lifetime must outlive [pointer_valid_for] the pointer is valid for [data_valid_for] but the referenced data is only valid for [empty] {""} }{$pref_kind -> [empty] {""} *[other] {" "} }{$desc_kind -> *[should_not_happen] [{$desc_kind}] [restatic] the static lifetime [revar] lifetime {$desc_arg} [as_defined] the lifetime `{$desc_arg}` as defined here [as_defined_anon] the anonymous lifetime as defined here [defined_here] the anonymous lifetime defined here [defined_here_reg] the lifetime `{$desc_arg}` as defined here }{$suff_kind -> *[should_not_happen] [{$suff_kind}] [empty]{""} [continues] ... [req_by_binding] {" "}as required by this binding } trait_selection_relate_object_bound = ...so that it can be closed over into an object trait_selection_relate_param_bound = ...so that the type `{$name}` will meet its required lifetime bounds{$continues -> [true] ... *[false] {""} } trait_selection_relate_param_bound_2 = ...that is required by this bound trait_selection_relate_region_param_bound = ...so that the declared lifetime parameter bounds are satisfied trait_selection_ril_because_of = because of this returned expression trait_selection_ril_introduced_by = requirement introduced by this return type trait_selection_ril_introduced_here = `'static` requirement introduced here trait_selection_ril_static_introduced_by = "`'static` lifetime requirement introduced by the return type trait_selection_rustc_on_unimplemented_empty_on_clause = empty `on`-clause in `#[rustc_on_unimplemented]` .label = empty `on`-clause here trait_selection_rustc_on_unimplemented_expected_identifier = expected an identifier inside this `on`-clause .label = expected an identifier here, not `{$path}` trait_selection_rustc_on_unimplemented_expected_one_predicate_in_not = expected a single predicate in `not(..)` .label = unexpected quantity of predicates here trait_selection_rustc_on_unimplemented_invalid_flag = invalid flag in `on`-clause .label = expected one of the `crate_local`, `direct` or `from_desugaring` flags, not `{$invalid_flag}` trait_selection_rustc_on_unimplemented_invalid_predicate = this predicate is invalid .label = expected one of `any`, `all` or `not` here, not `{$invalid_pred}` trait_selection_rustc_on_unimplemented_missing_value = this attribute must have a value .label = expected value here .note = e.g. `#[rustc_on_unimplemented(message="foo")]` trait_selection_rustc_on_unimplemented_unsupported_literal_in_on = literals inside `on`-clauses are not supported .label = unexpected literal here trait_selection_source_kind_closure_return = try giving this closure an explicit return type # coroutine_kind may need to be translated trait_selection_source_kind_fully_qualified = try using a fully qualified path to specify the expected types trait_selection_source_kind_subdiag_generic_label = cannot infer {$is_type -> [true] type *[false] the value } of the {$is_type -> [true] type *[false] const } {$parent_exists -> [true] parameter `{$param_name}` declared on the {$parent_prefix} `{$parent_name}` *[false] parameter {$param_name} } trait_selection_source_kind_subdiag_generic_suggestion = consider specifying the generic {$arg_count -> [one] argument *[other] arguments } trait_selection_source_kind_subdiag_let = {$kind -> [with_pattern] consider giving `{$name}` an explicit type [closure] consider giving this closure parameter an explicit type *[other] consider giving this pattern a type }{$x_kind -> [has_name] , where the {$prefix_kind -> *[type] type for {$prefix} [const_with_param] value of const parameter [const] value of the constant } `{$arg_name}` is specified [underscore] , where the placeholders `_` are specified *[empty] {""} } trait_selection_srs_add = consider returning the local binding `{$ident}` trait_selection_srs_add_one = consider returning one of these bindings trait_selection_srs_remove = consider removing this semicolon trait_selection_srs_remove_and_box = consider removing this semicolon and boxing the expressions trait_selection_stp_wrap_many = try wrapping the pattern in a variant of `{$path}` trait_selection_stp_wrap_one = try wrapping the pattern in `{$variant}` trait_selection_subtype = ...so that the {$requirement -> [method_compat] method type is compatible with trait [type_compat] associated type is compatible with trait [const_compat] const is compatible with trait [expr_assignable] expression is assignable [if_else_different] `if` and `else` have incompatible types [no_else] `if` missing an `else` returns `()` [fn_main_correct_type] `main` function has the correct type [fn_lang_correct_type] lang item function has the correct type [intrinsic_correct_type] intrinsic has the correct type [method_correct_type] method receiver has the correct type *[other] types are compatible } trait_selection_subtype_2 = ...so that {$requirement -> [method_compat] method type is compatible with trait [type_compat] associated type is compatible with trait [const_compat] const is compatible with trait [expr_assignable] expression is assignable [if_else_different] `if` and `else` have incompatible types [no_else] `if` missing an `else` returns `()` [fn_main_correct_type] `main` function has the correct type [fn_lang_correct_type] lang item function has the correct type [intrinsic_correct_type] intrinsic has the correct type [method_correct_type] method receiver has the correct type *[other] types are compatible } trait_selection_suggest_accessing_field = you might have meant to use field `{$name}` whose type is `{$ty}` trait_selection_suggest_add_let_for_letchains = consider adding `let` trait_selection_tid_consider_borrowing = consider borrowing this type parameter in the trait trait_selection_tid_param_help = the lifetime requirements from the `impl` do not correspond to the requirements in the `trait` trait_selection_tid_rel_help = verify the lifetime relationships in the `trait` and `impl` between the `self` argument, the other inputs and its output trait_selection_trait_has_no_impls = this trait has no implementations, consider adding one trait_selection_trait_impl_diff = `impl` item signature doesn't match `trait` item signature .found = found `{$found}` .expected = expected `{$expected}` .expected_found = expected signature `{$expected}` {" "}found signature `{$found}` trait_selection_trait_placeholder_mismatch = implementation of `{$trait_def_id}` is not general enough .label_satisfy = doesn't satisfy where-clause .label_where = due to a where-clause on `{$def_id}`... .label_dup = implementation of `{$trait_def_id}` is not general enough trait_selection_try_cannot_convert = `?` operator cannot convert from `{$found}` to `{$expected}` trait_selection_tuple_trailing_comma = use a trailing comma to create a tuple with one element trait_selection_ty_alias_overflow = in case this is a recursive type alias, consider using a struct, enum, or union instead trait_selection_type_annotations_needed = {$source_kind -> [closure] type annotations needed for the closure `{$source_name}` [normal] type annotations needed for `{$source_name}` *[other] type annotations needed } .label = type must be known at this point trait_selection_type_annotations_needed_error_time = this is an inference error on crate `time` caused by an API change in Rust 1.80.0; update `time` to version `>=0.3.35` by calling `cargo update` trait_selection_types_declared_different = these two types are declared with different lifetimes... trait_selection_unable_to_construct_constant_value = unable to construct a constant value for the unevaluated constant {$unevaluated} trait_selection_unknown_format_parameter_for_on_unimplemented_attr = there is no parameter `{$argument_name}` on trait `{$trait_name}` .help = expect either a generic argument name or {"`{Self}`"} as format argument trait_selection_warn_removing_apit_params_for_overcapture = you could use a `use<...>` bound to explicitly specify captures, but argument-position `impl Trait`s are not nameable trait_selection_warn_removing_apit_params_for_undercapture = you could use a `use<...>` bound to explicitly capture `{$new_lifetime}`, but argument-position `impl Trait`s are not nameable trait_selection_where_copy_predicates = copy the `where` clause predicates from the trait trait_selection_where_remove = remove the `where` clause trait_selection_wrapped_parser_error = {$description} .label = {$label} ty_utils_address_and_deref_not_supported = dereferencing or taking the address is not supported in generic constants ty_utils_adt_not_supported = struct/enum construction is not supported in generic constants ty_utils_array_not_supported = array construction is not supported in generic constants ty_utils_assign_not_supported = assignment is not supported in generic constants ty_utils_binary_not_supported = unsupported binary operation in generic constants ty_utils_block_not_supported = blocks are not supported in generic constants ty_utils_borrow_not_supported = borrowing is not supported in generic constants ty_utils_box_not_supported = allocations are not allowed in generic constants ty_utils_by_use_not_supported = .use is not allowed in generic constants ty_utils_closure_and_return_not_supported = closures and function keywords are not supported in generic constants ty_utils_const_block_not_supported = const blocks are not supported in generic constants ty_utils_control_flow_not_supported = control flow is not supported in generic constants ty_utils_field_not_supported = field access is not supported in generic constants ty_utils_generic_constant_too_complex = overly complex generic constant .help = consider moving this anonymous constant into a `const` function .maybe_supported = this operation may be supported in the future ty_utils_impl_trait_duplicate_arg = non-defining opaque type use in defining scope .label = generic argument `{$arg}` used twice .note = for this opaque type ty_utils_impl_trait_not_param = non-defining opaque type use in defining scope .label = argument `{$arg}` is not a generic parameter .note = for this opaque type ty_utils_index_not_supported = indexing is not supported in generic constants ty_utils_inline_asm_not_supported = assembly is not supported in generic constants ty_utils_logical_op_not_supported = unsupported operation in generic constants, short-circuiting operations would imply control flow ty_utils_loop_not_supported = loops and loop control flow are not supported in generic constants ty_utils_needs_drop_overflow = overflow while checking whether `{$query_ty}` requires drop ty_utils_never_to_any_not_supported = coercing the `never` type is not supported in generic constants ty_utils_non_primitive_simd_type = monomorphising SIMD type `{$ty}` with a non-primitive-scalar (integer/float/pointer) element type `{$e_ty}` ty_utils_operation_not_supported = unsupported operation in generic constants ty_utils_oversized_simd_type = monomorphising SIMD type `{$ty}` of length greater than {$max_lanes} ty_utils_pointer_not_supported = pointer casts are not allowed in generic constants ty_utils_tuple_not_supported = tuple construction is not supported in generic constants ty_utils_unexpected_fnptr_associated_item = `FnPtr` trait with unexpected associated item ty_utils_yield_not_supported = coroutine control flow is not allowed in generic constants ty_utils_zero_length_simd_type = monomorphising SIMD type `{$ty}` of zero length explaincfgcheck-cfgno input filename givencompiler/rustc_driver_impl/src/lib.rsunstable_feature_usage_metrics-.jsonout-diroUNSTABLE_RUSTDOC_TEST_PATHUNSTABLE_RUSTDOC_TEST_LINEwhen UNSTABLE_RUSTDOC_TEST_PATH is set UNSTABLE_RUSTDOC_TEST_LINE also needs to be setUNSTABLE_RUSTDOC_TEST_LINE needs to be an numbercouldn't read from stdin, as it did not contain valid UTF-8multiple input filenames provided (first two filenames are `` and ``)```# is not a valid error codePAGER-Rbatbatcatdeltadriver_impl_rlink_wrong_file_typedriver_impl_rlink_empty_version_numberdriver_impl_rlink_no_a_filecannot list metadata for stdinany()=any() any() ==any()allowexpectforce-warnforbidonly Apple targets currently support deployment version infostdoutx86_64-unknown-linux-gnu