src/librustc_typeck/error_codes.rs

   1 // ignore-tidy-filelength
   2
   3 #![allow(non_snake_case)]
   4
   5 register_long_diagnostics! {
   6
   7 E0023: r##"
   8 A pattern used to match against an enum variant must provide a sub-pattern for
   9 each field of the enum variant. This error indicates that a pattern attempted to
  10 extract an incorrect number of fields from a variant.
  11
  12 ```
  13 enum Fruit {
  14     Apple(String, String),
  15     Pear(u32),
  16 }
  17 ```
  18
  19 Here the `Apple` variant has two fields, and should be matched against like so:
  20
  21 ```
  22 enum Fruit {
  23     Apple(String, String),
  24     Pear(u32),
  25 }
  26
  27 let x = Fruit::Apple(String::new(), String::new());
  28
  29 // Correct.
  30 match x {
  31     Fruit::Apple(a, b) => {},
  32     _ => {}
  33 }
  34 ```
  35
  36 Matching with the wrong number of fields has no sensible interpretation:
  37
  38 ```compile_fail,E0023
  39 enum Fruit {
  40     Apple(String, String),
  41     Pear(u32),
  42 }
  43
  44 let x = Fruit::Apple(String::new(), String::new());
  45
  46 // Incorrect.
  47 match x {
  48     Fruit::Apple(a) => {},
  49     Fruit::Apple(a, b, c) => {},
  50 }
  51 ```
  52
  53 Check how many fields the enum was declared with and ensure that your pattern
  54 uses the same number.
  55 "##,
  56
  57 E0025: r##"
  58 Each field of a struct can only be bound once in a pattern. Erroneous code
  59 example:
  60
  61 ```compile_fail,E0025
  62 struct Foo {
  63     a: u8,
  64     b: u8,
  65 }
  66
  67 fn main(){
  68     let x = Foo { a:1, b:2 };
  69
  70     let Foo { a: x, a: y } = x;
  71     // error: field `a` bound multiple times in the pattern
  72 }
  73 ```
  74
  75 Each occurrence of a field name binds the value of that field, so to fix this
  76 error you will have to remove or alter the duplicate uses of the field name.
  77 Perhaps you misspelled another field name? Example:
  78
  79 ```
  80 struct Foo {
  81     a: u8,
  82     b: u8,
  83 }
  84
  85 fn main(){
  86     let x = Foo { a:1, b:2 };
  87
  88     let Foo { a: x, b: y } = x; // ok!
  89 }
  90 ```
  91 "##,
  92
  93 E0026: r##"
  94 This error indicates that a struct pattern attempted to extract a non-existent
  95 field from a struct. Struct fields are identified by the name used before the
  96 colon `:` so struct patterns should resemble the declaration of the struct type
  97 being matched.
  98
  99 ```
 100 // Correct matching.
 101 struct Thing {
 102     x: u32,
 103     y: u32
 104 }
 105
 106 let thing = Thing { x: 1, y: 2 };
 107
 108 match thing {
 109     Thing { x: xfield, y: yfield } => {}
 110 }
 111 ```
 112
 113 If you are using shorthand field patterns but want to refer to the struct field
 114 by a different name, you should rename it explicitly.
 115
 116 Change this:
 117
 118 ```compile_fail,E0026
 119 struct Thing {
 120     x: u32,
 121     y: u32
 122 }
 123
 124 let thing = Thing { x: 0, y: 0 };
 125
 126 match thing {
 127     Thing { x, z } => {}
 128 }
 129 ```
 130
 131 To this:
 132
 133 ```
 134 struct Thing {
 135     x: u32,
 136     y: u32
 137 }
 138
 139 let thing = Thing { x: 0, y: 0 };
 140
 141 match thing {
 142     Thing { x, y: z } => {}
 143 }
 144 ```
 145 "##,
 146
 147 E0027: r##"
 148 This error indicates that a pattern for a struct fails to specify a sub-pattern
 149 for every one of the struct's fields. Ensure that each field from the struct's
 150 definition is mentioned in the pattern, or use `..` to ignore unwanted fields.
 151
 152 For example:
 153
 154 ```compile_fail,E0027
 155 struct Dog {
 156     name: String,
 157     age: u32,
 158 }
 159
 160 let d = Dog { name: "Rusty".to_string(), age: 8 };
 161
 162 // This is incorrect.
 163 match d {
 164     Dog { age: x } => {}
 165 }
 166 ```
 167
 168 This is correct (explicit):
 169
 170 ```
 171 struct Dog {
 172     name: String,
 173     age: u32,
 174 }
 175
 176 let d = Dog { name: "Rusty".to_string(), age: 8 };
 177
 178 match d {
 179     Dog { name: ref n, age: x } => {}
 180 }
 181
 182 // This is also correct (ignore unused fields).
 183 match d {
 184     Dog { age: x, .. } => {}
 185 }
 186 ```
 187 "##,
 188
 189 E0029: r##"
 190 In a match expression, only numbers and characters can be matched against a
 191 range. This is because the compiler checks that the range is non-empty at
 192 compile-time, and is unable to evaluate arbitrary comparison functions. If you
 193 want to capture values of an orderable type between two end-points, you can use
 194 a guard.
 195
 196 ```compile_fail,E0029
 197 let string = "salutations !";
 198
 199 // The ordering relation for strings can't be evaluated at compile time,
 200 // so this doesn't work:
 201 match string {
 202     "hello" ..= "world" => {}
 203     _ => {}
 204 }
 205
 206 // This is a more general version, using a guard:
 207 match string {
 208     s if s >= "hello" && s <= "world" => {}
 209     _ => {}
 210 }
 211 ```
 212 "##,
 213
 214 E0033: r##"
 215 This error indicates that a pointer to a trait type cannot be implicitly
 216 dereferenced by a pattern. Every trait defines a type, but because the
 217 size of trait implementors isn't fixed, this type has no compile-time size.
 218 Therefore, all accesses to trait types must be through pointers. If you
 219 encounter this error you should try to avoid dereferencing the pointer.
 220
 221 ```compile_fail,E0033
 222 # trait SomeTrait { fn method_one(&self){} fn method_two(&self){} }
 223 # impl<T> SomeTrait for T {}
 224 let trait_obj: &SomeTrait = &"some_value";
 225
 226 // This tries to implicitly dereference to create an unsized local variable.
 227 let &invalid = trait_obj;
 228
 229 // You can call methods without binding to the value being pointed at.
 230 trait_obj.method_one();
 231 trait_obj.method_two();
 232 ```
 233
 234 You can read more about trait objects in the [Trait Objects] section of the
 235 Reference.
 236
 237 [Trait Objects]: https://doc.rust-lang.org/reference/types.html#trait-objects
 238 "##,
 239
 240 E0034: r##"
 241 The compiler doesn't know what method to call because more than one method
 242 has the same prototype. Erroneous code example:
 243
 244 ```compile_fail,E0034
 245 struct Test;
 246
 247 trait Trait1 {
 248     fn foo();
 249 }
 250
 251 trait Trait2 {
 252     fn foo();
 253 }
 254
 255 impl Trait1 for Test { fn foo() {} }
 256 impl Trait2 for Test { fn foo() {} }
 257
 258 fn main() {
 259     Test::foo() // error, which foo() to call?
 260 }
 261 ```
 262
 263 To avoid this error, you have to keep only one of them and remove the others.
 264 So let's take our example and fix it:
 265
 266 ```
 267 struct Test;
 268
 269 trait Trait1 {
 270     fn foo();
 271 }
 272
 273 impl Trait1 for Test { fn foo() {} }
 274
 275 fn main() {
 276     Test::foo() // and now that's good!
 277 }
 278 ```
 279
 280 However, a better solution would be using fully explicit naming of type and
 281 trait:
 282
 283 ```
 284 struct Test;
 285
 286 trait Trait1 {
 287     fn foo();
 288 }
 289
 290 trait Trait2 {
 291     fn foo();
 292 }
 293
 294 impl Trait1 for Test { fn foo() {} }
 295 impl Trait2 for Test { fn foo() {} }
 296
 297 fn main() {
 298     <Test as Trait1>::foo()
 299 }
 300 ```
 301
 302 One last example:
 303
 304 ```
 305 trait F {
 306     fn m(&self);
 307 }
 308
 309 trait G {
 310     fn m(&self);
 311 }
 312
 313 struct X;
 314
 315 impl F for X { fn m(&self) { println!("I am F"); } }
 316 impl G for X { fn m(&self) { println!("I am G"); } }
 317
 318 fn main() {
 319     let f = X;
 320
 321     F::m(&f); // it displays "I am F"
 322     G::m(&f); // it displays "I am G"
 323 }
 324 ```
 325 "##,
 326
 327 E0040: r##"
 328 It is not allowed to manually call destructors in Rust. It is also not
 329 necessary to do this since `drop` is called automatically whenever a value goes
 330 out of scope.
 331
 332 Here's an example of this error:
 333
 334 ```compile_fail,E0040
 335 struct Foo {
 336     x: i32,
 337 }
 338
 339 impl Drop for Foo {
 340     fn drop(&mut self) {
 341         println!("kaboom");
 342     }
 343 }
 344
 345 fn main() {
 346     let mut x = Foo { x: -7 };
 347     x.drop(); // error: explicit use of destructor method
 348 }
 349 ```
 350 "##,
 351
 352 E0044: r##"
 353 You can't use type or const parameters on foreign items.
 354 Example of erroneous code:
 355
 356 ```compile_fail,E0044
 357 extern { fn some_func<T>(x: T); }
 358 ```
 359
 360 To fix this, replace the generic parameter with the specializations that you
 361 need:
 362
 363 ```
 364 extern { fn some_func_i32(x: i32); }
 365 extern { fn some_func_i64(x: i64); }
 366 ```
 367 "##,
 368
 369 E0045: r##"
 370 Rust only supports variadic parameters for interoperability with C code in its
 371 FFI. As such, variadic parameters can only be used with functions which are
 372 using the C ABI. Examples of erroneous code:
 373
 374 ```compile_fail
 375 #![feature(unboxed_closures)]
 376
 377 extern "rust-call" { fn foo(x: u8, ...); }
 378
 379 // or
 380
 381 fn foo(x: u8, ...) {}
 382 ```
 383
 384 To fix such code, put them in an extern "C" block:
 385
 386 ```
 387 extern "C" {
 388     fn foo (x: u8, ...);
 389 }
 390 ```
 391 "##,
 392
 393 E0046: r##"
 394 Items are missing in a trait implementation. Erroneous code example:
 395
 396 ```compile_fail,E0046
 397 trait Foo {
 398     fn foo();
 399 }
 400
 401 struct Bar;
 402
 403 impl Foo for Bar {}
 404 // error: not all trait items implemented, missing: `foo`
 405 ```
 406
 407 When trying to make some type implement a trait `Foo`, you must, at minimum,
 408 provide implementations for all of `Foo`'s required methods (meaning the
 409 methods that do not have default implementations), as well as any required
 410 trait items like associated types or constants. Example:
 411
 412 ```
 413 trait Foo {
 414     fn foo();
 415 }
 416
 417 struct Bar;
 418
 419 impl Foo for Bar {
 420     fn foo() {} // ok!
 421 }
 422 ```
 423 "##,
 424
 425 E0049: r##"
 426 This error indicates that an attempted implementation of a trait method
 427 has the wrong number of type or const parameters.
 428
 429 For example, the trait below has a method `foo` with a type parameter `T`,
 430 but the implementation of `foo` for the type `Bar` is missing this parameter:
 431
 432 ```compile_fail,E0049
 433 trait Foo {
 434     fn foo<T: Default>(x: T) -> Self;
 435 }
 436
 437 struct Bar;
 438
 439 // error: method `foo` has 0 type parameters but its trait declaration has 1
 440 // type parameter
 441 impl Foo for Bar {
 442     fn foo(x: bool) -> Self { Bar }
 443 }
 444 ```
 445 "##,
 446
 447 E0050: r##"
 448 This error indicates that an attempted implementation of a trait method
 449 has the wrong number of function parameters.
 450
 451 For example, the trait below has a method `foo` with two function parameters
 452 (`&self` and `u8`), but the implementation of `foo` for the type `Bar` omits
 453 the `u8` parameter:
 454
 455 ```compile_fail,E0050
 456 trait Foo {
 457     fn foo(&self, x: u8) -> bool;
 458 }
 459
 460 struct Bar;
 461
 462 // error: method `foo` has 1 parameter but the declaration in trait `Foo::foo`
 463 // has 2
 464 impl Foo for Bar {
 465     fn foo(&self) -> bool { true }
 466 }
 467 ```
 468 "##,
 469
 470 E0053: r##"
 471 The parameters of any trait method must match between a trait implementation
 472 and the trait definition.
 473
 474 Here are a couple examples of this error:
 475
 476 ```compile_fail,E0053
 477 trait Foo {
 478     fn foo(x: u16);
 479     fn bar(&self);
 480 }
 481
 482 struct Bar;
 483
 484 impl Foo for Bar {
 485     // error, expected u16, found i16
 486     fn foo(x: i16) { }
 487
 488     // error, types differ in mutability
 489     fn bar(&mut self) { }
 490 }
 491 ```
 492 "##,
 493
 494 E0054: r##"
 495 It is not allowed to cast to a bool. If you are trying to cast a numeric type
 496 to a bool, you can compare it with zero instead:
 497
 498 ```compile_fail,E0054
 499 let x = 5;
 500
 501 // Not allowed, won't compile
 502 let x_is_nonzero = x as bool;
 503 ```
 504
 505 ```
 506 let x = 5;
 507
 508 // Ok
 509 let x_is_nonzero = x != 0;
 510 ```
 511 "##,
 512
 513 E0055: r##"
 514 During a method call, a value is automatically dereferenced as many times as
 515 needed to make the value's type match the method's receiver. The catch is that
 516 the compiler will only attempt to dereference a number of times up to the
 517 recursion limit (which can be set via the `recursion_limit` attribute).
 518
 519 For a somewhat artificial example:
 520
 521 ```compile_fail,E0055
 522 #![recursion_limit="5"]
 523
 524 struct Foo;
 525
 526 impl Foo {
 527     fn foo(&self) {}
 528 }
 529
 530 fn main() {
 531     let foo = Foo;
 532     let ref_foo = &&&&&Foo;
 533
 534     // error, reached the recursion limit while auto-dereferencing `&&&&&Foo`
 535     ref_foo.foo();
 536 }
 537 ```
 538
 539 One fix may be to increase the recursion limit. Note that it is possible to
 540 create an infinite recursion of dereferencing, in which case the only fix is to
 541 somehow break the recursion.
 542 "##,
 543
 544 E0057: r##"
 545 When invoking closures or other implementations of the function traits `Fn`,
 546 `FnMut` or `FnOnce` using call notation, the number of parameters passed to the
 547 function must match its definition.
 548
 549 An example using a closure:
 550
 551 ```compile_fail,E0057
 552 let f = |x| x * 3;
 553 let a = f();        // invalid, too few parameters
 554 let b = f(4);       // this works!
 555 let c = f(2, 3);    // invalid, too many parameters
 556 ```
 557
 558 A generic function must be treated similarly:
 559
 560 ```
 561 fn foo<F: Fn()>(f: F) {
 562     f(); // this is valid, but f(3) would not work
 563 }
 564 ```
 565 "##,
 566
 567 E0059: r##"
 568 The built-in function traits are generic over a tuple of the function arguments.
 569 If one uses angle-bracket notation (`Fn<(T,), Output=U>`) instead of parentheses
 570 (`Fn(T) -> U`) to denote the function trait, the type parameter should be a
 571 tuple. Otherwise function call notation cannot be used and the trait will not be
 572 implemented by closures.
 573
 574 The most likely source of this error is using angle-bracket notation without
 575 wrapping the function argument type into a tuple, for example:
 576
 577 ```compile_fail,E0059
 578 #![feature(unboxed_closures)]
 579
 580 fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) }
 581 ```
 582
 583 It can be fixed by adjusting the trait bound like this:
 584
 585 ```
 586 #![feature(unboxed_closures)]
 587
 588 fn foo<F: Fn<(i32,)>>(f: F) -> F::Output { f(3) }
 589 ```
 590
 591 Note that `(T,)` always denotes the type of a 1-tuple containing an element of
 592 type `T`. The comma is necessary for syntactic disambiguation.
 593 "##,
 594
 595 E0060: r##"
 596 External C functions are allowed to be variadic. However, a variadic function
 597 takes a minimum number of arguments. For example, consider C's variadic `printf`
 598 function:
 599
 600 ```
 601 use std::os::raw::{c_char, c_int};
 602
 603 extern "C" {
 604     fn printf(_: *const c_char, ...) -> c_int;
 605 }
 606 ```
 607
 608 Using this declaration, it must be called with at least one argument, so
 609 simply calling `printf()` is invalid. But the following uses are allowed:
 610
 611 ```
 612 # #![feature(static_nobundle)]
 613 # use std::os::raw::{c_char, c_int};
 614 # #[cfg_attr(all(windows, target_env = "msvc"),
 615 #            link(name = "legacy_stdio_definitions", kind = "static-nobundle"))]
 616 # extern "C" { fn printf(_: *const c_char, ...) -> c_int; }
 617 # fn main() {
 618 unsafe {
 619     use std::ffi::CString;
 620
 621     let fmt = CString::new("test\n").unwrap();
 622     printf(fmt.as_ptr());
 623
 624     let fmt = CString::new("number = %d\n").unwrap();
 625     printf(fmt.as_ptr(), 3);
 626
 627     let fmt = CString::new("%d, %d\n").unwrap();
 628     printf(fmt.as_ptr(), 10, 5);
 629 }
 630 # }
 631 ```
 632 "##,
 633 // ^ Note: On MSVC 2015, the `printf` function is "inlined" in the C code, and
 634 // the C runtime does not contain the `printf` definition. This leads to linker
 635 // error from the doc test (issue #42830).
 636 // This can be fixed by linking to the static library
 637 // `legacy_stdio_definitions.lib` (see https://stackoverflow.com/a/36504365/).
 638 // If this compatibility library is removed in the future, consider changing
 639 // `printf` in this example to another well-known variadic function.
 640
 641 E0061: r##"
 642 The number of arguments passed to a function must match the number of arguments
 643 specified in the function signature.
 644
 645 For example, a function like:
 646
 647 ```
 648 fn f(a: u16, b: &str) {}
 649 ```
 650
 651 Must always be called with exactly two arguments, e.g., `f(2, "test")`.
 652
 653 Note that Rust does not have a notion of optional function arguments or
 654 variadic functions (except for its C-FFI).
 655 "##,
 656
 657 E0062: r##"
 658 This error indicates that during an attempt to build a struct or struct-like
 659 enum variant, one of the fields was specified more than once. Erroneous code
 660 example:
 661
 662 ```compile_fail,E0062
 663 struct Foo {
 664     x: i32,
 665 }
 666
 667 fn main() {
 668     let x = Foo {
 669                 x: 0,
 670                 x: 0, // error: field `x` specified more than once
 671             };
 672 }
 673 ```
 674
 675 Each field should be specified exactly one time. Example:
 676
 677 ```
 678 struct Foo {
 679     x: i32,
 680 }
 681
 682 fn main() {
 683     let x = Foo { x: 0 }; // ok!
 684 }
 685 ```
 686 "##,
 687
 688 E0063: r##"
 689 This error indicates that during an attempt to build a struct or struct-like
 690 enum variant, one of the fields was not provided. Erroneous code example:
 691
 692 ```compile_fail,E0063
 693 struct Foo {
 694     x: i32,
 695     y: i32,
 696 }
 697
 698 fn main() {
 699     let x = Foo { x: 0 }; // error: missing field: `y`
 700 }
 701 ```
 702
 703 Each field should be specified exactly once. Example:
 704
 705 ```
 706 struct Foo {
 707     x: i32,
 708     y: i32,
 709 }
 710
 711 fn main() {
 712     let x = Foo { x: 0, y: 0 }; // ok!
 713 }
 714 ```
 715 "##,
 716
 717 E0067: r##"
 718 The left-hand side of a compound assignment expression must be a place
 719 expression. A place expression represents a memory location and includes
 720 item paths (ie, namespaced variables), dereferences, indexing expressions,
 721 and field references.
 722
 723 Let's start with some erroneous code examples:
 724
 725 ```compile_fail,E0067
 726 use std::collections::LinkedList;
 727
 728 // Bad: assignment to non-place expression
 729 LinkedList::new() += 1;
 730
 731 // ...
 732
 733 fn some_func(i: &mut i32) {
 734     i += 12; // Error : '+=' operation cannot be applied on a reference !
 735 }
 736 ```
 737
 738 And now some working examples:
 739
 740 ```
 741 let mut i : i32 = 0;
 742
 743 i += 12; // Good !
 744
 745 // ...
 746
 747 fn some_func(i: &mut i32) {
 748     *i += 12; // Good !
 749 }
 750 ```
 751 "##,
 752
 753 E0069: r##"
 754 The compiler found a function whose body contains a `return;` statement but
 755 whose return type is not `()`. An example of this is:
 756
 757 ```compile_fail,E0069
 758 // error
 759 fn foo() -> u8 {
 760     return;
 761 }
 762 ```
 763
 764 Since `return;` is just like `return ();`, there is a mismatch between the
 765 function's return type and the value being returned.
 766 "##,
 767
 768 E0070: r##"
 769 The left-hand side of an assignment operator must be a place expression. A
 770 place expression represents a memory location and can be a variable (with
 771 optional namespacing), a dereference, an indexing expression or a field
 772 reference.
 773
 774 More details can be found in the [Expressions] section of the Reference.
 775
 776 [Expressions]: https://doc.rust-lang.org/reference/expressions.html#places-rvalues-and-temporaries
 777
 778 Now, we can go further. Here are some erroneous code examples:
 779
 780 ```compile_fail,E0070
 781 struct SomeStruct {
 782     x: i32,
 783     y: i32
 784 }
 785
 786 const SOME_CONST : i32 = 12;
 787
 788 fn some_other_func() {}
 789
 790 fn some_function() {
 791     SOME_CONST = 14; // error : a constant value cannot be changed!
 792     1 = 3; // error : 1 isn't a valid place!
 793     some_other_func() = 4; // error : we can't assign value to a function!
 794     SomeStruct.x = 12; // error : SomeStruct a structure name but it is used
 795                        // like a variable!
 796 }
 797 ```
 798
 799 And now let's give working examples:
 800
 801 ```
 802 struct SomeStruct {
 803     x: i32,
 804     y: i32
 805 }
 806 let mut s = SomeStruct {x: 0, y: 0};
 807
 808 s.x = 3; // that's good !
 809
 810 // ...
 811
 812 fn some_func(x: &mut i32) {
 813     *x = 12; // that's good !
 814 }
 815 ```
 816 "##,
 817
 818 E0071: r##"
 819 You tried to use structure-literal syntax to create an item that is
 820 not a structure or enum variant.
 821
 822 Example of erroneous code:
 823
 824 ```compile_fail,E0071
 825 type U32 = u32;
 826 let t = U32 { value: 4 }; // error: expected struct, variant or union type,
 827                           // found builtin type `u32`
 828 ```
 829
 830 To fix this, ensure that the name was correctly spelled, and that
 831 the correct form of initializer was used.
 832
 833 For example, the code above can be fixed to:
 834
 835 ```
 836 enum Foo {
 837     FirstValue(i32)
 838 }
 839
 840 fn main() {
 841     let u = Foo::FirstValue(0i32);
 842
 843     let t = 4;
 844 }
 845 ```
 846 "##,
 847
 848 E0073: r##"
 849 #### Note: this error code is no longer emitted by the compiler.
 850
 851 You cannot define a struct (or enum) `Foo` that requires an instance of `Foo`
 852 in order to make a new `Foo` value. This is because there would be no way a
 853 first instance of `Foo` could be made to initialize another instance!
 854
 855 Here's an example of a struct that has this problem:
 856
 857 ```
 858 struct Foo { x: Box<Foo> } // error
 859 ```
 860
 861 One fix is to use `Option`, like so:
 862
 863 ```
 864 struct Foo { x: Option<Box<Foo>> }
 865 ```
 866
 867 Now it's possible to create at least one instance of `Foo`: `Foo { x: None }`.
 868 "##,
 869
 870 E0074: r##"
 871 #### Note: this error code is no longer emitted by the compiler.
 872
 873 When using the `#[simd]` attribute on a tuple struct, the components of the
 874 tuple struct must all be of a concrete, nongeneric type so the compiler can
 875 reason about how to use SIMD with them. This error will occur if the types
 876 are generic.
 877
 878 This will cause an error:
 879
 880 ```
 881 #![feature(repr_simd)]
 882
 883 #[repr(simd)]
 884 struct Bad<T>(T, T, T);
 885 ```
 886
 887 This will not:
 888
 889 ```
 890 #![feature(repr_simd)]
 891
 892 #[repr(simd)]
 893 struct Good(u32, u32, u32);
 894 ```
 895 "##,
 896
 897 E0075: r##"
 898 The `#[simd]` attribute can only be applied to non empty tuple structs, because
 899 it doesn't make sense to try to use SIMD operations when there are no values to
 900 operate on.
 901
 902 This will cause an error:
 903
 904 ```compile_fail,E0075
 905 #![feature(repr_simd)]
 906
 907 #[repr(simd)]
 908 struct Bad;
 909 ```
 910
 911 This will not:
 912
 913 ```
 914 #![feature(repr_simd)]
 915
 916 #[repr(simd)]
 917 struct Good(u32);
 918 ```
 919 "##,
 920
 921 E0076: r##"
 922 When using the `#[simd]` attribute to automatically use SIMD operations in tuple
 923 struct, the types in the struct must all be of the same type, or the compiler
 924 will trigger this error.
 925
 926 This will cause an error:
 927
 928 ```compile_fail,E0076
 929 #![feature(repr_simd)]
 930
 931 #[repr(simd)]
 932 struct Bad(u16, u32, u32);
 933 ```
 934
 935 This will not:
 936
 937 ```
 938 #![feature(repr_simd)]
 939
 940 #[repr(simd)]
 941 struct Good(u32, u32, u32);
 942 ```
 943 "##,
 944
 945 E0077: r##"
 946 When using the `#[simd]` attribute on a tuple struct, the elements in the tuple
 947 must be machine types so SIMD operations can be applied to them.
 948
 949 This will cause an error:
 950
 951 ```compile_fail,E0077
 952 #![feature(repr_simd)]
 953
 954 #[repr(simd)]
 955 struct Bad(String);
 956 ```
 957
 958 This will not:
 959
 960 ```
 961 #![feature(repr_simd)]
 962
 963 #[repr(simd)]
 964 struct Good(u32, u32, u32);
 965 ```
 966 "##,
 967
 968 E0081: r##"
 969 Enum discriminants are used to differentiate enum variants stored in memory.
 970 This error indicates that the same value was used for two or more variants,
 971 making them impossible to tell apart.
 972
 973 ```compile_fail,E0081
 974 // Bad.
 975 enum Enum {
 976     P = 3,
 977     X = 3,
 978     Y = 5,
 979 }
 980 ```
 981
 982 ```
 983 // Good.
 984 enum Enum {
 985     P,
 986     X = 3,
 987     Y = 5,
 988 }
 989 ```
 990
 991 Note that variants without a manually specified discriminant are numbered from
 992 top to bottom starting from 0, so clashes can occur with seemingly unrelated
 993 variants.
 994
 995 ```compile_fail,E0081
 996 enum Bad {
 997     X,
 998     Y = 0
 999 }
1000 ```
1001
1002 Here `X` will have already been specified the discriminant 0 by the time `Y` is
1003 encountered, so a conflict occurs.
1004 "##,
1005
1006 E0084: r##"
1007 An unsupported representation was attempted on a zero-variant enum.
1008
1009 Erroneous code example:
1010
1011 ```compile_fail,E0084
1012 #[repr(i32)]
1013 enum NightsWatch {} // error: unsupported representation for zero-variant enum
1014 ```
1015
1016 It is impossible to define an integer type to be used to represent zero-variant
1017 enum values because there are no zero-variant enum values. There is no way to
1018 construct an instance of the following type using only safe code. So you have
1019 two solutions. Either you add variants in your enum:
1020
1021 ```
1022 #[repr(i32)]
1023 enum NightsWatch {
1024     JonSnow,
1025     Commander,
1026 }
1027 ```
1028
1029 or you remove the integer represention of your enum:
1030
1031 ```
1032 enum NightsWatch {}
1033 ```
1034 "##,
1035
1036 // FIXME(const_generics:docs): example of inferring const parameter.
1037 E0087: r##"
1038 #### Note: this error code is no longer emitted by the compiler.
1039
1040 Too many type arguments were supplied for a function. For example:
1041
1042 ```compile_fail,E0107
1043 fn foo<T>() {}
1044
1045 fn main() {
1046     foo::<f64, bool>(); // error: wrong number of type arguments:
1047                         //        expected 1, found 2
1048 }
1049 ```
1050
1051 The number of supplied arguments must exactly match the number of defined type
1052 parameters.
1053 "##,
1054
1055 E0088: r##"
1056 #### Note: this error code is no longer emitted by the compiler.
1057
1058 You gave too many lifetime arguments. Erroneous code example:
1059
1060 ```compile_fail,E0107
1061 fn f() {}
1062
1063 fn main() {
1064     f::<'static>() // error: wrong number of lifetime arguments:
1065                    //        expected 0, found 1
1066 }
1067 ```
1068
1069 Please check you give the right number of lifetime arguments. Example:
1070
1071 ```
1072 fn f() {}
1073
1074 fn main() {
1075     f() // ok!
1076 }
1077 ```
1078
1079 It's also important to note that the Rust compiler can generally
1080 determine the lifetime by itself. Example:
1081
1082 ```
1083 struct Foo {
1084     value: String
1085 }
1086
1087 impl Foo {
1088     // it can be written like this
1089     fn get_value<'a>(&'a self) -> &'a str { &self.value }
1090     // but the compiler works fine with this too:
1091     fn without_lifetime(&self) -> &str { &self.value }
1092 }
1093
1094 fn main() {
1095     let f = Foo { value: "hello".to_owned() };
1096
1097     println!("{}", f.get_value());
1098     println!("{}", f.without_lifetime());
1099 }
1100 ```
1101 "##,
1102
1103 E0089: r##"
1104 #### Note: this error code is no longer emitted by the compiler.
1105
1106 Too few type arguments were supplied for a function. For example:
1107
1108 ```compile_fail,E0107
1109 fn foo<T, U>() {}
1110
1111 fn main() {
1112     foo::<f64>(); // error: wrong number of type arguments: expected 2, found 1
1113 }
1114 ```
1115
1116 Note that if a function takes multiple type arguments but you want the compiler
1117 to infer some of them, you can use type placeholders:
1118
1119 ```compile_fail,E0107
1120 fn foo<T, U>(x: T) {}
1121
1122 fn main() {
1123     let x: bool = true;
1124     foo::<f64>(x);    // error: wrong number of type arguments:
1125                       //        expected 2, found 1
1126     foo::<_, f64>(x); // same as `foo::<bool, f64>(x)`
1127 }
1128 ```
1129 "##,
1130
1131 E0090: r##"
1132 #### Note: this error code is no longer emitted by the compiler.
1133
1134 You gave too few lifetime arguments. Example:
1135
1136 ```compile_fail,E0107
1137 fn foo<'a: 'b, 'b: 'a>() {}
1138
1139 fn main() {
1140     foo::<'static>(); // error: wrong number of lifetime arguments:
1141                       //        expected 2, found 1
1142 }
1143 ```
1144
1145 Please check you give the right number of lifetime arguments. Example:
1146
1147 ```
1148 fn foo<'a: 'b, 'b: 'a>() {}
1149
1150 fn main() {
1151     foo::<'static, 'static>();
1152 }
1153 ```
1154 "##,
1155
1156 E0091: r##"
1157 You gave an unnecessary type or const parameter in a type alias. Erroneous
1158 code example:
1159
1160 ```compile_fail,E0091
1161 type Foo<T> = u32; // error: type parameter `T` is unused
1162 // or:
1163 type Foo<A,B> = Box<A>; // error: type parameter `B` is unused
1164 ```
1165
1166 Please check you didn't write too many parameters. Example:
1167
1168 ```
1169 type Foo = u32; // ok!
1170 type Foo2<A> = Box<A>; // ok!
1171 ```
1172 "##,
1173
1174 E0092: r##"
1175 You tried to declare an undefined atomic operation function.
1176 Erroneous code example:
1177
1178 ```compile_fail,E0092
1179 #![feature(intrinsics)]
1180
1181 extern "rust-intrinsic" {
1182     fn atomic_foo(); // error: unrecognized atomic operation
1183                      //        function
1184 }
1185 ```
1186
1187 Please check you didn't make a mistake in the function's name. All intrinsic
1188 functions are defined in librustc_codegen_llvm/intrinsic.rs and in
1189 libcore/intrinsics.rs in the Rust source code. Example:
1190
1191 ```
1192 #![feature(intrinsics)]
1193
1194 extern "rust-intrinsic" {
1195     fn atomic_fence(); // ok!
1196 }
1197 ```
1198 "##,
1199
1200 E0093: r##"
1201 You declared an unknown intrinsic function. Erroneous code example:
1202
1203 ```compile_fail,E0093
1204 #![feature(intrinsics)]
1205
1206 extern "rust-intrinsic" {
1207     fn foo(); // error: unrecognized intrinsic function: `foo`
1208 }
1209
1210 fn main() {
1211     unsafe {
1212         foo();
1213     }
1214 }
1215 ```
1216
1217 Please check you didn't make a mistake in the function's name. All intrinsic
1218 functions are defined in librustc_codegen_llvm/intrinsic.rs and in
1219 libcore/intrinsics.rs in the Rust source code. Example:
1220
1221 ```
1222 #![feature(intrinsics)]
1223
1224 extern "rust-intrinsic" {
1225     fn atomic_fence(); // ok!
1226 }
1227
1228 fn main() {
1229     unsafe {
1230         atomic_fence();
1231     }
1232 }
1233 ```
1234 "##,
1235
1236 E0094: r##"
1237 You gave an invalid number of type parameters to an intrinsic function.
1238 Erroneous code example:
1239
1240 ```compile_fail,E0094
1241 #![feature(intrinsics)]
1242
1243 extern "rust-intrinsic" {
1244     fn size_of<T, U>() -> usize; // error: intrinsic has wrong number
1245                                  //        of type parameters
1246 }
1247 ```
1248
1249 Please check that you provided the right number of type parameters
1250 and verify with the function declaration in the Rust source code.
1251 Example:
1252
1253 ```
1254 #![feature(intrinsics)]
1255
1256 extern "rust-intrinsic" {
1257     fn size_of<T>() -> usize; // ok!
1258 }
1259 ```
1260 "##,
1261
1262 E0107: r##"
1263 This error means that an incorrect number of generic arguments were provided:
1264
1265 ```compile_fail,E0107
1266 struct Foo<T> { x: T }
1267
1268 struct Bar { x: Foo }             // error: wrong number of type arguments:
1269                                   //        expected 1, found 0
1270 struct Baz<S, T> { x: Foo<S, T> } // error: wrong number of type arguments:
1271                                   //        expected 1, found 2
1272
1273 fn foo<T, U>(x: T, y: U) {}
1274
1275 fn main() {
1276     let x: bool = true;
1277     foo::<bool>(x);                 // error: wrong number of type arguments:
1278                                     //        expected 2, found 1
1279     foo::<bool, i32, i32>(x, 2, 4); // error: wrong number of type arguments:
1280                                     //        expected 2, found 3
1281 }
1282
1283 fn f() {}
1284
1285 fn main() {
1286     f::<'static>(); // error: wrong number of lifetime arguments:
1287                     //        expected 0, found 1
1288 }
1289 ```
1290
1291 "##,
1292
1293 E0109: r##"
1294 You tried to provide a generic argument to a type which doesn't need it.
1295 Erroneous code example:
1296
1297 ```compile_fail,E0109
1298 type X = u32<i32>; // error: type arguments are not allowed for this type
1299 type Y = bool<'static>; // error: lifetime parameters are not allowed on
1300                         //        this type
1301 ```
1302
1303 Check that you used the correct argument and that the definition is correct.
1304
1305 Example:
1306
1307 ```
1308 type X = u32; // ok!
1309 type Y = bool; // ok!
1310 ```
1311
1312 Note that generic arguments for enum variant constructors go after the variant,
1313 not after the enum. For example, you would write `Option::None::<u32>`,
1314 rather than `Option::<u32>::None`.
1315 "##,
1316
1317 E0110: r##"
1318 #### Note: this error code is no longer emitted by the compiler.
1319
1320 You tried to provide a lifetime to a type which doesn't need it.
1321 See `E0109` for more details.
1322 "##,
1323
1324 E0116: r##"
1325 You can only define an inherent implementation for a type in the same crate
1326 where the type was defined. For example, an `impl` block as below is not allowed
1327 since `Vec` is defined in the standard library:
1328
1329 ```compile_fail,E0116
1330 impl Vec<u8> { } // error
1331 ```
1332
1333 To fix this problem, you can do either of these things:
1334
1335  - define a trait that has the desired associated functions/types/constants and
1336    implement the trait for the type in question
1337  - define a new type wrapping the type and define an implementation on the new
1338    type
1339
1340 Note that using the `type` keyword does not work here because `type` only
1341 introduces a type alias:
1342
1343 ```compile_fail,E0116
1344 type Bytes = Vec<u8>;
1345
1346 impl Bytes { } // error, same as above
1347 ```
1348 "##,
1349
1350 E0117: r##"
1351 This error indicates a violation of one of Rust's orphan rules for trait
1352 implementations. The rule prohibits any implementation of a foreign trait (a
1353 trait defined in another crate) where
1354
1355  - the type that is implementing the trait is foreign
1356  - all of the parameters being passed to the trait (if there are any) are also
1357    foreign.
1358
1359 Here's one example of this error:
1360
1361 ```compile_fail,E0117
1362 impl Drop for u32 {}
1363 ```
1364
1365 To avoid this kind of error, ensure that at least one local type is referenced
1366 by the `impl`:
1367
1368 ```
1369 pub struct Foo; // you define your type in your crate
1370
1371 impl Drop for Foo { // and you can implement the trait on it!
1372     // code of trait implementation here
1373 #   fn drop(&mut self) { }
1374 }
1375
1376 impl From<Foo> for i32 { // or you use a type from your crate as
1377                          // a type parameter
1378     fn from(i: Foo) -> i32 {
1379         0
1380     }
1381 }
1382 ```
1383
1384 Alternatively, define a trait locally and implement that instead:
1385
1386 ```
1387 trait Bar {
1388     fn get(&self) -> usize;
1389 }
1390
1391 impl Bar for u32 {
1392     fn get(&self) -> usize { 0 }
1393 }
1394 ```
1395
1396 For information on the design of the orphan rules, see [RFC 1023].
1397
1398 [RFC 1023]: https://github.com/rust-lang/rfcs/blob/master/text/1023-rebalancing-coherence.md
1399 "##,
1400
1401 E0118: r##"
1402 You're trying to write an inherent implementation for something which isn't a
1403 struct nor an enum. Erroneous code example:
1404
1405 ```compile_fail,E0118
1406 impl (u8, u8) { // error: no base type found for inherent implementation
1407     fn get_state(&self) -> String {
1408         // ...
1409     }
1410 }
1411 ```
1412
1413 To fix this error, please implement a trait on the type or wrap it in a struct.
1414 Example:
1415
1416 ```
1417 // we create a trait here
1418 trait LiveLongAndProsper {
1419     fn get_state(&self) -> String;
1420 }
1421
1422 // and now you can implement it on (u8, u8)
1423 impl LiveLongAndProsper for (u8, u8) {
1424     fn get_state(&self) -> String {
1425         "He's dead, Jim!".to_owned()
1426     }
1427 }
1428 ```
1429
1430 Alternatively, you can create a newtype. A newtype is a wrapping tuple-struct.
1431 For example, `NewType` is a newtype over `Foo` in `struct NewType(Foo)`.
1432 Example:
1433
1434 ```
1435 struct TypeWrapper((u8, u8));
1436
1437 impl TypeWrapper {
1438     fn get_state(&self) -> String {
1439         "Fascinating!".to_owned()
1440     }
1441 }
1442 ```
1443 "##,
1444
1445 E0120: r##"
1446 An attempt was made to implement Drop on a trait, which is not allowed: only
1447 structs and enums can implement Drop. An example causing this error:
1448
1449 ```compile_fail,E0120
1450 trait MyTrait {}
1451
1452 impl Drop for MyTrait {
1453     fn drop(&mut self) {}
1454 }
1455 ```
1456
1457 A workaround for this problem is to wrap the trait up in a struct, and implement
1458 Drop on that. An example is shown below:
1459
1460 ```
1461 trait MyTrait {}
1462 struct MyWrapper<T: MyTrait> { foo: T }
1463
1464 impl <T: MyTrait> Drop for MyWrapper<T> {
1465     fn drop(&mut self) {}
1466 }
1467
1468 ```
1469
1470 Alternatively, wrapping trait objects requires something like the following:
1471
1472 ```
1473 trait MyTrait {}
1474
1475 //or Box<MyTrait>, if you wanted an owned trait object
1476 struct MyWrapper<'a> { foo: &'a MyTrait }
1477
1478 impl <'a> Drop for MyWrapper<'a> {
1479     fn drop(&mut self) {}
1480 }
1481 ```
1482 "##,
1483
1484 E0121: r##"
1485 In order to be consistent with Rust's lack of global type inference,
1486 type and const placeholders are disallowed by design in item signatures.
1487
1488 Examples of this error include:
1489
1490 ```compile_fail,E0121
1491 fn foo() -> _ { 5 } // error, explicitly write out the return type instead
1492
1493 static BAR: _ = "test"; // error, explicitly write out the type instead
1494 ```
1495 "##,
1496
1497 E0124: r##"
1498 You declared two fields of a struct with the same name. Erroneous code
1499 example:
1500
1501 ```compile_fail,E0124
1502 struct Foo {
1503     field1: i32,
1504     field1: i32, // error: field is already declared
1505 }
1506 ```
1507
1508 Please verify that the field names have been correctly spelled. Example:
1509
1510 ```
1511 struct Foo {
1512     field1: i32,
1513     field2: i32, // ok!
1514 }
1515 ```
1516 "##,
1517
1518 E0131: r##"
1519 It is not possible to define `main` with generic parameters.
1520 When `main` is present, it must take no arguments and return `()`.
1521 Erroneous code example:
1522
1523 ```compile_fail,E0131
1524 fn main<T>() { // error: main function is not allowed to have generic parameters
1525 }
1526 ```
1527 "##,
1528
1529 E0132: r##"
1530 A function with the `start` attribute was declared with type parameters.
1531
1532 Erroneous code example:
1533
1534 ```compile_fail,E0132
1535 #![feature(start)]
1536
1537 #[start]
1538 fn f<T>() {}
1539 ```
1540
1541 It is not possible to declare type parameters on a function that has the `start`
1542 attribute. Such a function must have the following type signature (for more
1543 information, view [the unstable book][1]):
1544
1545 [1]: https://doc.rust-lang.org/unstable-book/language-features/lang-items.html#writing-an-executable-without-stdlib
1546
1547 ```
1548 # let _:
1549 fn(isize, *const *const u8) -> isize;
1550 ```
1551
1552 Example:
1553
1554 ```
1555 #![feature(start)]
1556
1557 #[start]
1558 fn my_start(argc: isize, argv: *const *const u8) -> isize {
1559     0
1560 }
1561 ```
1562 "##,
1563
1564 E0164: r##"
1565 This error means that an attempt was made to match a struct type enum
1566 variant as a non-struct type:
1567
1568 ```compile_fail,E0164
1569 enum Foo { B { i: u32 } }
1570
1571 fn bar(foo: Foo) -> u32 {
1572     match foo {
1573         Foo::B(i) => i, // error E0164
1574     }
1575 }
1576 ```
1577
1578 Try using `{}` instead:
1579
1580 ```
1581 enum Foo { B { i: u32 } }
1582
1583 fn bar(foo: Foo) -> u32 {
1584     match foo {
1585         Foo::B{i} => i,
1586     }
1587 }
1588 ```
1589 "##,
1590
1591 E0184: r##"
1592 Explicitly implementing both Drop and Copy for a type is currently disallowed.
1593 This feature can make some sense in theory, but the current implementation is
1594 incorrect and can lead to memory unsafety (see [issue #20126][iss20126]), so
1595 it has been disabled for now.
1596
1597 [iss20126]: https://github.com/rust-lang/rust/issues/20126
1598 "##,
1599
1600 E0185: r##"
1601 An associated function for a trait was defined to be static, but an
1602 implementation of the trait declared the same function to be a method (i.e., to
1603 take a `self` parameter).
1604
1605 Here's an example of this error:
1606
1607 ```compile_fail,E0185
1608 trait Foo {
1609     fn foo();
1610 }
1611
1612 struct Bar;
1613
1614 impl Foo for Bar {
1615     // error, method `foo` has a `&self` declaration in the impl, but not in
1616     // the trait
1617     fn foo(&self) {}
1618 }
1619 ```
1620 "##,
1621
1622 E0186: r##"
1623 An associated function for a trait was defined to be a method (i.e., to take a
1624 `self` parameter), but an implementation of the trait declared the same function
1625 to be static.
1626
1627 Here's an example of this error:
1628
1629 ```compile_fail,E0186
1630 trait Foo {
1631     fn foo(&self);
1632 }
1633
1634 struct Bar;
1635
1636 impl Foo for Bar {
1637     // error, method `foo` has a `&self` declaration in the trait, but not in
1638     // the impl
1639     fn foo() {}
1640 }
1641 ```
1642 "##,
1643
1644 E0191: r##"
1645 Trait objects need to have all associated types specified. Erroneous code
1646 example:
1647
1648 ```compile_fail,E0191
1649 trait Trait {
1650     type Bar;
1651 }
1652
1653 type Foo = Trait; // error: the value of the associated type `Bar` (from
1654                   //        the trait `Trait`) must be specified
1655 ```
1656
1657 Please verify you specified all associated types of the trait and that you
1658 used the right trait. Example:
1659
1660 ```
1661 trait Trait {
1662     type Bar;
1663 }
1664
1665 type Foo = Trait<Bar=i32>; // ok!
1666 ```
1667 "##,
1668
1669 E0192: r##"
1670 Negative impls are only allowed for auto traits. For more
1671 information see the [opt-in builtin traits RFC][RFC 19].
1672
1673 [RFC 19]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md
1674 "##,
1675
1676 E0193: r##"
1677 #### Note: this error code is no longer emitted by the compiler.
1678
1679 `where` clauses must use generic type parameters: it does not make sense to use
1680 them otherwise. An example causing this error:
1681
1682 ```
1683 trait Foo {
1684     fn bar(&self);
1685 }
1686
1687 #[derive(Copy,Clone)]
1688 struct Wrapper<T> {
1689     Wrapped: T
1690 }
1691
1692 impl Foo for Wrapper<u32> where Wrapper<u32>: Clone {
1693     fn bar(&self) { }
1694 }
1695 ```
1696
1697 This use of a `where` clause is strange - a more common usage would look
1698 something like the following:
1699
1700 ```
1701 trait Foo {
1702     fn bar(&self);
1703 }
1704
1705 #[derive(Copy,Clone)]
1706 struct Wrapper<T> {
1707     Wrapped: T
1708 }
1709 impl <T> Foo for Wrapper<T> where Wrapper<T>: Clone {
1710     fn bar(&self) { }
1711 }
1712 ```
1713
1714 Here, we're saying that the implementation exists on Wrapper only when the
1715 wrapped type `T` implements `Clone`. The `where` clause is important because
1716 some types will not implement `Clone`, and thus will not get this method.
1717
1718 In our erroneous example, however, we're referencing a single concrete type.
1719 Since we know for certain that `Wrapper<u32>` implements `Clone`, there's no
1720 reason to also specify it in a `where` clause.
1721 "##,
1722
1723 E0194: r##"
1724 A type parameter was declared which shadows an existing one. An example of this
1725 error:
1726
1727 ```compile_fail,E0194
1728 trait Foo<T> {
1729     fn do_something(&self) -> T;
1730     fn do_something_else<T: Clone>(&self, bar: T);
1731 }
1732 ```
1733
1734 In this example, the trait `Foo` and the trait method `do_something_else` both
1735 define a type parameter `T`. This is not allowed: if the method wishes to
1736 define a type parameter, it must use a different name for it.
1737 "##,
1738
1739 E0195: r##"
1740 Your method's lifetime parameters do not match the trait declaration.
1741 Erroneous code example:
1742
1743 ```compile_fail,E0195
1744 trait Trait {
1745     fn bar<'a,'b:'a>(x: &'a str, y: &'b str);
1746 }
1747
1748 struct Foo;
1749
1750 impl Trait for Foo {
1751     fn bar<'a,'b>(x: &'a str, y: &'b str) {
1752     // error: lifetime parameters or bounds on method `bar`
1753     // do not match the trait declaration
1754     }
1755 }
1756 ```
1757
1758 The lifetime constraint `'b` for bar() implementation does not match the
1759 trait declaration. Ensure lifetime declarations match exactly in both trait
1760 declaration and implementation. Example:
1761
1762 ```
1763 trait Trait {
1764     fn t<'a,'b:'a>(x: &'a str, y: &'b str);
1765 }
1766
1767 struct Foo;
1768
1769 impl Trait for Foo {
1770     fn t<'a,'b:'a>(x: &'a str, y: &'b str) { // ok!
1771     }
1772 }
1773 ```
1774 "##,
1775
1776 E0199: r##"
1777 Safe traits should not have unsafe implementations, therefore marking an
1778 implementation for a safe trait unsafe will cause a compiler error. Removing
1779 the unsafe marker on the trait noted in the error will resolve this problem.
1780
1781 ```compile_fail,E0199
1782 struct Foo;
1783
1784 trait Bar { }
1785
1786 // this won't compile because Bar is safe
1787 unsafe impl Bar for Foo { }
1788 // this will compile
1789 impl Bar for Foo { }
1790 ```
1791 "##,
1792
1793 E0200: r##"
1794 Unsafe traits must have unsafe implementations. This error occurs when an
1795 implementation for an unsafe trait isn't marked as unsafe. This may be resolved
1796 by marking the unsafe implementation as unsafe.
1797
1798 ```compile_fail,E0200
1799 struct Foo;
1800
1801 unsafe trait Bar { }
1802
1803 // this won't compile because Bar is unsafe and impl isn't unsafe
1804 impl Bar for Foo { }
1805 // this will compile
1806 unsafe impl Bar for Foo { }
1807 ```
1808 "##,
1809
1810 E0201: r##"
1811 It is an error to define two associated items (like methods, associated types,
1812 associated functions, etc.) with the same identifier.
1813
1814 For example:
1815
1816 ```compile_fail,E0201
1817 struct Foo(u8);
1818
1819 impl Foo {
1820     fn bar(&self) -> bool { self.0 > 5 }
1821     fn bar() {} // error: duplicate associated function
1822 }
1823
1824 trait Baz {
1825     type Quux;
1826     fn baz(&self) -> bool;
1827 }
1828
1829 impl Baz for Foo {
1830     type Quux = u32;
1831
1832     fn baz(&self) -> bool { true }
1833
1834     // error: duplicate method
1835     fn baz(&self) -> bool { self.0 > 5 }
1836
1837     // error: duplicate associated type
1838     type Quux = u32;
1839 }
1840 ```
1841
1842 Note, however, that items with the same name are allowed for inherent `impl`
1843 blocks that don't overlap:
1844
1845 ```
1846 struct Foo<T>(T);
1847
1848 impl Foo<u8> {
1849     fn bar(&self) -> bool { self.0 > 5 }
1850 }
1851
1852 impl Foo<bool> {
1853     fn bar(&self) -> bool { self.0 }
1854 }
1855 ```
1856 "##,
1857
1858 E0202: r##"
1859 Inherent associated types were part of [RFC 195] but are not yet implemented.
1860 See [the tracking issue][iss8995] for the status of this implementation.
1861
1862 [RFC 195]: https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-items.md
1863 [iss8995]: https://github.com/rust-lang/rust/issues/8995
1864 "##,
1865
1866 E0204: r##"
1867 An attempt to implement the `Copy` trait for a struct failed because one of the
1868 fields does not implement `Copy`. To fix this, you must implement `Copy` for the
1869 mentioned field. Note that this may not be possible, as in the example of
1870
1871 ```compile_fail,E0204
1872 struct Foo {
1873     foo : Vec<u32>,
1874 }
1875
1876 impl Copy for Foo { }
1877 ```
1878
1879 This fails because `Vec<T>` does not implement `Copy` for any `T`.
1880
1881 Here's another example that will fail:
1882
1883 ```compile_fail,E0204
1884 #[derive(Copy)]
1885 struct Foo<'a> {
1886     ty: &'a mut bool,
1887 }
1888 ```
1889
1890 This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
1891 differs from the behavior for `&T`, which is always `Copy`).
1892 "##,
1893
1894 /*
1895 E0205: r##"
1896 An attempt to implement the `Copy` trait for an enum failed because one of the
1897 variants does not implement `Copy`. To fix this, you must implement `Copy` for
1898 the mentioned variant. Note that this may not be possible, as in the example of
1899
1900 ```compile_fail,E0205
1901 enum Foo {
1902     Bar(Vec<u32>),
1903     Baz,
1904 }
1905
1906 impl Copy for Foo { }
1907 ```
1908
1909 This fails because `Vec<T>` does not implement `Copy` for any `T`.
1910
1911 Here's another example that will fail:
1912
1913 ```compile_fail,E0205
1914 #[derive(Copy)]
1915 enum Foo<'a> {
1916     Bar(&'a mut bool),
1917     Baz,
1918 }
1919 ```
1920
1921 This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
1922 differs from the behavior for `&T`, which is always `Copy`).
1923 "##,
1924 */
1925
1926 E0206: r##"
1927 You can only implement `Copy` for a struct or enum. Both of the following
1928 examples will fail, because neither `[u8; 256]` nor `&'static mut Bar`
1929 (mutable reference to `Bar`) is a struct or enum:
1930
1931 ```compile_fail,E0206
1932 type Foo = [u8; 256];
1933 impl Copy for Foo { } // error
1934
1935 #[derive(Copy, Clone)]
1936 struct Bar;
1937 impl Copy for &'static mut Bar { } // error
1938 ```
1939 "##,
1940
1941 E0207: r##"
1942 Any type parameter or lifetime parameter of an `impl` must meet at least one of
1943 the following criteria:
1944
1945  - it appears in the _implementing type_ of the impl, e.g. `impl<T> Foo<T>`
1946  - for a trait impl, it appears in the _implemented trait_, e.g.
1947    `impl<T> SomeTrait<T> for Foo`
1948  - it is bound as an associated type, e.g. `impl<T, U> SomeTrait for T
1949    where T: AnotherTrait<AssocType=U>`
1950
1951 ### Error example 1
1952
1953 Suppose we have a struct `Foo` and we would like to define some methods for it.
1954 The following definition leads to a compiler error:
1955
1956 ```compile_fail,E0207
1957 struct Foo;
1958
1959 impl<T: Default> Foo {
1960 // error: the type parameter `T` is not constrained by the impl trait, self
1961 // type, or predicates [E0207]
1962     fn get(&self) -> T {
1963         <T as Default>::default()
1964     }
1965 }
1966 ```
1967
1968 The problem is that the parameter `T` does not appear in the implementing type
1969 (`Foo`) of the impl. In this case, we can fix the error by moving the type
1970 parameter from the `impl` to the method `get`:
1971
1972
1973 ```
1974 struct Foo;
1975
1976 // Move the type parameter from the impl to the method
1977 impl Foo {
1978     fn get<T: Default>(&self) -> T {
1979         <T as Default>::default()
1980     }
1981 }
1982 ```
1983
1984 ### Error example 2
1985
1986 As another example, suppose we have a `Maker` trait and want to establish a
1987 type `FooMaker` that makes `Foo`s:
1988
1989 ```compile_fail,E0207
1990 trait Maker {
1991     type Item;
1992     fn make(&mut self) -> Self::Item;
1993 }
1994
1995 struct Foo<T> {
1996     foo: T
1997 }
1998
1999 struct FooMaker;
2000
2001 impl<T: Default> Maker for FooMaker {
2002 // error: the type parameter `T` is not constrained by the impl trait, self
2003 // type, or predicates [E0207]
2004     type Item = Foo<T>;
2005
2006     fn make(&mut self) -> Foo<T> {
2007         Foo { foo: <T as Default>::default() }
2008     }
2009 }
2010 ```
2011
2012 This fails to compile because `T` does not appear in the trait or in the
2013 implementing type.
2014
2015 One way to work around this is to introduce a phantom type parameter into
2016 `FooMaker`, like so:
2017
2018 ```
2019 use std::marker::PhantomData;
2020
2021 trait Maker {
2022     type Item;
2023     fn make(&mut self) -> Self::Item;
2024 }
2025
2026 struct Foo<T> {
2027     foo: T
2028 }
2029
2030 // Add a type parameter to `FooMaker`
2031 struct FooMaker<T> {
2032     phantom: PhantomData<T>,
2033 }
2034
2035 impl<T: Default> Maker for FooMaker<T> {
2036     type Item = Foo<T>;
2037
2038     fn make(&mut self) -> Foo<T> {
2039         Foo {
2040             foo: <T as Default>::default(),
2041         }
2042     }
2043 }
2044 ```
2045
2046 Another way is to do away with the associated type in `Maker` and use an input
2047 type parameter instead:
2048
2049 ```
2050 // Use a type parameter instead of an associated type here
2051 trait Maker<Item> {
2052     fn make(&mut self) -> Item;
2053 }
2054
2055 struct Foo<T> {
2056     foo: T
2057 }
2058
2059 struct FooMaker;
2060
2061 impl<T: Default> Maker<Foo<T>> for FooMaker {
2062     fn make(&mut self) -> Foo<T> {
2063         Foo { foo: <T as Default>::default() }
2064     }
2065 }
2066 ```
2067
2068 ### Additional information
2069
2070 For more information, please see [RFC 447].
2071
2072 [RFC 447]: https://github.com/rust-lang/rfcs/blob/master/text/0447-no-unused-impl-parameters.md
2073 "##,
2074
2075 E0210: r##"
2076 This error indicates a violation of one of Rust's orphan rules for trait
2077 implementations. The rule concerns the use of type parameters in an
2078 implementation of a foreign trait (a trait defined in another crate), and
2079 states that type parameters must be "covered" by a local type. To understand
2080 what this means, it is perhaps easiest to consider a few examples.
2081
2082 If `ForeignTrait` is a trait defined in some external crate `foo`, then the
2083 following trait `impl` is an error:
2084
2085 ```compile_fail,E0210
2086 # #[cfg(for_demonstration_only)]
2087 extern crate foo;
2088 # #[cfg(for_demonstration_only)]
2089 use foo::ForeignTrait;
2090 # use std::panic::UnwindSafe as ForeignTrait;
2091
2092 impl<T> ForeignTrait for T { } // error
2093 # fn main() {}
2094 ```
2095
2096 To work around this, it can be covered with a local type, `MyType`:
2097
2098 ```
2099 # use std::panic::UnwindSafe as ForeignTrait;
2100 struct MyType<T>(T);
2101 impl<T> ForeignTrait for MyType<T> { } // Ok
2102 ```
2103
2104 Please note that a type alias is not sufficient.
2105
2106 For another example of an error, suppose there's another trait defined in `foo`
2107 named `ForeignTrait2` that takes two type parameters. Then this `impl` results
2108 in the same rule violation:
2109
2110 ```ignore (cannot-doctest-multicrate-project)
2111 struct MyType2;
2112 impl<T> ForeignTrait2<T, MyType<T>> for MyType2 { } // error
2113 ```
2114
2115 The reason for this is that there are two appearances of type parameter `T` in
2116 the `impl` header, both as parameters for `ForeignTrait2`. The first appearance
2117 is uncovered, and so runs afoul of the orphan rule.
2118
2119 Consider one more example:
2120
2121 ```ignore (cannot-doctest-multicrate-project)
2122 impl<T> ForeignTrait2<MyType<T>, T> for MyType2 { } // Ok
2123 ```
2124
2125 This only differs from the previous `impl` in that the parameters `T` and
2126 `MyType<T>` for `ForeignTrait2` have been swapped. This example does *not*
2127 violate the orphan rule; it is permitted.
2128
2129 To see why that last example was allowed, you need to understand the general
2130 rule. Unfortunately this rule is a bit tricky to state. Consider an `impl`:
2131
2132 ```ignore (only-for-syntax-highlight)
2133 impl<P1, ..., Pm> ForeignTrait<T1, ..., Tn> for T0 { ... }
2134 ```
2135
2136 where `P1, ..., Pm` are the type parameters of the `impl` and `T0, ..., Tn`
2137 are types. One of the types `T0, ..., Tn` must be a local type (this is another
2138 orphan rule, see the explanation for E0117). Let `i` be the smallest integer
2139 such that `Ti` is a local type. Then no type parameter can appear in any of the
2140 `Tj` for `j < i`.
2141
2142 For information on the design of the orphan rules, see [RFC 1023].
2143
2144 [RFC 1023]: https://github.com/rust-lang/rfcs/blob/master/text/1023-rebalancing-coherence.md
2145 "##,
2146
2147 /*
2148 E0211: r##"
2149 You used a function or type which doesn't fit the requirements for where it was
2150 used. Erroneous code examples:
2151
2152 ```compile_fail
2153 #![feature(intrinsics)]
2154
2155 extern "rust-intrinsic" {
2156     fn size_of<T>(); // error: intrinsic has wrong type
2157 }
2158
2159 // or:
2160
2161 fn main() -> i32 { 0 }
2162 // error: main function expects type: `fn() {main}`: expected (), found i32
2163
2164 // or:
2165
2166 let x = 1u8;
2167 match x {
2168     0u8..=3i8 => (),
2169     // error: mismatched types in range: expected u8, found i8
2170     _ => ()
2171 }
2172
2173 // or:
2174
2175 use std::rc::Rc;
2176 struct Foo;
2177
2178 impl Foo {
2179     fn x(self: Rc<Foo>) {}
2180     // error: mismatched self type: expected `Foo`: expected struct
2181     //        `Foo`, found struct `alloc::rc::Rc`
2182 }
2183 ```
2184
2185 For the first code example, please check the function definition. Example:
2186
2187 ```
2188 #![feature(intrinsics)]
2189
2190 extern "rust-intrinsic" {
2191     fn size_of<T>() -> usize; // ok!
2192 }
2193 ```
2194
2195 The second case example is a bit particular : the main function must always
2196 have this definition:
2197
2198 ```compile_fail
2199 fn main();
2200 ```
2201
2202 They never take parameters and never return types.
2203
2204 For the third example, when you match, all patterns must have the same type
2205 as the type you're matching on. Example:
2206
2207 ```
2208 let x = 1u8;
2209
2210 match x {
2211     0u8..=3u8 => (), // ok!
2212     _ => ()
2213 }
2214 ```
2215
2216 And finally, for the last example, only `Box<Self>`, `&Self`, `Self`,
2217 or `&mut Self` work as explicit self parameters. Example:
2218
2219 ```
2220 struct Foo;
2221
2222 impl Foo {
2223     fn x(self: Box<Foo>) {} // ok!
2224 }
2225 ```
2226 "##,
2227      */
2228
2229 E0220: r##"
2230 You used an associated type which isn't defined in the trait.
2231 Erroneous code example:
2232
2233 ```compile_fail,E0220
2234 trait T1 {
2235     type Bar;
2236 }
2237
2238 type Foo = T1<F=i32>; // error: associated type `F` not found for `T1`
2239
2240 // or:
2241
2242 trait T2 {
2243     type Bar;
2244
2245     // error: Baz is used but not declared
2246     fn return_bool(&self, _: &Self::Bar, _: &Self::Baz) -> bool;
2247 }
2248 ```
2249
2250 Make sure that you have defined the associated type in the trait body.
2251 Also, verify that you used the right trait or you didn't misspell the
2252 associated type name. Example:
2253
2254 ```
2255 trait T1 {
2256     type Bar;
2257 }
2258
2259 type Foo = T1<Bar=i32>; // ok!
2260
2261 // or:
2262
2263 trait T2 {
2264     type Bar;
2265     type Baz; // we declare `Baz` in our trait.
2266
2267     // and now we can use it here:
2268     fn return_bool(&self, _: &Self::Bar, _: &Self::Baz) -> bool;
2269 }
2270 ```
2271 "##,
2272
2273 E0221: r##"
2274 An attempt was made to retrieve an associated type, but the type was ambiguous.
2275 For example:
2276
2277 ```compile_fail,E0221
2278 trait T1 {}
2279 trait T2 {}
2280
2281 trait Foo {
2282     type A: T1;
2283 }
2284
2285 trait Bar : Foo {
2286     type A: T2;
2287     fn do_something() {
2288         let _: Self::A;
2289     }
2290 }
2291 ```
2292
2293 In this example, `Foo` defines an associated type `A`. `Bar` inherits that type
2294 from `Foo`, and defines another associated type of the same name. As a result,
2295 when we attempt to use `Self::A`, it's ambiguous whether we mean the `A` defined
2296 by `Foo` or the one defined by `Bar`.
2297
2298 There are two options to work around this issue. The first is simply to rename
2299 one of the types. Alternatively, one can specify the intended type using the
2300 following syntax:
2301
2302 ```
2303 trait T1 {}
2304 trait T2 {}
2305
2306 trait Foo {
2307     type A: T1;
2308 }
2309
2310 trait Bar : Foo {
2311     type A: T2;
2312     fn do_something() {
2313         let _: <Self as Bar>::A;
2314     }
2315 }
2316 ```
2317 "##,
2318
2319 E0223: r##"
2320 An attempt was made to retrieve an associated type, but the type was ambiguous.
2321 For example:
2322
2323 ```compile_fail,E0223
2324 trait MyTrait {type X; }
2325
2326 fn main() {
2327     let foo: MyTrait::X;
2328 }
2329 ```
2330
2331 The problem here is that we're attempting to take the type of X from MyTrait.
2332 Unfortunately, the type of X is not defined, because it's only made concrete in
2333 implementations of the trait. A working version of this code might look like:
2334
2335 ```
2336 trait MyTrait {type X; }
2337 struct MyStruct;
2338
2339 impl MyTrait for MyStruct {
2340     type X = u32;
2341 }
2342
2343 fn main() {
2344     let foo: <MyStruct as MyTrait>::X;
2345 }
2346 ```
2347
2348 This syntax specifies that we want the X type from MyTrait, as made concrete in
2349 MyStruct. The reason that we cannot simply use `MyStruct::X` is that MyStruct
2350 might implement two different traits with identically-named associated types.
2351 This syntax allows disambiguation between the two.
2352 "##,
2353
2354 E0225: r##"
2355 You attempted to use multiple types as bounds for a closure or trait object.
2356 Rust does not currently support this. A simple example that causes this error:
2357
2358 ```compile_fail,E0225
2359 fn main() {
2360     let _: Box<dyn std::io::Read + std::io::Write>;
2361 }
2362 ```
2363
2364 Auto traits such as Send and Sync are an exception to this rule:
2365 It's possible to have bounds of one non-builtin trait, plus any number of
2366 auto traits. For example, the following compiles correctly:
2367
2368 ```
2369 fn main() {
2370     let _: Box<dyn std::io::Read + Send + Sync>;
2371 }
2372 ```
2373 "##,
2374
2375 E0229: r##"
2376 An associated type binding was done outside of the type parameter declaration
2377 and `where` clause. Erroneous code example:
2378
2379 ```compile_fail,E0229
2380 pub trait Foo {
2381     type A;
2382     fn boo(&self) -> <Self as Foo>::A;
2383 }
2384
2385 struct Bar;
2386
2387 impl Foo for isize {
2388     type A = usize;
2389     fn boo(&self) -> usize { 42 }
2390 }
2391
2392 fn baz<I>(x: &<I as Foo<A=Bar>>::A) {}
2393 // error: associated type bindings are not allowed here
2394 ```
2395
2396 To solve this error, please move the type bindings in the type parameter
2397 declaration:
2398
2399 ```
2400 # struct Bar;
2401 # trait Foo { type A; }
2402 fn baz<I: Foo<A=Bar>>(x: &<I as Foo>::A) {} // ok!
2403 ```
2404
2405 Or in the `where` clause:
2406
2407 ```
2408 # struct Bar;
2409 # trait Foo { type A; }
2410 fn baz<I>(x: &<I as Foo>::A) where I: Foo<A=Bar> {}
2411 ```
2412 "##,
2413
2414 E0243: r##"
2415 #### Note: this error code is no longer emitted by the compiler.
2416
2417 This error indicates that not enough type parameters were found in a type or
2418 trait.
2419
2420 For example, the `Foo` struct below is defined to be generic in `T`, but the
2421 type parameter is missing in the definition of `Bar`:
2422
2423 ```compile_fail,E0107
2424 struct Foo<T> { x: T }
2425
2426 struct Bar { x: Foo }
2427 ```
2428 "##,
2429
2430 E0244: r##"
2431 #### Note: this error code is no longer emitted by the compiler.
2432
2433 This error indicates that too many type parameters were found in a type or
2434 trait.
2435
2436 For example, the `Foo` struct below has no type parameters, but is supplied
2437 with two in the definition of `Bar`:
2438
2439 ```compile_fail,E0107
2440 struct Foo { x: bool }
2441
2442 struct Bar<S, T> { x: Foo<S, T> }
2443 ```
2444 "##,
2445
2446 E0321: r##"
2447 A cross-crate opt-out trait was implemented on something which wasn't a struct
2448 or enum type. Erroneous code example:
2449
2450 ```compile_fail,E0321
2451 #![feature(optin_builtin_traits)]
2452
2453 struct Foo;
2454
2455 impl !Sync for Foo {}
2456
2457 unsafe impl Send for &'static Foo {}
2458 // error: cross-crate traits with a default impl, like `core::marker::Send`,
2459 //        can only be implemented for a struct/enum type, not
2460 //        `&'static Foo`
2461 ```
2462
2463 Only structs and enums are permitted to impl Send, Sync, and other opt-out
2464 trait, and the struct or enum must be local to the current crate. So, for
2465 example, `unsafe impl Send for Rc<Foo>` is not allowed.
2466 "##,
2467
2468 E0322: r##"
2469 The `Sized` trait is a special trait built-in to the compiler for types with a
2470 constant size known at compile-time. This trait is automatically implemented
2471 for types as needed by the compiler, and it is currently disallowed to
2472 explicitly implement it for a type.
2473 "##,
2474
2475 E0323: r##"
2476 An associated const was implemented when another trait item was expected.
2477 Erroneous code example:
2478
2479 ```compile_fail,E0323
2480 trait Foo {
2481     type N;
2482 }
2483
2484 struct Bar;
2485
2486 impl Foo for Bar {
2487     const N : u32 = 0;
2488     // error: item `N` is an associated const, which doesn't match its
2489     //        trait `<Bar as Foo>`
2490 }
2491 ```
2492
2493 Please verify that the associated const wasn't misspelled and the correct trait
2494 was implemented. Example:
2495
2496 ```
2497 struct Bar;
2498
2499 trait Foo {
2500     type N;
2501 }
2502
2503 impl Foo for Bar {
2504     type N = u32; // ok!
2505 }
2506 ```
2507
2508 Or:
2509
2510 ```
2511 struct Bar;
2512
2513 trait Foo {
2514     const N : u32;
2515 }
2516
2517 impl Foo for Bar {
2518     const N : u32 = 0; // ok!
2519 }
2520 ```
2521 "##,
2522
2523 E0324: r##"
2524 A method was implemented when another trait item was expected. Erroneous
2525 code example:
2526
2527 ```compile_fail,E0324
2528 struct Bar;
2529
2530 trait Foo {
2531     const N : u32;
2532
2533     fn M();
2534 }
2535
2536 impl Foo for Bar {
2537     fn N() {}
2538     // error: item `N` is an associated method, which doesn't match its
2539     //        trait `<Bar as Foo>`
2540 }
2541 ```
2542
2543 To fix this error, please verify that the method name wasn't misspelled and
2544 verify that you are indeed implementing the correct trait items. Example:
2545
2546 ```
2547 struct Bar;
2548
2549 trait Foo {
2550     const N : u32;
2551
2552     fn M();
2553 }
2554
2555 impl Foo for Bar {
2556     const N : u32 = 0;
2557
2558     fn M() {} // ok!
2559 }
2560 ```
2561 "##,
2562
2563 E0325: r##"
2564 An associated type was implemented when another trait item was expected.
2565 Erroneous code example:
2566
2567 ```compile_fail,E0325
2568 struct Bar;
2569
2570 trait Foo {
2571     const N : u32;
2572 }
2573
2574 impl Foo for Bar {
2575     type N = u32;
2576     // error: item `N` is an associated type, which doesn't match its
2577     //        trait `<Bar as Foo>`
2578 }
2579 ```
2580
2581 Please verify that the associated type name wasn't misspelled and your
2582 implementation corresponds to the trait definition. Example:
2583
2584 ```
2585 struct Bar;
2586
2587 trait Foo {
2588     type N;
2589 }
2590
2591 impl Foo for Bar {
2592     type N = u32; // ok!
2593 }
2594 ```
2595
2596 Or:
2597
2598 ```
2599 struct Bar;
2600
2601 trait Foo {
2602     const N : u32;
2603 }
2604
2605 impl Foo for Bar {
2606     const N : u32 = 0; // ok!
2607 }
2608 ```
2609 "##,
2610
2611 E0326: r##"
2612 The types of any associated constants in a trait implementation must match the
2613 types in the trait definition. This error indicates that there was a mismatch.
2614
2615 Here's an example of this error:
2616
2617 ```compile_fail,E0326
2618 trait Foo {
2619     const BAR: bool;
2620 }
2621
2622 struct Bar;
2623
2624 impl Foo for Bar {
2625     const BAR: u32 = 5; // error, expected bool, found u32
2626 }
2627 ```
2628 "##,
2629
2630 E0328: r##"
2631 The Unsize trait should not be implemented directly. All implementations of
2632 Unsize are provided automatically by the compiler.
2633
2634 Erroneous code example:
2635
2636 ```compile_fail,E0328
2637 #![feature(unsize)]
2638
2639 use std::marker::Unsize;
2640
2641 pub struct MyType;
2642
2643 impl<T> Unsize<T> for MyType {}
2644 ```
2645
2646 If you are defining your own smart pointer type and would like to enable
2647 conversion from a sized to an unsized type with the
2648 [DST coercion system][RFC 982], use [`CoerceUnsized`] instead.
2649
2650 ```
2651 #![feature(coerce_unsized)]
2652
2653 use std::ops::CoerceUnsized;
2654
2655 pub struct MyType<T: ?Sized> {
2656     field_with_unsized_type: T,
2657 }
2658
2659 impl<T, U> CoerceUnsized<MyType<U>> for MyType<T>
2660     where T: CoerceUnsized<U> {}
2661 ```
2662
2663 [RFC 982]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
2664 [`CoerceUnsized`]: https://doc.rust-lang.org/std/ops/trait.CoerceUnsized.html
2665 "##,
2666
2667 /*
2668 // Associated consts can now be accessed through generic type parameters, and
2669 // this error is no longer emitted.
2670 //
2671 // FIXME: consider whether to leave it in the error index, or remove it entirely
2672 //        as associated consts is not stabilized yet.
2673
2674 E0329: r##"
2675 An attempt was made to access an associated constant through either a generic
2676 type parameter or `Self`. This is not supported yet. An example causing this
2677 error is shown below:
2678
2679 ```
2680 trait Foo {
2681     const BAR: f64;
2682 }
2683
2684 struct MyStruct;
2685
2686 impl Foo for MyStruct {
2687     const BAR: f64 = 0f64;
2688 }
2689
2690 fn get_bar_bad<F: Foo>(t: F) -> f64 {
2691     F::BAR
2692 }
2693 ```
2694
2695 Currently, the value of `BAR` for a particular type can only be accessed
2696 through a concrete type, as shown below:
2697
2698 ```
2699 trait Foo {
2700     const BAR: f64;
2701 }
2702
2703 struct MyStruct;
2704
2705 fn get_bar_good() -> f64 {
2706     <MyStruct as Foo>::BAR
2707 }
2708 ```
2709 "##,
2710 */
2711
2712 E0366: r##"
2713 An attempt was made to implement `Drop` on a concrete specialization of a
2714 generic type. An example is shown below:
2715
2716 ```compile_fail,E0366
2717 struct Foo<T> {
2718     t: T
2719 }
2720
2721 impl Drop for Foo<u32> {
2722     fn drop(&mut self) {}
2723 }
2724 ```
2725
2726 This code is not legal: it is not possible to specialize `Drop` to a subset of
2727 implementations of a generic type. One workaround for this is to wrap the
2728 generic type, as shown below:
2729
2730 ```
2731 struct Foo<T> {
2732     t: T
2733 }
2734
2735 struct Bar {
2736     t: Foo<u32>
2737 }
2738
2739 impl Drop for Bar {
2740     fn drop(&mut self) {}
2741 }
2742 ```
2743 "##,
2744
2745 E0367: r##"
2746 An attempt was made to implement `Drop` on a specialization of a generic type.
2747 An example is shown below:
2748
2749 ```compile_fail,E0367
2750 trait Foo{}
2751
2752 struct MyStruct<T> {
2753     t: T
2754 }
2755
2756 impl<T: Foo> Drop for MyStruct<T> {
2757     fn drop(&mut self) {}
2758 }
2759 ```
2760
2761 This code is not legal: it is not possible to specialize `Drop` to a subset of
2762 implementations of a generic type. In order for this code to work, `MyStruct`
2763 must also require that `T` implements `Foo`. Alternatively, another option is
2764 to wrap the generic type in another that specializes appropriately:
2765
2766 ```
2767 trait Foo{}
2768
2769 struct MyStruct<T> {
2770     t: T
2771 }
2772
2773 struct MyStructWrapper<T: Foo> {
2774     t: MyStruct<T>
2775 }
2776
2777 impl <T: Foo> Drop for MyStructWrapper<T> {
2778     fn drop(&mut self) {}
2779 }
2780 ```
2781 "##,
2782
2783 E0368: r##"
2784 This error indicates that a binary assignment operator like `+=` or `^=` was
2785 applied to a type that doesn't support it. For example:
2786
2787 ```compile_fail,E0368
2788 let mut x = 12f32; // error: binary operation `<<` cannot be applied to
2789                    //        type `f32`
2790
2791 x <<= 2;
2792 ```
2793
2794 To fix this error, please check that this type implements this binary
2795 operation. Example:
2796
2797 ```
2798 let mut x = 12u32; // the `u32` type does implement the `ShlAssign` trait
2799
2800 x <<= 2; // ok!
2801 ```
2802
2803 It is also possible to overload most operators for your own type by
2804 implementing the `[OP]Assign` traits from `std::ops`.
2805
2806 Another problem you might be facing is this: suppose you've overloaded the `+`
2807 operator for some type `Foo` by implementing the `std::ops::Add` trait for
2808 `Foo`, but you find that using `+=` does not work, as in this example:
2809
2810 ```compile_fail,E0368
2811 use std::ops::Add;
2812
2813 struct Foo(u32);
2814
2815 impl Add for Foo {
2816     type Output = Foo;
2817
2818     fn add(self, rhs: Foo) -> Foo {
2819         Foo(self.0 + rhs.0)
2820     }
2821 }
2822
2823 fn main() {
2824     let mut x: Foo = Foo(5);
2825     x += Foo(7); // error, `+= cannot be applied to the type `Foo`
2826 }
2827 ```
2828
2829 This is because `AddAssign` is not automatically implemented, so you need to
2830 manually implement it for your type.
2831 "##,
2832
2833 E0369: r##"
2834 A binary operation was attempted on a type which doesn't support it.
2835 Erroneous code example:
2836
2837 ```compile_fail,E0369
2838 let x = 12f32; // error: binary operation `<<` cannot be applied to
2839                //        type `f32`
2840
2841 x << 2;
2842 ```
2843
2844 To fix this error, please check that this type implements this binary
2845 operation. Example:
2846
2847 ```
2848 let x = 12u32; // the `u32` type does implement it:
2849                // https://doc.rust-lang.org/stable/std/ops/trait.Shl.html
2850
2851 x << 2; // ok!
2852 ```
2853
2854 It is also possible to overload most operators for your own type by
2855 implementing traits from `std::ops`.
2856
2857 String concatenation appends the string on the right to the string on the
2858 left and may require reallocation. This requires ownership of the string
2859 on the left. If something should be added to a string literal, move the
2860 literal to the heap by allocating it with `to_owned()` like in
2861 `"Your text".to_owned()`.
2862
2863 "##,
2864
2865 E0370: r##"
2866 The maximum value of an enum was reached, so it cannot be automatically
2867 set in the next enum value. Erroneous code example:
2868
2869 ```compile_fail,E0370
2870 #[repr(i64)]
2871 enum Foo {
2872     X = 0x7fffffffffffffff,
2873     Y, // error: enum discriminant overflowed on value after
2874        //        9223372036854775807: i64; set explicitly via
2875        //        Y = -9223372036854775808 if that is desired outcome
2876 }
2877 ```
2878
2879 To fix this, please set manually the next enum value or put the enum variant
2880 with the maximum value at the end of the enum. Examples:
2881
2882 ```
2883 #[repr(i64)]
2884 enum Foo {
2885     X = 0x7fffffffffffffff,
2886     Y = 0, // ok!
2887 }
2888 ```
2889
2890 Or:
2891
2892 ```
2893 #[repr(i64)]
2894 enum Foo {
2895     Y = 0, // ok!
2896     X = 0x7fffffffffffffff,
2897 }
2898 ```
2899 "##,
2900
2901 E0371: r##"
2902 When `Trait2` is a subtrait of `Trait1` (for example, when `Trait2` has a
2903 definition like `trait Trait2: Trait1 { ... }`), it is not allowed to implement
2904 `Trait1` for `Trait2`. This is because `Trait2` already implements `Trait1` by
2905 definition, so it is not useful to do this.
2906
2907 Example:
2908
2909 ```compile_fail,E0371
2910 trait Foo { fn foo(&self) { } }
2911 trait Bar: Foo { }
2912 trait Baz: Bar { }
2913
2914 impl Bar for Baz { } // error, `Baz` implements `Bar` by definition
2915 impl Foo for Baz { } // error, `Baz` implements `Bar` which implements `Foo`
2916 impl Baz for Baz { } // error, `Baz` (trivially) implements `Baz`
2917 impl Baz for Bar { } // Note: This is OK
2918 ```
2919 "##,
2920
2921 E0374: r##"
2922 A struct without a field containing an unsized type cannot implement
2923 `CoerceUnsized`. An [unsized type][1] is any type that the compiler
2924 doesn't know the length or alignment of at compile time. Any struct
2925 containing an unsized type is also unsized.
2926
2927 [1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait
2928
2929 Example of erroneous code:
2930
2931 ```compile_fail,E0374
2932 #![feature(coerce_unsized)]
2933 use std::ops::CoerceUnsized;
2934
2935 struct Foo<T: ?Sized> {
2936     a: i32,
2937 }
2938
2939 // error: Struct `Foo` has no unsized fields that need `CoerceUnsized`.
2940 impl<T, U> CoerceUnsized<Foo<U>> for Foo<T>
2941     where T: CoerceUnsized<U> {}
2942 ```
2943
2944 `CoerceUnsized` is used to coerce one struct containing an unsized type
2945 into another struct containing a different unsized type. If the struct
2946 doesn't have any fields of unsized types then you don't need explicit
2947 coercion to get the types you want. To fix this you can either
2948 not try to implement `CoerceUnsized` or you can add a field that is
2949 unsized to the struct.
2950
2951 Example:
2952
2953 ```
2954 #![feature(coerce_unsized)]
2955 use std::ops::CoerceUnsized;
2956
2957 // We don't need to impl `CoerceUnsized` here.
2958 struct Foo {
2959     a: i32,
2960 }
2961
2962 // We add the unsized type field to the struct.
2963 struct Bar<T: ?Sized> {
2964     a: i32,
2965     b: T,
2966 }
2967
2968 // The struct has an unsized field so we can implement
2969 // `CoerceUnsized` for it.
2970 impl<T, U> CoerceUnsized<Bar<U>> for Bar<T>
2971     where T: CoerceUnsized<U> {}
2972 ```
2973
2974 Note that `CoerceUnsized` is mainly used by smart pointers like `Box`, `Rc`
2975 and `Arc` to be able to mark that they can coerce unsized types that they
2976 are pointing at.
2977 "##,
2978
2979 E0375: r##"
2980 A struct with more than one field containing an unsized type cannot implement
2981 `CoerceUnsized`. This only occurs when you are trying to coerce one of the
2982 types in your struct to another type in the struct. In this case we try to
2983 impl `CoerceUnsized` from `T` to `U` which are both types that the struct
2984 takes. An [unsized type][1] is any type that the compiler doesn't know the
2985 length or alignment of at compile time. Any struct containing an unsized type
2986 is also unsized.
2987
2988 Example of erroneous code:
2989
2990 ```compile_fail,E0375
2991 #![feature(coerce_unsized)]
2992 use std::ops::CoerceUnsized;
2993
2994 struct Foo<T: ?Sized, U: ?Sized> {
2995     a: i32,
2996     b: T,
2997     c: U,
2998 }
2999
3000 // error: Struct `Foo` has more than one unsized field.
3001 impl<T, U> CoerceUnsized<Foo<U, T>> for Foo<T, U> {}
3002 ```
3003
3004 `CoerceUnsized` only allows for coercion from a structure with a single
3005 unsized type field to another struct with a single unsized type field.
3006 In fact Rust only allows for a struct to have one unsized type in a struct
3007 and that unsized type must be the last field in the struct. So having two
3008 unsized types in a single struct is not allowed by the compiler. To fix this
3009 use only one field containing an unsized type in the struct and then use
3010 multiple structs to manage each unsized type field you need.
3011
3012 Example:
3013
3014 ```
3015 #![feature(coerce_unsized)]
3016 use std::ops::CoerceUnsized;
3017
3018 struct Foo<T: ?Sized> {
3019     a: i32,
3020     b: T,
3021 }
3022
3023 impl <T, U> CoerceUnsized<Foo<U>> for Foo<T>
3024     where T: CoerceUnsized<U> {}
3025
3026 fn coerce_foo<T: CoerceUnsized<U>, U>(t: T) -> Foo<U> {
3027     Foo { a: 12i32, b: t } // we use coercion to get the `Foo<U>` type we need
3028 }
3029 ```
3030
3031 [1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait
3032 "##,
3033
3034 E0376: r##"
3035 The type you are trying to impl `CoerceUnsized` for is not a struct.
3036 `CoerceUnsized` can only be implemented for a struct. Unsized types are
3037 already able to be coerced without an implementation of `CoerceUnsized`
3038 whereas a struct containing an unsized type needs to know the unsized type
3039 field it's containing is able to be coerced. An [unsized type][1]
3040 is any type that the compiler doesn't know the length or alignment of at
3041 compile time. Any struct containing an unsized type is also unsized.
3042
3043 [1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait
3044
3045 Example of erroneous code:
3046
3047 ```compile_fail,E0376
3048 #![feature(coerce_unsized)]
3049 use std::ops::CoerceUnsized;
3050
3051 struct Foo<T: ?Sized> {
3052     a: T,
3053 }
3054
3055 // error: The type `U` is not a struct
3056 impl<T, U> CoerceUnsized<U> for Foo<T> {}
3057 ```
3058
3059 The `CoerceUnsized` trait takes a struct type. Make sure the type you are
3060 providing to `CoerceUnsized` is a struct with only the last field containing an
3061 unsized type.
3062
3063 Example:
3064
3065 ```
3066 #![feature(coerce_unsized)]
3067 use std::ops::CoerceUnsized;
3068
3069 struct Foo<T> {
3070     a: T,
3071 }
3072
3073 // The `Foo<U>` is a struct so `CoerceUnsized` can be implemented
3074 impl<T, U> CoerceUnsized<Foo<U>> for Foo<T> where T: CoerceUnsized<U> {}
3075 ```
3076
3077 Note that in Rust, structs can only contain an unsized type if the field
3078 containing the unsized type is the last and only unsized type field in the
3079 struct.
3080 "##,
3081
3082 E0378: r##"
3083 The `DispatchFromDyn` trait currently can only be implemented for
3084 builtin pointer types and structs that are newtype wrappers around them
3085 — that is, the struct must have only one field (except for`PhantomData`),
3086 and that field must itself implement `DispatchFromDyn`.
3087
3088 Examples:
3089
3090 ```
3091 #![feature(dispatch_from_dyn, unsize)]
3092 use std::{
3093     marker::Unsize,
3094     ops::DispatchFromDyn,
3095 };
3096
3097 struct Ptr<T: ?Sized>(*const T);
3098
3099 impl<T: ?Sized, U: ?Sized> DispatchFromDyn<Ptr<U>> for Ptr<T>
3100 where
3101     T: Unsize<U>,
3102 {}
3103 ```
3104
3105 ```
3106 #![feature(dispatch_from_dyn)]
3107 use std::{
3108     ops::DispatchFromDyn,
3109     marker::PhantomData,
3110 };
3111
3112 struct Wrapper<T> {
3113     ptr: T,
3114     _phantom: PhantomData<()>,
3115 }
3116
3117 impl<T, U> DispatchFromDyn<Wrapper<U>> for Wrapper<T>
3118 where
3119     T: DispatchFromDyn<U>,
3120 {}
3121 ```
3122
3123 Example of illegal `DispatchFromDyn` implementation
3124 (illegal because of extra field)
3125
3126 ```compile-fail,E0378
3127 #![feature(dispatch_from_dyn)]
3128 use std::ops::DispatchFromDyn;
3129
3130 struct WrapperExtraField<T> {
3131     ptr: T,
3132     extra_stuff: i32,
3133 }
3134
3135 impl<T, U> DispatchFromDyn<WrapperExtraField<U>> for WrapperExtraField<T>
3136 where
3137     T: DispatchFromDyn<U>,
3138 {}
3139 ```
3140 "##,
3141
3142 E0390: r##"
3143 You tried to implement methods for a primitive type. Erroneous code example:
3144
3145 ```compile_fail,E0390
3146 struct Foo {
3147     x: i32
3148 }
3149
3150 impl *mut Foo {}
3151 // error: only a single inherent implementation marked with
3152 //        `#[lang = "mut_ptr"]` is allowed for the `*mut T` primitive
3153 ```
3154
3155 This isn't allowed, but using a trait to implement a method is a good solution.
3156 Example:
3157
3158 ```
3159 struct Foo {
3160     x: i32
3161 }
3162
3163 trait Bar {
3164     fn bar();
3165 }
3166
3167 impl Bar for *mut Foo {
3168     fn bar() {} // ok!
3169 }
3170 ```
3171 "##,
3172
3173 E0392: r##"
3174 This error indicates that a type or lifetime parameter has been declared
3175 but not actually used. Here is an example that demonstrates the error:
3176
3177 ```compile_fail,E0392
3178 enum Foo<T> {
3179     Bar,
3180 }
3181 ```
3182
3183 If the type parameter was included by mistake, this error can be fixed
3184 by simply removing the type parameter, as shown below:
3185
3186 ```
3187 enum Foo {
3188     Bar,
3189 }
3190 ```
3191
3192 Alternatively, if the type parameter was intentionally inserted, it must be
3193 used. A simple fix is shown below:
3194
3195 ```
3196 enum Foo<T> {
3197     Bar(T),
3198 }
3199 ```
3200
3201 This error may also commonly be found when working with unsafe code. For
3202 example, when using raw pointers one may wish to specify the lifetime for
3203 which the pointed-at data is valid. An initial attempt (below) causes this
3204 error:
3205
3206 ```compile_fail,E0392
3207 struct Foo<'a, T> {
3208     x: *const T,
3209 }
3210 ```
3211
3212 We want to express the constraint that Foo should not outlive `'a`, because
3213 the data pointed to by `T` is only valid for that lifetime. The problem is
3214 that there are no actual uses of `'a`. It's possible to work around this
3215 by adding a PhantomData type to the struct, using it to tell the compiler
3216 to act as if the struct contained a borrowed reference `&'a T`:
3217
3218 ```
3219 use std::marker::PhantomData;
3220
3221 struct Foo<'a, T: 'a> {
3222     x: *const T,
3223     phantom: PhantomData<&'a T>
3224 }
3225 ```
3226
3227 [PhantomData] can also be used to express information about unused type
3228 parameters.
3229
3230 [PhantomData]: https://doc.rust-lang.org/std/marker/struct.PhantomData.html
3231 "##,
3232
3233 E0393: r##"
3234 A type parameter which references `Self` in its default value was not specified.
3235 Example of erroneous code:
3236
3237 ```compile_fail,E0393
3238 trait A<T=Self> {}
3239
3240 fn together_we_will_rule_the_galaxy(son: &A) {}
3241 // error: the type parameter `T` must be explicitly specified in an
3242 //        object type because its default value `Self` references the
3243 //        type `Self`
3244 ```
3245
3246 A trait object is defined over a single, fully-defined trait. With a regular
3247 default parameter, this parameter can just be substituted in. However, if the
3248 default parameter is `Self`, the trait changes for each concrete type; i.e.
3249 `i32` will be expected to implement `A<i32>`, `bool` will be expected to
3250 implement `A<bool>`, etc... These types will not share an implementation of a
3251 fully-defined trait; instead they share implementations of a trait with
3252 different parameters substituted in for each implementation. This is
3253 irreconcilable with what we need to make a trait object work, and is thus
3254 disallowed. Making the trait concrete by explicitly specifying the value of the
3255 defaulted parameter will fix this issue. Fixed example:
3256
3257 ```
3258 trait A<T=Self> {}
3259
3260 fn together_we_will_rule_the_galaxy(son: &A<i32>) {} // Ok!
3261 ```
3262 "##,
3263
3264 E0399: r##"
3265 You implemented a trait, overriding one or more of its associated types but did
3266 not reimplement its default methods.
3267
3268 Example of erroneous code:
3269
3270 ```compile_fail,E0399
3271 #![feature(associated_type_defaults)]
3272
3273 pub trait Foo {
3274     type Assoc = u8;
3275     fn bar(&self) {}
3276 }
3277
3278 impl Foo for i32 {
3279     // error - the following trait items need to be reimplemented as
3280     //         `Assoc` was overridden: `bar`
3281     type Assoc = i32;
3282 }
3283 ```
3284
3285 To fix this, add an implementation for each default method from the trait:
3286
3287 ```
3288 #![feature(associated_type_defaults)]
3289
3290 pub trait Foo {
3291     type Assoc = u8;
3292     fn bar(&self) {}
3293 }
3294
3295 impl Foo for i32 {
3296     type Assoc = i32;
3297     fn bar(&self) {} // ok!
3298 }
3299 ```
3300 "##,
3301
3302 E0436: r##"
3303 The functional record update syntax is only allowed for structs. (Struct-like
3304 enum variants don't qualify, for example.)
3305
3306 Erroneous code example:
3307
3308 ```compile_fail,E0436
3309 enum PublicationFrequency {
3310     Weekly,
3311     SemiMonthly { days: (u8, u8), annual_special: bool },
3312 }
3313
3314 fn one_up_competitor(competitor_frequency: PublicationFrequency)
3315                      -> PublicationFrequency {
3316     match competitor_frequency {
3317         PublicationFrequency::Weekly => PublicationFrequency::SemiMonthly {
3318             days: (1, 15), annual_special: false
3319         },
3320         c @ PublicationFrequency::SemiMonthly{ .. } =>
3321             PublicationFrequency::SemiMonthly {
3322                 annual_special: true, ..c // error: functional record update
3323                                           //        syntax requires a struct
3324         }
3325     }
3326 }
3327 ```
3328
3329 Rewrite the expression without functional record update syntax:
3330
3331 ```
3332 enum PublicationFrequency {
3333     Weekly,
3334     SemiMonthly { days: (u8, u8), annual_special: bool },
3335 }
3336
3337 fn one_up_competitor(competitor_frequency: PublicationFrequency)
3338                      -> PublicationFrequency {
3339     match competitor_frequency {
3340         PublicationFrequency::Weekly => PublicationFrequency::SemiMonthly {
3341             days: (1, 15), annual_special: false
3342         },
3343         PublicationFrequency::SemiMonthly{ days, .. } =>
3344             PublicationFrequency::SemiMonthly {
3345                 days, annual_special: true // ok!
3346         }
3347     }
3348 }
3349 ```
3350 "##,
3351
3352 E0439: r##"
3353 The length of the platform-intrinsic function `simd_shuffle`
3354 wasn't specified. Erroneous code example:
3355
3356 ```compile_fail,E0439
3357 #![feature(platform_intrinsics)]
3358
3359 extern "platform-intrinsic" {
3360     fn simd_shuffle<A,B>(a: A, b: A, c: [u32; 8]) -> B;
3361     // error: invalid `simd_shuffle`, needs length: `simd_shuffle`
3362 }
3363 ```
3364
3365 The `simd_shuffle` function needs the length of the array passed as
3366 last parameter in its name. Example:
3367
3368 ```
3369 #![feature(platform_intrinsics)]
3370
3371 extern "platform-intrinsic" {
3372     fn simd_shuffle8<A,B>(a: A, b: A, c: [u32; 8]) -> B;
3373 }
3374 ```
3375 "##,
3376
3377 E0516: r##"
3378 The `typeof` keyword is currently reserved but unimplemented.
3379 Erroneous code example:
3380
3381 ```compile_fail,E0516
3382 fn main() {
3383     let x: typeof(92) = 92;
3384 }
3385 ```
3386
3387 Try using type inference instead. Example:
3388
3389 ```
3390 fn main() {
3391     let x = 92;
3392 }
3393 ```
3394 "##,
3395
3396 E0520: r##"
3397 A non-default implementation was already made on this type so it cannot be
3398 specialized further. Erroneous code example:
3399
3400 ```compile_fail,E0520
3401 #![feature(specialization)]
3402
3403 trait SpaceLlama {
3404     fn fly(&self);
3405 }
3406
3407 // applies to all T
3408 impl<T> SpaceLlama for T {
3409     default fn fly(&self) {}
3410 }
3411
3412 // non-default impl
3413 // applies to all `Clone` T and overrides the previous impl
3414 impl<T: Clone> SpaceLlama for T {
3415     fn fly(&self) {}
3416 }
3417
3418 // since `i32` is clone, this conflicts with the previous implementation
3419 impl SpaceLlama for i32 {
3420     default fn fly(&self) {}
3421     // error: item `fly` is provided by an `impl` that specializes
3422     //        another, but the item in the parent `impl` is not marked
3423     //        `default` and so it cannot be specialized.
3424 }
3425 ```
3426
3427 Specialization only allows you to override `default` functions in
3428 implementations.
3429
3430 To fix this error, you need to mark all the parent implementations as default.
3431 Example:
3432
3433 ```
3434 #![feature(specialization)]
3435
3436 trait SpaceLlama {
3437     fn fly(&self);
3438 }
3439
3440 // applies to all T
3441 impl<T> SpaceLlama for T {
3442     default fn fly(&self) {} // This is a parent implementation.
3443 }
3444
3445 // applies to all `Clone` T; overrides the previous impl
3446 impl<T: Clone> SpaceLlama for T {
3447     default fn fly(&self) {} // This is a parent implementation but was
3448                              // previously not a default one, causing the error
3449 }
3450
3451 // applies to i32, overrides the previous two impls
3452 impl SpaceLlama for i32 {
3453     fn fly(&self) {} // And now that's ok!
3454 }
3455 ```
3456 "##,
3457
3458 E0527: r##"
3459 The number of elements in an array or slice pattern differed from the number of
3460 elements in the array being matched.
3461
3462 Example of erroneous code:
3463
3464 ```compile_fail,E0527
3465 let r = &[1, 2, 3, 4];
3466 match r {
3467     &[a, b] => { // error: pattern requires 2 elements but array
3468                  //        has 4
3469         println!("a={}, b={}", a, b);
3470     }
3471 }
3472 ```
3473
3474 Ensure that the pattern is consistent with the size of the matched
3475 array. Additional elements can be matched with `..`:
3476
3477 ```
3478 #![feature(slice_patterns)]
3479
3480 let r = &[1, 2, 3, 4];
3481 match r {
3482     &[a, b, ..] => { // ok!
3483         println!("a={}, b={}", a, b);
3484     }
3485 }
3486 ```
3487 "##,
3488
3489 E0528: r##"
3490 An array or slice pattern required more elements than were present in the
3491 matched array.
3492
3493 Example of erroneous code:
3494
3495 ```compile_fail,E0528
3496 #![feature(slice_patterns)]
3497
3498 let r = &[1, 2];
3499 match r {
3500     &[a, b, c, rest..] => { // error: pattern requires at least 3
3501                             //        elements but array has 2
3502         println!("a={}, b={}, c={} rest={:?}", a, b, c, rest);
3503     }
3504 }
3505 ```
3506
3507 Ensure that the matched array has at least as many elements as the pattern
3508 requires. You can match an arbitrary number of remaining elements with `..`:
3509
3510 ```
3511 #![feature(slice_patterns)]
3512
3513 let r = &[1, 2, 3, 4, 5];
3514 match r {
3515     &[a, b, c, rest..] => { // ok!
3516         // prints `a=1, b=2, c=3 rest=[4, 5]`
3517         println!("a={}, b={}, c={} rest={:?}", a, b, c, rest);
3518     }
3519 }
3520 ```
3521 "##,
3522
3523 E0529: r##"
3524 An array or slice pattern was matched against some other type.
3525
3526 Example of erroneous code:
3527
3528 ```compile_fail,E0529
3529 let r: f32 = 1.0;
3530 match r {
3531     [a, b] => { // error: expected an array or slice, found `f32`
3532         println!("a={}, b={}", a, b);
3533     }
3534 }
3535 ```
3536
3537 Ensure that the pattern and the expression being matched on are of consistent
3538 types:
3539
3540 ```
3541 let r = [1.0, 2.0];
3542 match r {
3543     [a, b] => { // ok!
3544         println!("a={}, b={}", a, b);
3545     }
3546 }
3547 ```
3548 "##,
3549
3550 E0534: r##"
3551 The `inline` attribute was malformed.
3552
3553 Erroneous code example:
3554
3555 ```ignore (compile_fail not working here; see Issue #43707)
3556 #[inline()] // error: expected one argument
3557 pub fn something() {}
3558
3559 fn main() {}
3560 ```
3561
3562 The parenthesized `inline` attribute requires the parameter to be specified:
3563
3564 ```
3565 #[inline(always)]
3566 fn something() {}
3567 ```
3568
3569 or:
3570
3571 ```
3572 #[inline(never)]
3573 fn something() {}
3574 ```
3575
3576 Alternatively, a paren-less version of the attribute may be used to hint the
3577 compiler about inlining opportunity:
3578
3579 ```
3580 #[inline]
3581 fn something() {}
3582 ```
3583
3584 For more information about the inline attribute, read:
3585 https://doc.rust-lang.org/reference.html#inline-attributes
3586 "##,
3587
3588 E0535: r##"
3589 An unknown argument was given to the `inline` attribute.
3590
3591 Erroneous code example:
3592
3593 ```ignore (compile_fail not working here; see Issue #43707)
3594 #[inline(unknown)] // error: invalid argument
3595 pub fn something() {}
3596
3597 fn main() {}
3598 ```
3599
3600 The `inline` attribute only supports two arguments:
3601
3602  * always
3603  * never
3604
3605 All other arguments given to the `inline` attribute will return this error.
3606 Example:
3607
3608 ```
3609 #[inline(never)] // ok!
3610 pub fn something() {}
3611
3612 fn main() {}
3613 ```
3614
3615 For more information about the inline attribute, https:
3616 read://doc.rust-lang.org/reference.html#inline-attributes
3617 "##,
3618
3619 E0559: r##"
3620 An unknown field was specified into an enum's structure variant.
3621
3622 Erroneous code example:
3623
3624 ```compile_fail,E0559
3625 enum Field {
3626     Fool { x: u32 },
3627 }
3628
3629 let s = Field::Fool { joke: 0 };
3630 // error: struct variant `Field::Fool` has no field named `joke`
3631 ```
3632
3633 Verify you didn't misspell the field's name or that the field exists. Example:
3634
3635 ```
3636 enum Field {
3637     Fool { joke: u32 },
3638 }
3639
3640 let s = Field::Fool { joke: 0 }; // ok!
3641 ```
3642 "##,
3643
3644 E0560: r##"
3645 An unknown field was specified into a structure.
3646
3647 Erroneous code example:
3648
3649 ```compile_fail,E0560
3650 struct Simba {
3651     mother: u32,
3652 }
3653
3654 let s = Simba { mother: 1, father: 0 };
3655 // error: structure `Simba` has no field named `father`
3656 ```
3657
3658 Verify you didn't misspell the field's name or that the field exists. Example:
3659
3660 ```
3661 struct Simba {
3662     mother: u32,
3663     father: u32,
3664 }
3665
3666 let s = Simba { mother: 1, father: 0 }; // ok!
3667 ```
3668 "##,
3669
3670 E0569: r##"
3671 If an impl has a generic parameter with the `#[may_dangle]` attribute, then
3672 that impl must be declared as an `unsafe impl.
3673
3674 Erroneous code example:
3675
3676 ```compile_fail,E0569
3677 #![feature(dropck_eyepatch)]
3678
3679 struct Foo<X>(X);
3680 impl<#[may_dangle] X> Drop for Foo<X> {
3681     fn drop(&mut self) { }
3682 }
3683 ```
3684
3685 In this example, we are asserting that the destructor for `Foo` will not
3686 access any data of type `X`, and require this assertion to be true for
3687 overall safety in our program. The compiler does not currently attempt to
3688 verify this assertion; therefore we must tag this `impl` as unsafe.
3689 "##,
3690
3691 E0570: r##"
3692 The requested ABI is unsupported by the current target.
3693
3694 The rust compiler maintains for each target a blacklist of ABIs unsupported on
3695 that target. If an ABI is present in such a list this usually means that the
3696 target / ABI combination is currently unsupported by llvm.
3697
3698 If necessary, you can circumvent this check using custom target specifications.
3699 "##,
3700
3701 E0572: r##"
3702 A return statement was found outside of a function body.
3703
3704 Erroneous code example:
3705
3706 ```compile_fail,E0572
3707 const FOO: u32 = return 0; // error: return statement outside of function body
3708
3709 fn main() {}
3710 ```
3711
3712 To fix this issue, just remove the return keyword or move the expression into a
3713 function. Example:
3714
3715 ```
3716 const FOO: u32 = 0;
3717
3718 fn some_fn() -> u32 {
3719     return FOO;
3720 }
3721
3722 fn main() {
3723     some_fn();
3724 }
3725 ```
3726 "##,
3727
3728 E0581: r##"
3729 In a `fn` type, a lifetime appears only in the return type,
3730 and not in the arguments types.
3731
3732 Erroneous code example:
3733
3734 ```compile_fail,E0581
3735 fn main() {
3736     // Here, `'a` appears only in the return type:
3737     let x: for<'a> fn() -> &'a i32;
3738 }
3739 ```
3740
3741 To fix this issue, either use the lifetime in the arguments, or use
3742 `'static`. Example:
3743
3744 ```
3745 fn main() {
3746     // Here, `'a` appears only in the return type:
3747     let x: for<'a> fn(&'a i32) -> &'a i32;
3748     let y: fn() -> &'static i32;
3749 }
3750 ```
3751
3752 Note: The examples above used to be (erroneously) accepted by the
3753 compiler, but this was since corrected. See [issue #33685] for more
3754 details.
3755
3756 [issue #33685]: https://github.com/rust-lang/rust/issues/33685
3757 "##,
3758
3759 E0582: r##"
3760 A lifetime appears only in an associated-type binding,
3761 and not in the input types to the trait.
3762
3763 Erroneous code example:
3764
3765 ```compile_fail,E0582
3766 fn bar<F>(t: F)
3767     // No type can satisfy this requirement, since `'a` does not
3768     // appear in any of the input types (here, `i32`):
3769     where F: for<'a> Fn(i32) -> Option<&'a i32>
3770 {
3771 }
3772
3773 fn main() { }
3774 ```
3775
3776 To fix this issue, either use the lifetime in the inputs, or use
3777 `'static`. Example:
3778
3779 ```
3780 fn bar<F, G>(t: F, u: G)
3781     where F: for<'a> Fn(&'a i32) -> Option<&'a i32>,
3782           G: Fn(i32) -> Option<&'static i32>,
3783 {
3784 }
3785
3786 fn main() { }
3787 ```
3788
3789 Note: The examples above used to be (erroneously) accepted by the
3790 compiler, but this was since corrected. See [issue #33685] for more
3791 details.
3792
3793 [issue #33685]: https://github.com/rust-lang/rust/issues/33685
3794 "##,
3795
3796 E0592: r##"
3797 This error occurs when you defined methods or associated functions with same
3798 name.
3799
3800 Erroneous code example:
3801
3802 ```compile_fail,E0592
3803 struct Foo;
3804
3805 impl Foo {
3806     fn bar() {} // previous definition here
3807 }
3808
3809 impl Foo {
3810     fn bar() {} // duplicate definition here
3811 }
3812 ```
3813
3814 A similar error is E0201. The difference is whether there is one declaration
3815 block or not. To avoid this error, you must give each `fn` a unique name.
3816
3817 ```
3818 struct Foo;
3819
3820 impl Foo {
3821     fn bar() {}
3822 }
3823
3824 impl Foo {
3825     fn baz() {} // define with different name
3826 }
3827 ```
3828 "##,
3829
3830 E0599: r##"
3831 This error occurs when a method is used on a type which doesn't implement it:
3832
3833 Erroneous code example:
3834
3835 ```compile_fail,E0599
3836 struct Mouth;
3837
3838 let x = Mouth;
3839 x.chocolate(); // error: no method named `chocolate` found for type `Mouth`
3840                //        in the current scope
3841 ```
3842 "##,
3843
3844 E0600: r##"
3845 An unary operator was used on a type which doesn't implement it.
3846
3847 Example of erroneous code:
3848
3849 ```compile_fail,E0600
3850 enum Question {
3851     Yes,
3852     No,
3853 }
3854
3855 !Question::Yes; // error: cannot apply unary operator `!` to type `Question`
3856 ```
3857
3858 In this case, `Question` would need to implement the `std::ops::Not` trait in
3859 order to be able to use `!` on it. Let's implement it:
3860
3861 ```
3862 use std::ops::Not;
3863
3864 enum Question {
3865     Yes,
3866     No,
3867 }
3868
3869 // We implement the `Not` trait on the enum.
3870 impl Not for Question {
3871     type Output = bool;
3872
3873     fn not(self) -> bool {
3874         match self {
3875             Question::Yes => false, // If the `Answer` is `Yes`, then it
3876                                     // returns false.
3877             Question::No => true, // And here we do the opposite.
3878         }
3879     }
3880 }
3881
3882 assert_eq!(!Question::Yes, false);
3883 assert_eq!(!Question::No, true);
3884 ```
3885 "##,
3886
3887 E0608: r##"
3888 An attempt to index into a type which doesn't implement the `std::ops::Index`
3889 trait was performed.
3890
3891 Erroneous code example:
3892
3893 ```compile_fail,E0608
3894 0u8[2]; // error: cannot index into a value of type `u8`
3895 ```
3896
3897 To be able to index into a type it needs to implement the `std::ops::Index`
3898 trait. Example:
3899
3900 ```
3901 let v: Vec<u8> = vec![0, 1, 2, 3];
3902
3903 // The `Vec` type implements the `Index` trait so you can do:
3904 println!("{}", v[2]);
3905 ```
3906 "##,
3907
3908 E0604: r##"
3909 A cast to `char` was attempted on a type other than `u8`.
3910
3911 Erroneous code example:
3912
3913 ```compile_fail,E0604
3914 0u32 as char; // error: only `u8` can be cast as `char`, not `u32`
3915 ```
3916
3917 As the error message indicates, only `u8` can be cast into `char`. Example:
3918
3919 ```
3920 let c = 86u8 as char; // ok!
3921 assert_eq!(c, 'V');
3922 ```
3923
3924 For more information about casts, take a look at the Type cast section in
3925 [The Reference Book][1].
3926
3927 [1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions
3928 "##,
3929
3930 E0605: r##"
3931 An invalid cast was attempted.
3932
3933 Erroneous code examples:
3934
3935 ```compile_fail,E0605
3936 let x = 0u8;
3937 x as Vec<u8>; // error: non-primitive cast: `u8` as `std::vec::Vec<u8>`
3938
3939 // Another example
3940
3941 let v = core::ptr::null::<u8>(); // So here, `v` is a `*const u8`.
3942 v as &u8; // error: non-primitive cast: `*const u8` as `&u8`
3943 ```
3944
3945 Only primitive types can be cast into each other. Examples:
3946
3947 ```
3948 let x = 0u8;
3949 x as u32; // ok!
3950
3951 let v = core::ptr::null::<u8>();
3952 v as *const i8; // ok!
3953 ```
3954
3955 For more information about casts, take a look at the Type cast section in
3956 [The Reference Book][1].
3957
3958 [1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions
3959 "##,
3960
3961 E0606: r##"
3962 An incompatible cast was attempted.
3963
3964 Erroneous code example:
3965
3966 ```compile_fail,E0606
3967 let x = &0u8; // Here, `x` is a `&u8`.
3968 let y: u32 = x as u32; // error: casting `&u8` as `u32` is invalid
3969 ```
3970
3971 When casting, keep in mind that only primitive types can be cast into each
3972 other. Example:
3973
3974 ```
3975 let x = &0u8;
3976 let y: u32 = *x as u32; // We dereference it first and then cast it.
3977 ```
3978
3979 For more information about casts, take a look at the Type cast section in
3980 [The Reference Book][1].
3981
3982 [1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions
3983 "##,
3984
3985 E0607: r##"
3986 A cast between a thin and a fat pointer was attempted.
3987
3988 Erroneous code example:
3989
3990 ```compile_fail,E0607
3991 let v = core::ptr::null::<u8>();
3992 v as *const [u8];
3993 ```
3994
3995 First: what are thin and fat pointers?
3996
3997 Thin pointers are "simple" pointers: they are purely a reference to a memory
3998 address.
3999
4000 Fat pointers are pointers referencing Dynamically Sized Types (also called DST).
4001 DST don't have a statically known size, therefore they can only exist behind
4002 some kind of pointers that contain additional information. Slices and trait
4003 objects are DSTs. In the case of slices, the additional information the fat
4004 pointer holds is their size.
4005
4006 To fix this error, don't try to cast directly between thin and fat pointers.
4007
4008 For more information about casts, take a look at the Type cast section in
4009 [The Reference Book][1].
4010
4011 [1]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions
4012 "##,
4013
4014 E0609: r##"
4015 Attempted to access a non-existent field in a struct.
4016
4017 Erroneous code example:
4018
4019 ```compile_fail,E0609
4020 struct StructWithFields {
4021     x: u32,
4022 }
4023
4024 let s = StructWithFields { x: 0 };
4025 println!("{}", s.foo); // error: no field `foo` on type `StructWithFields`
4026 ```
4027
4028 To fix this error, check that you didn't misspell the field's name or that the
4029 field actually exists. Example:
4030
4031 ```
4032 struct StructWithFields {
4033     x: u32,
4034 }
4035
4036 let s = StructWithFields { x: 0 };
4037 println!("{}", s.x); // ok!
4038 ```
4039 "##,
4040
4041 E0610: r##"
4042 Attempted to access a field on a primitive type.
4043
4044 Erroneous code example:
4045
4046 ```compile_fail,E0610
4047 let x: u32 = 0;
4048 println!("{}", x.foo); // error: `{integer}` is a primitive type, therefore
4049                        //        doesn't have fields
4050 ```
4051
4052 Primitive types are the most basic types available in Rust and don't have
4053 fields. To access data via named fields, struct types are used. Example:
4054
4055 ```
4056 // We declare struct called `Foo` containing two fields:
4057 struct Foo {
4058     x: u32,
4059     y: i64,
4060 }
4061
4062 // We create an instance of this struct:
4063 let variable = Foo { x: 0, y: -12 };
4064 // And we can now access its fields:
4065 println!("x: {}, y: {}", variable.x, variable.y);
4066 ```
4067
4068 For more information about primitives and structs, take a look at The Book:
4069 https://doc.rust-lang.org/book/ch03-02-data-types.html
4070 https://doc.rust-lang.org/book/ch05-00-structs.html
4071 "##,
4072
4073 E0614: r##"
4074 Attempted to dereference a variable which cannot be dereferenced.
4075
4076 Erroneous code example:
4077
4078 ```compile_fail,E0614
4079 let y = 0u32;
4080 *y; // error: type `u32` cannot be dereferenced
4081 ```
4082
4083 Only types implementing `std::ops::Deref` can be dereferenced (such as `&T`).
4084 Example:
4085
4086 ```
4087 let y = 0u32;
4088 let x = &y;
4089 // So here, `x` is a `&u32`, so we can dereference it:
4090 *x; // ok!
4091 ```
4092 "##,
4093
4094 E0615: r##"
4095 Attempted to access a method like a field.
4096
4097 Erroneous code example:
4098
4099 ```compile_fail,E0615
4100 struct Foo {
4101     x: u32,
4102 }
4103
4104 impl Foo {
4105     fn method(&self) {}
4106 }
4107
4108 let f = Foo { x: 0 };
4109 f.method; // error: attempted to take value of method `method` on type `Foo`
4110 ```
4111
4112 If you want to use a method, add `()` after it:
4113
4114 ```
4115 # struct Foo { x: u32 }
4116 # impl Foo { fn method(&self) {} }
4117 # let f = Foo { x: 0 };
4118 f.method();
4119 ```
4120
4121 However, if you wanted to access a field of a struct check that the field name
4122 is spelled correctly. Example:
4123
4124 ```
4125 # struct Foo { x: u32 }
4126 # impl Foo { fn method(&self) {} }
4127 # let f = Foo { x: 0 };
4128 println!("{}", f.x);
4129 ```
4130 "##,
4131
4132 E0616: r##"
4133 Attempted to access a private field on a struct.
4134
4135 Erroneous code example:
4136
4137 ```compile_fail,E0616
4138 mod some_module {
4139     pub struct Foo {
4140         x: u32, // So `x` is private in here.
4141     }
4142
4143     impl Foo {
4144         pub fn new() -> Foo { Foo { x: 0 } }
4145     }
4146 }
4147
4148 let f = some_module::Foo::new();
4149 println!("{}", f.x); // error: field `x` of struct `some_module::Foo` is private
4150 ```
4151
4152 If you want to access this field, you have two options:
4153
4154 1) Set the field public:
4155
4156 ```
4157 mod some_module {
4158     pub struct Foo {
4159         pub x: u32, // `x` is now public.
4160     }
4161
4162     impl Foo {
4163         pub fn new() -> Foo { Foo { x: 0 } }
4164     }
4165 }
4166
4167 let f = some_module::Foo::new();
4168 println!("{}", f.x); // ok!
4169 ```
4170
4171 2) Add a getter function:
4172
4173 ```
4174 mod some_module {
4175     pub struct Foo {
4176         x: u32, // So `x` is still private in here.
4177     }
4178
4179     impl Foo {
4180         pub fn new() -> Foo { Foo { x: 0 } }
4181
4182         // We create the getter function here:
4183         pub fn get_x(&self) -> &u32 { &self.x }
4184     }
4185 }
4186
4187 let f = some_module::Foo::new();
4188 println!("{}", f.get_x()); // ok!
4189 ```
4190 "##,
4191
4192 E0617: r##"
4193 Attempted to pass an invalid type of variable into a variadic function.
4194
4195 Erroneous code example:
4196
4197 ```compile_fail,E0617
4198 extern {
4199     fn printf(c: *const i8, ...);
4200 }
4201
4202 unsafe {
4203     printf(::std::ptr::null(), 0f32);
4204     // error: can't pass an `f32` to variadic function, cast to `c_double`
4205 }
4206 ```
4207
4208 Certain Rust types must be cast before passing them to a variadic function,
4209 because of arcane ABI rules dictated by the C standard. To fix the error,
4210 cast the value to the type specified by the error message (which you may need
4211 to import from `std::os::raw`).
4212 "##,
4213
4214 E0618: r##"
4215 Attempted to call something which isn't a function nor a method.
4216
4217 Erroneous code examples:
4218
4219 ```compile_fail,E0618
4220 enum X {
4221     Entry,
4222 }
4223
4224 X::Entry(); // error: expected function, found `X::Entry`
4225
4226 // Or even simpler:
4227 let x = 0i32;
4228 x(); // error: expected function, found `i32`
4229 ```
4230
4231 Only functions and methods can be called using `()`. Example:
4232
4233 ```
4234 // We declare a function:
4235 fn i_am_a_function() {}
4236
4237 // And we call it:
4238 i_am_a_function();
4239 ```
4240 "##,
4241
4242 E0619: r##"
4243 #### Note: this error code is no longer emitted by the compiler.
4244 The type-checker needed to know the type of an expression, but that type had not
4245 yet been inferred.
4246
4247 Erroneous code example:
4248
4249 ```compile_fail
4250 let mut x = vec![];
4251 match x.pop() {
4252     Some(v) => {
4253         // Here, the type of `v` is not (yet) known, so we
4254         // cannot resolve this method call:
4255         v.to_uppercase(); // error: the type of this value must be known in
4256                           //        this context
4257     }
4258     None => {}
4259 }
4260 ```
4261
4262 Type inference typically proceeds from the top of the function to the bottom,
4263 figuring out types as it goes. In some cases -- notably method calls and
4264 overloadable operators like `*` -- the type checker may not have enough
4265 information *yet* to make progress. This can be true even if the rest of the
4266 function provides enough context (because the type-checker hasn't looked that
4267 far ahead yet). In this case, type annotations can be used to help it along.
4268
4269 To fix this error, just specify the type of the variable. Example:
4270
4271 ```
4272 let mut x: Vec<String> = vec![]; // We precise the type of the vec elements.
4273 match x.pop() {
4274     Some(v) => {
4275         v.to_uppercase(); // Since rustc now knows the type of the vec elements,
4276                           // we can use `v`'s methods.
4277     }
4278     None => {}
4279 }
4280 ```
4281 "##,
4282
4283 E0620: r##"
4284 A cast to an unsized type was attempted.
4285
4286 Erroneous code example:
4287
4288 ```compile_fail,E0620
4289 let x = &[1_usize, 2] as [usize]; // error: cast to unsized type: `&[usize; 2]`
4290                                   //        as `[usize]`
4291 ```
4292
4293 In Rust, some types don't have a known size at compile-time. For example, in a
4294 slice type like `[u32]`, the number of elements is not known at compile-time and
4295 hence the overall size cannot be computed. As a result, such types can only be
4296 manipulated through a reference (e.g., `&T` or `&mut T`) or other pointer-type
4297 (e.g., `Box` or `Rc`). Try casting to a reference instead:
4298
4299 ```
4300 let x = &[1_usize, 2] as &[usize]; // ok!
4301 ```
4302 "##,
4303
4304 E0622: r##"
4305 An intrinsic was declared without being a function.
4306
4307 Erroneous code example:
4308
4309 ```compile_fail,E0622
4310 #![feature(intrinsics)]
4311 extern "rust-intrinsic" {
4312     pub static breakpoint : unsafe extern "rust-intrinsic" fn();
4313     // error: intrinsic must be a function
4314 }
4315
4316 fn main() { unsafe { breakpoint(); } }
4317 ```
4318
4319 An intrinsic is a function available for use in a given programming language
4320 whose implementation is handled specially by the compiler. In order to fix this
4321 error, just declare a function.
4322 "##,
4323
4324 E0624: r##"
4325 A private item was used outside of its scope.
4326
4327 Erroneous code example:
4328
4329 ```compile_fail,E0624
4330 mod inner {
4331     pub struct Foo;
4332
4333     impl Foo {
4334         fn method(&self) {}
4335     }
4336 }
4337
4338 let foo = inner::Foo;
4339 foo.method(); // error: method `method` is private
4340 ```
4341
4342 Two possibilities are available to solve this issue:
4343
4344 1. Only use the item in the scope it has been defined:
4345
4346 ```
4347 mod inner {
4348     pub struct Foo;
4349
4350     impl Foo {
4351         fn method(&self) {}
4352     }
4353
4354     pub fn call_method(foo: &Foo) { // We create a public function.
4355         foo.method(); // Which calls the item.
4356     }
4357 }
4358
4359 let foo = inner::Foo;
4360 inner::call_method(&foo); // And since the function is public, we can call the
4361                           // method through it.
4362 ```
4363
4364 2. Make the item public:
4365
4366 ```
4367 mod inner {
4368     pub struct Foo;
4369
4370     impl Foo {
4371         pub fn method(&self) {} // It's now public.
4372     }
4373 }
4374
4375 let foo = inner::Foo;
4376 foo.method(); // Ok!
4377 ```
4378 "##,
4379
4380 E0638: r##"
4381 This error indicates that the struct, enum or enum variant must be matched
4382 non-exhaustively as it has been marked as `non_exhaustive`.
4383
4384 When applied within a crate, downstream users of the crate will need to use the
4385 `_` pattern when matching enums and use the `..` pattern when matching structs.
4386 Downstream crates cannot match against non-exhaustive enum variants.
4387
4388 For example, in the below example, since the enum is marked as
4389 `non_exhaustive`, it is required that downstream crates match non-exhaustively
4390 on it.
4391
4392 ```rust,ignore (pseudo-Rust)
4393 use std::error::Error as StdError;
4394
4395 #[non_exhaustive] pub enum Error {
4396    Message(String),
4397    Other,
4398 }
4399
4400 impl StdError for Error {
4401    fn description(&self) -> &str {
4402         // This will not error, despite being marked as non_exhaustive, as this
4403         // enum is defined within the current crate, it can be matched
4404         // exhaustively.
4405         match *self {
4406            Message(ref s) => s,
4407            Other => "other or unknown error",
4408         }
4409    }
4410 }
4411 ```
4412
4413 An example of matching non-exhaustively on the above enum is provided below:
4414
4415 ```rust,ignore (pseudo-Rust)
4416 use mycrate::Error;
4417
4418 // This will not error as the non_exhaustive Error enum has been matched with a
4419 // wildcard.
4420 match error {
4421    Message(ref s) => ...,
4422    Other => ...,
4423    _ => ...,
4424 }
4425 ```
4426
4427 Similarly, for structs, match with `..` to avoid this error.
4428 "##,
4429
4430 E0639: r##"
4431 This error indicates that the struct, enum or enum variant cannot be
4432 instantiated from outside of the defining crate as it has been marked
4433 as `non_exhaustive` and as such more fields/variants may be added in
4434 future that could cause adverse side effects for this code.
4435
4436 It is recommended that you look for a `new` function or equivalent in the
4437 crate's documentation.
4438 "##,
4439
4440 E0643: r##"
4441 This error indicates that there is a mismatch between generic parameters and
4442 impl Trait parameters in a trait declaration versus its impl.
4443
4444 ```compile_fail,E0643
4445 trait Foo {
4446     fn foo(&self, _: &impl Iterator);
4447 }
4448 impl Foo for () {
4449     fn foo<U: Iterator>(&self, _: &U) { } // error method `foo` has incompatible
4450                                           // signature for trait
4451 }
4452 ```
4453 "##,
4454
4455 E0646: r##"
4456 It is not possible to define `main` with a where clause.
4457 Erroneous code example:
4458
4459 ```compile_fail,E0646
4460 fn main() where i32: Copy { // error: main function is not allowed to have
4461                             // a where clause
4462 }
4463 ```
4464 "##,
4465
4466 E0647: r##"
4467 It is not possible to define `start` with a where clause.
4468 Erroneous code example:
4469
4470 ```compile_fail,E0647
4471 #![feature(start)]
4472
4473 #[start]
4474 fn start(_: isize, _: *const *const u8) -> isize where (): Copy {
4475     //^ error: start function is not allowed to have a where clause
4476     0
4477 }
4478 ```
4479 "##,
4480
4481 E0648: r##"
4482 `export_name` attributes may not contain null characters (`\0`).
4483
4484 ```compile_fail,E0648
4485 #[export_name="\0foo"] // error: `export_name` may not contain null characters
4486 pub fn bar() {}
4487 ```
4488 "##,
4489
4490 E0689: r##"
4491 This error indicates that the numeric value for the method being passed exists
4492 but the type of the numeric value or binding could not be identified.
4493
4494 The error happens on numeric literals:
4495
4496 ```compile_fail,E0689
4497 2.0.neg();
4498 ```
4499
4500 and on numeric bindings without an identified concrete type:
4501
4502 ```compile_fail,E0689
4503 let x = 2.0;
4504 x.neg();  // same error as above
4505 ```
4506
4507 Because of this, you must give the numeric literal or binding a type:
4508
4509 ```
4510 use std::ops::Neg;
4511
4512 let _ = 2.0_f32.neg();
4513 let x: f32 = 2.0;
4514 let _ = x.neg();
4515 let _ = (2.0 as f32).neg();
4516 ```
4517 "##,
4518
4519 E0690: r##"
4520 A struct with the representation hint `repr(transparent)` had zero or more than
4521 one fields that were not guaranteed to be zero-sized.
4522
4523 Erroneous code example:
4524
4525 ```compile_fail,E0690
4526 #[repr(transparent)]
4527 struct LengthWithUnit<U> { // error: transparent struct needs exactly one
4528     value: f32,            //        non-zero-sized field, but has 2
4529     unit: U,
4530 }
4531 ```
4532
4533 Because transparent structs are represented exactly like one of their fields at
4534 run time, said field must be uniquely determined. If there is no field, or if
4535 there are multiple fields, it is not clear how the struct should be represented.
4536 Note that fields of zero-typed types (e.g., `PhantomData`) can also exist
4537 alongside the field that contains the actual data, they do not count for this
4538 error. When generic types are involved (as in the above example), an error is
4539 reported because the type parameter could be non-zero-sized.
4540
4541 To combine `repr(transparent)` with type parameters, `PhantomData` may be
4542 useful:
4543
4544 ```
4545 use std::marker::PhantomData;
4546
4547 #[repr(transparent)]
4548 struct LengthWithUnit<U> {
4549     value: f32,
4550     unit: PhantomData<U>,
4551 }
4552 ```
4553 "##,
4554
4555 E0691: r##"
4556 A struct, enum, or union with the `repr(transparent)` representation hint
4557 contains a zero-sized field that requires non-trivial alignment.
4558
4559 Erroneous code example:
4560
4561 ```compile_fail,E0691
4562 #![feature(repr_align)]
4563
4564 #[repr(align(32))]
4565 struct ForceAlign32;
4566
4567 #[repr(transparent)]
4568 struct Wrapper(f32, ForceAlign32); // error: zero-sized field in transparent
4569                                    //        struct has alignment larger than 1
4570 ```
4571
4572 A transparent struct, enum, or union is supposed to be represented exactly like
4573 the piece of data it contains. Zero-sized fields with different alignment
4574 requirements potentially conflict with this property. In the example above,
4575 `Wrapper` would have to be aligned to 32 bytes even though `f32` has a smaller
4576 alignment requirement.
4577
4578 Consider removing the over-aligned zero-sized field:
4579
4580 ```
4581 #[repr(transparent)]
4582 struct Wrapper(f32);
4583 ```
4584
4585 Alternatively, `PhantomData<T>` has alignment 1 for all `T`, so you can use it
4586 if you need to keep the field for some reason:
4587
4588 ```
4589 #![feature(repr_align)]
4590
4591 use std::marker::PhantomData;
4592
4593 #[repr(align(32))]
4594 struct ForceAlign32;
4595
4596 #[repr(transparent)]
4597 struct Wrapper(f32, PhantomData<ForceAlign32>);
4598 ```
4599
4600 Note that empty arrays `[T; 0]` have the same alignment requirement as the
4601 element type `T`. Also note that the error is conservatively reported even when
4602 the alignment of the zero-sized type is less than or equal to the data field's
4603 alignment.
4604 "##,
4605
4606 E0699: r##"
4607 A method was called on a raw pointer whose inner type wasn't completely known.
4608
4609 For example, you may have done something like:
4610
4611 ```compile_fail
4612 # #![deny(warnings)]
4613 let foo = &1;
4614 let bar = foo as *const _;
4615 if bar.is_null() {
4616     // ...
4617 }
4618 ```
4619
4620 Here, the type of `bar` isn't known; it could be a pointer to anything. Instead,
4621 specify a type for the pointer (preferably something that makes sense for the
4622 thing you're pointing to):
4623
4624 ```
4625 let foo = &1;
4626 let bar = foo as *const i32;
4627 if bar.is_null() {
4628     // ...
4629 }
4630 ```
4631
4632 Even though `is_null()` exists as a method on any raw pointer, Rust shows this
4633 error because  Rust allows for `self` to have arbitrary types (behind the
4634 arbitrary_self_types feature flag).
4635
4636 This means that someone can specify such a function:
4637
4638 ```ignore (cannot-doctest-feature-doesnt-exist-yet)
4639 impl Foo {
4640     fn is_null(self: *const Self) -> bool {
4641         // do something else
4642     }
4643 }
4644 ```
4645
4646 and now when you call `.is_null()` on a raw pointer to `Foo`, there's ambiguity.
4647
4648 Given that we don't know what type the pointer is, and there's potential
4649 ambiguity for some types, we disallow calling methods on raw pointers when
4650 the type is unknown.
4651 "##,
4652
4653 E0714: r##"
4654 A `#[marker]` trait contained an associated item.
4655
4656 The items of marker traits cannot be overridden, so there's no need to have them
4657 when they cannot be changed per-type anyway.  If you wanted them for ergonomic
4658 reasons, consider making an extension trait instead.
4659 "##,
4660
4661 E0715: r##"
4662 An `impl` for a `#[marker]` trait tried to override an associated item.
4663
4664 Because marker traits are allowed to have multiple implementations for the same
4665 type, it's not allowed to override anything in those implementations, as it
4666 would be ambiguous which override should actually be used.
4667 "##,
4668
4669
4670 E0720: r##"
4671 An `impl Trait` type expands to a recursive type.
4672
4673 An `impl Trait` type must be expandable to a concrete type that contains no
4674 `impl Trait` types. For example the following example tries to create an
4675 `impl Trait` type `T` that is equal to `[T, T]`:
4676
4677 ```compile_fail,E0720
4678 fn make_recursive_type() -> impl Sized {
4679     [make_recursive_type(), make_recursive_type()]
4680 }
4681 ```
4682 "##,
4683
4684 E0730: r##"
4685 An array without a fixed length was pattern-matched.
4686
4687 Example of erroneous code:
4688
4689 ```compile_fail,E0730
4690 #![feature(const_generics)]
4691
4692 fn is_123<const N: usize>(x: [u32; N]) -> bool {
4693     match x {
4694         [1, 2, 3] => true, // error: cannot pattern-match on an
4695                            //        array without a fixed length
4696         _ => false
4697     }
4698 }
4699 ```
4700
4701 Ensure that the pattern is consistent with the size of the matched
4702 array. Additional elements can be matched with `..`:
4703
4704 ```
4705 #![feature(slice_patterns)]
4706
4707 let r = &[1, 2, 3, 4];
4708 match r {
4709     &[a, b, ..] => { // ok!
4710         println!("a={}, b={}", a, b);
4711     }
4712 }
4713 ```
4714 "##,
4715
4716 E0731: r##"
4717 An enum with the representation hint `repr(transparent)` had zero or more than
4718 one variants.
4719
4720 Erroneous code example:
4721
4722 ```compile_fail,E0731
4723 #[repr(transparent)]
4724 enum Status { // error: transparent enum needs exactly one variant, but has 2
4725     Errno(u32),
4726     Ok,
4727 }
4728 ```
4729
4730 Because transparent enums are represented exactly like one of their variants at
4731 run time, said variant must be uniquely determined. If there is no variant, or
4732 if there are multiple variants, it is not clear how the enum should be
4733 represented.
4734 "##,
4735
4736 E0732: r##"
4737 An `enum` with a discriminant must specify a `#[repr(inttype)]`.
4738
4739 A `#[repr(inttype)]` must be provided on an `enum` if it has a non-unit
4740 variant with a discriminant, or where there are both unit variants with
4741 discriminants and non-unit variants. This restriction ensures that there
4742 is a well-defined way to extract a variant's discriminant from a value;
4743 for instance:
4744
4745 ```
4746 #![feature(arbitrary_enum_discriminant)]
4747
4748 #[repr(u8)]
4749 enum Enum {
4750     Unit = 3,
4751     Tuple(u16) = 2,
4752     Struct {
4753         a: u8,
4754         b: u16,
4755     } = 1,
4756 }
4757
4758 fn discriminant(v : &Enum) -> u8 {
4759     unsafe { *(v as *const Enum as *const u8) }
4760 }
4761
4762 assert_eq!(3, discriminant(&Enum::Unit));
4763 assert_eq!(2, discriminant(&Enum::Tuple(5)));
4764 assert_eq!(1, discriminant(&Enum::Struct{a: 7, b: 11}));
4765 ```
4766 "##,
4767
4768 E0733: r##"
4769 Recursion in an `async fn` requires boxing. For example, this will not compile:
4770
4771 ```edition2018,compile_fail,E0733
4772 #![feature(async_await)]
4773 async fn foo(n: usize) {
4774     if n > 0 {
4775         foo(n - 1).await;
4776     }
4777 }
4778 ```
4779
4780 To achieve async recursion, the `async fn` needs to be desugared
4781 such that the `Future` is explicit in the return type:
4782
4783 ```edition2018,compile_fail,E0720
4784 # #![feature(async_await)]
4785 use std::future::Future;
4786 fn foo_desugered(n: usize) -> impl Future<Output = ()> {
4787     async move {
4788         if n > 0 {
4789             foo_desugered(n - 1).await;
4790         }
4791     }
4792 }
4793 ```
4794
4795 Finally, the future is wrapped in a pinned box:
4796
4797 ```edition2018
4798 # #![feature(async_await)]
4799 use std::future::Future;
4800 use std::pin::Pin;
4801 fn foo_recursive(n: usize) -> Pin<Box<dyn Future<Output = ()>>> {
4802     Box::pin(async move {
4803         if n > 0 {
4804             foo_recursive(n - 1).await;
4805         }
4806     })
4807 }
4808 ```
4809
4810 The `Box<...>` ensures that the result is of known size,
4811 and the pin is required to keep it in the same place in memory.
4812 "##,
4813
4814 }  // (end of detailed error messages)
4815
4816 register_diagnostics! {
4817 //  E0035, merged into E0087/E0089
4818 //  E0036, merged into E0087/E0089
4819 //  E0068,
4820 //  E0085,
4821 //  E0086,
4822 //  E0103,
4823 //  E0104,
4824 //  E0122, // bounds in type aliases are ignored, turned into proper lint
4825 //  E0123,
4826 //  E0127,
4827 //  E0129,
4828 //  E0141,
4829 //  E0159, // use of trait `{}` as struct constructor
4830 //  E0163, // merged into E0071
4831 //  E0167,
4832 //  E0168,
4833 //  E0172, // non-trait found in a type sum, moved to resolve
4834 //  E0173, // manual implementations of unboxed closure traits are experimental
4835 //  E0174,
4836 //  E0182, // merged into E0229
4837     E0183,
4838 //  E0187, // can't infer the kind of the closure
4839 //  E0188, // can not cast an immutable reference to a mutable pointer
4840 //  E0189, // deprecated: can only cast a boxed pointer to a boxed object
4841 //  E0190, // deprecated: can only cast a &-pointer to an &-object
4842 //  E0196, // cannot determine a type for this closure
4843     E0203, // type parameter has more than one relaxed default bound,
4844            // and only one is supported
4845     E0208,
4846 //  E0209, // builtin traits can only be implemented on structs or enums
4847     E0212, // cannot extract an associated type from a higher-ranked trait bound
4848 //  E0213, // associated types are not accepted in this context
4849 //  E0215, // angle-bracket notation is not stable with `Fn`
4850 //  E0216, // parenthetical notation is only stable with `Fn`
4851 //  E0217, // ambiguous associated type, defined in multiple supertraits
4852 //  E0218, // no associated type defined
4853 //  E0219, // associated type defined in higher-ranked supertrait
4854 //  E0222, // Error code E0045 (variadic function must have C or cdecl calling
4855            // convention) duplicate
4856     E0224, // at least one non-builtin train is required for an object type
4857     E0227, // ambiguous lifetime bound, explicit lifetime bound required
4858     E0228, // explicit lifetime bound required
4859 //  E0233,
4860 //  E0234,
4861 //  E0235, // structure constructor specifies a structure of type but
4862 //  E0236, // no lang item for range syntax
4863 //  E0237, // no lang item for range syntax
4864 //  E0238, // parenthesized parameters may only be used with a trait
4865 //  E0239, // `next` method of `Iterator` trait has unexpected type
4866 //  E0240,
4867 //  E0241,
4868 //  E0242,
4869 //  E0245, // not a trait
4870 //  E0246, // invalid recursive type
4871 //  E0247,
4872 //  E0248, // value used as a type, now reported earlier during resolution as E0412
4873 //  E0249,
4874     E0307, // invalid method `self` type
4875 //  E0319, // trait impls for defaulted traits allowed just for structs/enums
4876 //  E0372, // coherence not object safe
4877     E0377, // the trait `CoerceUnsized` may only be implemented for a coercion
4878            // between structures with the same definition
4879 //  E0558, // replaced with a generic attribute input check
4880     E0533, // `{}` does not name a unit variant, unit struct or a constant
4881 //  E0563, // cannot determine a type for this `impl Trait`: {} // removed in 6383de15
4882     E0564, // only named lifetimes are allowed in `impl Trait`,
4883            // but `{}` was found in the type `{}`
4884     E0587, // type has conflicting packed and align representation hints
4885     E0588, // packed type cannot transitively contain a `[repr(align)]` type
4886 //  E0611, // merged into E0616
4887 //  E0612, // merged into E0609
4888 //  E0613, // Removed (merged with E0609)
4889     E0627, // yield statement outside of generator literal
4890     E0632, // cannot provide explicit type parameters when `impl Trait` is used in
4891            // argument position.
4892     E0634, // type has conflicting packed representaton hints
4893     E0640, // infer outlives requirements
4894     E0641, // cannot cast to/from a pointer with an unknown kind
4895     E0645, // trait aliases not finished
4896     E0719, // duplicate values for associated type binding
4897     E0722, // Malformed `#[optimize]` attribute
4898     E0724, // `#[ffi_returns_twice]` is only allowed in foreign functions
4899 }