]> git.lizzy.rs Git - rust.git/blob - src/libsyntax/diagnostic_list.rs
Auto merge of #43648 - RalfJung:jemalloc-debug, r=alexcrichton
[rust.git] / 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 E0558: r##"
223 The `export_name` attribute was malformed.
224
225 Erroneous code example:
226
227 ```compile_fail,E0558
228 #[export_name] // error: export_name attribute has invalid format
229 pub fn something() {}
230
231 fn main() {}
232 ```
233
234 The `export_name` attribute expects a string in order to determine the name of
235 the exported symbol. Example:
236
237 ```
238 #[export_name = "some_function"] // ok!
239 pub fn something() {}
240
241 fn main() {}
242 ```
243 "##,
244
245 E0565: r##"
246 A literal was used in an attribute that doesn't support literals.
247
248 Erroneous code example:
249
250 ```ignore (compile_fail not working here; see Issue #43707)
251 #![feature(attr_literals)]
252
253 #[inline("always")] // error: unsupported literal
254 pub fn something() {}
255 ```
256
257 Literals in attributes are new and largely unsupported. Work to support literals
258 where appropriate is ongoing. Try using an unquoted name instead:
259
260 ```
261 #[inline(always)]
262 pub fn something() {}
263 ```
264 "##,
265
266 E0583: r##"
267 A file wasn't found for an out-of-line module.
268
269 Erroneous code example:
270
271 ```ignore (compile_fail not working here; see Issue #43707)
272 mod file_that_doesnt_exist; // error: file not found for module
273
274 fn main() {}
275 ```
276
277 Please be sure that a file corresponding to the module exists. If you
278 want to use a module named `file_that_doesnt_exist`, you need to have a file
279 named `file_that_doesnt_exist.rs` or `file_that_doesnt_exist/mod.rs` in the
280 same directory.
281 "##,
282
283 E0585: r##"
284 A documentation comment that doesn't document anything was found.
285
286 Erroneous code example:
287
288 ```compile_fail,E0585
289 fn main() {
290     // The following doc comment will fail:
291     /// This is a useless doc comment!
292 }
293 ```
294
295 Documentation comments need to be followed by items, including functions,
296 types, modules, etc. Examples:
297
298 ```
299 /// I'm documenting the following struct:
300 struct Foo;
301
302 /// I'm documenting the following function:
303 fn foo() {}
304 ```
305 "##,
306
307 E0586: r##"
308 An inclusive range was used with no end.
309
310 Erroneous code example:
311
312 ```compile_fail,E0586
313 #![feature(inclusive_range_syntax)]
314
315 fn main() {
316     let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
317     let x = &tmp[1...]; // error: inclusive range was used with no end
318 }
319 ```
320
321 An inclusive range needs an end in order to *include* it. If you just need a
322 start and no end, use a non-inclusive range (with `..`):
323
324 ```
325 fn main() {
326     let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
327     let x = &tmp[1..]; // ok!
328 }
329 ```
330
331 Or put an end to your inclusive range:
332
333 ```
334 #![feature(inclusive_range_syntax)]
335
336 fn main() {
337     let tmp = vec![0, 1, 2, 3, 4, 4, 3, 3, 2, 1];
338     let x = &tmp[1...3]; // ok!
339 }
340 ```
341 "##,
342
343 }
344
345 register_diagnostics! {
346     E0538, // multiple [same] items
347     E0539, // incorrect meta item
348     E0540, // multiple rustc_deprecated attributes
349     E0541, // unknown meta item
350     E0542, // missing 'since'
351     E0543, // missing 'reason'
352     E0544, // multiple stability levels
353     E0545, // incorrect 'issue'
354     E0546, // missing 'feature'
355     E0547, // missing 'issue'
356     E0548, // incorrect stability attribute type
357     E0549, // rustc_deprecated attribute must be paired with either stable or unstable attribute
358     E0550, // multiple deprecated attributes
359     E0551, // incorrect meta item
360     E0555, // malformed feature attribute, expected #![feature(...)]
361     E0556, // malformed feature, expected just one word
362     E0584, // file for module `..` found at both .. and ..
363     E0589, // invalid `repr(align)` attribute
364 }