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 }
 321
 322 register_diagnostics! {
 323     E0538, // multiple [same] items
 324     E0539, // incorrect meta item
 325     E0540, // multiple rustc_deprecated attributes
 326     E0541, // unknown meta item
 327     E0542, // missing 'since'
 328     E0543, // missing 'reason'
 329     E0544, // multiple stability levels
 330     E0545, // incorrect 'issue'
 331     E0546, // missing 'feature'
 332     E0547, // missing 'issue'
 333     E0548, // incorrect stability attribute type
 334     E0549, // rustc_deprecated attribute must be paired with either stable or unstable attribute
 335     E0550, // multiple deprecated attributes
 336     E0551, // incorrect meta item
 337     E0553, // multiple rustc_const_unstable attributes
 338     E0555, // malformed feature attribute, expected #![feature(...)]
 339     E0556, // malformed feature, expected just one word
 340     E0584, // file for module `..` found at both .. and ..
 341     E0589, // invalid `repr(align)` attribute
 342     E0629, // missing 'feature' (rustc_const_unstable)
 343     E0630, // rustc_const_unstable attribute must be paired with stable/unstable attribute
 344 }