| // Error messages for EXXXX errors. |
| // Each message should start and end with a new line, and be wrapped to 80 |
| // characters. In vim you can `:set tw=80` and use `gq` to wrap paragraphs. Use |
| // `:set tw=0` to disable. |
| register_diagnostics! { |
| |
| E0178: r##" |
| In types, the `+` type operator has low precedence, so it is often necessary |
| to use parentheses. |
| |
| For example: |
| |
| ```compile_fail,E0178 |
| trait Foo {} |
| |
| struct Bar<'a> { |
| w: &'a Foo + Copy, // error, use &'a (Foo + Copy) |
| x: &'a Foo + 'a, // error, use &'a (Foo + 'a) |
| y: &'a mut Foo + 'a, // error, use &'a mut (Foo + 'a) |
| z: fn() -> Foo + 'a, // error, use fn() -> (Foo + 'a) |
| } |
| ``` |
| |
| More details can be found in [RFC 438]. |
| |
| [RFC 438]: https://github.com/rust-lang/rfcs/pull/438 |
| "##, |
| |
| E0536: r##" |
| The `not` cfg-predicate was malformed. |
| |
| Erroneous code example: |
| |
| ```compile_fail,E0536 |
| #[cfg(not())] // error: expected 1 cfg-pattern |
| pub fn something() {} |
| |
| pub fn main() {} |
| ``` |
| |
| The `not` predicate expects one cfg-pattern. Example: |
| |
| ``` |
| #[cfg(not(target_os = "linux"))] // ok! |
| pub fn something() {} |
| |
| pub fn main() {} |
| ``` |
| |
| For more information about the cfg attribute, read: |
| https://doc.rust-lang.org/reference.html#conditional-compilation |
| "##, |
| |
| E0537: r##" |
| An unknown predicate was used inside the `cfg` attribute. |
| |
| Erroneous code example: |
| |
| ```compile_fail,E0537 |
| #[cfg(unknown())] // error: invalid predicate `unknown` |
| pub fn something() {} |
| |
| pub fn main() {} |
| ``` |
| |
| The `cfg` attribute supports only three kinds of predicates: |
| |
| * any |
| * all |
| * not |
| |
| Example: |
| |
| ``` |
| #[cfg(not(target_os = "linux"))] // ok! |
| pub fn something() {} |
| |
| pub fn main() {} |
| ``` |
| |
| For more information about the cfg attribute, read: |
| https://doc.rust-lang.org/reference.html#conditional-compilation |
| "##, |
| |
| E0538: r##" |
| Attribute contains same meta item more than once. |
| |
| Erroneous code example: |
| |
| ```compile_fail,E0538 |
| #[deprecated( |
| since="1.0.0", |
| note="First deprecation note.", |
| note="Second deprecation note." // error: multiple same meta item |
| )] |
| fn deprecated_function() {} |
| ``` |
| |
| Meta items are the key-value pairs inside of an attribute. Each key may only be |
| used once in each attribute. |
| |
| To fix the problem, remove all but one of the meta items with the same key. |
| |
| Example: |
| |
| ``` |
| #[deprecated( |
| since="1.0.0", |
| note="First deprecation note." |
| )] |
| fn deprecated_function() {} |
| ``` |
| "##, |
| |
| E0541: r##" |
| An unknown meta item was used. |
| |
| Erroneous code example: |
| |
| ```compile_fail,E0541 |
| #[deprecated( |
| since="1.0.0", |
| // error: unknown meta item |
| reason="Example invalid meta item. Should be 'note'") |
| ] |
| fn deprecated_function() {} |
| ``` |
| |
| Meta items are the key-value pairs inside of an attribute. The keys provided |
| must be one of the valid keys for the specified attribute. |
| |
| To fix the problem, either remove the unknown meta item, or rename it if you |
| provided the wrong name. |
| |
| In the erroneous code example above, the wrong name was provided, so changing |
| to a correct one it will fix the error. Example: |
| |
| ``` |
| #[deprecated( |
| since="1.0.0", |
| note="This is a valid meta item for the deprecated attribute." |
| )] |
| fn deprecated_function() {} |
| ``` |
| "##, |
| |
| E0552: r##" |
| A unrecognized representation attribute was used. |
| |
| Erroneous code example: |
| |
| ```compile_fail,E0552 |
| #[repr(D)] // error: unrecognized representation hint |
| struct MyStruct { |
| my_field: usize |
| } |
| ``` |
| |
| You can use a `repr` attribute to tell the compiler how you want a struct or |
| enum to be laid out in memory. |
| |
| Make sure you're using one of the supported options: |
| |
| ``` |
| #[repr(C)] // ok! |
| struct MyStruct { |
| my_field: usize |
| } |
| ``` |
| |
| For more information about specifying representations, see the ["Alternative |
| Representations" section] of the Rustonomicon. |
| |
| ["Alternative Representations" section]: https://doc.rust-lang.org/nomicon/other-reprs.html |
| "##, |
| |
| E0554: r##" |
| Feature attributes are only allowed on the nightly release channel. Stable or |
| beta compilers will not comply. |
| |
| Example of erroneous code (on a stable compiler): |
| |
| ```ignore (depends on release channel) |
| #![feature(non_ascii_idents)] // error: `#![feature]` may not be used on the |
| // stable release channel |
| ``` |
| |
| If you need the feature, make sure to use a nightly release of the compiler |
| (but be warned that the feature may be removed or altered in the future). |
| "##, |
| |
| E0557: r##" |
| A feature attribute named a feature that has been removed. |
| |
| Erroneous code example: |
| |
| ```compile_fail,E0557 |
| #![feature(managed_boxes)] // error: feature has been removed |
| ``` |
| |
| Delete the offending feature attribute. |
| "##, |
| |
| E0565: r##" |
| A literal was used in a built-in attribute that doesn't support literals. |
| |
| Erroneous code example: |
| |
| ```ignore (compile_fail not working here; see Issue #43707) |
| #[inline("always")] // error: unsupported literal |
| pub fn something() {} |
| ``` |
| |
| Literals in attributes are new and largely unsupported in built-in attributes. |
| Work to support literals where appropriate is ongoing. Try using an unquoted |
| name instead: |
| |
| ``` |
| #[inline(always)] |
| pub fn something() {} |
| ``` |
| "##, |
| |
| E0583: r##" |
| A file wasn't found for an out-of-line module. |
| |
| Erroneous code example: |
| |
| ```ignore (compile_fail not working here; see Issue #43707) |
| mod file_that_doesnt_exist; // error: file not found for module |
| |
| fn main() {} |
| ``` |
| |
| Please be sure that a file corresponding to the module exists. If you |
| want to use a module named `file_that_doesnt_exist`, you need to have a file |
| named `file_that_doesnt_exist.rs` or `file_that_doesnt_exist/mod.rs` in the |
| same directory. |
| "##, |
| |
| E0585: r##" |
| A documentation comment that doesn't document anything was found. |
| |
| Erroneous code example: |
| |
| ```compile_fail,E0585 |
| fn main() { |
| // The following doc comment will fail: |
| /// This is a useless doc comment! |
| } |
| ``` |
| |
| Documentation comments need to be followed by items, including functions, |
| types, modules, etc. Examples: |
| |
| ``` |
| /// I'm documenting the following struct: |
| struct Foo; |
| |
| /// I'm documenting the following function: |
| fn foo() {} |
| ``` |
| "##, |
| |
| E0586: r##" |
| An inclusive range was used with no end. |
| |
| Erroneous code example: |
| |
| ```compile_fail,E0586 |
| fn main() { |
| let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1]; |
| let x = &tmp[1..=]; // error: inclusive range was used with no end |
| } |
| ``` |
| |
| An inclusive range needs an end in order to *include* it. If you just need a |
| start and no end, use a non-inclusive range (with `..`): |
| |
| ``` |
| fn main() { |
| let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1]; |
| let x = &tmp[1..]; // ok! |
| } |
| ``` |
| |
| Or put an end to your inclusive range: |
| |
| ``` |
| fn main() { |
| let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1]; |
| let x = &tmp[1..=3]; // ok! |
| } |
| ``` |
| "##, |
| |
| E0589: r##" |
| The value of `N` that was specified for `repr(align(N))` was not a power |
| of two, or was greater than 2^29. |
| |
| ```compile_fail,E0589 |
| #[repr(align(15))] // error: invalid `repr(align)` attribute: not a power of two |
| enum Foo { |
| Bar(u64), |
| } |
| ``` |
| "##, |
| |
| E0658: r##" |
| An unstable feature was used. |
| |
| Erroneous code example: |
| |
| ```compile_fail,E658 |
| #[repr(u128)] // error: use of unstable library feature 'repr128' |
| enum Foo { |
| Bar(u64), |
| } |
| ``` |
| |
| If you're using a stable or a beta version of rustc, you won't be able to use |
| any unstable features. In order to do so, please switch to a nightly version of |
| rustc (by using rustup). |
| |
| If you're using a nightly version of rustc, just add the corresponding feature |
| to be able to use it: |
| |
| ``` |
| #![feature(repr128)] |
| |
| #[repr(u128)] // ok! |
| enum Foo { |
| Bar(u64), |
| } |
| ``` |
| "##, |
| |
| E0633: r##" |
| The `unwind` attribute was malformed. |
| |
| Erroneous code example: |
| |
| ```ignore (compile_fail not working here; see Issue #43707) |
| #[unwind()] // error: expected one argument |
| pub extern fn something() {} |
| |
| fn main() {} |
| ``` |
| |
| The `#[unwind]` attribute should be used as follows: |
| |
| - `#[unwind(aborts)]` -- specifies that if a non-Rust ABI function |
| should abort the process if it attempts to unwind. This is the safer |
| and preferred option. |
| |
| - `#[unwind(allowed)]` -- specifies that a non-Rust ABI function |
| should be allowed to unwind. This can easily result in Undefined |
| Behavior (UB), so be careful. |
| |
| NB. The default behavior here is "allowed", but this is unspecified |
| and likely to change in the future. |
| |
| "##, |
| |
| E0704: r##" |
| This error indicates that a incorrect visibility restriction was specified. |
| |
| Example of erroneous code: |
| |
| ```compile_fail,E0704 |
| mod foo { |
| pub(foo) struct Bar { |
| x: i32 |
| } |
| } |
| ``` |
| |
| To make struct `Bar` only visible in module `foo` the `in` keyword should be |
| used: |
| ``` |
| mod foo { |
| pub(in crate::foo) struct Bar { |
| x: i32 |
| } |
| } |
| # fn main() {} |
| ``` |
| |
| For more information see the Rust Reference on [Visibility]. |
| |
| [Visibility]: https://doc.rust-lang.org/reference/visibility-and-privacy.html |
| "##, |
| |
| E0705: r##" |
| A `#![feature]` attribute was declared for a feature that is stable in |
| the current edition, but not in all editions. |
| |
| Erroneous code example: |
| |
| ```ignore (limited to a warning during 2018 edition development) |
| #![feature(rust_2018_preview)] |
| #![feature(test_2018_feature)] // error: the feature |
| // `test_2018_feature` is |
| // included in the Rust 2018 edition |
| ``` |
| |
| "##, |
| |
| E0725: r##" |
| A feature attribute named a feature that was disallowed in the compiler |
| command line flags. |
| |
| Erroneous code example: |
| |
| ```ignore (can't specify compiler flags from doctests) |
| #![feature(never_type)] // error: the feature `never_type` is not in |
| // the list of allowed features |
| ``` |
| |
| Delete the offending feature attribute, or add it to the list of allowed |
| features in the `-Z allow_features` flag. |
| "##, |
| |
| ; |
| |
| E0539, // incorrect meta item |
| E0540, // multiple rustc_deprecated attributes |
| E0542, // missing 'since' |
| E0543, // missing 'reason' |
| E0544, // multiple stability levels |
| E0545, // incorrect 'issue' |
| E0546, // missing 'feature' |
| E0547, // missing 'issue' |
| // E0548, // replaced with a generic attribute input check |
| // rustc_deprecated attribute must be paired with either stable or unstable |
| // attribute |
| E0549, |
| E0550, // multiple deprecated attributes |
| E0551, // incorrect meta item |
| E0553, // multiple rustc_const_unstable attributes |
| // E0555, // replaced with a generic attribute input check |
| E0556, // malformed feature, expected just one word |
| E0584, // file for module `..` found at both .. and .. |
| E0629, // missing 'feature' (rustc_const_unstable) |
| // rustc_const_unstable attribute must be paired with stable/unstable |
| // attribute |
| E0630, |
| E0693, // incorrect `repr(align)` attribute format |
| // E0694, // an unknown tool name found in scoped attributes |
| E0703, // invalid ABI |
| E0717, // rustc_promotable without stability attribute |
| } |