src/libsyntax/diagnostic_list.rs

   1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 #![allow(non_snake_case)]
  12
  13 // Error messages for EXXXX errors.
  14 // Each message should start and end with a new line, and be wrapped to 80 characters.
  15 // In vim you can `:set tw=80` and use `gq` to wrap paragraphs. Use `:set tw=0` to disable.
  16 register_long_diagnostics! {
  17
  18 E0178: r##"
  19 In types, the `+` type operator has low precedence, so it is often necessary
  20 to use parentheses.
  21
  22 For example:
  23
  24 ```compile_fail,E0178
  25 trait Foo {}
  26
  27 struct Bar<'a> {
  28     w: &'a Foo + Copy,   // error, use &'a (Foo + Copy)
  29     x: &'a Foo + 'a,     // error, use &'a (Foo + 'a)
  30     y: &'a mut Foo + 'a, // error, use &'a mut (Foo + 'a)
  31     z: fn() -> Foo + 'a, // error, use fn() -> (Foo + 'a)
  32 }
  33 ```
  34
  35 More details can be found in [RFC 438].
  36
  37 [RFC 438]: https://github.com/rust-lang/rfcs/pull/438
  38 "##,
  39
  40 E0536: r##"
  41 The `not` cfg-predicate was malformed.
  42
  43 Erroneous code example:
  44
  45 ```compile_fail,E0536
  46 #[cfg(not())] // error: expected 1 cfg-pattern
  47 pub fn something() {}
  48
  49 pub fn main() {}
  50 ```
  51
  52 The `not` predicate expects one cfg-pattern. Example:
  53
  54 ```
  55 #[cfg(not(target_os = "linux"))] // ok!
  56 pub fn something() {}
  57
  58 pub fn main() {}
  59 ```
  60
  61 For more information about the cfg attribute, read:
  62 https://doc.rust-lang.org/reference.html#conditional-compilation
  63 "##,
  64
  65 E0537: r##"
  66 An unknown predicate was used inside the `cfg` attribute.
  67
  68 Erroneous code example:
  69
  70 ```compile_fail,E0537
  71 #[cfg(unknown())] // error: invalid predicate `unknown`
  72 pub fn something() {}
  73
  74 pub fn main() {}
  75 ```
  76
  77 The `cfg` attribute supports only three kinds of predicates:
  78
  79  * any
  80  * all
  81  * not
  82
  83 Example:
  84
  85 ```
  86 #[cfg(not(target_os = "linux"))] // ok!
  87 pub fn something() {}
  88
  89 pub fn main() {}
  90 ```
  91
  92 For more information about the cfg attribute, read:
  93 https://doc.rust-lang.org/reference.html#conditional-compilation
  94 "##,
  95
  96 E0538: r##"
  97 Attribute contains same meta item more than once.
  98
  99 Erroneous code example:
 100
 101 ```compile_fail,E0538
 102 #[deprecated(
 103     since="1.0.0",
 104     note="First deprecation note.",
 105     note="Second deprecation note." // error: multiple same meta item
 106 )]
 107 fn deprecated_function() {}
 108 ```
 109
 110 Meta items are the key-value pairs inside of an attribute. Each key may only be
 111 used once in each attribute.
 112
 113 To fix the problem, remove all but one of the meta items with the same key.
 114
 115 Example:
 116
 117 ```
 118 #[deprecated(
 119     since="1.0.0",
 120     note="First deprecation note."
 121 )]
 122 fn deprecated_function() {}
 123 ```
 124 "##,
 125
 126 E0541: r##"
 127 An unknown meta item was used.
 128
 129 Erroneous code example:
 130
 131 ```compile_fail,E0541
 132 #[deprecated(
 133     since="1.0.0",
 134     // error: unknown meta item
 135     reason="Example invalid meta item. Should be 'note'")
 136 ]
 137 fn deprecated_function() {}
 138 ```
 139
 140 Meta items are the key-value pairs inside of an attribute. The keys provided
 141 must be one of the valid keys for the specified attribute.
 142
 143 To fix the problem, either remove the unknown meta item, or rename it if you
 144 provided the wrong name.
 145
 146 In the erroneous code example above, the wrong name was provided, so changing
 147 to a correct one it will fix the error. Example:
 148
 149 ```
 150 #[deprecated(
 151     since="1.0.0",
 152     note="This is a valid meta item for the deprecated attribute."
 153 )]
 154 fn deprecated_function() {}
 155 ```
 156 "##,
 157
 158 E0552: r##"
 159 A unrecognized representation attribute was used.
 160
 161 Erroneous code example:
 162
 163 ```compile_fail,E0552
 164 #[repr(D)] // error: unrecognized representation hint
 165 struct MyStruct {
 166     my_field: usize
 167 }
 168 ```
 169
 170 You can use a `repr` attribute to tell the compiler how you want a struct or
 171 enum to be laid out in memory.
 172
 173 Make sure you're using one of the supported options:
 174
 175 ```
 176 #[repr(C)] // ok!
 177 struct MyStruct {
 178     my_field: usize
 179 }
 180 ```
 181
 182 For more information about specifying representations, see the ["Alternative
 183 Representations" section] of the Rustonomicon.
 184
 185 ["Alternative Representations" section]: https://doc.rust-lang.org/nomicon/other-reprs.html
 186 "##,
 187
 188 E0554: r##"
 189 Feature attributes are only allowed on the nightly release channel. Stable or
 190 beta compilers will not comply.
 191
 192 Example of erroneous code (on a stable compiler):
 193
 194 ```ignore (depends on release channel)
 195 #![feature(non_ascii_idents)] // error: #![feature] may not be used on the
 196                               //        stable release channel
 197 ```
 198
 199 If you need the feature, make sure to use a nightly release of the compiler
 200 (but be warned that the feature may be removed or altered in the future).
 201 "##,
 202
 203 E0557: r##"
 204 A feature attribute named a feature that has been removed.
 205
 206 Erroneous code example:
 207
 208 ```compile_fail,E0557
 209 #![feature(managed_boxes)] // error: feature has been removed
 210 ```
 211
 212 Delete the offending feature attribute.
 213 "##,
 214
 215 E0565: r##"
 216 A literal was used in an attribute that doesn't support literals.
 217
 218 Erroneous code example:
 219
 220 ```ignore (compile_fail not working here; see Issue #43707)
 221 #![feature(attr_literals)]
 222
 223 #[inline("always")] // error: unsupported literal
 224 pub fn something() {}
 225 ```
 226
 227 Literals in attributes are new and largely unsupported. Work to support literals
 228 where appropriate is ongoing. Try using an unquoted name instead:
 229
 230 ```
 231 #[inline(always)]
 232 pub fn something() {}
 233 ```
 234 "##,
 235
 236 E0583: r##"
 237 A file wasn't found for an out-of-line module.
 238
 239 Erroneous code example:
 240
 241 ```ignore (compile_fail not working here; see Issue #43707)
 242 mod file_that_doesnt_exist; // error: file not found for module
 243
 244 fn main() {}
 245 ```
 246
 247 Please be sure that a file corresponding to the module exists. If you
 248 want to use a module named `file_that_doesnt_exist`, you need to have a file
 249 named `file_that_doesnt_exist.rs` or `file_that_doesnt_exist/mod.rs` in the
 250 same directory.
 251 "##,
 252
 253 E0585: r##"
 254 A documentation comment that doesn't document anything was found.
 255
 256 Erroneous code example:
 257
 258 ```compile_fail,E0585
 259 fn main() {
 260     // The following doc comment will fail:
 261     /// This is a useless doc comment!
 262 }
 263 ```
 264
 265 Documentation comments need to be followed by items, including functions,
 266 types, modules, etc. Examples:
 267
 268 ```
 269 /// I'm documenting the following struct:
 270 struct Foo;
 271
 272 /// I'm documenting the following function:
 273 fn foo() {}
 274 ```
 275 "##,
 276
 277 E0586: r##"
 278 An inclusive range was used with no end.
 279
 280 Erroneous code example:
 281
 282 ```compile_fail,E0586
 283 fn main() {
 284     let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
 285     let x = &tmp[1..=]; // error: inclusive range was used with no end
 286 }
 287 ```
 288
 289 An inclusive range needs an end in order to *include* it. If you just need a
 290 start and no end, use a non-inclusive range (with `..`):
 291
 292 ```
 293 fn main() {
 294     let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
 295     let x = &tmp[1..]; // ok!
 296 }
 297 ```
 298
 299 Or put an end to your inclusive range:
 300
 301 ```
 302 fn main() {
 303     let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
 304     let x = &tmp[1..=3]; // ok!
 305 }
 306 ```
 307 "##,
 308
 309 E0589: r##"
 310 The value of `N` that was specified for `repr(align(N))` was not a power
 311 of two, or was greater than 2^29.
 312
 313 ```compile_fail,E0589
 314 #[repr(align(15))] // error: invalid `repr(align)` attribute: not a power of two
 315 enum Foo {
 316     Bar(u64),
 317 }
 318 ```
 319 "##,
 320
 321 E0658: r##"
 322 An unstable feature was used.
 323
 324 Erroneous code example:
 325
 326 ```compile_fail,E658
 327 #[repr(u128)] // error: use of unstable library feature 'repr128'
 328 enum Foo {
 329     Bar(u64),
 330 }
 331 ```
 332
 333 If you're using a stable or a beta version of rustc, you won't be able to use
 334 any unstable features. In order to do so, please switch to a nightly version of
 335 rustc (by using rustup).
 336
 337 If you're using a nightly version of rustc, just add the corresponding feature
 338 to be able to use it:
 339
 340 ```
 341 #![feature(repr128)]
 342
 343 #[repr(u128)] // ok!
 344 enum Foo {
 345     Bar(u64),
 346 }
 347 ```
 348 "##,
 349
 350 E0633: r##"
 351 The `unwind` attribute was malformed.
 352
 353 Erroneous code example:
 354
 355 ```ignore (compile_fail not working here; see Issue #43707)
 356 #[unwind()] // error: expected one argument
 357 pub extern fn something() {}
 358
 359 fn main() {}
 360 ```
 361
 362 The `#[unwind]` attribute should be used as follows:
 363
 364 - `#[unwind(aborts)]` -- specifies that if a non-Rust ABI function
 365   should abort the process if it attempts to unwind. This is the safer
 366   and preferred option.
 367
 368 - `#[unwind(allowed)]` -- specifies that a non-Rust ABI function
 369   should be allowed to unwind. This can easily result in Undefined
 370   Behavior (UB), so be careful.
 371
 372 NB. The default behavior here is "allowed", but this is unspecified
 373 and likely to change in the future.
 374
 375 "##,
 376
 377 }
 378
 379 register_diagnostics! {
 380     E0539, // incorrect meta item
 381     E0540, // multiple rustc_deprecated attributes
 382     E0542, // missing 'since'
 383     E0543, // missing 'reason'
 384     E0544, // multiple stability levels
 385     E0545, // incorrect 'issue'
 386     E0546, // missing 'feature'
 387     E0547, // missing 'issue'
 388     E0548, // incorrect stability attribute type
 389     E0549, // rustc_deprecated attribute must be paired with either stable or unstable attribute
 390     E0550, // multiple deprecated attributes
 391     E0551, // incorrect meta item
 392     E0553, // multiple rustc_const_unstable attributes
 393     E0555, // malformed feature attribute, expected #![feature(...)]
 394     E0556, // malformed feature, expected just one word
 395     E0584, // file for module `..` found at both .. and ..
 396     E0629, // missing 'feature' (rustc_const_unstable)
 397     E0630, // rustc_const_unstable attribute must be paired with stable/unstable attribute
 398     E0693, // incorrect `repr(align)` attribute format
 399     E0694, // an unknown tool name found in scoped attributes
 400     E0703, // invalid ABI
 401     E0704, // incorrect visibility restriction
 402 }