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 E0534: r##"
  41 The `inline` attribute was malformed.
  42
  43 Erroneous code example:
  44
  45 ```ignore (compile_fail not working here; see Issue #43707)
  46 #[inline()] // error: expected one argument
  47 pub fn something() {}
  48
  49 fn main() {}
  50 ```
  51
  52 The parenthesized `inline` attribute requires the parameter to be specified:
  53
  54 ```
  55 #[inline(always)]
  56 fn something() {}
  57 ```
  58
  59 or:
  60
  61 ```
  62 #[inline(never)]
  63 fn something() {}
  64 ```
  65
  66 Alternatively, a paren-less version of the attribute may be used to hint the
  67 compiler about inlining opportunity:
  68
  69 ```
  70 #[inline]
  71 fn something() {}
  72 ```
  73
  74 For more information about the inline attribute, read:
  75 https://doc.rust-lang.org/reference.html#inline-attributes
  76 "##,
  77
  78 E0535: r##"
  79 An unknown argument was given to the `inline` attribute.
  80
  81 Erroneous code example:
  82
  83 ```ignore (compile_fail not working here; see Issue #43707)
  84 #[inline(unknown)] // error: invalid argument
  85 pub fn something() {}
  86
  87 fn main() {}
  88 ```
  89
  90 The `inline` attribute only supports two arguments:
  91
  92  * always
  93  * never
  94
  95 All other arguments given to the `inline` attribute will return this error.
  96 Example:
  97
  98 ```
  99 #[inline(never)] // ok!
 100 pub fn something() {}
 101
 102 fn main() {}
 103 ```
 104
 105 For more information about the inline attribute, https:
 106 read://doc.rust-lang.org/reference.html#inline-attributes
 107 "##,
 108
 109 E0536: r##"
 110 The `not` cfg-predicate was malformed.
 111
 112 Erroneous code example:
 113
 114 ```compile_fail,E0536
 115 #[cfg(not())] // error: expected 1 cfg-pattern
 116 pub fn something() {}
 117
 118 pub fn main() {}
 119 ```
 120
 121 The `not` predicate expects one cfg-pattern. Example:
 122
 123 ```
 124 #[cfg(not(target_os = "linux"))] // ok!
 125 pub fn something() {}
 126
 127 pub fn main() {}
 128 ```
 129
 130 For more information about the cfg attribute, read:
 131 https://doc.rust-lang.org/reference.html#conditional-compilation
 132 "##,
 133
 134 E0537: r##"
 135 An unknown predicate was used inside the `cfg` attribute.
 136
 137 Erroneous code example:
 138
 139 ```compile_fail,E0537
 140 #[cfg(unknown())] // error: invalid predicate `unknown`
 141 pub fn something() {}
 142
 143 pub fn main() {}
 144 ```
 145
 146 The `cfg` attribute supports only three kinds of predicates:
 147
 148  * any
 149  * all
 150  * not
 151
 152 Example:
 153
 154 ```
 155 #[cfg(not(target_os = "linux"))] // ok!
 156 pub fn something() {}
 157
 158 pub fn main() {}
 159 ```
 160
 161 For more information about the cfg attribute, read:
 162 https://doc.rust-lang.org/reference.html#conditional-compilation
 163 "##,
 164
 165 E0552: r##"
 166 A unrecognized representation attribute was used.
 167
 168 Erroneous code example:
 169
 170 ```compile_fail,E0552
 171 #[repr(D)] // error: unrecognized representation hint
 172 struct MyStruct {
 173     my_field: usize
 174 }
 175 ```
 176
 177 You can use a `repr` attribute to tell the compiler how you want a struct or
 178 enum to be laid out in memory.
 179
 180 Make sure you're using one of the supported options:
 181
 182 ```
 183 #[repr(C)] // ok!
 184 struct MyStruct {
 185     my_field: usize
 186 }
 187 ```
 188
 189 For more information about specifying representations, see the ["Alternative
 190 Representations" section] of the Rustonomicon.
 191
 192 ["Alternative Representations" section]: https://doc.rust-lang.org/nomicon/other-reprs.html
 193 "##,
 194
 195 E0554: r##"
 196 Feature attributes are only allowed on the nightly release channel. Stable or
 197 beta compilers will not comply.
 198
 199 Example of erroneous code (on a stable compiler):
 200
 201 ```ignore (depends on release channel)
 202 #![feature(non_ascii_idents)] // error: #![feature] may not be used on the
 203                               //        stable release channel
 204 ```
 205
 206 If you need the feature, make sure to use a nightly release of the compiler
 207 (but be warned that the feature may be removed or altered in the future).
 208 "##,
 209
 210 E0557: r##"
 211 A feature attribute named a feature that has been removed.
 212
 213 Erroneous code example:
 214
 215 ```compile_fail,E0557
 216 #![feature(managed_boxes)] // error: feature has been removed
 217 ```
 218
 219 Delete the offending feature attribute.
 220 "##,
 221
 222 E0565: r##"
 223 A literal was used in an attribute that doesn't support literals.
 224
 225 Erroneous code example:
 226
 227 ```ignore (compile_fail not working here; see Issue #43707)
 228 #![feature(attr_literals)]
 229
 230 #[inline("always")] // error: unsupported literal
 231 pub fn something() {}
 232 ```
 233
 234 Literals in attributes are new and largely unsupported. Work to support literals
 235 where appropriate is ongoing. Try using an unquoted name instead:
 236
 237 ```
 238 #[inline(always)]
 239 pub fn something() {}
 240 ```
 241 "##,
 242
 243 E0583: r##"
 244 A file wasn't found for an out-of-line module.
 245
 246 Erroneous code example:
 247
 248 ```ignore (compile_fail not working here; see Issue #43707)
 249 mod file_that_doesnt_exist; // error: file not found for module
 250
 251 fn main() {}
 252 ```
 253
 254 Please be sure that a file corresponding to the module exists. If you
 255 want to use a module named `file_that_doesnt_exist`, you need to have a file
 256 named `file_that_doesnt_exist.rs` or `file_that_doesnt_exist/mod.rs` in the
 257 same directory.
 258 "##,
 259
 260 E0585: r##"
 261 A documentation comment that doesn't document anything was found.
 262
 263 Erroneous code example:
 264
 265 ```compile_fail,E0585
 266 fn main() {
 267     // The following doc comment will fail:
 268     /// This is a useless doc comment!
 269 }
 270 ```
 271
 272 Documentation comments need to be followed by items, including functions,
 273 types, modules, etc. Examples:
 274
 275 ```
 276 /// I'm documenting the following struct:
 277 struct Foo;
 278
 279 /// I'm documenting the following function:
 280 fn foo() {}
 281 ```
 282 "##,
 283
 284 E0586: r##"
 285 An inclusive range was used with no end.
 286
 287 Erroneous code example:
 288
 289 ```compile_fail,E0586
 290 #![feature(inclusive_range_syntax)]
 291
 292 fn main() {
 293     let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
 294     let x = &tmp[1..=]; // error: inclusive range was used with no end
 295 }
 296 ```
 297
 298 An inclusive range needs an end in order to *include* it. If you just need a
 299 start and no end, use a non-inclusive range (with `..`):
 300
 301 ```
 302 fn main() {
 303     let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
 304     let x = &tmp[1..]; // ok!
 305 }
 306 ```
 307
 308 Or put an end to your inclusive range:
 309
 310 ```
 311 #![feature(inclusive_range_syntax)]
 312
 313 fn main() {
 314     let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
 315     let x = &tmp[1..=3]; // ok!
 316 }
 317 ```
 318 "##,
 319
 320 E0658: r##"
 321 An unstable feature was used.
 322
 323 Erroneous code example:
 324
 325 ```compile_fail,E658
 326 let x = ::std::u128::MAX; // error: use of unstable library feature 'i128'
 327 ```
 328
 329 If you're using a stable or a beta version of rustc, you won't be able to use
 330 any unstable features. In order to do so, please switch to a nightly version of
 331 rustc (by using rustup).
 332
 333 If you're using a nightly version of rustc, just add the corresponding feature
 334 to be able to use it:
 335
 336 ```
 337 #![feature(i128)]
 338
 339 fn main() {
 340     let x = ::std::u128::MAX; // ok!
 341 }
 342 ```
 343 "##,
 344
 345 E0633: r##"
 346 The `unwind` attribute was malformed.
 347
 348 Erroneous code example:
 349
 350 ```ignore (compile_fail not working here; see Issue #43707)
 351 #[unwind()] // error: expected one argument
 352 pub extern fn something() {}
 353
 354 fn main() {}
 355 ```
 356
 357 The `#[unwind]` attribute should be used as follows:
 358
 359 - `#[unwind(aborts)]` -- specifies that if a non-Rust ABI function
 360   should abort the process if it attempts to unwind. This is the safer
 361   and preferred option.
 362
 363 - `#[unwind(allowed)]` -- specifies that a non-Rust ABI function
 364   should be allowed to unwind. This can easily result in Undefined
 365   Behavior (UB), so be careful.
 366
 367 NB. The default behavior here is "allowed", but this is unspecified
 368 and likely to change in the future.
 369
 370 "##,
 371
 372 }
 373
 374 register_diagnostics! {
 375     E0538, // multiple [same] items
 376     E0539, // incorrect meta item
 377     E0540, // multiple rustc_deprecated attributes
 378     E0541, // unknown meta item
 379     E0542, // missing 'since'
 380     E0543, // missing 'reason'
 381     E0544, // multiple stability levels
 382     E0545, // incorrect 'issue'
 383     E0546, // missing 'feature'
 384     E0547, // missing 'issue'
 385     E0548, // incorrect stability attribute type
 386     E0549, // rustc_deprecated attribute must be paired with either stable or unstable attribute
 387     E0550, // multiple deprecated attributes
 388     E0551, // incorrect meta item
 389     E0553, // multiple rustc_const_unstable attributes
 390     E0555, // malformed feature attribute, expected #![feature(...)]
 391     E0556, // malformed feature, expected just one word
 392     E0584, // file for module `..` found at both .. and ..
 393     E0589, // invalid `repr(align)` attribute
 394     E0629, // missing 'feature' (rustc_const_unstable)
 395     E0630, // rustc_const_unstable attribute must be paired with stable/unstable attribute
 396 }