compiler/rustc_error_messages/locales/en-US/lint.ftl

   1 lint_array_into_iter =
   2     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 2021
   3     .use_iter_suggestion = use `.iter()` instead of `.into_iter()` to avoid ambiguity
   4     .remove_into_iter_suggestion = or remove `.into_iter()` to iterate by value
   5     .use_explicit_into_iter_suggestion =
   6         or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
   7
   8 lint_enum_intrinsics_mem_discriminant =
   9     the return value of `mem::discriminant` is unspecified when called with a non-enum type
  10     .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.
  11
  12 lint_enum_intrinsics_mem_variant =
  13     the return value of `mem::variant_count` is unspecified when called with a non-enum type
  14     .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.
  15
  16 lint_expectation = this lint expectation is unfulfilled
  17     .note = the `unfulfilled_lint_expectations` lint can't be expected and will always produce this message
  18     .rationale = {$rationale}
  19
  20 lint_for_loops_over_fallibles =
  21     for loop over {$article} `{$ty}`. This is more readably written as an `if let` statement
  22     .suggestion = consider using `if let` to clear intent
  23     .remove_next = to iterate over `{$recv_snip}` remove the call to `next`
  24     .use_while_let = to check pattern in a loop use `while let`
  25     .use_question_mark = consider unwrapping the `Result` with `?` to iterate over its contents
  26
  27 lint_non_binding_let_on_sync_lock =
  28     non-binding let on a synchronization lock
  29
  30 lint_non_binding_let_on_drop_type =
  31     non-binding let on a type that implements `Drop`
  32
  33 lint_non_binding_let_suggestion =
  34     consider binding to an unused variable to avoid immediately dropping the value
  35
  36 lint_non_binding_let_multi_suggestion =
  37     consider immediately dropping the value
  38
  39 lint_deprecated_lint_name =
  40     lint name `{$name}` is deprecated and may not have an effect in the future.
  41     .suggestion = change it to
  42
  43 lint_renamed_or_removed_lint = {$msg}
  44     .suggestion = use the new name
  45
  46 lint_unknown_lint =
  47     unknown lint: `{$name}`
  48     .suggestion = did you mean
  49
  50 lint_ignored_unless_crate_specified = {$level}({$name}) is ignored unless specified at crate level
  51
  52 lint_unknown_gated_lint =
  53     unknown lint: `{$name}`
  54     .note = the `{$name}` lint is unstable
  55
  56 lint_hidden_unicode_codepoints = unicode codepoint changing visible direction of text present in {$label}
  57     .label = this {$label} contains {$count ->
  58         [one] an invisible
  59         *[other] invisible
  60     } unicode text flow control {$count ->
  61         [one] codepoint
  62         *[other] codepoints
  63     }
  64     .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
  65     .suggestion_remove = if their presence wasn't intentional, you can remove them
  66     .suggestion_escape = if you want to keep them but make them visible in your source code, you can escape them
  67     .no_suggestion_note_escape = if you want to keep them but make them visible in your source code, you can escape them: {$escaped}
  68
  69 lint_default_hash_types = prefer `{$preferred}` over `{$used}`, it has better performance
  70     .note = a `use rustc_data_structures::fx::{$preferred}` may be necessary
  71
  72 lint_query_instability = using `{$query}` can result in unstable query results
  73     .note = if you believe this case to be fine, allow this lint and add a comment explaining your rationale
  74
  75 lint_tykind_kind = usage of `ty::TyKind::<kind>`
  76     .suggestion = try using `ty::<kind>` directly
  77
  78 lint_tykind = usage of `ty::TyKind`
  79     .help = try using `Ty` instead
  80
  81 lint_ty_qualified = usage of qualified `ty::{$ty}`
  82     .suggestion = try importing it and using it unqualified
  83
  84 lint_lintpass_by_hand = implementing `LintPass` by hand
  85     .help = try using `declare_lint_pass!` or `impl_lint_pass!` instead
  86
  87 lint_non_existant_doc_keyword = found non-existing keyword `{$keyword}` used in `#[doc(keyword = \"...\")]`
  88     .help = only existing keywords are allowed in core/std
  89
  90 lint_diag_out_of_impl =
  91     diagnostics should only be created in `IntoDiagnostic`/`AddToDiagnostic` impls
  92
  93 lint_untranslatable_diag = diagnostics should be created using translatable messages
  94
  95 lint_bad_opt_access = {$msg}
  96
  97 lint_cstring_ptr = getting the inner pointer of a temporary `CString`
  98     .as_ptr_label = this pointer will be invalid
  99     .unwrap_label = this `CString` is deallocated at the end of the statement, bind it to a variable to extend its lifetime
 100     .note = pointers do not have a lifetime; when calling `as_ptr` the `CString` will be deallocated at the end of the statement because nothing is referencing it as far as the type system is concerned
 101     .help = for more information, see https://doc.rust-lang.org/reference/destructors.html
 102
 103 lint_identifier_non_ascii_char = identifier contains non-ASCII characters
 104
 105 lint_identifier_uncommon_codepoints = identifier contains uncommon Unicode codepoints
 106
 107 lint_confusable_identifier_pair = identifier pair considered confusable between `{$existing_sym}` and `{$sym}`
 108     .label = this is where the previous identifier occurred
 109
 110 lint_mixed_script_confusables =
 111     the usage of Script Group `{$set}` in this crate consists solely of mixed script confusables
 112     .includes_note = the usage includes {$includes}
 113     .note = please recheck to make sure their usages are indeed what you want
 114
 115 lint_non_fmt_panic = panic message is not a string literal
 116     .note = this usage of `{$name}!()` is deprecated; it will be a hard error in Rust 2021
 117     .more_info_note = for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/panic-macro-consistency.html>
 118     .supports_fmt_note = the `{$name}!()` macro supports formatting, so there's no need for the `format!()` macro here
 119     .supports_fmt_suggestion = remove the `format!(..)` macro call
 120     .display_suggestion = add a "{"{"}{"}"}" format string to `Display` the message
 121     .debug_suggestion =
 122         add a "{"{"}:?{"}"}" format string to use the `Debug` implementation of `{$ty}`
 123     .panic_suggestion = {$already_suggested ->
 124         [true] or use
 125         *[false] use
 126     } std::panic::panic_any instead
 127
 128 lint_non_fmt_panic_unused =
 129     panic message contains {$count ->
 130         [one] an unused
 131         *[other] unused
 132     } formatting {$count ->
 133         [one] placeholder
 134         *[other] placeholders
 135     }
 136     .note = this message is not used as a format string when given without arguments, but will be in Rust 2021
 137     .add_args_suggestion = add the missing {$count ->
 138         [one] argument
 139         *[other] arguments
 140     }
 141     .add_fmt_suggestion = or add a "{"{"}{"}"}" format string to use the message literally
 142
 143 lint_non_fmt_panic_braces =
 144     panic message contains {$count ->
 145         [one] a brace
 146         *[other] braces
 147     }
 148     .note = this message is not used as a format string, but will be in Rust 2021
 149     .suggestion = add a "{"{"}{"}"}" format string to use the message literally
 150
 151 lint_non_camel_case_type = {$sort} `{$name}` should have an upper camel case name
 152     .suggestion = convert the identifier to upper camel case
 153     .label = should have an UpperCamelCase name
 154
 155 lint_non_snake_case = {$sort} `{$name}` should have a snake case name
 156     .rename_or_convert_suggestion = rename the identifier or convert it to a snake case raw identifier
 157     .cannot_convert_note = `{$sc}` cannot be used as a raw identifier
 158     .rename_suggestion = rename the identifier
 159     .convert_suggestion = convert the identifier to snake case
 160     .help = convert the identifier to snake case: `{$sc}`
 161     .label = should have a snake_case name
 162
 163 lint_non_upper_case_global = {$sort} `{$name}` should have an upper case name
 164     .suggestion = convert the identifier to upper case
 165     .label = should have an UPPER_CASE name
 166
 167 lint_noop_method_call = call to `.{$method}()` on a reference in this situation does nothing
 168     .label = unnecessary method call
 169     .note = the type `{$receiver_ty}` which `{$method}` is being called on is the same as the type returned from `{$method}`, so the method call does not do anything and can be removed
 170
 171 lint_pass_by_value = passing `{$ty}` by reference
 172     .suggestion = try passing by value
 173
 174 lint_redundant_semicolons =
 175     unnecessary trailing {$multiple ->
 176         [true] semicolons
 177         *[false] semicolon
 178     }
 179     .suggestion = remove {$multiple ->
 180         [true] these semicolons
 181         *[false] this semicolon
 182     }
 183
 184 lint_drop_trait_constraints =
 185     bounds on `{$predicate}` are most likely incorrect, consider instead using `{$needs_drop}` to detect whether a type can be trivially dropped
 186
 187 lint_drop_glue =
 188     types that do not implement `Drop` can still have drop glue, consider instead using `{$needs_drop}` to detect whether a type is trivially dropped
 189
 190 lint_range_endpoint_out_of_range = range endpoint is out of range for `{$ty}`
 191     .suggestion = use an inclusive range instead
 192
 193 lint_overflowing_bin_hex = literal out of range for `{$ty}`
 194     .negative_note = the literal `{$lit}` (decimal `{$dec}`) does not fit into the type `{$ty}`
 195     .negative_becomes_note = and the value `-{$lit}` will become `{$actually}{$ty}`
 196     .positive_note = the literal `{$lit}` (decimal `{$dec}`) does not fit into the type `{$ty}` and will become `{$actually}{$ty}`
 197     .suggestion = consider using the type `{$suggestion_ty}` instead
 198     .help = consider using the type `{$suggestion_ty}` instead
 199
 200 lint_overflowing_int = literal out of range for `{$ty}`
 201     .note = the literal `{$lit}` does not fit into the type `{$ty}` whose range is `{$min}..={$max}`
 202     .help = consider using the type `{$suggestion_ty}` instead
 203
 204 lint_only_cast_u8_to_char = only `u8` can be cast into `char`
 205     .suggestion = use a `char` literal instead
 206
 207 lint_overflowing_uint = literal out of range for `{$ty}`
 208     .note = the literal `{$lit}` does not fit into the type `{$ty}` whose range is `{$min}..={$max}`
 209
 210 lint_overflowing_literal = literal out of range for `{$ty}`
 211     .note = the literal `{$lit}` does not fit into the type `{$ty}` and will be converted to `{$ty}::INFINITY`
 212
 213 lint_unused_comparisons = comparison is useless due to type limits
 214
 215 lint_improper_ctypes = `extern` {$desc} uses type `{$ty}`, which is not FFI-safe
 216     .label = not FFI-safe
 217     .note = the type is defined here
 218
 219 lint_improper_ctypes_opaque = opaque types have no C equivalent
 220
 221 lint_improper_ctypes_fnptr_reason = this function pointer has Rust-specific calling convention
 222 lint_improper_ctypes_fnptr_help = consider using an `extern fn(...) -> ...` function pointer instead
 223
 224 lint_improper_ctypes_tuple_reason = tuples have unspecified layout
 225 lint_improper_ctypes_tuple_help = consider using a struct instead
 226
 227 lint_improper_ctypes_str_reason = string slices have no C equivalent
 228 lint_improper_ctypes_str_help = consider using `*const u8` and a length instead
 229
 230 lint_improper_ctypes_dyn = trait objects have no C equivalent
 231
 232 lint_improper_ctypes_slice_reason = slices have no C equivalent
 233 lint_improper_ctypes_slice_help = consider using a raw pointer instead
 234
 235 lint_improper_ctypes_128bit = 128-bit integers don't currently have a known stable ABI
 236
 237 lint_improper_ctypes_char_reason = the `char` type has no C equivalent
 238 lint_improper_ctypes_char_help = consider using `u32` or `libc::wchar_t` instead
 239
 240 lint_improper_ctypes_non_exhaustive = this enum is non-exhaustive
 241 lint_improper_ctypes_non_exhaustive_variant = this enum has non-exhaustive variants
 242
 243 lint_improper_ctypes_enum_repr_reason = enum has no representation hint
 244 lint_improper_ctypes_enum_repr_help =
 245     consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
 246
 247 lint_improper_ctypes_struct_fieldless_reason = this struct has no fields
 248 lint_improper_ctypes_struct_fieldless_help = consider adding a member to this struct
 249
 250 lint_improper_ctypes_union_fieldless_reason = this union has no fields
 251 lint_improper_ctypes_union_fieldless_help = consider adding a member to this union
 252
 253 lint_improper_ctypes_struct_non_exhaustive = this struct is non-exhaustive
 254 lint_improper_ctypes_union_non_exhaustive = this union is non-exhaustive
 255
 256 lint_improper_ctypes_struct_layout_reason = this struct has unspecified layout
 257 lint_improper_ctypes_struct_layout_help = consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
 258
 259 lint_improper_ctypes_union_layout_reason = this union has unspecified layout
 260 lint_improper_ctypes_union_layout_help = consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this union
 261
 262 lint_improper_ctypes_box = box cannot be represented as a single pointer
 263
 264 lint_improper_ctypes_enum_phantomdata = this enum contains a PhantomData field
 265
 266 lint_improper_ctypes_struct_zst = this struct contains only zero-sized fields
 267
 268 lint_improper_ctypes_array_reason = passing raw arrays by value is not FFI-safe
 269 lint_improper_ctypes_array_help = consider passing a pointer to the array
 270
 271 lint_improper_ctypes_only_phantomdata = composed only of `PhantomData`
 272
 273 lint_variant_size_differences =
 274     enum variant is more than three times larger ({$largest} bytes) than the next largest
 275
 276 lint_atomic_ordering_load = atomic loads cannot have `Release` or `AcqRel` ordering
 277     .help = consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
 278
 279 lint_atomic_ordering_store = atomic stores cannot have `Acquire` or `AcqRel` ordering
 280     .help = consider using ordering modes `Release`, `SeqCst` or `Relaxed`
 281
 282 lint_atomic_ordering_fence = memory fences cannot have `Relaxed` ordering
 283     .help = consider using ordering modes `Acquire`, `Release`, `AcqRel` or `SeqCst`
 284
 285 lint_atomic_ordering_invalid = `{$method}`'s failure ordering may not be `Release` or `AcqRel`, since a failed `{$method}` does not result in a write
 286     .label = invalid failure ordering
 287     .help = consider using `Acquire` or `Relaxed` failure ordering instead
 288
 289 lint_unused_op = unused {$op} that must be used
 290     .label = the {$op} produces a value
 291     .suggestion = use `let _ = ...` to ignore the resulting value
 292
 293 lint_unused_result = unused result of type `{$ty}`
 294
 295 lint_unused_closure =
 296     unused {$pre}{$count ->
 297         [one] closure
 298         *[other] closures
 299     }{$post} that must be used
 300     .note = closures are lazy and do nothing unless called
 301
 302 lint_unused_generator =
 303     unused {$pre}{$count ->
 304         [one] generator
 305         *[other] generator
 306     }{$post} that must be used
 307     .note = generators are lazy and do nothing unless resumed
 308
 309 lint_unused_def = unused {$pre}`{$def}`{$post} that must be used
 310
 311 lint_path_statement_drop = path statement drops value
 312     .suggestion = use `drop` to clarify the intent
 313
 314 lint_path_statement_no_effect = path statement with no effect
 315
 316 lint_unused_delim = unnecessary {$delim} around {$item}
 317     .suggestion = remove these {$delim}
 318
 319 lint_unused_import_braces = braces around {$node} is unnecessary
 320
 321 lint_unused_allocation = unnecessary allocation, use `&` instead
 322 lint_unused_allocation_mut = unnecessary allocation, use `&mut` instead
 323
 324 lint_builtin_while_true = denote infinite loops with `loop {"{"} ... {"}"}`
 325     .suggestion = use `loop`
 326
 327 lint_builtin_box_pointers = type uses owned (Box type) pointers: {$ty}
 328
 329 lint_builtin_non_shorthand_field_patterns = the `{$ident}:` in this pattern is redundant
 330     .suggestion = use shorthand field pattern
 331
 332 lint_builtin_overridden_symbol_name =
 333     the linker's behavior with multiple libraries exporting duplicate symbol names is undefined and Rust cannot provide guarantees when you manually override them
 334
 335 lint_builtin_overridden_symbol_section =
 336     the program's behavior with overridden link sections on items is unpredictable and Rust cannot provide guarantees when you manually override them
 337
 338 lint_builtin_allow_internal_unsafe =
 339     `allow_internal_unsafe` allows defining macros using unsafe without triggering the `unsafe_code` lint at their call site
 340
 341 lint_builtin_unsafe_block = usage of an `unsafe` block
 342
 343 lint_builtin_unsafe_trait = declaration of an `unsafe` trait
 344
 345 lint_builtin_unsafe_impl = implementation of an `unsafe` trait
 346
 347 lint_builtin_no_mangle_fn = declaration of a `no_mangle` function
 348 lint_builtin_export_name_fn = declaration of a function with `export_name`
 349 lint_builtin_link_section_fn = declaration of a function with `link_section`
 350
 351 lint_builtin_no_mangle_static = declaration of a `no_mangle` static
 352 lint_builtin_export_name_static = declaration of a static with `export_name`
 353 lint_builtin_link_section_static = declaration of a static with `link_section`
 354
 355 lint_builtin_no_mangle_method = declaration of a `no_mangle` method
 356 lint_builtin_export_name_method = declaration of a method with `export_name`
 357
 358 lint_builtin_decl_unsafe_fn = declaration of an `unsafe` function
 359 lint_builtin_decl_unsafe_method = declaration of an `unsafe` method
 360 lint_builtin_impl_unsafe_method = implementation of an `unsafe` method
 361
 362 lint_builtin_missing_doc = missing documentation for {$article} {$desc}
 363
 364 lint_builtin_missing_copy_impl = type could implement `Copy`; consider adding `impl Copy`
 365
 366 lint_builtin_missing_debug_impl =
 367     type does not implement `{$debug}`; consider adding `#[derive(Debug)]` or a manual implementation
 368
 369 lint_builtin_anonymous_params = anonymous parameters are deprecated and will be removed in the next edition
 370     .suggestion = try naming the parameter or explicitly ignoring it
 371
 372 lint_builtin_deprecated_attr_link = use of deprecated attribute `{$name}`: {$reason}. See {$link}
 373     .msg_suggestion = {$msg}
 374     .default_suggestion = remove this attribute
 375 lint_builtin_deprecated_attr_used = use of deprecated attribute `{$name}`: no longer used.
 376 lint_builtin_deprecated_attr_default_suggestion = remove this attribute
 377
 378 lint_builtin_unused_doc_comment = unused doc comment
 379     .label = rustdoc does not generate documentation for {$kind}
 380     .plain_help = use `//` for a plain comment
 381     .block_help = use `/* */` for a plain comment
 382
 383 lint_builtin_no_mangle_generic = functions generic over types or consts must be mangled
 384     .suggestion = remove this attribute
 385
 386 lint_builtin_const_no_mangle = const items should never be `#[no_mangle]`
 387     .suggestion = try a static value
 388
 389 lint_builtin_mutable_transmutes =
 390     transmuting &T to &mut T is undefined behavior, even if the reference is unused, consider instead using an UnsafeCell
 391
 392 lint_builtin_unstable_features = unstable feature
 393
 394 lint_ungated_async_fn_track_caller = `#[track_caller]` on async functions is a no-op
 395      .label = this function will not propagate the caller location
 396
 397 lint_builtin_unreachable_pub = unreachable `pub` {$what}
 398     .suggestion = consider restricting its visibility
 399     .help = or consider exporting it for use by other crates
 400
 401 lint_builtin_unexpected_cli_config_name = unexpected `{$name}` as condition name
 402     .help = was set with `--cfg` but isn't in the `--check-cfg` expected names
 403
 404 lint_builtin_unexpected_cli_config_value = unexpected condition value `{$value}` for condition name `{$name}`
 405     .help = was set with `--cfg` but isn't in the `--check-cfg` expected values
 406
 407 lint_builtin_type_alias_bounds_help = use fully disambiguated paths (i.e., `<T as Trait>::Assoc`) to refer to associated types in type aliases
 408
 409 lint_builtin_type_alias_where_clause = where clauses are not enforced in type aliases
 410     .suggestion = the clause will not be checked when the type alias is used, and should be removed
 411
 412 lint_builtin_type_alias_generic_bounds = bounds on generic parameters are not enforced in type aliases
 413     .suggestion = the bound will not be checked when the type alias is used, and should be removed
 414
 415 lint_builtin_trivial_bounds = {$predicate_kind_name} bound {$predicate} does not depend on any type or lifetime parameters
 416
 417 lint_builtin_ellipsis_inclusive_range_patterns = `...` range patterns are deprecated
 418     .suggestion = use `..=` for an inclusive range
 419
 420 lint_builtin_unnameable_test_items = cannot test inner items
 421
 422 lint_builtin_keyword_idents = `{$kw}` is a keyword in the {$next} edition
 423     .suggestion = you can use a raw identifier to stay compatible
 424
 425 lint_builtin_explicit_outlives = outlives requirements can be inferred
 426     .suggestion = remove {$count ->
 427         [one] this bound
 428         *[other] these bounds
 429     }
 430
 431 lint_builtin_incomplete_features = the feature `{$name}` is incomplete and may not be safe to use and/or cause compiler crashes
 432     .note = see issue #{$n} <https://github.com/rust-lang/rust/issues/{$n}> for more information
 433     .help = consider using `min_{$name}` instead, which is more stable and complete
 434
 435 lint_builtin_unpermitted_type_init_zeroed = the type `{$ty}` does not permit zero-initialization
 436 lint_builtin_unpermitted_type_init_unint = the type `{$ty}` does not permit being left uninitialized
 437
 438 lint_builtin_unpermitted_type_init_label = this code causes undefined behavior when executed
 439 lint_builtin_unpermitted_type_init_label_suggestion = help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
 440
 441 lint_builtin_clashing_extern_same_name = `{$this}` redeclared with a different signature
 442     .previous_decl_label = `{$orig}` previously declared here
 443     .mismatch_label = this signature doesn't match the previous declaration
 444 lint_builtin_clashing_extern_diff_name = `{$this}` redeclares `{$orig}` with a different signature
 445     .previous_decl_label = `{$orig}` previously declared here
 446     .mismatch_label = this signature doesn't match the previous declaration
 447
 448 lint_builtin_deref_nullptr = dereferencing a null pointer
 449     .label = this code causes undefined behavior when executed
 450
 451 lint_builtin_asm_labels = avoid using named labels in inline assembly
 452
 453 lint_builtin_special_module_name_used_lib = found module declaration for lib.rs
 454     .note = lib.rs is the root of this crate's library target
 455     .help = to refer to it from other targets, use the library's name as the path
 456
 457 lint_builtin_special_module_name_used_main = found module declaration for main.rs
 458     .note = a binary crate cannot be used as library
 459
 460 lint_supertrait_as_deref_target = `{$t}` implements `Deref` with supertrait `{$target_principal}` as target
 461     .label = target type is set here
 462
 463 lint_overruled_attribute = {$lint_level}({$lint_source}) incompatible with previous forbid
 464     .label = overruled by previous forbid
 465
 466 lint_default_source = `forbid` lint level is the default for {$id}
 467
 468 lint_node_source = `forbid` level set here
 469     .note = {$reason}
 470
 471 lint_command_line_source = `forbid` lint level was set on command line
 472
 473 lint_malformed_attribute = malformed lint attribute input
 474
 475 lint_bad_attribute_argument = bad attribute argument
 476
 477 lint_reason_must_be_string_literal = reason must be a string literal
 478
 479 lint_reason_must_come_last = reason in lint attribute must come last
 480
 481 lint_unknown_tool_in_scoped_lint = unknown tool name `{$tool_name}` found in scoped lint: `{$tool_name}::{$lint_name}`
 482     .help = add `#![register_tool({$tool_name})]` to the crate root
 483
 484 lint_unsupported_group = `{$lint_group}` lint group is not supported with ´--force-warn´
 485
 486 lint_requested_level = requested on the command line with `{$level} {$lint_name}`
 487
 488 lint_check_name_unknown = unknown lint: `{$lint_name}`
 489     .help = did you mean: `{$suggestion}`
 490
 491 lint_check_name_unknown_tool = unknown lint tool: `{$tool_name}`
 492
 493 lint_check_name_warning = {$msg}
 494
 495 lint_check_name_deprecated = lint name `{$lint_name}` is deprecated and does not have an effect anymore. Use: {$new_name}
 496
 497 lint_opaque_hidden_inferred_bound = opaque type `{$ty}` does not satisfy its associated type bounds
 498     .specifically = this associated type bound is unsatisfied for `{$proj_ty}`
 499
 500 lint_opaque_hidden_inferred_bound_sugg = add this bound