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