nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 06:44:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace - with _ in ftl slugs for better grepability

Browse Source 
Having to replace - with _ (and vice versa) makes the slugs less greppable
and thus constitutes a contributor roadblock.

Result of running this repeatedly up until reaching a fixpoint:

find compiler/rustc_error_messages/locales/en-US/ -type f -exec sed -i 's/\(.+\)-\(.*\)=/\1_\2=/' {} \;

Plus some fixes to update usages of slugs leading with -.
This commit is contained in:
est31 2022-08-10 09:42:10 +02:00
parent f22819bcce
commit cc6cff564f
9 changed files with 358 additions and 358 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
compiler/rustc_error_messages/locales/en-US/borrowck.ftl
View File

@ -1,18 +1,18 @@
borrowck-move-unsized = borrowck_move_unsized =
cannot move a value of type `{$ty}` cannot move a value of type `{$ty}`
.label = the size of `{$ty}` cannot be statically determined .label = the size of `{$ty}` cannot be statically determined
borrowck-higher-ranked-lifetime-error = borrowck_higher_ranked_lifetime_error =
higher-ranked lifetime error higher-ranked lifetime error
borrowck-could-not-prove = borrowck_could_not_prove =
could not prove `{$predicate}` could not prove `{$predicate}`
borrowck-could-not-normalize = borrowck_could_not_normalize =
could not normalize `{$value}` could not normalize `{$value}`
borrowck-higher-ranked-subtype-error = borrowck_higher_ranked_subtype_error =
higher-ranked subtype error higher-ranked subtype error
generic-does-not-live-long-enough = generic_does_not_live_long_enough =
`{$kind}` does not live long enough `{$kind}` does not live long enough

4
compiler/rustc_error_messages/locales/en-US/builtin_macros.ftl
View File

@ -1,5 +1,5 @@
builtin-macros-requires-cfg-pattern = builtin_macros_requires_cfg_pattern =
macro requires a cfg-pattern as an argument macro requires a cfg-pattern as an argument
.label = cfg-pattern required .label = cfg-pattern required
builtin-macros-expected-one-cfg-pattern = expected 1 cfg-pattern builtin_macros_expected_one_cfg_pattern = expected 1 cfg-pattern

26
compiler/rustc_error_messages/locales/en-US/const_eval.ftl
View File

@ -1,31 +1,31 @@
const-eval-unstable-in-stable = const_eval_unstable_in_stable =
const-stable function cannot use `#[feature({$gate})]` const-stable function cannot use `#[feature({$gate})]`
.unstable-sugg = if it is not part of the public API, make this function unstably const .unstable_sugg = if it is not part of the public API, make this function unstably const
.bypass-sugg = otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks .bypass_sugg = otherwise `#[rustc_allow_const_fn_unstable]` can be used to bypass stability checks
const-eval-thread-local-access = const_eval_thread_local_access =
thread-local statics cannot be accessed at compile-time thread-local statics cannot be accessed at compile-time
const-eval-static-access = const_eval_static_access =
{$kind}s cannot refer to statics {$kind}s cannot refer to statics
.help = consider extracting the value of the `static` to a `const`, and referring to that .help = consider extracting the value of the `static` to a `const`, and referring to that
.teach-note = `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable. .teach_note = `static` and `const` variables can refer to other `const` variables. A `const` variable, however, cannot refer to a `static` variable.
.teach-help = To fix this, the value can be extracted to a `const` and then used. .teach_help = To fix this, the value can be extracted to a `const` and then used.
const-eval-raw-ptr-to-int = const_eval_raw_ptr_to_int =
pointers cannot be cast to integers during const eval pointers cannot be cast to integers during const eval
.note = at compile-time, pointers do not have an integer value .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 .note2 = avoiding this restriction via `transmute`, `union`, or raw pointers leads to compile-time undefined behavior
const-eval-raw-ptr-comparison = const_eval_raw_ptr_comparison =
pointers cannot be reliably compared during const eval pointers cannot be reliably compared during const eval
.note = see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information .note = see issue #53020 <https://github.com/rust-lang/rust/issues/53020> for more information
const-eval-panic-non-str = argument to `panic!()` in a const context must have type `&str` const_eval_panic_non_str = argument to `panic!()` in a const context must have type `&str`
const-eval-mut-deref = const_eval_mut_deref =
mutation through a reference is not allowed in {$kind}s mutation through a reference is not allowed in {$kind}s
const-eval-transient-mut-borrow = mutable references are not allowed in {$kind}s const_eval_transient_mut_borrow = mutable references are not allowed in {$kind}s
const-eval-transient-mut-borrow-raw = raw mutable references are not allowed in {$kind}s const_eval_transient_mut_borrow_raw = raw mutable references are not allowed in {$kind}s

4
compiler/rustc_error_messages/locales/en-US/expand.ftl
View File

@ -1,5 +1,5 @@
expand-explain-doc-comment-outer = expand_explain_doc_comment_outer =
outer doc comments expand to `#[doc = "..."]`, which is what this macro attempted to match outer doc comments expand to `#[doc = "..."]`, which is what this macro attempted to match
expand-explain-doc-comment-inner = expand_explain_doc_comment_inner =
inner doc comments expand to `#![doc = "..."]`, which is what this macro attempted to match inner doc comments expand to `#![doc = "..."]`, which is what this macro attempted to match

326
compiler/rustc_error_messages/locales/en-US/lint.ftl
View File

@ -1,22 +1,22 @@
lint-array-into-iter = lint_array_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 2021 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
.use-iter-suggestion = use `.iter()` instead of `.into_iter()` to avoid ambiguity .use_iter_suggestion = use `.iter()` instead of `.into_iter()` to avoid ambiguity
.remove-into-iter-suggestion = or remove `.into_iter()` to iterate by value .remove_into_iter_suggestion = or remove `.into_iter()` to iterate by value
.use-explicit-into-iter-suggestion = .use_explicit_into_iter_suggestion =
or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
lint-enum-intrinsics-mem-discriminant = lint_enum_intrinsics_mem_discriminant =
the return value of `mem::discriminant` is unspecified when called with a non-enum type 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. .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 = lint_enum_intrinsics_mem_variant =
the return value of `mem::variant_count` is unspecified when called with a non-enum type 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. .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 lint_expectation = this lint expectation is unfulfilled
.note = the `unfulfilled_lint_expectations` lint can't be expected and will always produce this message .note = the `unfulfilled_lint_expectations` lint can't be expected and will always produce this message
lint-hidden-unicode-codepoints = unicode codepoint changing visible direction of text present in {$label} lint_hidden_unicode_codepoints = unicode codepoint changing visible direction of text present in {$label}
.label = this {$label} contains {$count -> .label = this {$label} contains {$count ->
[one] an invisible [one] an invisible
*[other] invisible *[other] invisible
@ -25,68 +25,68 @@ lint-hidden-unicode-codepoints = unicode codepoint changing visible direction of
*[other] codepoints *[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 .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_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 .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} .no_suggestion_note_escape = if you want to keep them but make them visible in your source code, you can escape them: {$escaped}
lint-default-hash-types = prefer `{$preferred}` over `{$used}`, it has better performance lint_default_hash_types = prefer `{$preferred}` over `{$used}`, it has better performance
.note = a `use rustc_data_structures::fx::{$preferred}` may be necessary .note = a `use rustc_data_structures::fx::{$preferred}` may be necessary
lint-query-instability = using `{$query}` can result in unstable query results 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 .note = if you believe this case to be fine, allow this lint and add a comment explaining your rationale
lint-tykind-kind = usage of `ty::TyKind::<kind>` lint_tykind_kind = usage of `ty::TyKind::<kind>`
.suggestion = try using `ty::<kind>` directly .suggestion = try using `ty::<kind>` directly
lint-tykind = usage of `ty::TyKind` lint_tykind = usage of `ty::TyKind`
.help = try using `Ty` instead .help = try using `Ty` instead
lint-ty-qualified = usage of qualified `ty::{$ty}` lint_ty_qualified = usage of qualified `ty::{$ty}`
.suggestion = try importing it and using it unqualified .suggestion = try importing it and using it unqualified
lint-lintpass-by-hand = implementing `LintPass` by hand lint_lintpass_by_hand = implementing `LintPass` by hand
.help = try using `declare_lint_pass!` or `impl_lint_pass!` instead .help = try using `declare_lint_pass!` or `impl_lint_pass!` instead
lint-non-existant-doc-keyword = found non-existing keyword `{$keyword}` used in `#[doc(keyword = \"...\")]` lint_non_existant_doc_keyword = found non-existing keyword `{$keyword}` used in `#[doc(keyword = \"...\")]`
.help = only existing keywords are allowed in core/std .help = only existing keywords are allowed in core/std
lint-diag-out-of-impl = lint_diag_out_of_impl =
diagnostics should only be created in `SessionDiagnostic`/`AddSubdiagnostic` impls diagnostics should only be created in `SessionDiagnostic`/`AddSubdiagnostic` impls
lint-untranslatable-diag = diagnostics should be created using translatable messages lint_untranslatable_diag = diagnostics should be created using translatable messages
lint-cstring-ptr = getting the inner pointer of a temporary `CString` lint_cstring_ptr = getting the inner pointer of a temporary `CString`
.as-ptr-label = this pointer will be invalid .as_ptr_label = this pointer will be invalid
.unwrap-label = this `CString` is deallocated at the end of the statement, bind it to a variable to extend its lifetime .unwrap_label = this `CString` 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 `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 .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
.help = for more information, see https://doc.rust-lang.org/reference/destructors.html .help = for more information, see https://doc.rust-lang.org/reference/destructors.html
lint-identifier-non-ascii-char = identifier contains non-ASCII characters lint_identifier_non_ascii_char = identifier contains non-ASCII characters
lint-identifier-uncommon-codepoints = identifier contains uncommon Unicode codepoints lint_identifier_uncommon_codepoints = identifier contains uncommon Unicode codepoints
lint-confusable-identifier-pair = identifier pair considered confusable between `{$existing_sym}` and `{$sym}` lint_confusable_identifier_pair = identifier pair considered confusable between `{$existing_sym}` and `{$sym}`
.label = this is where the previous identifier occurred .label = this is where the previous identifier occurred
lint-mixed-script-confusables = lint_mixed_script_confusables =
the usage of Script Group `{$set}` in this crate consists solely of mixed script confusables the usage of Script Group `{$set}` in this crate consists solely of mixed script confusables
.includes-note = the usage includes {$includes} .includes_note = the usage includes {$includes}
.note = please recheck to make sure their usages are indeed what you want .note = please recheck to make sure their usages are indeed what you want
lint-non-fmt-panic = panic message is not a string literal 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 .note = this usage of `{$name}!()` is deprecated; it will be a hard error in Rust 2021
.more-info-note = for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/panic-macro-consistency.html> .more_info_note = for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/panic-macro-consistency.html>
.supports-fmt-note = the `{$name}!()` macro supports formatting, so there's no need for the `format!()` macro here .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 .supports_fmt_suggestion = remove the `format!(..)` macro call
.display-suggestion = add a "{"{"}{"}"}" format string to `Display` the message .display_suggestion = add a "{"{"}{"}"}" format string to `Display` the message
.debug-suggestion = .debug_suggestion =
add a "{"{"}:?{"}"}" format string to use the `Debug` implementation of `{$ty}` add a "{"{"}:?{"}"}" format string to use the `Debug` implementation of `{$ty}`
.panic-suggestion = {$already_suggested -> .panic_suggestion = {$already_suggested ->
[true] or use [true] or use
*[false] use *[false] use
} std::panic::panic_any instead } std::panic::panic_any instead
lint-non-fmt-panic-unused = lint_non_fmt_panic_unused =
panic message contains {$count -> panic message contains {$count ->
[one] an unused [one] an unused
*[other] unused *[other] unused
@ -95,13 +95,13 @@ lint-non-fmt-panic-unused =
*[other] placeholders *[other] placeholders
} }
.note = this message is not used as a format string when given without arguments, but will be in Rust 2021 .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 -> .add_args_suggestion = add the missing {$count ->
[one] argument [one] argument
*[other] arguments *[other] arguments
} }
.add-fmt-suggestion = or add a "{"{"}{"}"}" format string to use the message literally .add_fmt_suggestion = or add a "{"{"}{"}"}" format string to use the message literally
lint-non-fmt-panic-braces = lint_non_fmt_panic_braces =
panic message contains {$count -> panic message contains {$count ->
[one] a brace [one] a brace
*[other] braces *[other] braces
@ -109,30 +109,30 @@ lint-non-fmt-panic-braces =
.note = this message is not used as a format string, but will be in Rust 2021 .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 .suggestion = add a "{"{"}{"}"}" format string to use the message literally
lint-non-camel-case-type = {$sort} `{$name}` should have an upper camel case name lint_non_camel_case_type = {$sort} `{$name}` should have an upper camel case name
.suggestion = convert the identifier to upper camel case .suggestion = convert the identifier to upper camel case
.label = should have an UpperCamelCase name .label = should have an UpperCamelCase name
lint-non-snake-case = {$sort} `{$name}` should have a snake case name 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 .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 .cannot_convert_note = `{$sc}` cannot be used as a raw identifier
.rename-suggestion = rename the identifier .rename_suggestion = rename the identifier
.convert-suggestion = convert the identifier to snake case .convert_suggestion = convert the identifier to snake case
.help = convert the identifier to snake case: `{$sc}` .help = convert the identifier to snake case: `{$sc}`
.label = should have a snake_case name .label = should have a snake_case name
lint-non-upper_case-global = {$sort} `{$name}` should have an upper case name lint_non_upper_case_global = {$sort} `{$name}` should have an upper case name
.suggestion = convert the identifier to upper case .suggestion = convert the identifier to upper case
.label = should have an UPPER_CASE name .label = should have an UPPER_CASE name
lint-noop-method-call = call to `.{$method}()` on a reference in this situation does nothing lint_noop_method_call = call to `.{$method}()` on a reference in this situation does nothing
.label = unnecessary method call .label = unnecessary method call
.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 .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
lint-pass-by-value = passing `{$ty}` by reference lint_pass_by_value = passing `{$ty}` by reference
.suggestion = try passing by value .suggestion = try passing by value
lint-redundant-semicolons = lint_redundant_semicolons =
unnecessary trailing {$multiple -> unnecessary trailing {$multiple ->
[true] semicolons [true] semicolons
*[false] semicolon *[false] semicolon
@ -142,254 +142,254 @@ lint-redundant-semicolons =
*[false] this semicolon *[false] this semicolon
} }
lint-drop-trait-constraints = 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 bounds on `{$predicate}` are most likely incorrect, consider instead using `{$needs_drop}` to detect whether a type can be trivially dropped
lint-drop-glue = 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 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-range-endpoint-out-of-range = range endpoint is out of range for `{$ty}` lint_range_endpoint_out_of_range = range endpoint is out of range for `{$ty}`
.suggestion = use an inclusive range instead .suggestion = use an inclusive range instead
lint-overflowing-bin-hex = literal out of range for `{$ty}` 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_note = the literal `{$lit}` (decimal `{$dec}`) does not fit into the type `{$ty}`
.negative-becomes-note = and the value `-{$lit}` will become `{$actually}{$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}` .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 .suggestion = consider using the type `{$suggestion_ty}` instead
.help = consider using the type `{$suggestion_ty}` instead .help = consider using the type `{$suggestion_ty}` instead
lint-overflowing-int = literal out of range for `{$ty}` 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}` .note = the literal `{$lit}` does not fit into the type `{$ty}` whose range is `{$min}..={$max}`
.help = consider using the type `{$suggestion_ty}` instead .help = consider using the type `{$suggestion_ty}` instead
lint-only-cast-u8-to-char = only `u8` can be cast into `char` lint_only_cast_u8_to_char = only `u8` can be cast into `char`
.suggestion = use a `char` literal instead .suggestion = use a `char` literal instead
lint-overflowing-uint = literal out of range for `{$ty}` 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}` .note = the literal `{$lit}` does not fit into the type `{$ty}` whose range is `{$min}..={$max}`
lint-overflowing-literal = literal out of range for `{$ty}` 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` .note = the literal `{$lit}` does not fit into the type `{$ty}` and will be converted to `{$ty}::INFINITY`
lint-unused-comparisons = comparison is useless due to type limits lint_unused_comparisons = comparison is useless due to type limits
lint-improper-ctypes = `extern` {$desc} uses type `{$ty}`, which is not FFI-safe lint_improper_ctypes = `extern` {$desc} uses type `{$ty}`, which is not FFI-safe
.label = not FFI-safe .label = not FFI-safe
.note = the type is defined here .note = the type is defined here
lint-improper-ctypes-opaque = opaque types have no C equivalent lint_improper_ctypes_opaque = opaque types have no C equivalent
lint-improper-ctypes-fnptr-reason = this function pointer has Rust-specific calling convention lint_improper_ctypes_fnptr_reason = this function pointer has Rust-specific calling convention
lint-improper-ctypes-fnptr-help = consider using an `extern fn(...) -> ...` function pointer instead lint_improper_ctypes_fnptr_help = consider using an `extern fn(...) -> ...` function pointer instead
lint-improper-ctypes-tuple-reason = tuples have unspecified layout lint_improper_ctypes_tuple_reason = tuples have unspecified layout
lint-improper-ctypes-tuple-help = consider using a struct instead lint_improper_ctypes_tuple_help = consider using a struct instead
lint-improper-ctypes-str-reason = string slices have no C equivalent lint_improper_ctypes_str_reason = string slices have no C equivalent
lint-improper-ctypes-str-help = consider using `*const u8` and a length instead lint_improper_ctypes_str_help = consider using `*const u8` and a length instead
lint-improper-ctypes-dyn = trait objects have no C equivalent lint_improper_ctypes_dyn = trait objects have no C equivalent
lint-improper-ctypes-slice-reason = slices have no C equivalent lint_improper_ctypes_slice_reason = slices have no C equivalent
lint-improper-ctypes-slice-help = consider using a raw pointer instead lint_improper_ctypes_slice_help = consider using a raw pointer instead
lint-improper-ctypes-128bit = 128-bit integers don't currently have a known stable ABI lint_improper_ctypes_128bit = 128-bit integers don't currently have a known stable ABI
lint-improper-ctypes-char-reason = the `char` type has no C equivalent lint_improper_ctypes_char_reason = the `char` type has no C equivalent
lint-improper-ctypes-char-help = consider using `u32` or `libc::wchar_t` instead lint_improper_ctypes_char_help = consider using `u32` or `libc::wchar_t` instead
lint-improper-ctypes-non-exhaustive = this enum is non-exhaustive 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_non_exhaustive_variant = this enum has non-exhaustive variants
lint-improper-ctypes-enum-repr-reason = enum has no representation hint lint_improper_ctypes_enum_repr_reason = enum has no representation hint
lint-improper-ctypes-enum-repr-help = lint_improper_ctypes_enum_repr_help =
consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
lint-improper-ctypes-struct-fieldless-reason = this struct has no fields lint_improper_ctypes_struct_fieldless_reason = this struct has no fields
lint-improper-ctypes-struct-fieldless-help = consider adding a member to this struct lint_improper_ctypes_struct_fieldless_help = consider adding a member to this struct
lint-improper-ctypes-union-fieldless-reason = this union has no fields lint_improper_ctypes_union_fieldless_reason = this union has no fields
lint-improper-ctypes-union-fieldless-help = consider adding a member to this union lint_improper_ctypes_union_fieldless_help = consider adding a member to this union
lint-improper-ctypes-struct-non-exhaustive = this struct is non-exhaustive lint_improper_ctypes_struct_non_exhaustive = this struct is non-exhaustive
lint-improper-ctypes-union-non-exhaustive = this union is non-exhaustive lint_improper_ctypes_union_non_exhaustive = this union is non-exhaustive
lint-improper-ctypes-struct-layout-reason = this struct has unspecified layout lint_improper_ctypes_struct_layout_reason = this struct has unspecified layout
lint-improper-ctypes-struct-layout-help = consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct lint_improper_ctypes_struct_layout_help = consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this struct
lint-improper-ctypes-union-layout-reason = this union has unspecified layout lint_improper_ctypes_union_layout_reason = this union has unspecified layout
lint-improper-ctypes-union-layout-help = consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this union lint_improper_ctypes_union_layout_help = consider adding a `#[repr(C)]` or `#[repr(transparent)]` attribute to this union
lint-improper-ctypes-box = box cannot be represented as a single pointer lint_improper_ctypes_box = box cannot be represented as a single pointer
lint-improper-ctypes-enum-phantomdata = this enum contains a PhantomData field lint_improper_ctypes_enum_phantomdata = this enum contains a PhantomData field
lint-improper-ctypes-struct-zst = this struct contains only zero-sized fields lint_improper_ctypes_struct_zst = this struct contains only zero-sized fields
lint-improper-ctypes-array-reason = passing raw arrays by value is not FFI-safe lint_improper_ctypes_array_reason = passing raw arrays by value is not FFI-safe
lint-improper-ctypes-array-help = consider passing a pointer to the array lint_improper_ctypes_array_help = consider passing a pointer to the array
lint-improper-ctypes-only-phantomdata = composed only of `PhantomData` lint_improper_ctypes_only_phantomdata = composed only of `PhantomData`
lint-variant-size-differences = lint_variant_size_differences =
enum variant is more than three times larger ({$largest} bytes) than the next largest enum variant is more than three times larger ({$largest} bytes) than the next largest
lint-atomic-ordering-load = atomic loads cannot have `Release` or `AcqRel` ordering lint_atomic_ordering_load = atomic loads cannot have `Release` or `AcqRel` ordering
.help = consider using ordering modes `Acquire`, `SeqCst` or `Relaxed` .help = consider using ordering modes `Acquire`, `SeqCst` or `Relaxed`
lint-atomic-ordering-store = atomic stores cannot have `Acquire` or `AcqRel` ordering lint_atomic_ordering_store = atomic stores cannot have `Acquire` or `AcqRel` ordering
.help = consider using ordering modes `Release`, `SeqCst` or `Relaxed` .help = consider using ordering modes `Release`, `SeqCst` or `Relaxed`
lint-atomic-ordering-fence = memory fences cannot have `Relaxed` ordering lint_atomic_ordering_fence = memory fences cannot have `Relaxed` ordering
.help = consider using ordering modes `Acquire`, `Release`, `AcqRel` or `SeqCst` .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 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 .label = invalid failure ordering
.help = consider using `Acquire` or `Relaxed` failure ordering instead .help = consider using `Acquire` or `Relaxed` failure ordering instead
lint-unused-op = unused {$op} that must be used lint_unused_op = unused {$op} that must be used
.label = the {$op} produces a value .label = the {$op} produces a value
.suggestion = use `let _ = ...` to ignore the resulting value .suggestion = use `let _ = ...` to ignore the resulting value
lint-unused-result = unused result of type `{$ty}` lint_unused_result = unused result of type `{$ty}`
lint-unused-closure = lint_unused_closure =
unused {$pre}{$count -> unused {$pre}{$count ->
[one] closure [one] closure
*[other] closures *[other] closures
}{$post} that must be used }{$post} that must be used
.note = closures are lazy and do nothing unless called .note = closures are lazy and do nothing unless called
lint-unused-generator = lint_unused_generator =
unused {$pre}{$count -> unused {$pre}{$count ->
[one] generator [one] generator
*[other] generator *[other] generator
}{$post} that must be used }{$post} that must be used
.note = generators are lazy and do nothing unless resumed .note = generators are lazy and do nothing unless resumed
lint-unused-def = unused {$pre}`{$def}`{$post} that must be used lint_unused_def = unused {$pre}`{$def}`{$post} that must be used
lint-path-statement-drop = path statement drops value lint_path_statement_drop = path statement drops value
.suggestion = use `drop` to clarify the intent .suggestion = use `drop` to clarify the intent
lint-path-statement-no-effect = path statement with no effect lint_path_statement_no_effect = path statement with no effect
lint-unused-delim = unnecessary {$delim} around {$item} lint_unused_delim = unnecessary {$delim} around {$item}
.suggestion = remove these {$delim} .suggestion = remove these {$delim}
lint-unused-import-braces = braces around {$node} is unnecessary lint_unused_import_braces = braces around {$node} is unnecessary
lint-unused-allocation = unnecessary allocation, use `&` instead lint_unused_allocation = unnecessary allocation, use `&` instead
lint-unused-allocation-mut = unnecessary allocation, use `&mut` instead lint_unused_allocation_mut = unnecessary allocation, use `&mut` instead
lint-builtin-while-true = denote infinite loops with `loop {"{"} ... {"}"}` lint_builtin_while_true = denote infinite loops with `loop {"{"} ... {"}"}`
.suggestion = use `loop` .suggestion = use `loop`
lint-builtin-box-pointers = type uses owned (Box type) pointers: {$ty} lint_builtin_box_pointers = type uses owned (Box type) pointers: {$ty}
lint-builtin-non-shorthand-field-patterns = the `{$ident}:` in this pattern is redundant lint_builtin_non_shorthand_field_patterns = the `{$ident}:` in this pattern is redundant
.suggestion = use shorthand field pattern .suggestion = use shorthand field pattern
lint-builtin-overridden-symbol-name = 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 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 = 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 the program's behavior with overridden link sections on items is unpredictable and Rust cannot provide guarantees when you manually override them
lint-builtin-allow-internal-unsafe = lint_builtin_allow_internal_unsafe =
`allow_internal_unsafe` allows defining macros using unsafe without triggering the `unsafe_code` lint at their call site `allow_internal_unsafe` allows defining macros using unsafe without triggering the `unsafe_code` lint at their call site
lint-builtin-unsafe-block = usage of an `unsafe` block lint_builtin_unsafe_block = usage of an `unsafe` block
lint-builtin-unsafe-trait = declaration of an `unsafe` trait lint_builtin_unsafe_trait = declaration of an `unsafe` trait
lint-builtin-unsafe-impl = implementation of an `unsafe` trait lint_builtin_unsafe_impl = implementation of an `unsafe` trait
lint-builtin-no-mangle-fn = declaration of a `no_mangle` function lint_builtin_no_mangle_fn = declaration of a `no_mangle` function
lint-builtin-export-name-fn = declaration of a function with `export_name` lint_builtin_export_name_fn = declaration of a function with `export_name`
lint-builtin-link-section-fn = declaration of a function with `link_section` lint_builtin_link_section_fn = declaration of a function with `link_section`
lint-builtin-no-mangle-static = declaration of a `no_mangle` static lint_builtin_no_mangle_static = declaration of a `no_mangle` static
lint-builtin-export-name-static = declaration of a static with `export_name` lint_builtin_export_name_static = declaration of a static with `export_name`
lint-builtin-link-section-static = declaration of a static with `link_section` lint_builtin_link_section_static = declaration of a static with `link_section`
lint-builtin-no-mangle-method = declaration of a `no_mangle` method lint_builtin_no_mangle_method = declaration of a `no_mangle` method
lint-builtin-export-name-method = declaration of a method with `export_name` lint_builtin_export_name_method = declaration of a method with `export_name`
lint-builtin-decl-unsafe-fn = declaration of an `unsafe` function lint_builtin_decl_unsafe_fn = declaration of an `unsafe` function
lint-builtin-decl-unsafe-method = declaration of an `unsafe` method lint_builtin_decl_unsafe_method = declaration of an `unsafe` method
lint-builtin-impl-unsafe-method = implementation of an `unsafe` method lint_builtin_impl_unsafe_method = implementation of an `unsafe` method
lint-builtin-missing-doc = missing documentation for {$article} {$desc} lint_builtin_missing_doc = missing documentation for {$article} {$desc}
lint-builtin-missing-copy-impl = type could implement `Copy`; consider adding `impl Copy` lint_builtin_missing_copy_impl = type could implement `Copy`; consider adding `impl Copy`
lint-builtin-missing-debug-impl = lint_builtin_missing_debug_impl =
type does not implement `{$debug}`; consider adding `#[derive(Debug)]` or a manual implementation type does not implement `{$debug}`; consider adding `#[derive(Debug)]` or a manual implementation
lint-builtin-anonymous-params = anonymous parameters are deprecated and will be removed in the next edition 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 .suggestion = try naming the parameter or explicitly ignoring it
lint-builtin-deprecated-attr-link = use of deprecated attribute `{$name}`: {$reason}. See {$link} lint_builtin_deprecated_attr_link = use of deprecated attribute `{$name}`: {$reason}. See {$link}
lint-builtin-deprecated-attr-used = use of deprecated attribute `{$name}`: no longer used. lint_builtin_deprecated_attr_used = use of deprecated attribute `{$name}`: no longer used.
lint-builtin-deprecated-attr-default-suggestion = remove this attribute lint_builtin_deprecated_attr_default_suggestion = remove this attribute
lint-builtin-unused-doc-comment = unused doc comment lint_builtin_unused_doc_comment = unused doc comment
.label = rustdoc does not generate documentation for {$kind} .label = rustdoc does not generate documentation for {$kind}
.plain-help = use `//` for a plain comment .plain_help = use `//` for a plain comment
.block-help = use `/* */` for a plain comment .block_help = use `/* */` for a plain comment
lint-builtin-no-mangle-generic = functions generic over types or consts must be mangled lint_builtin_no_mangle_generic = functions generic over types or consts must be mangled
.suggestion = remove this attribute .suggestion = remove this attribute
lint-builtin-const-no-mangle = const items should never be `#[no_mangle]` lint_builtin_const_no_mangle = const items should never be `#[no_mangle]`
.suggestion = try a static value .suggestion = try a static value
lint-builtin-mutable-transmutes = lint_builtin_mutable_transmutes =
transmuting &T to &mut T is undefined behavior, even if the reference is unused, consider instead using an UnsafeCell transmuting &T to &mut T is undefined behavior, even if the reference is unused, consider instead using an UnsafeCell
lint-builtin-unstable-features = unstable feature lint_builtin_unstable_features = unstable feature
lint-builtin-unreachable-pub = unreachable `pub` {$what} lint_builtin_unreachable_pub = unreachable `pub` {$what}
.suggestion = consider restricting its visibility .suggestion = consider restricting its visibility
.help = or consider exporting it for use by other crates .help = or consider exporting it for use by other crates
lint-builtin-type-alias-bounds-help = use fully disambiguated paths (i.e., `<T as Trait>::Assoc`) to refer to associated types in type aliases lint_builtin_type_alias_bounds_help = use fully disambiguated paths (i.e., `<T as Trait>::Assoc`) to refer to associated types in type aliases
lint-builtin-type-alias-where-clause = where clauses are not enforced in type aliases lint_builtin_type_alias_where_clause = where clauses are not enforced in type aliases
.suggestion = the clause will not be checked when the type alias is used, and should be removed .suggestion = the clause will not be checked when the type alias is used, and should be removed
lint-builtin-type-alias-generic-bounds = bounds on generic parameters are not enforced in type aliases lint_builtin_type_alias_generic_bounds = bounds on generic parameters are not enforced in type aliases
.suggestion = the bound will not be checked when the type alias is used, and should be removed .suggestion = the bound will not be checked when the type alias is used, and should be removed
lint-builtin-trivial-bounds = {$predicate_kind_name} bound {$predicate} does not depend on any type or lifetime parameters lint_builtin_trivial_bounds = {$predicate_kind_name} bound {$predicate} does not depend on any type or lifetime parameters
lint-builtin-ellipsis-inclusive-range-patterns = `...` range patterns are deprecated lint_builtin_ellipsis_inclusive_range_patterns = `...` range patterns are deprecated
.suggestion = use `..=` for an inclusive range .suggestion = use `..=` for an inclusive range
lint-builtin-unnameable-test-items = cannot test inner items lint_builtin_unnameable_test_items = cannot test inner items
lint-builtin-keyword-idents = `{$kw}` is a keyword in the {$next} edition lint_builtin_keyword_idents = `{$kw}` is a keyword in the {$next} edition
.suggestion = you can use a raw identifier to stay compatible .suggestion = you can use a raw identifier to stay compatible
lint-builtin-explicit-outlives = outlives requirements can be inferred lint_builtin_explicit_outlives = outlives requirements can be inferred
.suggestion = remove {$count -> .suggestion = remove {$count ->
[one] this bound [one] this bound
*[other] these bounds *[other] these bounds
} }
lint-builtin-incomplete-features = the feature `{$name}` is incomplete and may not be safe to use and/or cause compiler crashes 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} <https://github.com/rust-lang/rust/issues/{$n}> for more information .note = see issue #{$n} <https://github.com/rust-lang/rust/issues/{$n}> for more information
.help = consider using `min_{$name}` instead, which is more stable and complete .help = consider using `min_{$name}` instead, which is more stable and complete
lint-builtin-clashing-extern-same-name = `{$this_fi}` redeclared with a different signature lint_builtin_clashing_extern_same_name = `{$this_fi}` redeclared with a different signature
.previous-decl-label = `{$orig}` previously declared here .previous_decl_label = `{$orig}` previously declared here
.mismatch-label = this signature doesn't match the previous declaration .mismatch_label = this signature doesn't match the previous declaration
lint-builtin-clashing-extern-diff-name = `{$this_fi}` redeclares `{$orig}` with a different signature lint_builtin_clashing_extern_diff_name = `{$this_fi}` redeclares `{$orig}` with a different signature
.previous-decl-label = `{$orig}` previously declared here .previous_decl_label = `{$orig}` previously declared here
.mismatch-label = this signature doesn't match the previous declaration .mismatch_label = this signature doesn't match the previous declaration
lint-builtin-deref-nullptr = dereferencing a null pointer lint_builtin_deref_nullptr = dereferencing a null pointer
.label = this code causes undefined behavior when executed .label = this code causes undefined behavior when executed
lint-builtin-asm-labels = avoid using named labels in inline assembly lint_builtin_asm_labels = avoid using named labels in inline assembly

24
compiler/rustc_error_messages/locales/en-US/parser.ftl
View File

@ -1,34 +1,34 @@
parser-struct-literal-body-without-path = parser_struct_literal_body_without_path =
struct literal body without path struct literal body without path
.suggestion = you might have forgotten to add the struct literal inside the block .suggestion = you might have forgotten to add the struct literal inside the block
parser-maybe-report-ambiguous-plus = parser_maybe_report_ambiguous_plus =
ambiguous `+` in a type ambiguous `+` in a type
.suggestion = use parentheses to disambiguate .suggestion = use parentheses to disambiguate
parser-maybe-recover-from-bad-type-plus = parser_maybe_recover_from_bad_type_plus =
expected a path on the left-hand side of `+`, not `{$ty}` expected a path on the left-hand side of `+`, not `{$ty}`
parser-add-paren = try adding parentheses parser_add_paren = try adding parentheses
parser-forgot-paren = perhaps you forgot parentheses? parser_forgot_paren = perhaps you forgot parentheses?
parser-expect-path = expected a path parser_expect_path = expected a path
parser-maybe-recover-from-bad-qpath-stage-2 = parser_maybe_recover_from_bad_qpath_stage_2 =
missing angle brackets in associated item path missing angle brackets in associated item path
.suggestion = try: `{$ty}` .suggestion = try: `{$ty}`
parser-incorrect-semicolon = parser_incorrect_semicolon =
expected item, found `;` expected item, found `;`
.suggestion = remove this semicolon .suggestion = remove this semicolon
.help = {$name} declarations are not followed by a semicolon .help = {$name} declarations are not followed by a semicolon
parser-incorrect-use-of-await = parser_incorrect_use_of_await =
incorrect use of `await` incorrect use of `await`
.parentheses-suggestion = `await` is not a method call, remove the parentheses .parentheses_suggestion = `await` is not a method call, remove the parentheses
.postfix-suggestion = `await` is a postfix operation .postfix_suggestion = `await` is a postfix operation
parser-in-in-typo = parser_in_in_typo =
expected iterable, found keyword `in` expected iterable, found keyword `in`
.suggestion = remove the duplicated `in` .suggestion = remove the duplicated `in`

228
compiler/rustc_error_messages/locales/en-US/passes.ftl
View File

@ -1,178 +1,178 @@
-passes-previously-accepted = -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! 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 = -passes_see_issue =
see issue #{$issue} <https://github.com/rust-lang/rust/issues/{$issue}> for more information see issue #{$issue} <https://github.com/rust-lang/rust/issues/{$issue}> for more information
passes-outer-crate-level-attr = passes_outer_crate_level_attr =
crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]` crate-level attribute should be an inner attribute: add an exclamation mark: `#![foo]`
passes-inner-crate-level-attr = passes_inner_crate_level_attr =
crate-level attribute should be in the root module crate-level attribute should be in the root module
passes-ignored-attr-with-macro = `#[{$sym}]` is ignored on struct fields, match arms and macro defs passes_ignored_attr_with_macro = `#[{$sym}]` is ignored on struct fields, match arms and macro defs
.warn = {-passes-previously-accepted} .warn = {-passes_previously_accepted}
.note = {-passes-see-issue(issue: "80564")} .note = {-passes_see_issue(issue: "80564")}
passes-ignored-attr = `#[{$sym}]` is ignored on struct fields and match arms passes_ignored_attr = `#[{$sym}]` is ignored on struct fields and match arms
.warn = {-passes-previously-accepted} .warn = {-passes_previously_accepted}
.note = {-passes-see-issue(issue: "80564")} .note = {-passes_see_issue(issue: "80564")}
passes-inline-ignored-function-prototype = `#[inline]` is ignored on function prototypes passes_inline_ignored_function_prototype = `#[inline]` is ignored on function prototypes
passes-inline-ignored-constants = `#[inline]` is ignored on constants passes_inline_ignored_constants = `#[inline]` is ignored on constants
.warn = {-passes-previously-accepted} .warn = {-passes_previously_accepted}
.note = {-passes-see-issue(issue: "65833")} .note = {-passes_see_issue(issue: "65833")}
passes-inline-not-fn-or-closure = attribute should be applied to function or closure passes_inline_not_fn_or_closure = attribute should be applied to function or closure
.label = not a function or closure .label = not a function or closure
passes-no-coverage-ignored-function-prototype = `#[no_coverage]` is ignored on function prototypes passes_no_coverage_ignored_function_prototype = `#[no_coverage]` is ignored on function prototypes
passes-no-coverage-propagate = passes_no_coverage_propagate =
`#[no_coverage]` does not propagate into items and must be applied to the contained functions directly `#[no_coverage]` does not propagate into items and must be applied to the contained functions directly
passes-no-coverage-fn-defn = `#[no_coverage]` may only be applied to function definitions passes_no_coverage_fn_defn = `#[no_coverage]` may only be applied to function definitions
passes-no-coverage-not-coverable = `#[no_coverage]` must be applied to coverable code passes_no_coverage_not_coverable = `#[no_coverage]` must be applied to coverable code
.label = not coverable code .label = not coverable code
passes-should-be-applied-to-fn = attribute should be applied to a function definition passes_should_be_applied_to_fn = attribute should be applied to a function definition
.label = not a function definition .label = not a function definition
passes-naked-tracked-caller = cannot use `#[track_caller]` with `#[naked]` passes_naked_tracked_caller = cannot use `#[track_caller]` with `#[naked]`
passes-should-be-applied-to-struct-enum = attribute should be applied to a struct or enum passes_should_be_applied_to_struct_enum = attribute should be applied to a struct or enum
.label = not a struct or enum .label = not a struct or enum
passes-should-be-applied-to-trait = attribute should be applied to a trait passes_should_be_applied_to_trait = attribute should be applied to a trait
.label = not a trait .label = not a trait
passes-target-feature-on-statement = {passes-should-be-applied-to-fn} passes_target_feature_on_statement = {passes_should_be_applied_to_fn}
.warn = {-passes-previously-accepted} .warn = {-passes_previously_accepted}
.label = {passes-should-be-applied-to-fn.label} .label = {passes_should_be_applied_to_fn.label}
passes-should-be-applied-to-static = attribute should be applied to a static passes_should_be_applied_to_static = attribute should be applied to a static
.label = not a static .label = not a static
passes-doc-expect-str = doc {$attr_name} attribute expects a string: #[doc({$attr_name} = "a")] passes_doc_expect_str = doc {$attr_name} attribute expects a string: #[doc({$attr_name} = "a")]
passes-doc-alias-empty = {$attr_str} attribute cannot have empty value passes_doc_alias_empty = {$attr_str} attribute cannot have empty value
passes-doc-alias-bad-char = {$char_} character isn't allowed in {$attr_str} passes_doc_alias_bad_char = {$char_} character isn't allowed in {$attr_str}
passes-doc-alias-start-end = {$attr_str} cannot start or end with ' ' passes_doc_alias_start_end = {$attr_str} cannot start or end with ' '
passes-doc-alias-bad-location = {$attr_str} isn't allowed on {$location} passes_doc_alias_bad_location = {$attr_str} isn't allowed on {$location}
passes-doc-alias-not-an-alias = {$attr_str} is the same as the item's name passes_doc_alias_not_an_alias = {$attr_str} is the same as the item's name
passes-doc-alias-duplicated = doc alias is duplicated passes_doc_alias_duplicated = doc alias is duplicated
.label = first defined here .label = first defined here
passes-doc-alias-not-string-literal = `#[doc(alias("a"))]` expects string literals passes_doc_alias_not_string_literal = `#[doc(alias("a"))]` expects string literals
passes-doc-alias-malformed = passes_doc_alias_malformed =
doc alias attribute expects a string `#[doc(alias = "a")]` or a list of strings `#[doc(alias("a", "b"))]` doc alias attribute expects a string `#[doc(alias = "a")]` or a list of strings `#[doc(alias("a", "b"))]`
passes-doc-keyword-empty-mod = `#[doc(keyword = "...")]` should be used on empty modules passes_doc_keyword_empty_mod = `#[doc(keyword = "...")]` should be used on empty modules
passes-doc-keyword-not-mod = `#[doc(keyword = "...")]` should be used on modules passes_doc_keyword_not_mod = `#[doc(keyword = "...")]` should be used on modules
passes-doc-keyword-invalid-ident = `{$doc_keyword}` is not a valid identifier passes_doc_keyword_invalid_ident = `{$doc_keyword}` is not a valid identifier
passes-doc-fake-variadic-not-valid = 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 `#[doc(fake_variadic)]` must be used on the first of a set of tuple or fn pointer trait impls with varying arity
passes-doc-keyword-only-impl = `#[doc(keyword = "...")]` should be used on impl blocks passes_doc_keyword_only_impl = `#[doc(keyword = "...")]` should be used on impl blocks
passes-doc-inline-conflict-first = this attribute... passes_doc_inline_conflict_first = this attribute...
passes-doc-inline-conflict-second = ...conflicts with this attribute passes_doc_inline_conflict_second = ...conflicts with this attribute
passes-doc-inline-conflict = conflicting doc inlining attributes passes_doc_inline_conflict = conflicting doc inlining attributes
.help = remove one of the conflicting attributes .help = remove one of the conflicting attributes
passes-doc-inline-only-use = this attribute can only be applied to a `use` item passes_doc_inline_only_use = this attribute can only be applied to a `use` item
.label = only applicable on `use` items .label = only applicable on `use` items
.not-a-use-item-label = not a `use` item .not_a_use_item_label = not a `use` item
.note = read <https://doc.rust-lang.org/nightly/rustdoc/the-doc-attribute.html#inline-and-no_inline> for more information .note = read <https://doc.rust-lang.org/nightly/rustdoc/the-doc-attribute.html#inline-and-no_inline> for more information
passes-doc-attr-not-crate-level = passes_doc_attr_not_crate_level =
`#![doc({$attr_name} = "...")]` isn't allowed as a crate-level attribute `#![doc({$attr_name} = "...")]` isn't allowed as a crate-level attribute
passes-attr-crate-level = this attribute can only be applied at the crate level passes_attr_crate_level = this attribute can only be applied at the crate level
.suggestion = to apply to the crate, use an inner attribute .suggestion = to apply to the crate, use an inner attribute
.help = to apply to the crate, use an inner attribute .help = to apply to the crate, use an inner attribute
.note = read <https://doc.rust-lang.org/nightly/rustdoc/the-doc-attribute.html#at-the-crate-level> for more information .note = read <https://doc.rust-lang.org/nightly/rustdoc/the-doc-attribute.html#at-the-crate-level> for more information
passes-doc-test-unknown = unknown `doc(test)` attribute `{$path}` passes_doc_test_unknown = unknown `doc(test)` attribute `{$path}`
passes-doc-test-takes-list = `#[doc(test(...)]` takes a list of attributes passes_doc_test_takes_list = `#[doc(test(...)]` takes a list of attributes
passes-doc-primitive = `doc(primitive)` should never have been stable passes_doc_primitive = `doc(primitive)` should never have been stable
passes-doc-test-unknown-any = unknown `doc` attribute `{$path}` passes_doc_test_unknown_any = unknown `doc` attribute `{$path}`
passes-doc-test-unknown-spotlight = unknown `doc` attribute `{$path}` passes_doc_test_unknown_spotlight = unknown `doc` attribute `{$path}`
.note = `doc(spotlight)` was renamed to `doc(notable_trait)` .note = `doc(spotlight)` was renamed to `doc(notable_trait)`
.suggestion = use `notable_trait` instead .suggestion = use `notable_trait` instead
.no-op-note = `doc(spotlight)` is now a no-op .no_op_note = `doc(spotlight)` is now a no-op
passes-doc-test-unknown-include = unknown `doc` attribute `{$path}` passes_doc_test_unknown_include = unknown `doc` attribute `{$path}`
.suggestion = use `doc = include_str!` instead .suggestion = use `doc = include_str!` instead
passes-doc-invalid = invalid `doc` attribute passes_doc_invalid = invalid `doc` attribute
passes-pass-by-value = `pass_by_value` attribute should be applied to a struct, enum or type alias 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 .label = is not a struct, enum or type alias
passes-allow-incoherent-impl = passes_allow_incoherent_impl =
`rustc_allow_incoherent_impl` attribute should be applied to impl items. `rustc_allow_incoherent_impl` attribute should be applied to impl items.
.label = the only currently supported targets are inherent methods .label = the only currently supported targets are inherent methods
passes-has-incoherent-inherent-impl = passes_has_incoherent_inherent_impl =
`rustc_has_incoherent_inherent_impls` attribute should be applied to types or traits. `rustc_has_incoherent_inherent_impls` attribute should be applied to types or traits.
.label = only adts, extern types and traits are supported .label = only adts, extern types and traits are supported
passes-must-use-async = passes_must_use_async =
`must_use` attribute on `async` functions applies to the anonymous `Future` returned by the function, not the value within `must_use` attribute on `async` functions applies to the anonymous `Future` returned by the function, not the value within
.label = this attribute does nothing, the `Future`s returned by async functions are already `must_use` .label = this attribute does nothing, the `Future`s returned by async functions are already `must_use`
passes-must-use-no-effect = `#[must_use]` has no effect when applied to {$article} {$target} passes_must_use_no_effect = `#[must_use]` has no effect when applied to {$article} {$target}
passes-must-not-suspend = `must_not_suspend` attribute should be applied to a struct, enum, or trait passes_must_not_suspend = `must_not_suspend` attribute should be applied to a struct, enum, or trait
.label = is not a struct, enum, or trait .label = is not a struct, enum, or trait
passes-cold = {passes-should-be-applied-to-fn} passes_cold = {passes_should_be_applied_to_fn}
.warn = {-passes-previously-accepted} .warn = {-passes_previously_accepted}
.label = {passes-should-be-applied-to-fn.label} .label = {passes_should_be_applied_to_fn.label}
passes-link = attribute should be applied to an `extern` block with non-Rust ABI passes_link = attribute should be applied to an `extern` block with non-Rust ABI
.warn = {-passes-previously-accepted} .warn = {-passes_previously_accepted}
.label = not an `extern` block .label = not an `extern` block
passes-link-name = attribute should be applied to a foreign function or static passes_link_name = attribute should be applied to a foreign function or static
.warn = {-passes-previously-accepted} .warn = {-passes_previously_accepted}
.label = not a foreign function or static .label = not a foreign function or static
.help = try `#[link(name = "{$value}")]` instead .help = try `#[link(name = "{$value}")]` instead
passes-no-link = attribute should be applied to an `extern crate` item passes_no_link = attribute should be applied to an `extern crate` item
.label = not an `extern crate` item .label = not an `extern crate` item
passes-export-name = attribute should be applied to a free function, impl method or static passes_export_name = attribute should be applied to a free function, impl method or static
.label = not a free function, impl method or static .label = not a free function, impl method or static
passes-rustc-layout-scalar-valid-range-not-struct = attribute should be applied to a struct passes_rustc_layout_scalar_valid_range_not_struct = attribute should be applied to a struct
.label = not a struct .label = not a struct
passes-rustc-layout-scalar-valid-range-arg = expected exactly one integer literal argument passes_rustc_layout_scalar_valid_range_arg = expected exactly one integer literal argument
passes-rustc-legacy-const-generics-only = #[rustc_legacy_const_generics] functions must only have const generics passes_rustc_legacy_const_generics_only = #[rustc_legacy_const_generics] functions must only have const generics
.label = non-const generic parameter .label = non-const generic parameter
passes-rustc-legacy-const-generics-index = #[rustc_legacy_const_generics] must have one index for each generic parameter passes_rustc_legacy_const_generics_index = #[rustc_legacy_const_generics] must have one index for each generic parameter
.label = generic parameters .label = generic parameters
passes-rustc-legacy-const-generics-index-exceed = index exceeds number of arguments passes_rustc_legacy_const_generics_index_exceed = index exceeds number of arguments
.label = there {$arg_count -> .label = there {$arg_count ->
[one] is [one] is
*[other] are *[other] are
@ -181,87 +181,87 @@ passes-rustc-legacy-const-generics-index-exceed = index exceeds number of argume
*[other] arguments *[other] arguments
} }
passes-rustc-legacy-const-generics-index-negative = arguments should be non-negative integers passes_rustc_legacy_const_generics_index_negative = arguments should be non-negative integers
passes-rustc-dirty-clean = attribute requires -Z query-dep-graph to be enabled passes_rustc_dirty_clean = attribute requires -Z query-dep-graph to be enabled
passes-link-section = attribute should be applied to a function or static passes_link_section = attribute should be applied to a function or static
.warn = {-passes-previously-accepted} .warn = {-passes_previously_accepted}
.label = not a function or static .label = not a function or static
passes-no-mangle-foreign = `#[no_mangle]` has no effect on a foreign {$foreign_item_kind} passes_no_mangle_foreign = `#[no_mangle]` has no effect on a foreign {$foreign_item_kind}
.warn = {-passes-previously-accepted} .warn = {-passes_previously_accepted}
.label = foreign {$foreign_item_kind} .label = foreign {$foreign_item_kind}
.note = symbol names in extern blocks are not mangled .note = symbol names in extern blocks are not mangled
.suggestion = remove this attribute .suggestion = remove this attribute
passes-no-mangle = attribute should be applied to a free function, impl method or static passes_no_mangle = attribute should be applied to a free function, impl method or static
.warn = {-passes-previously-accepted} .warn = {-passes_previously_accepted}
.label = not a free function, impl method or static .label = not a free function, impl method or static
passes-repr-ident = meta item in `repr` must be an identifier passes_repr_ident = meta item in `repr` must be an identifier
passes-repr-conflicting = conflicting representation hints passes_repr_conflicting = conflicting representation hints
passes-used-static = attribute must be applied to a `static` variable passes_used_static = attribute must be applied to a `static` variable
passes-used-compiler-linker = `used(compiler)` and `used(linker)` can't be used together passes_used_compiler_linker = `used(compiler)` and `used(linker)` can't be used together
passes-allow-internal-unstable = attribute should be applied to a macro passes_allow_internal_unstable = attribute should be applied to a macro
.label = not a macro .label = not a macro
passes-debug-visualizer-placement = attribute should be applied to a module passes_debug_visualizer_placement = attribute should be applied to a module
passes-debug-visualizer-invalid = invalid argument passes_debug_visualizer_invalid = invalid argument
.note-1 = expected: `natvis_file = "..."` .note_1 = expected: `natvis_file = "..."`
.note-2 = OR .note_2 = OR
.note-3 = expected: `gdb_script_file = "..."` .note_3 = expected: `gdb_script_file = "..."`
passes-rustc-allow-const-fn-unstable = attribute should be applied to `const fn` passes_rustc_allow_const_fn_unstable = attribute should be applied to `const fn`
.label = not a `const fn` .label = not a `const fn`
passes-rustc-std-internal-symbol = attribute should be applied to functions or statics passes_rustc_std_internal_symbol = attribute should be applied to functions or statics
.label = not a function or static .label = not a function or static
passes-const-trait = attribute should be applied to a trait passes_const_trait = attribute should be applied to a trait
passes-stability-promotable = attribute cannot be applied to an expression passes_stability_promotable = attribute cannot be applied to an expression
passes-deprecated = attribute is ignored here passes_deprecated = attribute is ignored here
passes-macro-use = `#[{$name}]` only has an effect on `extern crate` and modules passes_macro_use = `#[{$name}]` only has an effect on `extern crate` and modules
passes-macro-export = `#[macro_export]` only has an effect on macro definitions passes_macro_export = `#[macro_export]` only has an effect on macro definitions
passes-plugin-registrar = `#[plugin_registrar]` only has an effect on functions passes_plugin_registrar = `#[plugin_registrar]` only has an effect on functions
passes-unused-empty-lints-note = attribute `{$name}` with an empty list has no effect passes_unused_empty_lints_note = attribute `{$name}` with an empty list has no effect
passes-unused-no-lints-note = attribute `{$name}` without any lints has no effect passes_unused_no_lints_note = attribute `{$name}` without any lints has no effect
passes-unused-default-method-body-const-note = passes_unused_default_method_body_const_note =
`default_method_body_is_const` has been replaced with `#[const_trait]` on traits `default_method_body_is_const` has been replaced with `#[const_trait]` on traits
passes-unused = unused attribute passes_unused = unused attribute
.suggestion = remove this attribute .suggestion = remove this attribute
passes-non-exported-macro-invalid-attrs = attribute should be applied to function or closure passes_non_exported_macro_invalid_attrs = attribute should be applied to function or closure
.label = not a function or closure .label = not a function or closure
passes-unused-duplicate = unused attribute passes_unused_duplicate = unused attribute
.suggestion = remove this attribute .suggestion = remove this attribute
.note = attribute also specified here .note = attribute also specified here
.warn = {-passes-previously-accepted} .warn = {-passes_previously_accepted}
passes-unused-multiple = multiple `{$name}` attributes passes_unused_multiple = multiple `{$name}` attributes
.suggestion = remove this attribute .suggestion = remove this attribute
.note = attribute also specified here .note = attribute also specified here
passes-rustc-lint-opt-ty = `#[rustc_lint_opt_ty]` should be applied to a struct passes_rustc_lint_opt_ty = `#[rustc_lint_opt_ty]` should be applied to a struct
.label = not a struct .label = not a struct
passes-rustc-lint-opt-deny-field-access = `#[rustc_lint_opt_deny_field_access]` should be applied to a field passes_rustc_lint_opt_deny_field_access = `#[rustc_lint_opt_deny_field_access]` should be applied to a field
.label = not a field .label = not a field
passes-link-ordinal = attribute should be applied to a foreign function or static passes_link_ordinal = attribute should be applied to a foreign function or static
.label = not a foreign function or static .label = not a foreign function or static

18
compiler/rustc_error_messages/locales/en-US/privacy.ftl
View File

@ -1,20 +1,20 @@
privacy-field-is-private = field `{$field_name}` of {$variant_descr} `{$def_path_str}` is private privacy_field_is_private = field `{$field_name}` of {$variant_descr} `{$def_path_str}` is private
privacy-field-is-private-is-update-syntax-label = field `{$field_name}` is private privacy_field_is_private_is_update_syntax_label = field `{$field_name}` is private
privacy-field-is-private-label = private field privacy_field_is_private_label = private field
privacy-item-is-private = {$kind} `{$descr}` is private privacy_item_is_private = {$kind} `{$descr}` is private
.label = private {$kind} .label = private {$kind}
privacy-unnamed-item-is-private = {$kind} is private privacy_unnamed_item_is_private = {$kind} is private
.label = private {$kind} .label = private {$kind}
privacy-in-public-interface = {$vis_descr} {$kind} `{$descr}` in public interface privacy_in_public_interface = {$vis_descr} {$kind} `{$descr}` in public interface
.label = can't leak {$vis_descr} {$kind} .label = can't leak {$vis_descr} {$kind}
.visibility-label = `{$descr}` declared as {$vis_descr} .visibility_label = `{$descr}` declared as {$vis_descr}
privacy-from-private-dep-in-public-interface = privacy_from_private_dep_in_public_interface =
{$kind} `{$descr}` from private dependency '{$krate}' in public interface {$kind} `{$descr}` from private dependency '{$krate}' in public interface
private-in-public-lint = private_in_public_lint =
{$vis_descr} {$kind} `{$descr}` in public interface (error {$kind -> {$vis_descr} {$kind} `{$descr}` in public interface (error {$kind ->
[trait] E0445 [trait] E0445
*[other] E0446 *[other] E0446

74
compiler/rustc_error_messages/locales/en-US/typeck.ftl
View File

@ -1,101 +1,101 @@
typeck-field-multiply-specified-in-initializer = typeck_field_multiply_specified_in_initializer =
field `{$ident}` specified more than once field `{$ident}` specified more than once
.label = used more than once .label = used more than once
.previous-use-label = first use of `{$ident}` .previous_use_label = first use of `{$ident}`
typeck-unrecognized-atomic-operation = typeck_unrecognized_atomic_operation =
unrecognized atomic operation function: `{$op}` unrecognized atomic operation function: `{$op}`
.label = unrecognized atomic operation .label = unrecognized atomic operation
typeck-wrong-number-of-generic-arguments-to-intrinsic = typeck_wrong_number_of_generic_arguments_to_intrinsic =
intrinsic has wrong number of {$descr} parameters: found {$found}, expected {$expected} intrinsic has wrong number of {$descr} parameters: found {$found}, expected {$expected}
.label = expected {$expected} {$descr} {$expected -> .label = expected {$expected} {$descr} {$expected ->
[one] parameter [one] parameter
*[other] parameters *[other] parameters
} }
typeck-unrecognized-intrinsic-function = typeck_unrecognized_intrinsic_function =
unrecognized intrinsic function: `{$name}` unrecognized intrinsic function: `{$name}`
.label = unrecognized intrinsic .label = unrecognized intrinsic
typeck-lifetimes-or-bounds-mismatch-on-trait = typeck_lifetimes_or_bounds_mismatch_on_trait =
lifetime parameters or bounds on {$item_kind} `{$ident}` do not match the trait declaration lifetime parameters or bounds on {$item_kind} `{$ident}` do not match the trait declaration
.label = lifetimes do not match {$item_kind} in trait .label = lifetimes do not match {$item_kind} in trait
.generics-label = lifetimes in impl do not match this {$item_kind} in trait .generics_label = lifetimes in impl do not match this {$item_kind} in trait
typeck-drop-impl-on-wrong-item = typeck_drop_impl_on_wrong_item =
the `Drop` trait may only be implemented for structs, enums, and unions the `Drop` trait may only be implemented for structs, enums, and unions
.label = must be a struct, enum, or union .label = must be a struct, enum, or union
typeck-field-already-declared = typeck_field_already_declared =
field `{$field_name}` is already declared field `{$field_name}` is already declared
.label = field already declared .label = field already declared
.previous-decl-label = `{$field_name}` first declared here .previous_decl_label = `{$field_name}` first declared here
typeck-copy-impl-on-type-with-dtor = typeck_copy_impl_on_type_with_dtor =
the trait `Copy` may not be implemented for this type; the type has a destructor the trait `Copy` may not be implemented for this type; the type has a destructor
.label = `Copy` not allowed on types with destructors .label = `Copy` not allowed on types with destructors
typeck-multiple-relaxed-default-bounds = typeck_multiple_relaxed_default_bounds =
type parameter has more than one relaxed default bound, only one is supported type parameter has more than one relaxed default bound, only one is supported
typeck-copy-impl-on-non-adt = typeck_copy_impl_on_non_adt =
the trait `Copy` may not be implemented for this type the trait `Copy` may not be implemented for this type
.label = type is not a structure or enumeration .label = type is not a structure or enumeration
typeck-trait-object-declared-with-no-traits = typeck_trait_object_declared_with_no_traits =
at least one trait is required for an object type at least one trait is required for an object type
.alias-span = this alias does not contain a trait .alias_span = this alias does not contain a trait
typeck-ambiguous-lifetime-bound = typeck_ambiguous_lifetime_bound =
ambiguous lifetime bound, explicit lifetime bound required ambiguous lifetime bound, explicit lifetime bound required
typeck-assoc-type-binding-not-allowed = typeck_assoc_type_binding_not_allowed =
associated type bindings are not allowed here associated type bindings are not allowed here
.label = associated type not allowed here .label = associated type not allowed here
typeck-functional-record-update-on-non-struct = typeck_functional_record_update_on_non_struct =
functional record update syntax requires a struct functional record update syntax requires a struct
typeck-typeof-reserved-keyword-used = typeck_typeof_reserved_keyword_used =
`typeof` is a reserved keyword but unimplemented `typeof` is a reserved keyword but unimplemented
.suggestion = consider replacing `typeof(...)` with an actual type .suggestion = consider replacing `typeof(...)` with an actual type
.label = reserved keyword .label = reserved keyword
typeck-return-stmt-outside-of-fn-body = typeck_return_stmt_outside_of_fn_body =
return statement outside of function body return statement outside of function body
.encl-body-label = the return is part of this body... .encl_body_label = the return is part of this body...
.encl-fn-label = ...not the enclosing function body .encl_fn_label = ...not the enclosing function body
typeck-yield-expr-outside-of-generator = typeck_yield_expr_outside_of_generator =
yield expression outside of generator literal yield expression outside of generator literal
typeck-struct-expr-non-exhaustive = typeck_struct_expr_non_exhaustive =
cannot create non-exhaustive {$what} using struct expression cannot create non-exhaustive {$what} using struct expression
typeck-method-call-on-unknown-type = typeck_method_call_on_unknown_type =
the type of this value must be known to call a method on a raw pointer on it the type of this value must be known to call a method on a raw pointer on it
typeck-value-of-associated-struct-already-specified = typeck_value_of_associated_struct_already_specified =
the value of the associated type `{$item_name}` (from trait `{$def_path}`) is already specified the value of the associated type `{$item_name}` (from trait `{$def_path}`) is already specified
.label = re-bound here .label = re-bound here
.previous-bound-label = `{$item_name}` bound here first .previous_bound_label = `{$item_name}` bound here first
typeck-address-of-temporary-taken = cannot take address of a temporary typeck_address_of_temporary_taken = cannot take address of a temporary
.label = temporary value .label = temporary value
typeck-add-return-type-add = try adding a return type typeck_add_return_type_add = try adding a return type
typeck-add-return-type-missing-here = a return type might be missing here typeck_add_return_type_missing_here = a return type might be missing here
typeck-expected-default-return-type = expected `()` because of default return type typeck_expected_default_return_type = expected `()` because of default return type
typeck-expected-return-type = expected `{$expected}` because of return type typeck_expected_return_type = expected `{$expected}` because of return type
typeck-unconstrained-opaque-type = unconstrained opaque type typeck_unconstrained_opaque_type = unconstrained opaque type
.note = `{$name}` must be used in combination with a concrete type within the same module .note = `{$name}` must be used in combination with a concrete type within the same module
typeck-missing-type-params = typeck_missing_type_params =
the type {$parameterCount -> the type {$parameterCount ->
[one] parameter [one] parameter
*[other] parameters *[other] parameters
@ -111,15 +111,15 @@ typeck-missing-type-params =
[one] type [one] type
*[other] types *[other] types
} }
.no-suggestion-label = missing {$parameterCount -> .no_suggestion_label = missing {$parameterCount ->
[one] reference [one] reference
*[other] references *[other] references
} to {$parameters} } to {$parameters}
.note = because of the default `Self` reference, type parameters must be specified on object types .note = because of the default `Self` reference, type parameters must be specified on object types
typeck-manual-implementation = typeck_manual_implementation =
manual implementations of `{$trait_name}` are experimental manual implementations of `{$trait_name}` are experimental
.label = 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 .help = add `#![feature(unboxed_closures)]` to the crate attributes to enable
typeck-substs-on-overridden-impl = could not resolve substs on overridden impl typeck_substs_on_overridden_impl = could not resolve substs on overridden impl