]>
Commit | Line | Data |
---|---|---|
85aaf69f SL |
1 | // Copyright 2014 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 | ||
92a42be0 SL |
13 | // Error messages for EXXXX errors. Each message should start and end with a |
14 | // new line, and be wrapped to 80 characters. In vim you can `:set tw=80` and | |
15 | // use `gq` to wrap paragraphs. Use `:set tw=0` to disable. | |
d9579d0f AL |
16 | register_long_diagnostics! { |
17 | ||
8bb4bdeb XL |
18 | E0128: r##" |
19 | Type parameter defaults can only use parameters that occur before them. | |
20 | Erroneous code example: | |
21 | ||
22 | ```compile_fail,E0128 | |
23 | struct Foo<T=U, U=()> { | |
24 | field1: T, | |
25 | filed2: U, | |
26 | } | |
27 | // error: type parameters with a default cannot use forward declared | |
28 | // identifiers | |
29 | ``` | |
30 | ||
31 | Since type parameters are evaluated in-order, you may be able to fix this issue | |
32 | by doing: | |
33 | ||
34 | ``` | |
35 | struct Foo<U=(), T=U> { | |
36 | field1: T, | |
37 | filed2: U, | |
38 | } | |
39 | ``` | |
40 | ||
41 | Please also verify that this wasn't because of a name-clash and rename the type | |
42 | parameter if so. | |
43 | "##, | |
44 | ||
d9579d0f | 45 | E0154: r##" |
abe05a73 | 46 | #### Note: this error code is no longer emitted by the compiler. |
3157f602 | 47 | |
d9579d0f AL |
48 | Imports (`use` statements) are not allowed after non-item statements, such as |
49 | variable declarations and expression statements. | |
50 | ||
51 | Here is an example that demonstrates the error: | |
52 | ||
041b39d2 | 53 | ``` |
d9579d0f AL |
54 | fn f() { |
55 | // Variable declaration before import | |
56 | let x = 0; | |
57 | use std::io::Read; | |
7453a54e | 58 | // ... |
d9579d0f AL |
59 | } |
60 | ``` | |
61 | ||
62 | The solution is to declare the imports at the top of the block, function, or | |
63 | file. | |
64 | ||
65 | Here is the previous example again, with the correct order: | |
66 | ||
67 | ``` | |
68 | fn f() { | |
69 | use std::io::Read; | |
70 | let x = 0; | |
7453a54e | 71 | // ... |
d9579d0f AL |
72 | } |
73 | ``` | |
74 | ||
75 | See the Declaration Statements section of the reference for more information | |
76 | about what constitutes an Item declaration and what does not: | |
77 | ||
e9174d1e | 78 | https://doc.rust-lang.org/reference.html#statements |
d9579d0f AL |
79 | "##, |
80 | ||
81 | E0251: r##" | |
abe05a73 | 82 | #### Note: this error code is no longer emitted by the compiler. |
3157f602 | 83 | |
d9579d0f AL |
84 | Two items of the same name cannot be imported without rebinding one of the |
85 | items under a new local name. | |
86 | ||
87 | An example of this error: | |
88 | ||
041b39d2 | 89 | ``` |
d9579d0f AL |
90 | use foo::baz; |
91 | use bar::*; // error, do `use foo::baz as quux` instead on the previous line | |
92 | ||
93 | fn main() {} | |
94 | ||
95 | mod foo { | |
96 | pub struct baz; | |
97 | } | |
98 | ||
99 | mod bar { | |
100 | pub mod baz {} | |
101 | } | |
102 | ``` | |
103 | "##, | |
104 | ||
105 | E0252: r##" | |
106 | Two items of the same name cannot be imported without rebinding one of the | |
107 | items under a new local name. | |
108 | ||
3157f602 | 109 | Erroneous code example: |
d9579d0f | 110 | |
3157f602 | 111 | ```compile_fail,E0252 |
d9579d0f AL |
112 | use foo::baz; |
113 | use bar::baz; // error, do `use bar::baz as quux` instead | |
114 | ||
115 | fn main() {} | |
116 | ||
117 | mod foo { | |
118 | pub struct baz; | |
119 | } | |
120 | ||
3157f602 XL |
121 | mod bar { |
122 | pub mod baz {} | |
123 | } | |
124 | ``` | |
125 | ||
126 | You can use aliases in order to fix this error. Example: | |
127 | ||
128 | ``` | |
129 | use foo::baz as foo_baz; | |
130 | use bar::baz; // ok! | |
131 | ||
132 | fn main() {} | |
133 | ||
134 | mod foo { | |
135 | pub struct baz; | |
136 | } | |
137 | ||
138 | mod bar { | |
139 | pub mod baz {} | |
140 | } | |
141 | ``` | |
142 | ||
143 | Or you can reference the item with its parent: | |
144 | ||
145 | ``` | |
146 | use bar::baz; | |
147 | ||
148 | fn main() { | |
149 | let x = foo::baz; // ok! | |
150 | } | |
151 | ||
152 | mod foo { | |
153 | pub struct baz; | |
154 | } | |
155 | ||
d9579d0f AL |
156 | mod bar { |
157 | pub mod baz {} | |
158 | } | |
159 | ``` | |
160 | "##, | |
161 | ||
c1a9b12d | 162 | E0253: r##" |
7453a54e | 163 | Attempt was made to import an unimportable value. This can happen when trying |
3157f602 | 164 | to import a method from a trait. |
c1a9b12d | 165 | |
3157f602 XL |
166 | Erroneous code example: |
167 | ||
168 | ```compile_fail,E0253 | |
c1a9b12d SL |
169 | mod foo { |
170 | pub trait MyTrait { | |
171 | fn do_something(); | |
172 | } | |
173 | } | |
7453a54e | 174 | |
c1a9b12d | 175 | use foo::MyTrait::do_something; |
5bcae85e | 176 | // error: `do_something` is not directly importable |
3157f602 XL |
177 | |
178 | fn main() {} | |
c1a9b12d SL |
179 | ``` |
180 | ||
181 | It's invalid to directly import methods belonging to a trait or concrete type. | |
182 | "##, | |
183 | ||
5bcae85e SL |
184 | E0254: r##" |
185 | Attempt was made to import an item whereas an extern crate with this name has | |
186 | already been imported. | |
187 | ||
188 | Erroneous code example: | |
189 | ||
190 | ```compile_fail,E0254 | |
041b39d2 | 191 | extern crate core; |
5bcae85e SL |
192 | |
193 | mod foo { | |
041b39d2 | 194 | pub trait core { |
5bcae85e SL |
195 | fn do_something(); |
196 | } | |
197 | } | |
198 | ||
041b39d2 XL |
199 | use foo::core; // error: an extern crate named `core` has already |
200 | // been imported in this module | |
5bcae85e SL |
201 | |
202 | fn main() {} | |
203 | ``` | |
204 | ||
205 | To fix issue issue, you have to rename at least one of the two imports. | |
206 | Example: | |
207 | ||
041b39d2 XL |
208 | ``` |
209 | extern crate core as libcore; // ok! | |
5bcae85e SL |
210 | |
211 | mod foo { | |
041b39d2 | 212 | pub trait core { |
5bcae85e SL |
213 | fn do_something(); |
214 | } | |
215 | } | |
216 | ||
041b39d2 | 217 | use foo::core; |
5bcae85e SL |
218 | |
219 | fn main() {} | |
220 | ``` | |
221 | "##, | |
222 | ||
d9579d0f AL |
223 | E0255: r##" |
224 | You can't import a value whose name is the same as another value defined in the | |
225 | module. | |
226 | ||
3157f602 | 227 | Erroneous code example: |
d9579d0f | 228 | |
3157f602 XL |
229 | ```compile_fail,E0255 |
230 | use bar::foo; // error: an item named `foo` is already in scope | |
d9579d0f AL |
231 | |
232 | fn foo() {} | |
233 | ||
234 | mod bar { | |
235 | pub fn foo() {} | |
236 | } | |
237 | ||
238 | fn main() {} | |
239 | ``` | |
3157f602 XL |
240 | |
241 | You can use aliases in order to fix this error. Example: | |
242 | ||
243 | ``` | |
244 | use bar::foo as bar_foo; // ok! | |
245 | ||
246 | fn foo() {} | |
247 | ||
248 | mod bar { | |
249 | pub fn foo() {} | |
250 | } | |
251 | ||
252 | fn main() {} | |
253 | ``` | |
254 | ||
255 | Or you can reference the item with its parent: | |
256 | ||
257 | ``` | |
258 | fn foo() {} | |
259 | ||
260 | mod bar { | |
261 | pub fn foo() {} | |
262 | } | |
263 | ||
264 | fn main() { | |
265 | bar::foo(); // we get the item by referring to its parent | |
266 | } | |
267 | ``` | |
d9579d0f AL |
268 | "##, |
269 | ||
270 | E0256: r##" | |
abe05a73 | 271 | #### Note: this error code is no longer emitted by the compiler. |
3157f602 | 272 | |
d9579d0f AL |
273 | You can't import a type or module when the name of the item being imported is |
274 | the same as another type or submodule defined in the module. | |
275 | ||
276 | An example of this error: | |
277 | ||
7453a54e | 278 | ```compile_fail |
d9579d0f AL |
279 | use foo::Bar; // error |
280 | ||
281 | type Bar = u32; | |
282 | ||
283 | mod foo { | |
284 | pub mod Bar { } | |
285 | } | |
286 | ||
287 | fn main() {} | |
288 | ``` | |
289 | "##, | |
290 | ||
291 | E0259: r##" | |
7453a54e SL |
292 | The name chosen for an external crate conflicts with another external crate |
293 | that has been imported into the current module. | |
d9579d0f | 294 | |
7453a54e | 295 | Erroneous code example: |
d9579d0f | 296 | |
3157f602 | 297 | ```compile_fail,E0259 |
041b39d2 XL |
298 | # #![feature(libc)] |
299 | extern crate core; | |
300 | extern crate libc as core; | |
3157f602 XL |
301 | |
302 | fn main() {} | |
d9579d0f AL |
303 | ``` |
304 | ||
305 | The solution is to choose a different name that doesn't conflict with any | |
306 | external crate imported into the current module. | |
307 | ||
308 | Correct example: | |
309 | ||
041b39d2 XL |
310 | ``` |
311 | # #![feature(libc)] | |
312 | extern crate core; | |
3157f602 | 313 | extern crate libc as other_name; |
041b39d2 XL |
314 | |
315 | fn main() {} | |
d9579d0f AL |
316 | ``` |
317 | "##, | |
318 | ||
319 | E0260: r##" | |
320 | The name for an item declaration conflicts with an external crate's name. | |
321 | ||
3157f602 | 322 | Erroneous code example: |
d9579d0f | 323 | |
041b39d2 XL |
324 | ```compile_fail,E0260 |
325 | extern crate core; | |
d9579d0f | 326 | |
041b39d2 | 327 | struct core; |
0531ce1d XL |
328 | |
329 | fn main() {} | |
d9579d0f AL |
330 | ``` |
331 | ||
332 | There are two possible solutions: | |
333 | ||
334 | Solution #1: Rename the item. | |
335 | ||
041b39d2 XL |
336 | ``` |
337 | extern crate core; | |
d9579d0f AL |
338 | |
339 | struct xyz; | |
340 | ``` | |
341 | ||
342 | Solution #2: Import the crate with a different name. | |
343 | ||
041b39d2 XL |
344 | ``` |
345 | extern crate core as xyz; | |
d9579d0f AL |
346 | |
347 | struct abc; | |
348 | ``` | |
349 | ||
350 | See the Declaration Statements section of the reference for more information | |
351 | about what constitutes an Item declaration and what does not: | |
352 | ||
e9174d1e | 353 | https://doc.rust-lang.org/reference.html#statements |
d9579d0f AL |
354 | "##, |
355 | ||
c1a9b12d | 356 | E0364: r##" |
3157f602 | 357 | Private items cannot be publicly re-exported. This error indicates that you |
7453a54e | 358 | attempted to `pub use` a type or value that was not itself public. |
c1a9b12d | 359 | |
3157f602 | 360 | Erroneous code example: |
c1a9b12d | 361 | |
7453a54e | 362 | ```compile_fail |
c1a9b12d SL |
363 | mod foo { |
364 | const X: u32 = 1; | |
365 | } | |
7453a54e | 366 | |
c1a9b12d | 367 | pub use foo::X; |
3157f602 XL |
368 | |
369 | fn main() {} | |
c1a9b12d SL |
370 | ``` |
371 | ||
372 | The solution to this problem is to ensure that the items that you are | |
373 | re-exporting are themselves marked with `pub`: | |
374 | ||
3157f602 | 375 | ``` |
c1a9b12d SL |
376 | mod foo { |
377 | pub const X: u32 = 1; | |
378 | } | |
7453a54e | 379 | |
c1a9b12d | 380 | pub use foo::X; |
3157f602 XL |
381 | |
382 | fn main() {} | |
c1a9b12d SL |
383 | ``` |
384 | ||
7453a54e SL |
385 | See the 'Use Declarations' section of the reference for more information on |
386 | this topic: | |
c1a9b12d | 387 | |
e9174d1e | 388 | https://doc.rust-lang.org/reference.html#use-declarations |
c1a9b12d SL |
389 | "##, |
390 | ||
391 | E0365: r##" | |
7453a54e SL |
392 | Private modules cannot be publicly re-exported. This error indicates that you |
393 | attempted to `pub use` a module that was not itself public. | |
c1a9b12d | 394 | |
3157f602 | 395 | Erroneous code example: |
c1a9b12d | 396 | |
3157f602 | 397 | ```compile_fail,E0365 |
c1a9b12d SL |
398 | mod foo { |
399 | pub const X: u32 = 1; | |
400 | } | |
c1a9b12d | 401 | |
7453a54e | 402 | pub use foo as foo2; |
3157f602 XL |
403 | |
404 | fn main() {} | |
c1a9b12d | 405 | ``` |
7453a54e | 406 | |
c1a9b12d SL |
407 | The solution to this problem is to ensure that the module that you are |
408 | re-exporting is itself marked with `pub`: | |
409 | ||
3157f602 | 410 | ``` |
c1a9b12d SL |
411 | pub mod foo { |
412 | pub const X: u32 = 1; | |
413 | } | |
7453a54e | 414 | |
c1a9b12d | 415 | pub use foo as foo2; |
3157f602 XL |
416 | |
417 | fn main() {} | |
c1a9b12d SL |
418 | ``` |
419 | ||
420 | See the 'Use Declarations' section of the reference for more information | |
421 | on this topic: | |
422 | ||
e9174d1e | 423 | https://doc.rust-lang.org/reference.html#use-declarations |
c1a9b12d SL |
424 | "##, |
425 | ||
92a42be0 | 426 | E0401: r##" |
7453a54e | 427 | Inner items do not inherit type parameters from the functions they are embedded |
3157f602 | 428 | in. |
92a42be0 | 429 | |
3157f602 XL |
430 | Erroneous code example: |
431 | ||
432 | ```compile_fail,E0401 | |
92a42be0 SL |
433 | fn foo<T>(x: T) { |
434 | fn bar(y: T) { // T is defined in the "outer" function | |
435 | // .. | |
436 | } | |
437 | bar(x); | |
438 | } | |
439 | ``` | |
440 | ||
7453a54e | 441 | Nor will this: |
9cc50fc6 | 442 | |
3157f602 | 443 | ```compile_fail,E0401 |
9cc50fc6 SL |
444 | fn foo<T>(x: T) { |
445 | type MaybeT = Option<T>; | |
446 | // ... | |
447 | } | |
448 | ``` | |
449 | ||
7453a54e | 450 | Or this: |
9cc50fc6 | 451 | |
3157f602 | 452 | ```compile_fail,E0401 |
9cc50fc6 SL |
453 | fn foo<T>(x: T) { |
454 | struct Foo { | |
455 | x: T, | |
456 | } | |
457 | // ... | |
458 | } | |
459 | ``` | |
460 | ||
461 | Items inside functions are basically just like top-level items, except | |
462 | that they can only be used from the function they are in. | |
92a42be0 SL |
463 | |
464 | There are a couple of solutions for this. | |
465 | ||
9cc50fc6 | 466 | If the item is a function, you may use a closure: |
92a42be0 SL |
467 | |
468 | ``` | |
469 | fn foo<T>(x: T) { | |
470 | let bar = |y: T| { // explicit type annotation may not be necessary | |
471 | // .. | |
7453a54e | 472 | }; |
92a42be0 SL |
473 | bar(x); |
474 | } | |
475 | ``` | |
476 | ||
9cc50fc6 | 477 | For a generic item, you can copy over the parameters: |
92a42be0 SL |
478 | |
479 | ``` | |
480 | fn foo<T>(x: T) { | |
481 | fn bar<T>(y: T) { | |
482 | // .. | |
483 | } | |
484 | bar(x); | |
485 | } | |
486 | ``` | |
487 | ||
9cc50fc6 SL |
488 | ``` |
489 | fn foo<T>(x: T) { | |
490 | type MaybeT<T> = Option<T>; | |
491 | } | |
492 | ``` | |
493 | ||
92a42be0 SL |
494 | Be sure to copy over any bounds as well: |
495 | ||
496 | ``` | |
497 | fn foo<T: Copy>(x: T) { | |
498 | fn bar<T: Copy>(y: T) { | |
499 | // .. | |
500 | } | |
501 | bar(x); | |
502 | } | |
503 | ``` | |
504 | ||
9cc50fc6 SL |
505 | ``` |
506 | fn foo<T: Copy>(x: T) { | |
507 | struct Foo<T: Copy> { | |
508 | x: T, | |
509 | } | |
510 | } | |
511 | ``` | |
512 | ||
92a42be0 SL |
513 | This may require additional type hints in the function body. |
514 | ||
9cc50fc6 SL |
515 | In case the item is a function inside an `impl`, defining a private helper |
516 | function might be easier: | |
92a42be0 | 517 | |
041b39d2 XL |
518 | ``` |
519 | # struct Foo<T>(T); | |
92a42be0 SL |
520 | impl<T> Foo<T> { |
521 | pub fn foo(&self, x: T) { | |
522 | self.bar(x); | |
523 | } | |
7453a54e | 524 | |
92a42be0 SL |
525 | fn bar(&self, y: T) { |
526 | // .. | |
527 | } | |
528 | } | |
529 | ``` | |
530 | ||
531 | For default impls in traits, the private helper solution won't work, however | |
532 | closures or copying the parameters should still work. | |
533 | "##, | |
534 | ||
c1a9b12d | 535 | E0403: r##" |
3157f602 | 536 | Some type parameters have the same name. |
c1a9b12d | 537 | |
3157f602 XL |
538 | Erroneous code example: |
539 | ||
540 | ```compile_fail,E0403 | |
c1a9b12d SL |
541 | fn foo<T, T>(s: T, u: T) {} // error: the name `T` is already used for a type |
542 | // parameter in this type parameter list | |
543 | ``` | |
544 | ||
0531ce1d | 545 | Please verify that none of the type parameters are misspelled, and rename any |
c1a9b12d SL |
546 | clashing parameters. Example: |
547 | ||
548 | ``` | |
549 | fn foo<T, Y>(s: T, u: Y) {} // ok! | |
550 | ``` | |
551 | "##, | |
552 | ||
553 | E0404: r##" | |
0531ce1d XL |
554 | You tried to use something which is not a trait in a trait position, such as |
555 | a bound or `impl`. | |
c1a9b12d | 556 | |
3157f602 XL |
557 | Erroneous code example: |
558 | ||
559 | ```compile_fail,E0404 | |
c1a9b12d SL |
560 | struct Foo; |
561 | struct Bar; | |
562 | ||
563 | impl Foo for Bar {} // error: `Foo` is not a trait | |
564 | ``` | |
565 | ||
0531ce1d XL |
566 | Another erroneous code example: |
567 | ||
568 | ```compile_fail,E0404 | |
569 | struct Foo; | |
570 | ||
571 | fn bar<T: Foo>(t: T) {} // error: `Foo` is not a trait | |
572 | ``` | |
573 | ||
c1a9b12d SL |
574 | Please verify that you didn't misspell the trait's name or otherwise use the |
575 | wrong identifier. Example: | |
576 | ||
577 | ``` | |
578 | trait Foo { | |
579 | // some functions | |
580 | } | |
581 | struct Bar; | |
582 | ||
583 | impl Foo for Bar { // ok! | |
584 | // functions implementation | |
585 | } | |
586 | ``` | |
0531ce1d XL |
587 | |
588 | or | |
589 | ||
590 | ``` | |
591 | trait Foo { | |
592 | // some functions | |
593 | } | |
594 | ||
595 | fn bar<T: Foo>(t: T) {} // ok! | |
596 | ``` | |
597 | ||
c1a9b12d SL |
598 | "##, |
599 | ||
600 | E0405: r##" | |
3157f602 | 601 | The code refers to a trait that is not in scope. |
c1a9b12d | 602 | |
3157f602 XL |
603 | Erroneous code example: |
604 | ||
605 | ```compile_fail,E0405 | |
c1a9b12d SL |
606 | struct Foo; |
607 | ||
7453a54e | 608 | impl SomeTrait for Foo {} // error: trait `SomeTrait` is not in scope |
c1a9b12d SL |
609 | ``` |
610 | ||
611 | Please verify that the name of the trait wasn't misspelled and ensure that it | |
612 | was imported. Example: | |
613 | ||
041b39d2 XL |
614 | ``` |
615 | # #[cfg(for_demonstration_only)] | |
c1a9b12d SL |
616 | // solution 1: |
617 | use some_file::SomeTrait; | |
618 | ||
619 | // solution 2: | |
620 | trait SomeTrait { | |
621 | // some functions | |
622 | } | |
623 | ||
624 | struct Foo; | |
625 | ||
626 | impl SomeTrait for Foo { // ok! | |
627 | // implements functions | |
628 | } | |
629 | ``` | |
630 | "##, | |
631 | ||
632 | E0407: r##" | |
633 | A definition of a method not in the implemented trait was given in a trait | |
3157f602 | 634 | implementation. |
c1a9b12d | 635 | |
3157f602 XL |
636 | Erroneous code example: |
637 | ||
638 | ```compile_fail,E0407 | |
c1a9b12d SL |
639 | trait Foo { |
640 | fn a(); | |
641 | } | |
642 | ||
643 | struct Bar; | |
644 | ||
645 | impl Foo for Bar { | |
646 | fn a() {} | |
647 | fn b() {} // error: method `b` is not a member of trait `Foo` | |
648 | } | |
649 | ``` | |
650 | ||
651 | Please verify you didn't misspell the method name and you used the correct | |
652 | trait. First example: | |
653 | ||
654 | ``` | |
655 | trait Foo { | |
656 | fn a(); | |
657 | fn b(); | |
658 | } | |
659 | ||
660 | struct Bar; | |
661 | ||
662 | impl Foo for Bar { | |
663 | fn a() {} | |
664 | fn b() {} // ok! | |
665 | } | |
666 | ``` | |
667 | ||
668 | Second example: | |
669 | ||
670 | ``` | |
671 | trait Foo { | |
672 | fn a(); | |
673 | } | |
674 | ||
675 | struct Bar; | |
676 | ||
677 | impl Foo for Bar { | |
678 | fn a() {} | |
679 | } | |
680 | ||
681 | impl Bar { | |
682 | fn b() {} | |
683 | } | |
684 | ``` | |
685 | "##, | |
686 | ||
a7813a04 XL |
687 | E0408: r##" |
688 | An "or" pattern was used where the variable bindings are not consistently bound | |
689 | across patterns. | |
690 | ||
3157f602 | 691 | Erroneous code example: |
a7813a04 | 692 | |
3157f602 | 693 | ```compile_fail,E0408 |
a7813a04 XL |
694 | match x { |
695 | Some(y) | None => { /* use y */ } // error: variable `y` from pattern #1 is | |
696 | // not bound in pattern #2 | |
697 | _ => () | |
698 | } | |
699 | ``` | |
700 | ||
701 | Here, `y` is bound to the contents of the `Some` and can be used within the | |
702 | block corresponding to the match arm. However, in case `x` is `None`, we have | |
703 | not specified what `y` is, and the block will use a nonexistent variable. | |
704 | ||
705 | To fix this error, either split into multiple match arms: | |
706 | ||
707 | ``` | |
708 | let x = Some(1); | |
709 | match x { | |
710 | Some(y) => { /* use y */ } | |
711 | None => { /* ... */ } | |
712 | } | |
713 | ``` | |
714 | ||
715 | or, bind the variable to a field of the same type in all sub-patterns of the | |
716 | or pattern: | |
717 | ||
718 | ``` | |
719 | let x = (0, 2); | |
720 | match x { | |
721 | (0, y) | (y, 0) => { /* use y */} | |
722 | _ => {} | |
723 | } | |
724 | ``` | |
725 | ||
726 | In this example, if `x` matches the pattern `(0, _)`, the second field is set | |
727 | to `y`. If it matches `(_, 0)`, the first field is set to `y`; so in all | |
728 | cases `y` is set to some value. | |
729 | "##, | |
730 | ||
731 | E0409: r##" | |
732 | An "or" pattern was used where the variable bindings are not consistently bound | |
733 | across patterns. | |
734 | ||
3157f602 | 735 | Erroneous code example: |
a7813a04 | 736 | |
3157f602 | 737 | ```compile_fail,E0409 |
a7813a04 XL |
738 | let x = (0, 2); |
739 | match x { | |
740 | (0, ref y) | (y, 0) => { /* use y */} // error: variable `y` is bound with | |
741 | // different mode in pattern #2 | |
742 | // than in pattern #1 | |
743 | _ => () | |
744 | } | |
745 | ``` | |
746 | ||
747 | Here, `y` is bound by-value in one case and by-reference in the other. | |
748 | ||
749 | To fix this error, just use the same mode in both cases. | |
750 | Generally using `ref` or `ref mut` where not already used will fix this: | |
751 | ||
041b39d2 | 752 | ``` |
a7813a04 XL |
753 | let x = (0, 2); |
754 | match x { | |
755 | (0, ref y) | (ref y, 0) => { /* use y */} | |
756 | _ => () | |
757 | } | |
758 | ``` | |
759 | ||
760 | Alternatively, split the pattern: | |
761 | ||
762 | ``` | |
763 | let x = (0, 2); | |
764 | match x { | |
765 | (y, 0) => { /* use y */ } | |
766 | (0, ref y) => { /* use y */} | |
767 | _ => () | |
768 | } | |
769 | ``` | |
770 | "##, | |
771 | ||
e9174d1e | 772 | E0411: r##" |
3157f602 | 773 | The `Self` keyword was used outside an impl or a trait. |
e9174d1e | 774 | |
3157f602 XL |
775 | Erroneous code example: |
776 | ||
777 | ```compile_fail,E0411 | |
e9174d1e SL |
778 | <Self>::foo; // error: use of `Self` outside of an impl or trait |
779 | ``` | |
780 | ||
7453a54e SL |
781 | The `Self` keyword represents the current type, which explains why it can only |
782 | be used inside an impl or a trait. It gives access to the associated items of a | |
783 | type: | |
e9174d1e SL |
784 | |
785 | ``` | |
786 | trait Foo { | |
787 | type Bar; | |
788 | } | |
789 | ||
790 | trait Baz : Foo { | |
791 | fn bar() -> Self::Bar; // like this | |
792 | } | |
793 | ``` | |
794 | ||
7453a54e | 795 | However, be careful when two types have a common associated type: |
e9174d1e | 796 | |
7453a54e | 797 | ```compile_fail |
e9174d1e SL |
798 | trait Foo { |
799 | type Bar; | |
800 | } | |
801 | ||
802 | trait Foo2 { | |
803 | type Bar; | |
804 | } | |
805 | ||
806 | trait Baz : Foo + Foo2 { | |
807 | fn bar() -> Self::Bar; | |
808 | // error: ambiguous associated type `Bar` in bounds of `Self` | |
809 | } | |
810 | ``` | |
811 | ||
7453a54e SL |
812 | This problem can be solved by specifying from which trait we want to use the |
813 | `Bar` type: | |
e9174d1e SL |
814 | |
815 | ``` | |
7453a54e SL |
816 | trait Foo { |
817 | type Bar; | |
818 | } | |
819 | ||
820 | trait Foo2 { | |
821 | type Bar; | |
822 | } | |
823 | ||
e9174d1e SL |
824 | trait Baz : Foo + Foo2 { |
825 | fn bar() -> <Self as Foo>::Bar; // ok! | |
826 | } | |
827 | ``` | |
828 | "##, | |
829 | ||
830 | E0412: r##" | |
3157f602 | 831 | The type name used is not in scope. |
7453a54e | 832 | |
3157f602 XL |
833 | Erroneous code examples: |
834 | ||
835 | ```compile_fail,E0412 | |
7453a54e | 836 | impl Something {} // error: type name `Something` is not in scope |
e9174d1e | 837 | |
e9174d1e | 838 | // or: |
7453a54e | 839 | |
e9174d1e | 840 | trait Foo { |
7453a54e | 841 | fn bar(N); // error: type name `N` is not in scope |
e9174d1e | 842 | } |
7453a54e | 843 | |
e9174d1e | 844 | // or: |
7453a54e SL |
845 | |
846 | fn foo(x: T) {} // type name `T` is not in scope | |
e9174d1e SL |
847 | ``` |
848 | ||
7453a54e SL |
849 | To fix this error, please verify you didn't misspell the type name, you did |
850 | declare it or imported it into the scope. Examples: | |
e9174d1e SL |
851 | |
852 | ``` | |
853 | struct Something; | |
854 | ||
855 | impl Something {} // ok! | |
7453a54e | 856 | |
e9174d1e | 857 | // or: |
7453a54e | 858 | |
e9174d1e SL |
859 | trait Foo { |
860 | type N; | |
861 | ||
041b39d2 | 862 | fn bar(_: Self::N); // ok! |
e9174d1e | 863 | } |
7453a54e SL |
864 | |
865 | // or: | |
866 | ||
e9174d1e SL |
867 | fn foo<T>(x: T) {} // ok! |
868 | ``` | |
7cac9316 XL |
869 | |
870 | Another case that causes this error is when a type is imported into a parent | |
871 | module. To fix this, you can follow the suggestion and use File directly or | |
872 | `use super::File;` which will import the types from the parent namespace. An | |
873 | example that causes this error is below: | |
874 | ||
875 | ```compile_fail,E0412 | |
876 | use std::fs::File; | |
877 | ||
878 | mod foo { | |
879 | fn some_function(f: File) {} | |
880 | } | |
881 | ``` | |
882 | ||
883 | ``` | |
884 | use std::fs::File; | |
885 | ||
886 | mod foo { | |
887 | // either | |
888 | use super::File; | |
889 | // or | |
890 | // use std::fs::File; | |
891 | fn foo(f: File) {} | |
892 | } | |
893 | # fn main() {} // don't insert it for us; that'll break imports | |
894 | ``` | |
e9174d1e SL |
895 | "##, |
896 | ||
e9174d1e | 897 | E0415: r##" |
3157f602 | 898 | More than one function parameter have the same name. |
e9174d1e | 899 | |
3157f602 XL |
900 | Erroneous code example: |
901 | ||
902 | ```compile_fail,E0415 | |
e9174d1e SL |
903 | fn foo(f: i32, f: i32) {} // error: identifier `f` is bound more than |
904 | // once in this parameter list | |
905 | ``` | |
906 | ||
907 | Please verify you didn't misspell parameters' name. Example: | |
908 | ||
909 | ``` | |
910 | fn foo(f: i32, g: i32) {} // ok! | |
911 | ``` | |
912 | "##, | |
913 | ||
914 | E0416: r##" | |
3157f602 | 915 | An identifier is bound more than once in a pattern. |
e9174d1e | 916 | |
3157f602 XL |
917 | Erroneous code example: |
918 | ||
919 | ```compile_fail,E0416 | |
e9174d1e SL |
920 | match (1, 2) { |
921 | (x, x) => {} // error: identifier `x` is bound more than once in the | |
922 | // same pattern | |
923 | } | |
924 | ``` | |
925 | ||
926 | Please verify you didn't misspell identifiers' name. Example: | |
927 | ||
928 | ``` | |
929 | match (1, 2) { | |
930 | (x, y) => {} // ok! | |
931 | } | |
932 | ``` | |
933 | ||
934 | Or maybe did you mean to unify? Consider using a guard: | |
935 | ||
041b39d2 XL |
936 | ``` |
937 | # let (A, B, C) = (1, 2, 3); | |
e9174d1e SL |
938 | match (A, B, C) { |
939 | (x, x2, see) if x == x2 => { /* A and B are equal, do one thing */ } | |
940 | (y, z, see) => { /* A and B unequal; do another thing */ } | |
941 | } | |
942 | ``` | |
943 | "##, | |
944 | ||
32a655c1 SL |
945 | E0422: r##" |
946 | You are trying to use an identifier that is either undefined or not a struct. | |
947 | Erroneous code example: | |
cc61c64b XL |
948 | |
949 | ```compile_fail,E0422 | |
32a655c1 SL |
950 | fn main () { |
951 | let x = Foo { x: 1, y: 2 }; | |
952 | } | |
953 | ``` | |
cc61c64b | 954 | |
32a655c1 SL |
955 | In this case, `Foo` is undefined, so it inherently isn't anything, and |
956 | definitely not a struct. | |
cc61c64b | 957 | |
32a655c1 SL |
958 | ```compile_fail |
959 | fn main () { | |
960 | let foo = 1; | |
961 | let x = foo { x: 1, y: 2 }; | |
962 | } | |
963 | ``` | |
cc61c64b | 964 | |
32a655c1 SL |
965 | In this case, `foo` is defined, but is not a struct, so Rust can't use it as |
966 | one. | |
967 | "##, | |
968 | ||
e9174d1e | 969 | E0423: r##" |
3157f602 | 970 | A `struct` variant name was used like a function name. |
e9174d1e | 971 | |
3157f602 XL |
972 | Erroneous code example: |
973 | ||
974 | ```compile_fail,E0423 | |
9e0c209e | 975 | struct Foo { a: bool }; |
e9174d1e SL |
976 | |
977 | let f = Foo(); | |
978 | // error: `Foo` is a struct variant name, but this expression uses | |
979 | // it like a function name | |
980 | ``` | |
981 | ||
7453a54e SL |
982 | Please verify you didn't misspell the name of what you actually wanted to use |
983 | here. Example: | |
e9174d1e SL |
984 | |
985 | ``` | |
986 | fn Foo() -> u32 { 0 } | |
987 | ||
988 | let f = Foo(); // ok! | |
989 | ``` | |
990 | "##, | |
991 | ||
c1a9b12d | 992 | E0424: r##" |
3157f602 | 993 | The `self` keyword was used in a static method. |
c1a9b12d | 994 | |
3157f602 XL |
995 | Erroneous code example: |
996 | ||
997 | ```compile_fail,E0424 | |
c1a9b12d SL |
998 | struct Foo; |
999 | ||
1000 | impl Foo { | |
1001 | fn bar(self) {} | |
1002 | ||
1003 | fn foo() { | |
1004 | self.bar(); // error: `self` is not available in a static method. | |
1005 | } | |
1006 | } | |
1007 | ``` | |
1008 | ||
1009 | Please check if the method's argument list should have contained `self`, | |
1010 | `&self`, or `&mut self` (in case you didn't want to create a static | |
1011 | method), and add it if so. Example: | |
1012 | ||
1013 | ``` | |
1014 | struct Foo; | |
1015 | ||
1016 | impl Foo { | |
1017 | fn bar(self) {} | |
1018 | ||
1019 | fn foo(self) { | |
1020 | self.bar(); // ok! | |
1021 | } | |
1022 | } | |
1023 | ``` | |
1024 | "##, | |
1025 | ||
1026 | E0425: r##" | |
3157f602 | 1027 | An unresolved name was used. |
c1a9b12d | 1028 | |
3157f602 XL |
1029 | Erroneous code examples: |
1030 | ||
1031 | ```compile_fail,E0425 | |
c1a9b12d SL |
1032 | something_that_doesnt_exist::foo; |
1033 | // error: unresolved name `something_that_doesnt_exist::foo` | |
1034 | ||
1035 | // or: | |
7453a54e | 1036 | |
c1a9b12d SL |
1037 | trait Foo { |
1038 | fn bar() { | |
1039 | Self; // error: unresolved name `Self` | |
1040 | } | |
1041 | } | |
e9174d1e SL |
1042 | |
1043 | // or: | |
7453a54e | 1044 | |
e9174d1e | 1045 | let x = unknown_variable; // error: unresolved name `unknown_variable` |
c1a9b12d SL |
1046 | ``` |
1047 | ||
e9174d1e SL |
1048 | Please verify that the name wasn't misspelled and ensure that the |
1049 | identifier being referred to is valid for the given situation. Example: | |
c1a9b12d SL |
1050 | |
1051 | ``` | |
1052 | enum something_that_does_exist { | |
7453a54e | 1053 | Foo, |
c1a9b12d | 1054 | } |
7453a54e | 1055 | ``` |
e9174d1e | 1056 | |
7453a54e SL |
1057 | Or: |
1058 | ||
1059 | ``` | |
c1a9b12d SL |
1060 | mod something_that_does_exist { |
1061 | pub static foo : i32 = 0i32; | |
1062 | } | |
1063 | ||
1064 | something_that_does_exist::foo; // ok! | |
7453a54e | 1065 | ``` |
e9174d1e | 1066 | |
7453a54e SL |
1067 | Or: |
1068 | ||
1069 | ``` | |
e9174d1e SL |
1070 | let unknown_variable = 12u32; |
1071 | let x = unknown_variable; // ok! | |
c1a9b12d | 1072 | ``` |
3157f602 XL |
1073 | |
1074 | If the item is not defined in the current module, it must be imported using a | |
1075 | `use` statement, like so: | |
1076 | ||
041b39d2 XL |
1077 | ``` |
1078 | # mod foo { pub fn bar() {} } | |
1079 | # fn main() { | |
3157f602 XL |
1080 | use foo::bar; |
1081 | bar(); | |
041b39d2 | 1082 | # } |
3157f602 XL |
1083 | ``` |
1084 | ||
1085 | If the item you are importing is not defined in some super-module of the | |
1086 | current module, then it must also be declared as public (e.g., `pub fn`). | |
c1a9b12d SL |
1087 | "##, |
1088 | ||
1089 | E0426: r##" | |
3157f602 | 1090 | An undeclared label was used. |
c1a9b12d | 1091 | |
3157f602 XL |
1092 | Erroneous code example: |
1093 | ||
1094 | ```compile_fail,E0426 | |
c1a9b12d SL |
1095 | loop { |
1096 | break 'a; // error: use of undeclared label `'a` | |
1097 | } | |
1098 | ``` | |
1099 | ||
1100 | Please verify you spelt or declare the label correctly. Example: | |
1101 | ||
1102 | ``` | |
1103 | 'a: loop { | |
1104 | break 'a; // ok! | |
1105 | } | |
1106 | ``` | |
1107 | "##, | |
1108 | ||
1109 | E0428: r##" | |
3157f602 | 1110 | A type or module has been defined more than once. |
c1a9b12d | 1111 | |
3157f602 XL |
1112 | Erroneous code example: |
1113 | ||
1114 | ```compile_fail,E0428 | |
c1a9b12d SL |
1115 | struct Bar; |
1116 | struct Bar; // error: duplicate definition of value `Bar` | |
1117 | ``` | |
1118 | ||
1119 | Please verify you didn't misspell the type/module's name or remove/rename the | |
1120 | duplicated one. Example: | |
1121 | ||
1122 | ``` | |
1123 | struct Bar; | |
1124 | struct Bar2; // ok! | |
1125 | ``` | |
1126 | "##, | |
1127 | ||
3157f602 XL |
1128 | E0429: r##" |
1129 | The `self` keyword cannot appear alone as the last segment in a `use` | |
1130 | declaration. | |
1131 | ||
1132 | Erroneous code example: | |
1133 | ||
1134 | ```compile_fail,E0429 | |
1135 | use std::fmt::self; // error: `self` imports are only allowed within a { } list | |
1136 | ``` | |
1137 | ||
1138 | To use a namespace itself in addition to some of its members, `self` may appear | |
1139 | as part of a brace-enclosed list of imports: | |
1140 | ||
1141 | ``` | |
1142 | use std::fmt::{self, Debug}; | |
1143 | ``` | |
1144 | ||
1145 | If you only want to import the namespace, do so directly: | |
1146 | ||
1147 | ``` | |
1148 | use std::fmt; | |
1149 | ``` | |
1150 | "##, | |
1151 | ||
c1a9b12d | 1152 | E0430: r##" |
3157f602 | 1153 | The `self` import appears more than once in the list. |
c1a9b12d | 1154 | |
3157f602 XL |
1155 | Erroneous code example: |
1156 | ||
1157 | ```compile_fail,E0430 | |
c1a9b12d SL |
1158 | use something::{self, self}; // error: `self` import can only appear once in |
1159 | // the list | |
1160 | ``` | |
1161 | ||
1162 | Please verify you didn't misspell the import name or remove the duplicated | |
1163 | `self` import. Example: | |
1164 | ||
041b39d2 XL |
1165 | ``` |
1166 | # mod something {} | |
1167 | # fn main() { | |
1168 | use something::{self}; // ok! | |
1169 | # } | |
c1a9b12d SL |
1170 | ``` |
1171 | "##, | |
1172 | ||
1173 | E0431: r##" | |
3157f602 | 1174 | An invalid `self` import was made. |
c1a9b12d | 1175 | |
3157f602 XL |
1176 | Erroneous code example: |
1177 | ||
1178 | ```compile_fail,E0431 | |
c1a9b12d SL |
1179 | use {self}; // error: `self` import can only appear in an import list with a |
1180 | // non-empty prefix | |
1181 | ``` | |
1182 | ||
1183 | You cannot import the current module into itself, please remove this import | |
1184 | or verify you didn't misspell it. | |
1185 | "##, | |
1186 | ||
1187 | E0432: r##" | |
3157f602 | 1188 | An import was unresolved. |
c1a9b12d | 1189 | |
3157f602 XL |
1190 | Erroneous code example: |
1191 | ||
1192 | ```compile_fail,E0432 | |
c1a9b12d SL |
1193 | use something::Foo; // error: unresolved import `something::Foo`. |
1194 | ``` | |
1195 | ||
a7813a04 XL |
1196 | Paths in `use` statements are relative to the crate root. To import items |
1197 | relative to the current and parent modules, use the `self::` and `super::` | |
1198 | prefixes, respectively. Also verify that you didn't misspell the import | |
1199 | name and that the import exists in the module from where you tried to | |
1200 | import it. Example: | |
c1a9b12d | 1201 | |
041b39d2 | 1202 | ``` |
a7813a04 | 1203 | use self::something::Foo; // ok! |
c1a9b12d SL |
1204 | |
1205 | mod something { | |
1206 | pub struct Foo; | |
1207 | } | |
041b39d2 | 1208 | # fn main() {} |
c1a9b12d | 1209 | ``` |
92a42be0 SL |
1210 | |
1211 | Or, if you tried to use a module from an external crate, you may have missed | |
a7813a04 | 1212 | the `extern crate` declaration (which is usually placed in the crate root): |
92a42be0 | 1213 | |
041b39d2 XL |
1214 | ``` |
1215 | extern crate core; // Required to use the `core` crate | |
92a42be0 | 1216 | |
041b39d2 XL |
1217 | use core::any; |
1218 | # fn main() {} | |
92a42be0 | 1219 | ``` |
c1a9b12d SL |
1220 | "##, |
1221 | ||
1222 | E0433: r##" | |
3157f602 | 1223 | An undeclared type or module was used. |
c1a9b12d | 1224 | |
3157f602 XL |
1225 | Erroneous code example: |
1226 | ||
1227 | ```compile_fail,E0433 | |
1228 | let map = HashMap::new(); | |
1229 | // error: failed to resolve. Use of undeclared type or module `HashMap` | |
c1a9b12d SL |
1230 | ``` |
1231 | ||
3157f602 XL |
1232 | Please verify you didn't misspell the type/module's name or that you didn't |
1233 | forgot to import it: | |
1234 | ||
1235 | ||
1236 | ``` | |
1237 | use std::collections::HashMap; // HashMap has been imported. | |
1238 | let map: HashMap<u32, u32> = HashMap::new(); // So it can be used! | |
1239 | ``` | |
c1a9b12d SL |
1240 | "##, |
1241 | ||
a7813a04 XL |
1242 | E0434: r##" |
1243 | This error indicates that a variable usage inside an inner function is invalid | |
1244 | because the variable comes from a dynamic environment. Inner functions do not | |
1245 | have access to their containing environment. | |
1246 | ||
3157f602 | 1247 | Erroneous code example: |
a7813a04 | 1248 | |
3157f602 | 1249 | ```compile_fail,E0434 |
a7813a04 XL |
1250 | fn foo() { |
1251 | let y = 5; | |
1252 | fn bar() -> u32 { | |
1253 | y // error: can't capture dynamic environment in a fn item; use the | |
1254 | // || { ... } closure form instead. | |
1255 | } | |
1256 | } | |
1257 | ``` | |
1258 | ||
1259 | Functions do not capture local variables. To fix this error, you can replace the | |
1260 | function with a closure: | |
1261 | ||
1262 | ``` | |
1263 | fn foo() { | |
1264 | let y = 5; | |
1265 | let bar = || { | |
1266 | y | |
1267 | }; | |
1268 | } | |
1269 | ``` | |
1270 | ||
1271 | or replace the captured variable with a constant or a static item: | |
1272 | ||
1273 | ``` | |
1274 | fn foo() { | |
1275 | static mut X: u32 = 4; | |
1276 | const Y: u32 = 5; | |
1277 | fn bar() -> u32 { | |
1278 | unsafe { | |
1279 | X = 3; | |
1280 | } | |
1281 | Y | |
1282 | } | |
1283 | } | |
1284 | ``` | |
1285 | "##, | |
1286 | ||
e9174d1e | 1287 | E0435: r##" |
7cac9316 | 1288 | A non-constant value was used in a constant expression. |
e9174d1e | 1289 | |
3157f602 XL |
1290 | Erroneous code example: |
1291 | ||
1292 | ```compile_fail,E0435 | |
7cac9316 XL |
1293 | let foo = 42; |
1294 | let a: [u8; foo]; // error: attempt to use a non-constant value in a constant | |
e9174d1e SL |
1295 | ``` |
1296 | ||
1297 | To fix this error, please replace the value with a constant. Example: | |
1298 | ||
1299 | ``` | |
7cac9316 | 1300 | let a: [u8; 42]; // ok! |
7453a54e | 1301 | ``` |
e9174d1e | 1302 | |
7453a54e SL |
1303 | Or: |
1304 | ||
1305 | ``` | |
7cac9316 XL |
1306 | const FOO: usize = 42; |
1307 | let a: [u8; FOO]; // ok! | |
e9174d1e SL |
1308 | ``` |
1309 | "##, | |
1310 | ||
c1a9b12d SL |
1311 | E0437: r##" |
1312 | Trait implementations can only implement associated types that are members of | |
1313 | the trait in question. This error indicates that you attempted to implement | |
1314 | an associated type whose name does not match the name of any associated type | |
1315 | in the trait. | |
1316 | ||
3157f602 | 1317 | Erroneous code example: |
c1a9b12d | 1318 | |
3157f602 | 1319 | ```compile_fail,E0437 |
c1a9b12d SL |
1320 | trait Foo {} |
1321 | ||
1322 | impl Foo for i32 { | |
1323 | type Bar = bool; | |
1324 | } | |
1325 | ``` | |
1326 | ||
1327 | The solution to this problem is to remove the extraneous associated type: | |
1328 | ||
1329 | ``` | |
1330 | trait Foo {} | |
1331 | ||
1332 | impl Foo for i32 {} | |
1333 | ``` | |
1334 | "##, | |
1335 | ||
1336 | E0438: r##" | |
1337 | Trait implementations can only implement associated constants that are | |
1338 | members of the trait in question. This error indicates that you | |
1339 | attempted to implement an associated constant whose name does not | |
1340 | match the name of any associated constant in the trait. | |
1341 | ||
3157f602 | 1342 | Erroneous code example: |
c1a9b12d | 1343 | |
3157f602 | 1344 | ```compile_fail,E0438 |
c1a9b12d SL |
1345 | trait Foo {} |
1346 | ||
1347 | impl Foo for i32 { | |
1348 | const BAR: bool = true; | |
1349 | } | |
1350 | ``` | |
1351 | ||
1352 | The solution to this problem is to remove the extraneous associated constant: | |
1353 | ||
1354 | ``` | |
1355 | trait Foo {} | |
1356 | ||
1357 | impl Foo for i32 {} | |
1358 | ``` | |
9e0c209e SL |
1359 | "##, |
1360 | ||
c30ab7b3 SL |
1361 | E0466: r##" |
1362 | Macro import declarations were malformed. | |
1363 | ||
1364 | Erroneous code examples: | |
1365 | ||
1366 | ```compile_fail,E0466 | |
1367 | #[macro_use(a_macro(another_macro))] // error: invalid import declaration | |
1368 | extern crate core as some_crate; | |
1369 | ||
1370 | #[macro_use(i_want = "some_macros")] // error: invalid import declaration | |
1371 | extern crate core as another_crate; | |
1372 | ``` | |
1373 | ||
1374 | This is a syntax error at the level of attribute declarations. The proper | |
1375 | syntax for macro imports is the following: | |
1376 | ||
041b39d2 | 1377 | ```ignore (cannot-doctest-multicrate-project) |
c30ab7b3 SL |
1378 | // In some_crate: |
1379 | #[macro_export] | |
1380 | macro_rules! get_tacos { | |
1381 | ... | |
1382 | } | |
1383 | ||
1384 | #[macro_export] | |
1385 | macro_rules! get_pimientos { | |
1386 | ... | |
1387 | } | |
1388 | ||
1389 | // In your crate: | |
1390 | #[macro_use(get_tacos, get_pimientos)] // It imports `get_tacos` and | |
1391 | extern crate some_crate; // `get_pimientos` macros from some_crate | |
1392 | ``` | |
1393 | ||
1394 | If you would like to import all exported macros, write `macro_use` with no | |
1395 | arguments. | |
1396 | "##, | |
1397 | ||
1398 | E0467: r##" | |
2c00a5a8 | 1399 | Macro re-export declarations were empty or malformed. |
c30ab7b3 SL |
1400 | |
1401 | Erroneous code examples: | |
1402 | ||
1403 | ```compile_fail,E0467 | |
1404 | #[macro_reexport] // error: no macros listed for export | |
1405 | extern crate core as macros_for_good; | |
1406 | ||
1407 | #[macro_reexport(fun_macro = "foo")] // error: not a macro identifier | |
1408 | extern crate core as other_macros_for_good; | |
1409 | ``` | |
1410 | ||
1411 | This is a syntax error at the level of attribute declarations. | |
1412 | ||
1413 | Currently, `macro_reexport` requires at least one macro name to be listed. | |
2c00a5a8 | 1414 | Unlike `macro_use`, listing no names does not re-export all macros from the |
c30ab7b3 SL |
1415 | given crate. |
1416 | ||
1417 | Decide which macros you would like to export and list them properly. | |
1418 | ||
2c00a5a8 | 1419 | These are proper re-export declarations: |
c30ab7b3 | 1420 | |
041b39d2 | 1421 | ```ignore (cannot-doctest-multicrate-project) |
c30ab7b3 SL |
1422 | #[macro_reexport(some_macro, another_macro)] |
1423 | extern crate macros_for_good; | |
1424 | ``` | |
1425 | "##, | |
1426 | ||
1427 | E0468: r##" | |
1428 | A non-root module attempts to import macros from another crate. | |
1429 | ||
1430 | Example of erroneous code: | |
1431 | ||
1432 | ```compile_fail,E0468 | |
1433 | mod foo { | |
041b39d2 | 1434 | #[macro_use(debug_assert)] // error: must be at crate root to import |
c30ab7b3 | 1435 | extern crate core; // macros from another crate |
041b39d2 | 1436 | fn run_macro() { debug_assert!(true); } |
c30ab7b3 SL |
1437 | } |
1438 | ``` | |
1439 | ||
1440 | Only `extern crate` imports at the crate root level are allowed to import | |
1441 | macros. | |
1442 | ||
1443 | Either move the macro import to crate root or do without the foreign macros. | |
1444 | This will work: | |
1445 | ||
041b39d2 XL |
1446 | ``` |
1447 | #[macro_use(debug_assert)] | |
1448 | extern crate core; | |
c30ab7b3 SL |
1449 | |
1450 | mod foo { | |
041b39d2 | 1451 | fn run_macro() { debug_assert!(true); } |
c30ab7b3 | 1452 | } |
041b39d2 | 1453 | # fn main() {} |
c30ab7b3 SL |
1454 | ``` |
1455 | "##, | |
1456 | ||
1457 | E0469: r##" | |
1458 | A macro listed for import was not found. | |
1459 | ||
1460 | Erroneous code example: | |
1461 | ||
1462 | ```compile_fail,E0469 | |
1463 | #[macro_use(drink, be_merry)] // error: imported macro not found | |
041b39d2 | 1464 | extern crate alloc; |
c30ab7b3 SL |
1465 | |
1466 | fn main() { | |
1467 | // ... | |
1468 | } | |
1469 | ``` | |
1470 | ||
1471 | Either the listed macro is not contained in the imported crate, or it is not | |
1472 | exported from the given crate. | |
1473 | ||
1474 | This could be caused by a typo. Did you misspell the macro's name? | |
1475 | ||
1476 | Double-check the names of the macros listed for import, and that the crate | |
1477 | in question exports them. | |
1478 | ||
1479 | A working version would be: | |
1480 | ||
041b39d2 | 1481 | ```ignore (cannot-doctest-multicrate-project) |
c30ab7b3 SL |
1482 | // In some_crate crate: |
1483 | #[macro_export] | |
1484 | macro_rules! eat { | |
1485 | ... | |
1486 | } | |
1487 | ||
1488 | #[macro_export] | |
1489 | macro_rules! drink { | |
1490 | ... | |
1491 | } | |
1492 | ||
1493 | // In your crate: | |
1494 | #[macro_use(eat, drink)] | |
1495 | extern crate some_crate; //ok! | |
1496 | ``` | |
1497 | "##, | |
1498 | ||
1499 | E0470: r##" | |
2c00a5a8 | 1500 | A macro listed for re-export was not found. |
c30ab7b3 SL |
1501 | |
1502 | Erroneous code example: | |
1503 | ||
1504 | ```compile_fail,E0470 | |
1505 | #[macro_reexport(drink, be_merry)] | |
041b39d2 | 1506 | extern crate alloc; |
c30ab7b3 SL |
1507 | |
1508 | fn main() { | |
1509 | // ... | |
1510 | } | |
1511 | ``` | |
1512 | ||
1513 | Either the listed macro is not contained in the imported crate, or it is not | |
1514 | exported from the given crate. | |
1515 | ||
1516 | This could be caused by a typo. Did you misspell the macro's name? | |
1517 | ||
2c00a5a8 | 1518 | Double-check the names of the macros listed for re-export, and that the crate |
c30ab7b3 SL |
1519 | in question exports them. |
1520 | ||
1521 | A working version: | |
1522 | ||
041b39d2 | 1523 | ```ignore (cannot-doctest-multicrate-project) |
c30ab7b3 SL |
1524 | // In some_crate crate: |
1525 | #[macro_export] | |
1526 | macro_rules! eat { | |
1527 | ... | |
1528 | } | |
1529 | ||
1530 | #[macro_export] | |
1531 | macro_rules! drink { | |
1532 | ... | |
1533 | } | |
1534 | ||
1535 | // In your_crate: | |
1536 | #[macro_reexport(eat, drink)] | |
1537 | extern crate some_crate; | |
1538 | ``` | |
1539 | "##, | |
1540 | ||
9e0c209e SL |
1541 | E0530: r##" |
1542 | A binding shadowed something it shouldn't. | |
1543 | ||
1544 | Erroneous code example: | |
1545 | ||
1546 | ```compile_fail,E0530 | |
1547 | static TEST: i32 = 0; | |
1548 | ||
1549 | let r: (i32, i32) = (0, 0); | |
1550 | match r { | |
1551 | TEST => {} // error: match bindings cannot shadow statics | |
1552 | } | |
1553 | ``` | |
1554 | ||
1555 | To fix this error, just change the binding's name in order to avoid shadowing | |
1556 | one of the following: | |
1557 | ||
1558 | * struct name | |
1559 | * struct/enum variant | |
1560 | * static | |
1561 | * const | |
1562 | * associated const | |
1563 | ||
1564 | Fixed example: | |
1565 | ||
1566 | ``` | |
1567 | static TEST: i32 = 0; | |
1568 | ||
1569 | let r: (i32, i32) = (0, 0); | |
1570 | match r { | |
1571 | something => {} // ok! | |
1572 | } | |
1573 | ``` | |
1574 | "##, | |
d9579d0f | 1575 | |
c30ab7b3 SL |
1576 | E0532: r##" |
1577 | Pattern arm did not match expected kind. | |
1578 | ||
1579 | Erroneous code example: | |
1580 | ||
1581 | ```compile_fail,E0532 | |
1582 | enum State { | |
1583 | Succeeded, | |
1584 | Failed(String), | |
1585 | } | |
1586 | ||
1587 | fn print_on_failure(state: &State) { | |
1588 | match *state { | |
1589 | // error: expected unit struct/variant or constant, found tuple | |
1590 | // variant `State::Failed` | |
1591 | State::Failed => println!("Failed"), | |
1592 | _ => () | |
1593 | } | |
1594 | } | |
1595 | ``` | |
1596 | ||
1597 | To fix this error, ensure the match arm kind is the same as the expression | |
1598 | matched. | |
1599 | ||
1600 | Fixed example: | |
1601 | ||
1602 | ``` | |
1603 | enum State { | |
1604 | Succeeded, | |
1605 | Failed(String), | |
1606 | } | |
1607 | ||
1608 | fn print_on_failure(state: &State) { | |
1609 | match *state { | |
1610 | State::Failed(ref msg) => println!("Failed with {}", msg), | |
1611 | _ => () | |
1612 | } | |
1613 | } | |
1614 | ``` | |
1615 | "##, | |
1616 | ||
7cac9316 XL |
1617 | E0603: r##" |
1618 | A private item was used outside its scope. | |
1619 | ||
1620 | Erroneous code example: | |
1621 | ||
1622 | ```compile_fail,E0603 | |
1623 | mod SomeModule { | |
1624 | const PRIVATE: u32 = 0x_a_bad_1dea_u32; // This const is private, so we | |
1625 | // can't use it outside of the | |
1626 | // `SomeModule` module. | |
1627 | } | |
1628 | ||
1629 | println!("const value: {}", SomeModule::PRIVATE); // error: constant `CONSTANT` | |
1630 | // is private | |
1631 | ``` | |
1632 | ||
1633 | In order to fix this error, you need to make the item public by using the `pub` | |
1634 | keyword. Example: | |
1635 | ||
1636 | ``` | |
1637 | mod SomeModule { | |
1638 | pub const PRIVATE: u32 = 0x_a_bad_1dea_u32; // We set it public by using the | |
1639 | // `pub` keyword. | |
1640 | } | |
1641 | ||
1642 | println!("const value: {}", SomeModule::PRIVATE); // ok! | |
1643 | ``` | |
1644 | "##, | |
1645 | ||
2c00a5a8 XL |
1646 | E0659: r##" |
1647 | An item usage is ambiguous. | |
1648 | ||
1649 | Erroneous code example: | |
1650 | ||
1651 | ```compile_fail,E0659 | |
1652 | pub mod moon { | |
1653 | pub fn foo() {} | |
1654 | } | |
1655 | ||
1656 | pub mod earth { | |
1657 | pub fn foo() {} | |
1658 | } | |
1659 | ||
1660 | mod collider { | |
1661 | pub use moon::*; | |
1662 | pub use earth::*; | |
1663 | } | |
1664 | ||
1665 | fn main() { | |
1666 | collider::foo(); // ERROR: `foo` is ambiguous | |
1667 | } | |
1668 | ``` | |
1669 | ||
1670 | This error generally appears when two items with the same name are imported into | |
1671 | a module. Here, the `foo` functions are imported and reexported from the | |
1672 | `collider` module and therefore, when we're using `collider::foo()`, both | |
1673 | functions collide. | |
1674 | ||
1675 | To solve this error, the best solution is generally to keep the path before the | |
1676 | item when using it. Example: | |
1677 | ||
1678 | ``` | |
1679 | pub mod moon { | |
1680 | pub fn foo() {} | |
1681 | } | |
1682 | ||
1683 | pub mod earth { | |
1684 | pub fn foo() {} | |
1685 | } | |
1686 | ||
1687 | mod collider { | |
1688 | pub use moon; | |
1689 | pub use earth; | |
1690 | } | |
1691 | ||
1692 | fn main() { | |
1693 | collider::moon::foo(); // ok! | |
1694 | collider::earth::foo(); // ok! | |
1695 | } | |
1696 | ``` | |
1697 | "##, | |
1698 | ||
d9579d0f AL |
1699 | } |
1700 | ||
85aaf69f | 1701 | register_diagnostics! { |
e9174d1e SL |
1702 | // E0153, unused error code |
1703 | // E0157, unused error code | |
7453a54e SL |
1704 | // E0257, |
1705 | // E0258, | |
7cac9316 | 1706 | // E0402, // cannot use an outer type parameter in this context |
3157f602 | 1707 | // E0406, merged into 420 |
a7813a04 | 1708 | // E0410, merged into 408 |
3157f602 XL |
1709 | // E0413, merged into 530 |
1710 | // E0414, merged into 530 | |
1711 | // E0417, merged into 532 | |
1712 | // E0418, merged into 532 | |
1713 | // E0419, merged into 531 | |
1714 | // E0420, merged into 532 | |
1715 | // E0421, merged into 531 | |
3157f602 | 1716 | E0531, // unresolved pattern path kind `name` |
3157f602 | 1717 | // E0427, merged into 530 |
32a655c1 SL |
1718 | E0573, |
1719 | E0574, | |
1720 | E0575, | |
1721 | E0576, | |
1722 | E0577, | |
1723 | E0578, | |
85aaf69f | 1724 | } |