1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 #![allow(non_snake_case)]
13 register_long_diagnostics
! {
16 A pattern used to match against an enum variant must provide a sub-pattern for
17 each field of the enum variant. This error indicates that a pattern attempted to
18 extract an incorrect number of fields from a variant.
22 Apple(String, String),
27 Here the `Apple` variant has two fields, and should be matched against like so:
31 Apple(String, String),
35 let x = Fruit::Apple(String::new(), String::new());
39 Fruit::Apple(a, b) => {},
44 Matching with the wrong number of fields has no sensible interpretation:
48 Apple(String, String),
52 let x = Fruit::Apple(String::new(), String::new());
56 Fruit::Apple(a) => {},
57 Fruit::Apple(a, b, c) => {},
61 Check how many fields the enum was declared with and ensure that your pattern
66 Each field of a struct can only be bound once in a pattern. Erroneous code
76 let x = Foo { a:1, b:2 };
78 let Foo { a: x, a: y } = x;
79 // error: field `a` bound multiple times in the pattern
83 Each occurrence of a field name binds the value of that field, so to fix this
84 error you will have to remove or alter the duplicate uses of the field name.
85 Perhaps you misspelled another field name? Example:
94 let x = Foo { a:1, b:2 };
96 let Foo { a: x, b: y } = x; // ok!
102 This error indicates that a struct pattern attempted to extract a non-existent
103 field from a struct. Struct fields are identified by the name used before the
104 colon `:` so struct patterns should resemble the declaration of the struct type
114 let thing = Thing { x: 1, y: 2 };
117 Thing { x: xfield, y: yfield } => {}
121 If you are using shorthand field patterns but want to refer to the struct field
122 by a different name, you should rename it explicitly.
126 ```compile_fail,E0026
132 let thing = Thing { x: 0, y: 0 };
147 let thing = Thing { x: 0, y: 0 };
150 Thing { x, y: z } => {}
156 This error indicates that a pattern for a struct fails to specify a sub-pattern
157 for every one of the struct's fields. Ensure that each field from the struct's
158 definition is mentioned in the pattern, or use `..` to ignore unwanted fields.
162 ```compile_fail,E0027
168 let d = Dog { name: "Rusty".to_string(), age: 8 };
170 // This is incorrect.
176 This is correct (explicit):
184 let d = Dog { name: "Rusty".to_string(), age: 8 };
187 Dog { name: ref n, age: x } => {}
190 // This is also correct (ignore unused fields).
192 Dog { age: x, .. } => {}
198 In a match expression, only numbers and characters can be matched against a
199 range. This is because the compiler checks that the range is non-empty at
200 compile-time, and is unable to evaluate arbitrary comparison functions. If you
201 want to capture values of an orderable type between two end-points, you can use
204 ```compile_fail,E0029
205 let string = "salutations !";
207 // The ordering relation for strings can't be evaluated at compile time,
208 // so this doesn't work:
210 "hello" ... "world" => {}
214 // This is a more general version, using a guard:
216 s if s >= "hello" && s <= "world" => {}
223 This error indicates that a pointer to a trait type cannot be implicitly
224 dereferenced by a pattern. Every trait defines a type, but because the
225 size of trait implementors isn't fixed, this type has no compile-time size.
226 Therefore, all accesses to trait types must be through pointers. If you
227 encounter this error you should try to avoid dereferencing the pointer.
230 let trait_obj: &SomeTrait = ...;
232 // This tries to implicitly dereference to create an unsized local variable.
233 let &invalid = trait_obj;
235 // You can call methods without binding to the value being pointed at.
236 trait_obj.method_one();
237 trait_obj.method_two();
240 You can read more about trait objects in the Trait Object section of the
243 https://doc.rust-lang.org/reference.html#trait-objects
247 The compiler doesn't know what method to call because more than one method
248 has the same prototype. Erroneous code example:
250 ```compile_fail,E0034
261 impl Trait1 for Test { fn foo() {} }
262 impl Trait2 for Test { fn foo() {} }
265 Test::foo() // error, which foo() to call?
269 To avoid this error, you have to keep only one of them and remove the others.
270 So let's take our example and fix it:
279 impl Trait1 for Test { fn foo() {} }
282 Test::foo() // and now that's good!
286 However, a better solution would be using fully explicit naming of type and
300 impl Trait1 for Test { fn foo() {} }
301 impl Trait2 for Test { fn foo() {} }
304 <Test as Trait1>::foo()
321 impl F for X { fn m(&self) { println!("I am F"); } }
322 impl G for X { fn m(&self) { println!("I am G"); } }
327 F::m(&f); // it displays "I am F"
328 G::m(&f); // it displays "I am G"
334 You tried to give a type parameter where it wasn't needed. Erroneous code
337 ```compile_fail,E0035
347 x.method::<i32>(); // Error: Test::method doesn't need type parameter!
351 To fix this error, just remove the type parameter:
363 x.method(); // OK, we're good!
369 This error occurrs when you pass too many or not enough type parameters to
370 a method. Erroneous code example:
372 ```compile_fail,E0036
376 fn method<T>(&self, v: &[T]) -> usize {
385 x.method::<i32, i32>(v); // error: only one type parameter is expected!
389 To fix it, just specify a correct number of type parameters:
395 fn method<T>(&self, v: &[T]) -> usize {
404 x.method::<i32>(v); // OK, we're good!
408 Please note on the last example that we could have called `method` like this:
416 It is not allowed to manually call destructors in Rust. It is also not
417 necessary to do this since `drop` is called automatically whenever a value goes
420 Here's an example of this error:
422 ```compile_fail,E0040
434 let mut x = Foo { x: -7 };
435 x.drop(); // error: explicit use of destructor method
441 You can't use type parameters on foreign items. Example of erroneous code:
443 ```compile_fail,E0044
444 extern { fn some_func<T>(x: T); }
447 To fix this, replace the type parameter with the specializations that you
451 extern { fn some_func_i32(x: i32); }
452 extern { fn some_func_i64(x: i64); }
457 Rust only supports variadic parameters for interoperability with C code in its
458 FFI. As such, variadic parameters can only be used with functions which are
459 using the C ABI. Examples of erroneous code:
461 ```compile_fail,E0045
462 #![feature(unboxed_closures)]
464 extern "rust-call" { fn foo(x: u8, ...); }
468 fn foo(x: u8, ...) {}
471 To fix such code, put them in an extern "C" block:
481 Items are missing in a trait implementation. Erroneous code example:
483 ```compile_fail,E0046
491 // error: not all trait items implemented, missing: `foo`
494 When trying to make some type implement a trait `Foo`, you must, at minimum,
495 provide implementations for all of `Foo`'s required methods (meaning the
496 methods that do not have default implementations), as well as any required
497 trait items like associated types or constants. Example:
513 This error indicates that an attempted implementation of a trait method
514 has the wrong number of type parameters.
516 For example, the trait below has a method `foo` with a type parameter `T`,
517 but the implementation of `foo` for the type `Bar` is missing this parameter:
519 ```compile_fail,E0049
521 fn foo<T: Default>(x: T) -> Self;
526 // error: method `foo` has 0 type parameters but its trait declaration has 1
529 fn foo(x: bool) -> Self { Bar }
535 This error indicates that an attempted implementation of a trait method
536 has the wrong number of function parameters.
538 For example, the trait below has a method `foo` with two function parameters
539 (`&self` and `u8`), but the implementation of `foo` for the type `Bar` omits
542 ```compile_fail,E0050
544 fn foo(&self, x: u8) -> bool;
549 // error: method `foo` has 1 parameter but the declaration in trait `Foo::foo`
552 fn foo(&self) -> bool { true }
558 The parameters of any trait method must match between a trait implementation
559 and the trait definition.
561 Here are a couple examples of this error:
563 ```compile_fail,E0053
572 // error, expected u16, found i16
575 // error, types differ in mutability
576 fn bar(&mut self) { }
582 It is not allowed to cast to a bool. If you are trying to cast a numeric type
583 to a bool, you can compare it with zero instead:
585 ```compile_fail,E0054
588 // Not allowed, won't compile
589 let x_is_nonzero = x as bool;
596 let x_is_nonzero = x != 0;
601 During a method call, a value is automatically dereferenced as many times as
602 needed to make the value's type match the method's receiver. The catch is that
603 the compiler will only attempt to dereference a number of times up to the
604 recursion limit (which can be set via the `recursion_limit` attribute).
606 For a somewhat artificial example:
608 ```compile_fail,E0055
609 #![recursion_limit="2"]
621 // error, reached the recursion limit while auto-dereferencing &&Foo
626 One fix may be to increase the recursion limit. Note that it is possible to
627 create an infinite recursion of dereferencing, in which case the only fix is to
628 somehow break the recursion.
632 When invoking closures or other implementations of the function traits `Fn`,
633 `FnMut` or `FnOnce` using call notation, the number of parameters passed to the
634 function must match its definition.
636 An example using a closure:
638 ```compile_fail,E0057
640 let a = f(); // invalid, too few parameters
641 let b = f(4); // this works!
642 let c = f(2, 3); // invalid, too many parameters
645 A generic function must be treated similarly:
648 fn foo<F: Fn()>(f: F) {
649 f(); // this is valid, but f(3) would not work
655 The built-in function traits are generic over a tuple of the function arguments.
656 If one uses angle-bracket notation (`Fn<(T,), Output=U>`) instead of parentheses
657 (`Fn(T) -> U`) to denote the function trait, the type parameter should be a
658 tuple. Otherwise function call notation cannot be used and the trait will not be
659 implemented by closures.
661 The most likely source of this error is using angle-bracket notation without
662 wrapping the function argument type into a tuple, for example:
664 ```compile_fail,E0059
665 #![feature(unboxed_closures)]
667 fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) }
670 It can be fixed by adjusting the trait bound like this:
673 #![feature(unboxed_closures)]
675 fn foo<F: Fn<(i32,)>>(f: F) -> F::Output { f(3) }
678 Note that `(T,)` always denotes the type of a 1-tuple containing an element of
679 type `T`. The comma is necessary for syntactic disambiguation.
683 External C functions are allowed to be variadic. However, a variadic function
684 takes a minimum number of arguments. For example, consider C's variadic `printf`
689 use libc::{ c_char, c_int };
692 fn printf(_: *const c_char, ...) -> c_int;
696 Using this declaration, it must be called with at least one argument, so
697 simply calling `printf()` is invalid. But the following uses are allowed:
701 use std::ffi::CString;
703 printf(CString::new("test\n").unwrap().as_ptr());
704 printf(CString::new("number = %d\n").unwrap().as_ptr(), 3);
705 printf(CString::new("%d, %d\n").unwrap().as_ptr(), 10, 5);
711 The number of arguments passed to a function must match the number of arguments
712 specified in the function signature.
714 For example, a function like:
717 fn f(a: u16, b: &str) {}
720 Must always be called with exactly two arguments, e.g. `f(2, "test")`.
722 Note that Rust does not have a notion of optional function arguments or
723 variadic functions (except for its C-FFI).
727 This error indicates that during an attempt to build a struct or struct-like
728 enum variant, one of the fields was specified more than once. Erroneous code
731 ```compile_fail,E0062
739 x: 0, // error: field `x` specified more than once
744 Each field should be specified exactly one time. Example:
752 let x = Foo { x: 0 }; // ok!
758 This error indicates that during an attempt to build a struct or struct-like
759 enum variant, one of the fields was not provided. Erroneous code example:
761 ```compile_fail,E0063
768 let x = Foo { x: 0 }; // error: missing field: `y`
772 Each field should be specified exactly once. Example:
781 let x = Foo { x: 0, y: 0 }; // ok!
787 Box placement expressions (like C++'s "placement new") do not yet support any
788 place expression except the exchange heap (i.e. `std::boxed::HEAP`).
789 Furthermore, the syntax is changing to use `in` instead of `box`. See [RFC 470]
790 and [RFC 809] for more details.
792 [RFC 470]: https://github.com/rust-lang/rfcs/pull/470
793 [RFC 809]: https://github.com/rust-lang/rfcs/pull/809
797 The left-hand side of a compound assignment expression must be an lvalue
798 expression. An lvalue expression represents a memory location and includes
799 item paths (ie, namespaced variables), dereferences, indexing expressions,
800 and field references.
802 Let's start with some erroneous code examples:
804 ```compile_fail,E0067
805 use std::collections::LinkedList;
807 // Bad: assignment to non-lvalue expression
808 LinkedList::new() += 1;
812 fn some_func(i: &mut i32) {
813 i += 12; // Error : '+=' operation cannot be applied on a reference !
817 And now some working examples:
826 fn some_func(i: &mut i32) {
833 The compiler found a function whose body contains a `return;` statement but
834 whose return type is not `()`. An example of this is:
836 ```compile_fail,E0069
843 Since `return;` is just like `return ();`, there is a mismatch between the
844 function's return type and the value being returned.
848 The left-hand side of an assignment operator must be an lvalue expression. An
849 lvalue expression represents a memory location and can be a variable (with
850 optional namespacing), a dereference, an indexing expression or a field
853 More details can be found here:
854 https://doc.rust-lang.org/reference.html#lvalues-rvalues-and-temporaries
856 Now, we can go further. Here are some erroneous code examples:
858 ```compile_fail,E0070
864 const SOME_CONST : i32 = 12;
866 fn some_other_func() {}
869 SOME_CONST = 14; // error : a constant value cannot be changed!
870 1 = 3; // error : 1 isn't a valid lvalue!
871 some_other_func() = 4; // error : we can't assign value to a function!
872 SomeStruct.x = 12; // error : SomeStruct a structure name but it is used
877 And now let's give working examples:
884 let mut s = SomeStruct {x: 0, y: 0};
886 s.x = 3; // that's good !
890 fn some_func(x: &mut i32) {
891 *x = 12; // that's good !
897 You tried to use structure-literal syntax to create an item that is
898 not a struct-style structure or enum variant.
900 Example of erroneous code:
902 ```compile_fail,E0071
903 enum Foo { FirstValue(i32) };
905 let u = Foo::FirstValue { value: 0 }; // error: Foo::FirstValue
906 // isn't a structure!
907 // or even simpler, if the name doesn't refer to a structure at all.
908 let t = u32 { value: 4 }; // error: `u32` does not name a structure.
911 To fix this, ensure that the name was correctly spelled, and that
912 the correct form of initializer was used.
914 For example, the code above can be fixed to:
922 let u = Foo::FirstValue(0i32);
930 You cannot define a struct (or enum) `Foo` that requires an instance of `Foo`
931 in order to make a new `Foo` value. This is because there would be no way a
932 first instance of `Foo` could be made to initialize another instance!
934 Here's an example of a struct that has this problem:
937 struct Foo { x: Box<Foo> } // error
940 One fix is to use `Option`, like so:
943 struct Foo { x: Option<Box<Foo>> }
946 Now it's possible to create at least one instance of `Foo`: `Foo { x: None }`.
950 When using the `#[simd]` attribute on a tuple struct, the components of the
951 tuple struct must all be of a concrete, nongeneric type so the compiler can
952 reason about how to use SIMD with them. This error will occur if the types
955 This will cause an error:
958 #![feature(repr_simd)]
961 struct Bad<T>(T, T, T);
967 #![feature(repr_simd)]
970 struct Good(u32, u32, u32);
975 The `#[simd]` attribute can only be applied to non empty tuple structs, because
976 it doesn't make sense to try to use SIMD operations when there are no values to
979 This will cause an error:
981 ```compile_fail,E0075
982 #![feature(repr_simd)]
991 #![feature(repr_simd)]
999 When using the `#[simd]` attribute to automatically use SIMD operations in tuple
1000 struct, the types in the struct must all be of the same type, or the compiler
1001 will trigger this error.
1003 This will cause an error:
1005 ```compile_fail,E0076
1006 #![feature(repr_simd)]
1009 struct Bad(u16, u32, u32);
1015 #![feature(repr_simd)]
1018 struct Good(u32, u32, u32);
1023 When using the `#[simd]` attribute on a tuple struct, the elements in the tuple
1024 must be machine types so SIMD operations can be applied to them.
1026 This will cause an error:
1028 ```compile_fail,E0077
1029 #![feature(repr_simd)]
1038 #![feature(repr_simd)]
1041 struct Good(u32, u32, u32);
1046 Enum variants which contain no data can be given a custom integer
1047 representation. This error indicates that the value provided is not an integer
1048 literal and is therefore invalid.
1050 For example, in the following code:
1052 ```compile_fail,E0079
1058 We try to set the representation to a string.
1060 There's no general fix for this; if you can work with an integer then just set
1069 However if you actually wanted a mapping between variants and non-integer
1070 objects, it may be preferable to use a method with a match instead:
1075 fn get_str(&self) -> &'static str {
1085 Enum discriminants are used to differentiate enum variants stored in memory.
1086 This error indicates that the same value was used for two or more variants,
1087 making them impossible to tell apart.
1089 ```compile_fail,E0081
1107 Note that variants without a manually specified discriminant are numbered from
1108 top to bottom starting from 0, so clashes can occur with seemingly unrelated
1111 ```compile_fail,E0081
1118 Here `X` will have already been specified the discriminant 0 by the time `Y` is
1119 encountered, so a conflict occurs.
1123 When you specify enum discriminants with `=`, the compiler expects `isize`
1124 values by default. Or you can add the `repr` attibute to the enum declaration
1125 for an explicit choice of the discriminant type. In either cases, the
1126 discriminant values must fall within a valid range for the expected type;
1127 otherwise this error is raised. For example:
1137 Here, 1024 lies outside the valid range for `u8`, so the discriminant for `A` is
1138 invalid. Here is another, more subtle example which depends on target word size:
1141 enum DependsOnPointerSize {
1146 Here, `1 << 32` is interpreted as an `isize` value. So it is invalid for 32 bit
1147 target (`target_pointer_width = "32"`) but valid for 64 bit target.
1149 You may want to change representation types to fix this, or else change invalid
1150 discriminant values so that they fit within the existing type.
1154 An unsupported representation was attempted on a zero-variant enum.
1156 Erroneous code example:
1158 ```compile_fail,E0084
1160 enum NightsWatch {} // error: unsupported representation for zero-variant enum
1163 It is impossible to define an integer type to be used to represent zero-variant
1164 enum values because there are no zero-variant enum values. There is no way to
1165 construct an instance of the following type using only safe code. So you have
1166 two solutions. Either you add variants in your enum:
1176 or you remove the integer represention of your enum:
1184 Too many type parameters were supplied for a function. For example:
1186 ```compile_fail,E0087
1190 foo::<f64, bool>(); // error, expected 1 parameter, found 2 parameters
1194 The number of supplied parameters must exactly match the number of defined type
1199 You gave too many lifetime parameters. Erroneous code example:
1201 ```compile_fail,E0088
1205 f::<'static>() // error: too many lifetime parameters provided
1209 Please check you give the right number of lifetime parameters. Example:
1219 It's also important to note that the Rust compiler can generally
1220 determine the lifetime by itself. Example:
1228 // it can be written like this
1229 fn get_value<'a>(&'a self) -> &'a str { &self.value }
1230 // but the compiler works fine with this too:
1231 fn without_lifetime(&self) -> &str { &self.value }
1235 let f = Foo { value: "hello".to_owned() };
1237 println!("{}", f.get_value());
1238 println!("{}", f.without_lifetime());
1244 Not enough type parameters were supplied for a function. For example:
1246 ```compile_fail,E0089
1250 foo::<f64>(); // error, expected 2 parameters, found 1 parameter
1254 Note that if a function takes multiple type parameters but you want the compiler
1255 to infer some of them, you can use type placeholders:
1257 ```compile_fail,E0089
1258 fn foo<T, U>(x: T) {}
1262 foo::<f64>(x); // error, expected 2 parameters, found 1 parameter
1263 foo::<_, f64>(x); // same as `foo::<bool, f64>(x)`
1269 You gave an unnecessary type parameter in a type alias. Erroneous code
1272 ```compile_fail,E0091
1273 type Foo<T> = u32; // error: type parameter `T` is unused
1275 type Foo<A,B> = Box<A>; // error: type parameter `B` is unused
1278 Please check you didn't write too many type parameters. Example:
1281 type Foo = u32; // ok!
1282 type Foo2<A> = Box<A>; // ok!
1287 You tried to declare an undefined atomic operation function.
1288 Erroneous code example:
1290 ```compile_fail,E0092
1291 #![feature(intrinsics)]
1293 extern "rust-intrinsic" {
1294 fn atomic_foo(); // error: unrecognized atomic operation
1299 Please check you didn't make a mistake in the function's name. All intrinsic
1300 functions are defined in librustc_trans/trans/intrinsic.rs and in
1301 libcore/intrinsics.rs in the Rust source code. Example:
1304 #![feature(intrinsics)]
1306 extern "rust-intrinsic" {
1307 fn atomic_fence(); // ok!
1313 You declared an unknown intrinsic function. Erroneous code example:
1315 ```compile_fail,E0093
1316 #![feature(intrinsics)]
1318 extern "rust-intrinsic" {
1319 fn foo(); // error: unrecognized intrinsic function: `foo`
1329 Please check you didn't make a mistake in the function's name. All intrinsic
1330 functions are defined in librustc_trans/trans/intrinsic.rs and in
1331 libcore/intrinsics.rs in the Rust source code. Example:
1334 #![feature(intrinsics)]
1336 extern "rust-intrinsic" {
1337 fn atomic_fence(); // ok!
1349 You gave an invalid number of type parameters to an intrinsic function.
1350 Erroneous code example:
1352 ```compile_fail,E0094
1353 #![feature(intrinsics)]
1355 extern "rust-intrinsic" {
1356 fn size_of<T, U>() -> usize; // error: intrinsic has wrong number
1357 // of type parameters
1361 Please check that you provided the right number of lifetime parameters
1362 and verify with the function declaration in the Rust source code.
1366 #![feature(intrinsics)]
1368 extern "rust-intrinsic" {
1369 fn size_of<T>() -> usize; // ok!
1375 You hit this error because the compiler lacks the information to
1376 determine a type for this expression. Erroneous code example:
1378 ```compile_fail,E0101
1379 let x = |_| {}; // error: cannot determine a type for this expression
1382 You have two possibilities to solve this situation:
1383 * Give an explicit definition of the expression
1384 * Infer the expression
1389 let x = |_ : u32| {}; // ok!
1397 You hit this error because the compiler lacks the information to
1398 determine the type of this variable. Erroneous code example:
1400 ```compile_fail,E0102
1401 // could be an array of anything
1402 let x = []; // error: cannot determine a type for this local variable
1405 To solve this situation, constrain the type of the variable.
1409 #![allow(unused_variables)]
1412 let x: [u8; 0] = [];
1418 This error indicates that a lifetime is missing from a type. If it is an error
1419 inside a function signature, the problem may be with failing to adhere to the
1420 lifetime elision rules (see below).
1422 Here are some simple examples of where you'll run into this error:
1424 ```compile_fail,E0106
1425 struct Foo { x: &bool } // error
1426 struct Foo<'a> { x: &'a bool } // correct
1428 enum Bar { A(u8), B(&bool), } // error
1429 enum Bar<'a> { A(u8), B(&'a bool), } // correct
1431 type MyStr = &str; // error
1432 type MyStr<'a> = &'a str; // correct
1435 Lifetime elision is a special, limited kind of inference for lifetimes in
1436 function signatures which allows you to leave out lifetimes in certain cases.
1437 For more background on lifetime elision see [the book][book-le].
1439 The lifetime elision rules require that any function signature with an elided
1440 output lifetime must either have
1442 - exactly one input lifetime
1443 - or, multiple input lifetimes, but the function must also be a method with a
1444 `&self` or `&mut self` receiver
1446 In the first case, the output lifetime is inferred to be the same as the unique
1447 input lifetime. In the second case, the lifetime is instead inferred to be the
1448 same as the lifetime on `&self` or `&mut self`.
1450 Here are some examples of elision errors:
1452 ```compile_fail,E0106
1453 // error, no input lifetimes
1454 fn foo() -> &str { }
1456 // error, `x` and `y` have distinct lifetimes inferred
1457 fn bar(x: &str, y: &str) -> &str { }
1459 // error, `y`'s lifetime is inferred to be distinct from `x`'s
1460 fn baz<'a>(x: &'a str, y: &str) -> &str { }
1463 [book-le]: https://doc.rust-lang.org/nightly/book/lifetimes.html#lifetime-elision
1467 This error means that an incorrect number of lifetime parameters were provided
1468 for a type (like a struct or enum) or trait.
1470 Some basic examples include:
1472 ```compile_fail,E0107
1473 struct Foo<'a>(&'a str);
1474 enum Bar { A, B, C }
1477 foo: Foo, // error: expected 1, found 0
1478 bar: Bar<'a>, // error: expected 0, found 1
1482 Here's an example that is currently an error, but may work in a future version
1485 ```compile_fail,E0107
1486 struct Foo<'a>(&'a str);
1489 impl Quux for Foo { } // error: expected 1, found 0
1492 Lifetime elision in implementation headers was part of the lifetime elision
1493 RFC. It is, however, [currently unimplemented][iss15872].
1495 [iss15872]: https://github.com/rust-lang/rust/issues/15872
1499 You can only define an inherent implementation for a type in the same crate
1500 where the type was defined. For example, an `impl` block as below is not allowed
1501 since `Vec` is defined in the standard library:
1503 ```compile_fail,E0116
1504 impl Vec<u8> { } // error
1507 To fix this problem, you can do either of these things:
1509 - define a trait that has the desired associated functions/types/constants and
1510 implement the trait for the type in question
1511 - define a new type wrapping the type and define an implementation on the new
1514 Note that using the `type` keyword does not work here because `type` only
1515 introduces a type alias:
1517 ```compile_fail,E0116
1518 type Bytes = Vec<u8>;
1520 impl Bytes { } // error, same as above
1525 This error indicates a violation of one of Rust's orphan rules for trait
1526 implementations. The rule prohibits any implementation of a foreign trait (a
1527 trait defined in another crate) where
1529 - the type that is implementing the trait is foreign
1530 - all of the parameters being passed to the trait (if there are any) are also
1533 Here's one example of this error:
1535 ```compile_fail,E0117
1536 impl Drop for u32 {}
1539 To avoid this kind of error, ensure that at least one local type is referenced
1543 pub struct Foo; // you define your type in your crate
1545 impl Drop for Foo { // and you can implement the trait on it!
1546 // code of trait implementation here
1549 impl From<Foo> for i32 { // or you use a type from your crate as
1551 fn from(i: Foo) -> i32 {
1557 Alternatively, define a trait locally and implement that instead:
1561 fn get(&self) -> usize;
1565 fn get(&self) -> usize { 0 }
1569 For information on the design of the orphan rules, see [RFC 1023].
1571 [RFC 1023]: https://github.com/rust-lang/rfcs/pull/1023
1575 You're trying to write an inherent implementation for something which isn't a
1576 struct nor an enum. Erroneous code example:
1578 ```compile_fail,E0118
1579 impl (u8, u8) { // error: no base type found for inherent implementation
1580 fn get_state(&self) -> String {
1586 To fix this error, please implement a trait on the type or wrap it in a struct.
1590 // we create a trait here
1591 trait LiveLongAndProsper {
1592 fn get_state(&self) -> String;
1595 // and now you can implement it on (u8, u8)
1596 impl LiveLongAndProsper for (u8, u8) {
1597 fn get_state(&self) -> String {
1598 "He's dead, Jim!".to_owned()
1603 Alternatively, you can create a newtype. A newtype is a wrapping tuple-struct.
1604 For example, `NewType` is a newtype over `Foo` in `struct NewType(Foo)`.
1608 struct TypeWrapper((u8, u8));
1611 fn get_state(&self) -> String {
1612 "Fascinating!".to_owned()
1619 There are conflicting trait implementations for the same type.
1620 Example of erroneous code:
1622 ```compile_fail,E0119
1624 fn get(&self) -> usize;
1627 impl<T> MyTrait for T {
1628 fn get(&self) -> usize { 0 }
1635 impl MyTrait for Foo { // error: conflicting implementations of trait
1636 // `MyTrait` for type `Foo`
1637 fn get(&self) -> usize { self.value }
1641 When looking for the implementation for the trait, the compiler finds
1642 both the `impl<T> MyTrait for T` where T is all types and the `impl
1643 MyTrait for Foo`. Since a trait cannot be implemented multiple times,
1644 this is an error. So, when you write:
1648 fn get(&self) -> usize;
1651 impl<T> MyTrait for T {
1652 fn get(&self) -> usize { 0 }
1656 This makes the trait implemented on all types in the scope. So if you
1657 try to implement it on another one after that, the implementations will
1662 fn get(&self) -> usize;
1665 impl<T> MyTrait for T {
1666 fn get(&self) -> usize { 0 }
1674 f.get(); // the trait is implemented so we can use it
1680 An attempt was made to implement Drop on a trait, which is not allowed: only
1681 structs and enums can implement Drop. An example causing this error:
1683 ```compile_fail,E0120
1686 impl Drop for MyTrait {
1687 fn drop(&mut self) {}
1691 A workaround for this problem is to wrap the trait up in a struct, and implement
1692 Drop on that. An example is shown below:
1696 struct MyWrapper<T: MyTrait> { foo: T }
1698 impl <T: MyTrait> Drop for MyWrapper<T> {
1699 fn drop(&mut self) {}
1704 Alternatively, wrapping trait objects requires something like the following:
1709 //or Box<MyTrait>, if you wanted an owned trait object
1710 struct MyWrapper<'a> { foo: &'a MyTrait }
1712 impl <'a> Drop for MyWrapper<'a> {
1713 fn drop(&mut self) {}
1719 In order to be consistent with Rust's lack of global type inference, type
1720 placeholders are disallowed by design in item signatures.
1722 Examples of this error include:
1724 ```compile_fail,E0121
1725 fn foo() -> _ { 5 } // error, explicitly write out the return type instead
1727 static BAR: _ = "test"; // error, explicitly write out the type instead
1732 An attempt was made to add a generic constraint to a type alias. While Rust will
1733 allow this with a warning, it will not currently enforce the constraint.
1734 Consider the example below:
1739 type MyType<R: Foo> = (R, ());
1746 We're able to declare a variable of type `MyType<u32>`, despite the fact that
1747 `u32` does not implement `Foo`. As a result, one should avoid using generic
1748 constraints in concert with type aliases.
1752 You declared two fields of a struct with the same name. Erroneous code
1755 ```compile_fail,E0124
1758 field1: i32, // error: field is already declared
1762 Please verify that the field names have been correctly spelled. Example:
1773 Type parameter defaults can only use parameters that occur before them.
1774 Erroneous code example:
1776 ```compile_fail,E0128
1777 struct Foo<T=U, U=()> {
1781 // error: type parameters with a default cannot use forward declared
1785 Since type parameters are evaluated in-order, you may be able to fix this issue
1789 struct Foo<U=(), T=U> {
1795 Please also verify that this wasn't because of a name-clash and rename the type
1800 It is not possible to define `main` with type parameters, or even with function
1801 parameters. When `main` is present, it must take no arguments and return `()`.
1802 Erroneous code example:
1804 ```compile_fail,E0131
1805 fn main<T>() { // error: main function is not allowed to have type parameters
1811 A function with the `start` attribute was declared with type parameters.
1813 Erroneous code example:
1815 ```compile_fail,E0132
1822 It is not possible to declare type parameters on a function that has the `start`
1823 attribute. Such a function must have the following type signature (for more
1824 information: http://doc.rust-lang.org/stable/book/no-stdlib.html):
1827 fn(isize, *const *const u8) -> isize;
1836 fn my_start(argc: isize, argv: *const *const u8) -> isize {
1843 This error means that an attempt was made to match a struct type enum
1844 variant as a non-struct type:
1846 ```compile_fail,E0164
1847 enum Foo { B { i: u32 } }
1849 fn bar(foo: Foo) -> u32 {
1851 Foo::B(i) => i, // error E0164
1856 Try using `{}` instead:
1859 enum Foo { B { i: u32 } }
1861 fn bar(foo: Foo) -> u32 {
1870 This error means that an attempt was made to specify the type of a variable with
1871 a combination of a concrete type and a trait. Consider the following example:
1873 ```compile_fail,E0172
1874 fn foo(bar: i32+std::fmt::Display) {}
1877 The code is trying to specify that we want to receive a signed 32-bit integer
1878 which also implements `Display`. This doesn't make sense: when we pass `i32`, a
1879 concrete type, it implicitly includes all of the traits that it implements.
1880 This includes `Display`, `Debug`, `Clone`, and a host of others.
1882 If `i32` implements the trait we desire, there's no need to specify the trait
1883 separately. If it does not, then we need to `impl` the trait for `i32` before
1884 passing it into `foo`. Either way, a fixed definition for `foo` will look like
1891 To learn more about traits, take a look at the Book:
1893 https://doc.rust-lang.org/book/traits.html
1897 In types, the `+` type operator has low precedence, so it is often necessary
1902 ```compile_fail,E0178
1906 w: &'a Foo + Copy, // error, use &'a (Foo + Copy)
1907 x: &'a Foo + 'a, // error, use &'a (Foo + 'a)
1908 y: &'a mut Foo + 'a, // error, use &'a mut (Foo + 'a)
1909 z: fn() -> Foo + 'a, // error, use fn() -> (Foo + 'a)
1913 More details can be found in [RFC 438].
1915 [RFC 438]: https://github.com/rust-lang/rfcs/pull/438
1919 Explicitly implementing both Drop and Copy for a type is currently disallowed.
1920 This feature can make some sense in theory, but the current implementation is
1921 incorrect and can lead to memory unsafety (see [issue #20126][iss20126]), so
1922 it has been disabled for now.
1924 [iss20126]: https://github.com/rust-lang/rust/issues/20126
1928 An associated function for a trait was defined to be static, but an
1929 implementation of the trait declared the same function to be a method (i.e. to
1930 take a `self` parameter).
1932 Here's an example of this error:
1934 ```compile_fail,E0185
1942 // error, method `foo` has a `&self` declaration in the impl, but not in
1950 An associated function for a trait was defined to be a method (i.e. to take a
1951 `self` parameter), but an implementation of the trait declared the same function
1954 Here's an example of this error:
1956 ```compile_fail,E0186
1964 // error, method `foo` has a `&self` declaration in the trait, but not in
1972 Trait objects need to have all associated types specified. Erroneous code
1975 ```compile_fail,E0191
1980 type Foo = Trait; // error: the value of the associated type `Bar` (from
1981 // the trait `Trait`) must be specified
1984 Please verify you specified all associated types of the trait and that you
1985 used the right trait. Example:
1992 type Foo = Trait<Bar=i32>; // ok!
1997 Negative impls are only allowed for traits with default impls. For more
1998 information see the [opt-in builtin traits RFC](https://github.com/rust-lang/
1999 rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
2003 `where` clauses must use generic type parameters: it does not make sense to use
2004 them otherwise. An example causing this error:
2011 #[derive(Copy,Clone)]
2016 impl Foo for Wrapper<u32> where Wrapper<u32>: Clone {
2021 This use of a `where` clause is strange - a more common usage would look
2022 something like the following:
2029 #[derive(Copy,Clone)]
2033 impl <T> Foo for Wrapper<T> where Wrapper<T>: Clone {
2038 Here, we're saying that the implementation exists on Wrapper only when the
2039 wrapped type `T` implements `Clone`. The `where` clause is important because
2040 some types will not implement `Clone`, and thus will not get this method.
2042 In our erroneous example, however, we're referencing a single concrete type.
2043 Since we know for certain that `Wrapper<u32>` implements `Clone`, there's no
2044 reason to also specify it in a `where` clause.
2048 A type parameter was declared which shadows an existing one. An example of this
2051 ```compile_fail,E0194
2053 fn do_something(&self) -> T;
2054 fn do_something_else<T: Clone>(&self, bar: T);
2058 In this example, the trait `Foo` and the trait method `do_something_else` both
2059 define a type parameter `T`. This is not allowed: if the method wishes to
2060 define a type parameter, it must use a different name for it.
2064 Your method's lifetime parameters do not match the trait declaration.
2065 Erroneous code example:
2067 ```compile_fail,E0195
2069 fn bar<'a,'b:'a>(x: &'a str, y: &'b str);
2074 impl Trait for Foo {
2075 fn bar<'a,'b>(x: &'a str, y: &'b str) {
2076 // error: lifetime parameters or bounds on method `bar`
2077 // do not match the trait declaration
2082 The lifetime constraint `'b` for bar() implementation does not match the
2083 trait declaration. Ensure lifetime declarations match exactly in both trait
2084 declaration and implementation. Example:
2088 fn t<'a,'b:'a>(x: &'a str, y: &'b str);
2093 impl Trait for Foo {
2094 fn t<'a,'b:'a>(x: &'a str, y: &'b str) { // ok!
2101 Inherent implementations (one that do not implement a trait but provide
2102 methods associated with a type) are always safe because they are not
2103 implementing an unsafe trait. Removing the `unsafe` keyword from the inherent
2104 implementation will resolve this error.
2106 ```compile_fail,E0197
2109 // this will cause this error
2111 // converting it to this will fix it
2117 A negative implementation is one that excludes a type from implementing a
2118 particular trait. Not being able to use a trait is always a safe operation,
2119 so negative implementations are always safe and never need to be marked as
2123 #![feature(optin_builtin_traits)]
2127 // unsafe is unnecessary
2128 unsafe impl !Clone for Foo { }
2134 #![feature(optin_builtin_traits)]
2140 impl Enterprise for .. { }
2142 impl !Enterprise for Foo { }
2145 Please note that negative impls are only allowed for traits with default impls.
2149 Safe traits should not have unsafe implementations, therefore marking an
2150 implementation for a safe trait unsafe will cause a compiler error. Removing
2151 the unsafe marker on the trait noted in the error will resolve this problem.
2153 ```compile_fail,E0199
2158 // this won't compile because Bar is safe
2159 unsafe impl Bar for Foo { }
2160 // this will compile
2161 impl Bar for Foo { }
2166 Unsafe traits must have unsafe implementations. This error occurs when an
2167 implementation for an unsafe trait isn't marked as unsafe. This may be resolved
2168 by marking the unsafe implementation as unsafe.
2170 ```compile_fail,E0200
2173 unsafe trait Bar { }
2175 // this won't compile because Bar is unsafe and impl isn't unsafe
2176 impl Bar for Foo { }
2177 // this will compile
2178 unsafe impl Bar for Foo { }
2183 It is an error to define two associated items (like methods, associated types,
2184 associated functions, etc.) with the same identifier.
2188 ```compile_fail,E0201
2192 fn bar(&self) -> bool { self.0 > 5 }
2193 fn bar() {} // error: duplicate associated function
2198 fn baz(&self) -> bool;
2204 fn baz(&self) -> bool { true }
2206 // error: duplicate method
2207 fn baz(&self) -> bool { self.0 > 5 }
2209 // error: duplicate associated type
2214 Note, however, that items with the same name are allowed for inherent `impl`
2215 blocks that don't overlap:
2221 fn bar(&self) -> bool { self.0 > 5 }
2225 fn bar(&self) -> bool { self.0 }
2231 Inherent associated types were part of [RFC 195] but are not yet implemented.
2232 See [the tracking issue][iss8995] for the status of this implementation.
2234 [RFC 195]: https://github.com/rust-lang/rfcs/pull/195
2235 [iss8995]: https://github.com/rust-lang/rust/issues/8995
2239 An attempt to implement the `Copy` trait for a struct failed because one of the
2240 fields does not implement `Copy`. To fix this, you must implement `Copy` for the
2241 mentioned field. Note that this may not be possible, as in the example of
2243 ```compile_fail,E0204
2248 impl Copy for Foo { }
2251 This fails because `Vec<T>` does not implement `Copy` for any `T`.
2253 Here's another example that will fail:
2255 ```compile_fail,E0204
2262 This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
2263 differs from the behavior for `&T`, which is always `Copy`).
2267 An attempt to implement the `Copy` trait for an enum failed because one of the
2268 variants does not implement `Copy`. To fix this, you must implement `Copy` for
2269 the mentioned variant. Note that this may not be possible, as in the example of
2271 ```compile_fail,E0205
2277 impl Copy for Foo { }
2280 This fails because `Vec<T>` does not implement `Copy` for any `T`.
2282 Here's another example that will fail:
2284 ```compile_fail,E0205
2292 This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
2293 differs from the behavior for `&T`, which is always `Copy`).
2297 You can only implement `Copy` for a struct or enum. Both of the following
2298 examples will fail, because neither `i32` (primitive type) nor `&'static Bar`
2299 (reference to `Bar`) is a struct or enum:
2301 ```compile_fail,E0206
2303 impl Copy for Foo { } // error
2305 #[derive(Copy, Clone)]
2307 impl Copy for &'static Bar { } // error
2312 Any type parameter or lifetime parameter of an `impl` must meet at least one of
2313 the following criteria:
2315 - it appears in the self type of the impl
2316 - for a trait impl, it appears in the trait reference
2317 - it is bound as an associated type
2321 Suppose we have a struct `Foo` and we would like to define some methods for it.
2322 The following definition leads to a compiler error:
2324 ```compile_fail,E0207
2327 impl<T: Default> Foo {
2328 // error: the type parameter `T` is not constrained by the impl trait, self
2329 // type, or predicates [E0207]
2330 fn get(&self) -> T {
2331 <T as Default>::default()
2336 The problem is that the parameter `T` does not appear in the self type (`Foo`)
2337 of the impl. In this case, we can fix the error by moving the type parameter
2338 from the `impl` to the method `get`:
2344 // Move the type parameter from the impl to the method
2346 fn get<T: Default>(&self) -> T {
2347 <T as Default>::default()
2354 As another example, suppose we have a `Maker` trait and want to establish a
2355 type `FooMaker` that makes `Foo`s:
2357 ```compile_fail,E0207
2360 fn make(&mut self) -> Self::Item;
2369 impl<T: Default> Maker for FooMaker {
2370 // error: the type parameter `T` is not constrained by the impl trait, self
2371 // type, or predicates [E0207]
2374 fn make(&mut self) -> Foo<T> {
2375 Foo { foo: <T as Default>::default() }
2380 This fails to compile because `T` does not appear in the trait or in the
2383 One way to work around this is to introduce a phantom type parameter into
2384 `FooMaker`, like so:
2387 use std::marker::PhantomData;
2391 fn make(&mut self) -> Self::Item;
2398 // Add a type parameter to `FooMaker`
2399 struct FooMaker<T> {
2400 phantom: PhantomData<T>,
2403 impl<T: Default> Maker for FooMaker<T> {
2406 fn make(&mut self) -> Foo<T> {
2408 foo: <T as Default>::default(),
2414 Another way is to do away with the associated type in `Maker` and use an input
2415 type parameter instead:
2418 // Use a type parameter instead of an associated type here
2420 fn make(&mut self) -> Item;
2429 impl<T: Default> Maker<Foo<T>> for FooMaker {
2430 fn make(&mut self) -> Foo<T> {
2431 Foo { foo: <T as Default>::default() }
2436 ### Additional information
2438 For more information, please see [RFC 447].
2440 [RFC 447]: https://github.com/rust-lang/rfcs/blob/master/text/0447-no-unused-impl-parameters.md
2444 This error indicates a violation of one of Rust's orphan rules for trait
2445 implementations. The rule concerns the use of type parameters in an
2446 implementation of a foreign trait (a trait defined in another crate), and
2447 states that type parameters must be "covered" by a local type. To understand
2448 what this means, it is perhaps easiest to consider a few examples.
2450 If `ForeignTrait` is a trait defined in some external crate `foo`, then the
2451 following trait `impl` is an error:
2453 ```compile_fail,E0210
2454 extern crate collections;
2455 use collections::range::RangeArgument;
2457 impl<T> RangeArgument<T> for T { } // error
2462 To work around this, it can be covered with a local type, `MyType`:
2465 struct MyType<T>(T);
2466 impl<T> ForeignTrait for MyType<T> { } // Ok
2469 Please note that a type alias is not sufficient.
2471 For another example of an error, suppose there's another trait defined in `foo`
2472 named `ForeignTrait2` that takes two type parameters. Then this `impl` results
2473 in the same rule violation:
2477 impl<T> ForeignTrait2<T, MyType<T>> for MyType2 { } // error
2480 The reason for this is that there are two appearances of type parameter `T` in
2481 the `impl` header, both as parameters for `ForeignTrait2`. The first appearance
2482 is uncovered, and so runs afoul of the orphan rule.
2484 Consider one more example:
2487 impl<T> ForeignTrait2<MyType<T>, T> for MyType2 { } // Ok
2490 This only differs from the previous `impl` in that the parameters `T` and
2491 `MyType<T>` for `ForeignTrait2` have been swapped. This example does *not*
2492 violate the orphan rule; it is permitted.
2494 To see why that last example was allowed, you need to understand the general
2495 rule. Unfortunately this rule is a bit tricky to state. Consider an `impl`:
2498 impl<P1, ..., Pm> ForeignTrait<T1, ..., Tn> for T0 { ... }
2501 where `P1, ..., Pm` are the type parameters of the `impl` and `T0, ..., Tn`
2502 are types. One of the types `T0, ..., Tn` must be a local type (this is another
2503 orphan rule, see the explanation for E0117). Let `i` be the smallest integer
2504 such that `Ti` is a local type. Then no type parameter can appear in any of the
2507 For information on the design of the orphan rules, see [RFC 1023].
2509 [RFC 1023]: https://github.com/rust-lang/rfcs/pull/1023
2514 You used a function or type which doesn't fit the requirements for where it was
2515 used. Erroneous code examples:
2518 #![feature(intrinsics)]
2520 extern "rust-intrinsic" {
2521 fn size_of<T>(); // error: intrinsic has wrong type
2526 fn main() -> i32 { 0 }
2527 // error: main function expects type: `fn() {main}`: expected (), found i32
2534 // error: mismatched types in range: expected u8, found i8
2544 fn x(self: Rc<Foo>) {}
2545 // error: mismatched self type: expected `Foo`: expected struct
2546 // `Foo`, found struct `alloc::rc::Rc`
2550 For the first code example, please check the function definition. Example:
2553 #![feature(intrinsics)]
2555 extern "rust-intrinsic" {
2556 fn size_of<T>() -> usize; // ok!
2560 The second case example is a bit particular : the main function must always
2561 have this definition:
2567 They never take parameters and never return types.
2569 For the third example, when you match, all patterns must have the same type
2570 as the type you're matching on. Example:
2576 0u8...3u8 => (), // ok!
2581 And finally, for the last example, only `Box<Self>`, `&Self`, `Self`,
2582 or `&mut Self` work as explicit self parameters. Example:
2588 fn x(self: Box<Foo>) {} // ok!
2595 A generic type was described using parentheses rather than angle brackets. For
2598 ```compile_fail,E0214
2600 let v: Vec(&str) = vec!["foo"];
2604 This is not currently supported: `v` should be defined as `Vec<&str>`.
2605 Parentheses are currently only used with generic types when defining parameters
2606 for `Fn`-family traits.
2610 You used an associated type which isn't defined in the trait.
2611 Erroneous code example:
2613 ```compile_fail,E0220
2618 type Foo = T1<F=i32>; // error: associated type `F` not found for `T1`
2625 // error: Baz is used but not declared
2626 fn return_bool(&self, &Self::Bar, &Self::Baz) -> bool;
2630 Make sure that you have defined the associated type in the trait body.
2631 Also, verify that you used the right trait or you didn't misspell the
2632 associated type name. Example:
2639 type Foo = T1<Bar=i32>; // ok!
2645 type Baz; // we declare `Baz` in our trait.
2647 // and now we can use it here:
2648 fn return_bool(&self, &Self::Bar, &Self::Baz) -> bool;
2654 An attempt was made to retrieve an associated type, but the type was ambiguous.
2657 ```compile_fail,E0221
2673 In this example, `Foo` defines an associated type `A`. `Bar` inherits that type
2674 from `Foo`, and defines another associated type of the same name. As a result,
2675 when we attempt to use `Self::A`, it's ambiguous whether we mean the `A` defined
2676 by `Foo` or the one defined by `Bar`.
2678 There are two options to work around this issue. The first is simply to rename
2679 one of the types. Alternatively, one can specify the intended type using the
2693 let _: <Self as Bar>::A;
2700 An attempt was made to retrieve an associated type, but the type was ambiguous.
2703 ```compile_fail,E0223
2704 trait MyTrait {type X; }
2707 let foo: MyTrait::X;
2711 The problem here is that we're attempting to take the type of X from MyTrait.
2712 Unfortunately, the type of X is not defined, because it's only made concrete in
2713 implementations of the trait. A working version of this code might look like:
2716 trait MyTrait {type X; }
2719 impl MyTrait for MyStruct {
2724 let foo: <MyStruct as MyTrait>::X;
2728 This syntax specifies that we want the X type from MyTrait, as made concrete in
2729 MyStruct. The reason that we cannot simply use `MyStruct::X` is that MyStruct
2730 might implement two different traits with identically-named associated types.
2731 This syntax allows disambiguation between the two.
2735 You attempted to use multiple types as bounds for a closure or trait object.
2736 Rust does not currently support this. A simple example that causes this error:
2738 ```compile_fail,E0225
2740 let _: Box<std::io::Read + std::io::Write>;
2744 Builtin traits are an exception to this rule: it's possible to have bounds of
2745 one non-builtin type, plus any number of builtin types. For example, the
2746 following compiles correctly:
2750 let _: Box<std::io::Read + Send + Sync>;
2756 The attribute must have a value. Erroneous code example:
2758 ```compile_fail,E0232
2759 #![feature(on_unimplemented)]
2761 #[rustc_on_unimplemented] // error: this attribute must have a value
2765 Please supply the missing value of the attribute. Example:
2768 #![feature(on_unimplemented)]
2770 #[rustc_on_unimplemented = "foo"] // ok!
2776 This error indicates that not enough type parameters were found in a type or
2779 For example, the `Foo` struct below is defined to be generic in `T`, but the
2780 type parameter is missing in the definition of `Bar`:
2782 ```compile_fail,E0243
2783 struct Foo<T> { x: T }
2785 struct Bar { x: Foo }
2790 This error indicates that too many type parameters were found in a type or
2793 For example, the `Foo` struct below has no type parameters, but is supplied
2794 with two in the definition of `Bar`:
2796 ```compile_fail,E0244
2797 struct Foo { x: bool }
2799 struct Bar<S, T> { x: Foo<S, T> }
2804 This error indicates an attempt to use a value where a type is expected. For
2807 ```compile_fail,E0248
2812 fn do_something(x: Foo::Bar) { }
2815 In this example, we're attempting to take a type of `Foo::Bar` in the
2816 do_something function. This is not legal: `Foo::Bar` is a value of type `Foo`,
2817 not a distinct static type. Likewise, it's not legal to attempt to
2818 `impl Foo::Bar`: instead, you must `impl Foo` and then pattern match to specify
2819 behavior for specific enum variants.
2823 Default impls for a trait must be located in the same crate where the trait was
2824 defined. For more information see the [opt-in builtin traits RFC](https://github
2825 .com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
2829 A cross-crate opt-out trait was implemented on something which wasn't a struct
2830 or enum type. Erroneous code example:
2832 ```compile_fail,E0321
2833 #![feature(optin_builtin_traits)]
2837 impl !Sync for Foo {}
2839 unsafe impl Send for &'static Foo {}
2840 // error: cross-crate traits with a default impl, like `core::marker::Send`,
2841 // can only be implemented for a struct/enum type, not
2845 Only structs and enums are permitted to impl Send, Sync, and other opt-out
2846 trait, and the struct or enum must be local to the current crate. So, for
2847 example, `unsafe impl Send for Rc<Foo>` is not allowed.
2851 The `Sized` trait is a special trait built-in to the compiler for types with a
2852 constant size known at compile-time. This trait is automatically implemented
2853 for types as needed by the compiler, and it is currently disallowed to
2854 explicitly implement it for a type.
2858 An associated const was implemented when another trait item was expected.
2859 Erroneous code example:
2861 ```compile_fail,E0323
2862 #![feature(associated_consts)]
2872 // error: item `N` is an associated const, which doesn't match its
2873 // trait `<Bar as Foo>`
2877 Please verify that the associated const wasn't misspelled and the correct trait
2878 was implemented. Example:
2888 type N = u32; // ok!
2895 #![feature(associated_consts)]
2904 const N : u32 = 0; // ok!
2910 A method was implemented when another trait item was expected. Erroneous
2913 ```compile_fail,E0324
2914 #![feature(associated_consts)]
2926 // error: item `N` is an associated method, which doesn't match its
2927 // trait `<Bar as Foo>`
2931 To fix this error, please verify that the method name wasn't misspelled and
2932 verify that you are indeed implementing the correct trait items. Example:
2935 #![feature(associated_consts)]
2954 An associated type was implemented when another trait item was expected.
2955 Erroneous code example:
2957 ```compile_fail,E0325
2958 #![feature(associated_consts)]
2968 // error: item `N` is an associated type, which doesn't match its
2969 // trait `<Bar as Foo>`
2973 Please verify that the associated type name wasn't misspelled and your
2974 implementation corresponds to the trait definition. Example:
2984 type N = u32; // ok!
2991 #![feature(associated_consts)]
3000 const N : u32 = 0; // ok!
3006 The types of any associated constants in a trait implementation must match the
3007 types in the trait definition. This error indicates that there was a mismatch.
3009 Here's an example of this error:
3011 ```compile_fail,E0326
3012 #![feature(associated_consts)]
3021 const BAR: u32 = 5; // error, expected bool, found u32
3027 An attempt was made to access an associated constant through either a generic
3028 type parameter or `Self`. This is not supported yet. An example causing this
3029 error is shown below:
3032 #![feature(associated_consts)]
3040 impl Foo for MyStruct {
3041 const BAR: f64 = 0f64;
3044 fn get_bar_bad<F: Foo>(t: F) -> f64 {
3049 Currently, the value of `BAR` for a particular type can only be accessed
3050 through a concrete type, as shown below:
3053 #![feature(associated_consts)]
3061 fn get_bar_good() -> f64 {
3062 <MyStruct as Foo>::BAR
3068 An attempt was made to implement `Drop` on a concrete specialization of a
3069 generic type. An example is shown below:
3071 ```compile_fail,E0366
3076 impl Drop for Foo<u32> {
3077 fn drop(&mut self) {}
3081 This code is not legal: it is not possible to specialize `Drop` to a subset of
3082 implementations of a generic type. One workaround for this is to wrap the
3083 generic type, as shown below:
3095 fn drop(&mut self) {}
3101 An attempt was made to implement `Drop` on a specialization of a generic type.
3102 An example is shown below:
3104 ```compile_fail,E0367
3107 struct MyStruct<T> {
3111 impl<T: Foo> Drop for MyStruct<T> {
3112 fn drop(&mut self) {}
3116 This code is not legal: it is not possible to specialize `Drop` to a subset of
3117 implementations of a generic type. In order for this code to work, `MyStruct`
3118 must also require that `T` implements `Foo`. Alternatively, another option is
3119 to wrap the generic type in another that specializes appropriately:
3124 struct MyStruct<T> {
3128 struct MyStructWrapper<T: Foo> {
3132 impl <T: Foo> Drop for MyStructWrapper<T> {
3133 fn drop(&mut self) {}
3139 This error indicates that a binary assignment operator like `+=` or `^=` was
3140 applied to a type that doesn't support it. For example:
3142 ```compile_fail,E0368
3143 let mut x = 12f32; // error: binary operation `<<` cannot be applied to
3149 To fix this error, please check that this type implements this binary
3153 let mut x = 12u32; // the `u32` type does implement the `ShlAssign` trait
3158 It is also possible to overload most operators for your own type by
3159 implementing the `[OP]Assign` traits from `std::ops`.
3161 Another problem you might be facing is this: suppose you've overloaded the `+`
3162 operator for some type `Foo` by implementing the `std::ops::Add` trait for
3163 `Foo`, but you find that using `+=` does not work, as in this example:
3165 ```compile_fail,E0368
3173 fn add(self, rhs: Foo) -> Foo {
3179 let mut x: Foo = Foo(5);
3180 x += Foo(7); // error, `+= cannot be applied to the type `Foo`
3184 This is because `AddAssign` is not automatically implemented, so you need to
3185 manually implement it for your type.
3189 A binary operation was attempted on a type which doesn't support it.
3190 Erroneous code example:
3192 ```compile_fail,E0369
3193 let x = 12f32; // error: binary operation `<<` cannot be applied to
3199 To fix this error, please check that this type implements this binary
3203 let x = 12u32; // the `u32` type does implement it:
3204 // https://doc.rust-lang.org/stable/std/ops/trait.Shl.html
3209 It is also possible to overload most operators for your own type by
3210 implementing traits from `std::ops`.
3214 The maximum value of an enum was reached, so it cannot be automatically
3215 set in the next enum value. Erroneous code example:
3218 #[deny(overflowing_literals)]
3220 X = 0x7fffffffffffffff,
3221 Y, // error: enum discriminant overflowed on value after
3222 // 9223372036854775807: i64; set explicitly via
3223 // Y = -9223372036854775808 if that is desired outcome
3227 To fix this, please set manually the next enum value or put the enum variant
3228 with the maximum value at the end of the enum. Examples:
3232 X = 0x7fffffffffffffff,
3242 X = 0x7fffffffffffffff,
3248 When `Trait2` is a subtrait of `Trait1` (for example, when `Trait2` has a
3249 definition like `trait Trait2: Trait1 { ... }`), it is not allowed to implement
3250 `Trait1` for `Trait2`. This is because `Trait2` already implements `Trait1` by
3251 definition, so it is not useful to do this.
3255 ```compile_fail,E0371
3256 trait Foo { fn foo(&self) { } }
3260 impl Bar for Baz { } // error, `Baz` implements `Bar` by definition
3261 impl Foo for Baz { } // error, `Baz` implements `Bar` which implements `Foo`
3262 impl Baz for Baz { } // error, `Baz` (trivially) implements `Baz`
3263 impl Baz for Bar { } // Note: This is OK
3268 A struct without a field containing an unsized type cannot implement
3270 [unsized type](https://doc.rust-lang.org/book/unsized-types.html)
3271 is any type that the compiler doesn't know the length or alignment of at
3272 compile time. Any struct containing an unsized type is also unsized.
3274 Example of erroneous code:
3276 ```compile_fail,E0374
3277 #![feature(coerce_unsized)]
3278 use std::ops::CoerceUnsized;
3280 struct Foo<T: ?Sized> {
3284 // error: Struct `Foo` has no unsized fields that need `CoerceUnsized`.
3285 impl<T, U> CoerceUnsized<Foo<U>> for Foo<T>
3286 where T: CoerceUnsized<U> {}
3289 `CoerceUnsized` is used to coerce one struct containing an unsized type
3290 into another struct containing a different unsized type. If the struct
3291 doesn't have any fields of unsized types then you don't need explicit
3292 coercion to get the types you want. To fix this you can either
3293 not try to implement `CoerceUnsized` or you can add a field that is
3294 unsized to the struct.
3299 #![feature(coerce_unsized)]
3300 use std::ops::CoerceUnsized;
3302 // We don't need to impl `CoerceUnsized` here.
3307 // We add the unsized type field to the struct.
3308 struct Bar<T: ?Sized> {
3313 // The struct has an unsized field so we can implement
3314 // `CoerceUnsized` for it.
3315 impl<T, U> CoerceUnsized<Bar<U>> for Bar<T>
3316 where T: CoerceUnsized<U> {}
3319 Note that `CoerceUnsized` is mainly used by smart pointers like `Box`, `Rc`
3320 and `Arc` to be able to mark that they can coerce unsized types that they
3325 A struct with more than one field containing an unsized type cannot implement
3326 `CoerceUnsized`. This only occurs when you are trying to coerce one of the
3327 types in your struct to another type in the struct. In this case we try to
3328 impl `CoerceUnsized` from `T` to `U` which are both types that the struct
3329 takes. An [unsized type](https://doc.rust-lang.org/book/unsized-types.html)
3330 is any type that the compiler doesn't know the length or alignment of at
3331 compile time. Any struct containing an unsized type is also unsized.
3333 Example of erroneous code:
3335 ```compile_fail,E0375
3336 #![feature(coerce_unsized)]
3337 use std::ops::CoerceUnsized;
3339 struct Foo<T: ?Sized, U: ?Sized> {
3345 // error: Struct `Foo` has more than one unsized field.
3346 impl<T, U> CoerceUnsized<Foo<U, T>> for Foo<T, U> {}
3349 `CoerceUnsized` only allows for coercion from a structure with a single
3350 unsized type field to another struct with a single unsized type field.
3351 In fact Rust only allows for a struct to have one unsized type in a struct
3352 and that unsized type must be the last field in the struct. So having two
3353 unsized types in a single struct is not allowed by the compiler. To fix this
3354 use only one field containing an unsized type in the struct and then use
3355 multiple structs to manage each unsized type field you need.
3360 #![feature(coerce_unsized)]
3361 use std::ops::CoerceUnsized;
3363 struct Foo<T: ?Sized> {
3368 impl <T, U> CoerceUnsized<Foo<U>> for Foo<T>
3369 where T: CoerceUnsized<U> {}
3371 fn coerce_foo<T: CoerceUnsized<U>, U>(t: T) -> Foo<U> {
3372 Foo { a: 12i32, b: t } // we use coercion to get the `Foo<U>` type we need
3379 The type you are trying to impl `CoerceUnsized` for is not a struct.
3380 `CoerceUnsized` can only be implemented for a struct. Unsized types are
3381 already able to be coerced without an implementation of `CoerceUnsized`
3382 whereas a struct containing an unsized type needs to know the unsized type
3383 field it's containing is able to be coerced. An
3384 [unsized type](https://doc.rust-lang.org/book/unsized-types.html)
3385 is any type that the compiler doesn't know the length or alignment of at
3386 compile time. Any struct containing an unsized type is also unsized.
3388 Example of erroneous code:
3390 ```compile_fail,E0376
3391 #![feature(coerce_unsized)]
3392 use std::ops::CoerceUnsized;
3394 struct Foo<T: ?Sized> {
3398 // error: The type `U` is not a struct
3399 impl<T, U> CoerceUnsized<U> for Foo<T> {}
3402 The `CoerceUnsized` trait takes a struct type. Make sure the type you are
3403 providing to `CoerceUnsized` is a struct with only the last field containing an
3409 #![feature(coerce_unsized)]
3410 use std::ops::CoerceUnsized;
3416 // The `Foo<U>` is a struct so `CoerceUnsized` can be implemented
3417 impl<T, U> CoerceUnsized<Foo<U>> for Foo<T> where T: CoerceUnsized<U> {}
3420 Note that in Rust, structs can only contain an unsized type if the field
3421 containing the unsized type is the last and only unsized type field in the
3426 Default impls are only allowed for traits with no methods or associated items.
3427 For more information see the [opt-in builtin traits RFC](https://github.com/rust
3428 -lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
3432 You tried to implement methods for a primitive type. Erroneous code example:
3434 ```compile_fail,E0390
3440 // error: only a single inherent implementation marked with
3441 // `#[lang = "mut_ptr"]` is allowed for the `*mut T` primitive
3444 This isn't allowed, but using a trait to implement a method is a good solution.
3456 impl Bar for *mut Foo {
3463 This error indicates that some types or traits depend on each other
3464 and therefore cannot be constructed.
3466 The following example contains a circular dependency between two traits:
3468 ```compile_fail,E0391
3469 trait FirstTrait : SecondTrait {
3473 trait SecondTrait : FirstTrait {
3480 This error indicates that a type or lifetime parameter has been declared
3481 but not actually used. Here is an example that demonstrates the error:
3483 ```compile_fail,E0392
3489 If the type parameter was included by mistake, this error can be fixed
3490 by simply removing the type parameter, as shown below:
3498 Alternatively, if the type parameter was intentionally inserted, it must be
3499 used. A simple fix is shown below:
3507 This error may also commonly be found when working with unsafe code. For
3508 example, when using raw pointers one may wish to specify the lifetime for
3509 which the pointed-at data is valid. An initial attempt (below) causes this
3512 ```compile_fail,E0392
3518 We want to express the constraint that Foo should not outlive `'a`, because
3519 the data pointed to by `T` is only valid for that lifetime. The problem is
3520 that there are no actual uses of `'a`. It's possible to work around this
3521 by adding a PhantomData type to the struct, using it to tell the compiler
3522 to act as if the struct contained a borrowed reference `&'a T`:
3525 use std::marker::PhantomData;
3527 struct Foo<'a, T: 'a> {
3529 phantom: PhantomData<&'a T>
3533 PhantomData can also be used to express information about unused type
3534 parameters. You can read more about it in the API documentation:
3536 https://doc.rust-lang.org/std/marker/struct.PhantomData.html
3540 A type parameter which references `Self` in its default value was not specified.
3541 Example of erroneous code:
3543 ```compile_fail,E0393
3546 fn together_we_will_rule_the_galaxy(son: &A) {}
3547 // error: the type parameter `T` must be explicitly specified in an
3548 // object type because its default value `Self` references the
3552 A trait object is defined over a single, fully-defined trait. With a regular
3553 default parameter, this parameter can just be substituted in. However, if the
3554 default parameter is `Self`, the trait changes for each concrete type; i.e.
3555 `i32` will be expected to implement `A<i32>`, `bool` will be expected to
3556 implement `A<bool>`, etc... These types will not share an implementation of a
3557 fully-defined trait; instead they share implementations of a trait with
3558 different parameters substituted in for each implementation. This is
3559 irreconcilable with what we need to make a trait object work, and is thus
3560 disallowed. Making the trait concrete by explicitly specifying the value of the
3561 defaulted parameter will fix this issue. Fixed example:
3566 fn together_we_will_rule_the_galaxy(son: &A<i32>) {} // Ok!
3571 The length of the platform-intrinsic function `simd_shuffle`
3572 wasn't specified. Erroneous code example:
3574 ```compile_fail,E0439
3575 #![feature(platform_intrinsics)]
3577 extern "platform-intrinsic" {
3578 fn simd_shuffle<A,B>(a: A, b: A, c: [u32; 8]) -> B;
3579 // error: invalid `simd_shuffle`, needs length: `simd_shuffle`
3583 The `simd_shuffle` function needs the length of the array passed as
3584 last parameter in its name. Example:
3587 #![feature(platform_intrinsics)]
3589 extern "platform-intrinsic" {
3590 fn simd_shuffle8<A,B>(a: A, b: A, c: [u32; 8]) -> B;
3596 A platform-specific intrinsic function has the wrong number of type
3597 parameters. Erroneous code example:
3599 ```compile_fail,E0440
3600 #![feature(repr_simd)]
3601 #![feature(platform_intrinsics)]
3604 struct f64x2(f64, f64);
3606 extern "platform-intrinsic" {
3607 fn x86_mm_movemask_pd<T>(x: f64x2) -> i32;
3608 // error: platform-specific intrinsic has wrong number of type
3613 Please refer to the function declaration to see if it corresponds
3614 with yours. Example:
3617 #![feature(repr_simd)]
3618 #![feature(platform_intrinsics)]
3621 struct f64x2(f64, f64);
3623 extern "platform-intrinsic" {
3624 fn x86_mm_movemask_pd(x: f64x2) -> i32;
3630 An unknown platform-specific intrinsic function was used. Erroneous
3633 ```compile_fail,E0441
3634 #![feature(repr_simd)]
3635 #![feature(platform_intrinsics)]
3638 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3640 extern "platform-intrinsic" {
3641 fn x86_mm_adds_ep16(x: i16x8, y: i16x8) -> i16x8;
3642 // error: unrecognized platform-specific intrinsic function
3646 Please verify that the function name wasn't misspelled, and ensure
3647 that it is declared in the rust source code (in the file
3648 src/librustc_platform_intrinsics/x86.rs). Example:
3651 #![feature(repr_simd)]
3652 #![feature(platform_intrinsics)]
3655 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3657 extern "platform-intrinsic" {
3658 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8; // ok!
3664 Intrinsic argument(s) and/or return value have the wrong type.
3665 Erroneous code example:
3667 ```compile_fail,E0442
3668 #![feature(repr_simd)]
3669 #![feature(platform_intrinsics)]
3672 struct i8x16(i8, i8, i8, i8, i8, i8, i8, i8,
3673 i8, i8, i8, i8, i8, i8, i8, i8);
3675 struct i32x4(i32, i32, i32, i32);
3677 struct i64x2(i64, i64);
3679 extern "platform-intrinsic" {
3680 fn x86_mm_adds_epi16(x: i8x16, y: i32x4) -> i64x2;
3681 // error: intrinsic arguments/return value have wrong type
3685 To fix this error, please refer to the function declaration to give
3686 it the awaited types. Example:
3689 #![feature(repr_simd)]
3690 #![feature(platform_intrinsics)]
3693 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3695 extern "platform-intrinsic" {
3696 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8; // ok!
3702 Intrinsic argument(s) and/or return value have the wrong type.
3703 Erroneous code example:
3705 ```compile_fail,E0443
3706 #![feature(repr_simd)]
3707 #![feature(platform_intrinsics)]
3710 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3712 struct i64x8(i64, i64, i64, i64, i64, i64, i64, i64);
3714 extern "platform-intrinsic" {
3715 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i64x8;
3716 // error: intrinsic argument/return value has wrong type
3720 To fix this error, please refer to the function declaration to give
3721 it the awaited types. Example:
3724 #![feature(repr_simd)]
3725 #![feature(platform_intrinsics)]
3728 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3730 extern "platform-intrinsic" {
3731 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8; // ok!
3737 A platform-specific intrinsic function has wrong number of arguments.
3738 Erroneous code example:
3740 ```compile_fail,E0444
3741 #![feature(repr_simd)]
3742 #![feature(platform_intrinsics)]
3745 struct f64x2(f64, f64);
3747 extern "platform-intrinsic" {
3748 fn x86_mm_movemask_pd(x: f64x2, y: f64x2, z: f64x2) -> i32;
3749 // error: platform-specific intrinsic has invalid number of arguments
3753 Please refer to the function declaration to see if it corresponds
3754 with yours. Example:
3757 #![feature(repr_simd)]
3758 #![feature(platform_intrinsics)]
3761 struct f64x2(f64, f64);
3763 extern "platform-intrinsic" {
3764 fn x86_mm_movemask_pd(x: f64x2) -> i32; // ok!
3770 The type of the variable couldn't be found out.
3772 Erroneous code example:
3774 ```compile_fail,E0513
3778 let size = mem::size_of::<u32>();
3779 mem::transmute_copy::<u32, [u8; size]>(&8_8);
3780 // error: no type for local variable
3784 To fix this error, please use a constant size instead of `size`. To make
3785 this error more obvious, you could run:
3787 ```compile_fail,E0080
3791 mem::transmute_copy::<u32, [u8; mem::size_of::<u32>()]>(&8_8);
3792 // error: constant evaluation error
3796 So now, you can fix your code by setting the size directly:
3802 mem::transmute_copy::<u32, [u8; 4]>(&8_8);
3803 // `u32` is 4 bytes so we replace the `mem::size_of` call with its size
3809 The `typeof` keyword is currently reserved but unimplemented.
3810 Erroneous code example:
3812 ```compile_fail,E0516
3814 let x: typeof(92) = 92;
3818 Try using type inference instead. Example:
3828 A non-default implementation was already made on this type so it cannot be
3829 specialized further. Erroneous code example:
3831 ```compile_fail,E0520
3832 #![feature(specialization)]
3839 impl<T> SpaceLlama for T {
3840 default fn fly(&self) {}
3844 // applies to all `Clone` T and overrides the previous impl
3845 impl<T: Clone> SpaceLlama for T {
3849 // since `i32` is clone, this conflicts with the previous implementation
3850 impl SpaceLlama for i32 {
3851 default fn fly(&self) {}
3852 // error: item `fly` is provided by an `impl` that specializes
3853 // another, but the item in the parent `impl` is not marked
3854 // `default` and so it cannot be specialized.
3858 Specialization only allows you to override `default` functions in
3861 To fix this error, you need to mark all the parent implementations as default.
3865 #![feature(specialization)]
3872 impl<T> SpaceLlama for T {
3873 default fn fly(&self) {} // This is a parent implementation.
3876 // applies to all `Clone` T; overrides the previous impl
3877 impl<T: Clone> SpaceLlama for T {
3878 default fn fly(&self) {} // This is a parent implementation but was
3879 // previously not a default one, causing the error
3882 // applies to i32, overrides the previous two impls
3883 impl SpaceLlama for i32 {
3884 fn fly(&self) {} // And now that's ok!
3890 The number of elements in an array or slice pattern differed from the number of
3891 elements in the array being matched.
3893 Example of erroneous code:
3895 ```compile_fail,E0527
3896 #![feature(slice_patterns)]
3898 let r = &[1, 2, 3, 4];
3900 &[a, b] => { // error: pattern requires 2 elements but array
3902 println!("a={}, b={}", a, b);
3907 Ensure that the pattern is consistent with the size of the matched
3908 array. Additional elements can be matched with `..`:
3911 #![feature(slice_patterns)]
3913 let r = &[1, 2, 3, 4];
3915 &[a, b, ..] => { // ok!
3916 println!("a={}, b={}", a, b);
3923 An array or slice pattern required more elements than were present in the
3926 Example of erroneous code:
3928 ```compile_fail,E0528
3929 #![feature(slice_patterns)]
3933 &[a, b, c, rest..] => { // error: pattern requires at least 3
3934 // elements but array has 2
3935 println!("a={}, b={}, c={} rest={:?}", a, b, c, rest);
3940 Ensure that the matched array has at least as many elements as the pattern
3941 requires. You can match an arbitrary number of remaining elements with `..`:
3944 #![feature(slice_patterns)]
3946 let r = &[1, 2, 3, 4, 5];
3948 &[a, b, c, rest..] => { // ok!
3949 // prints `a=1, b=2, c=3 rest=[4, 5]`
3950 println!("a={}, b={}, c={} rest={:?}", a, b, c, rest);
3957 An array or slice pattern was matched against some other type.
3959 Example of erroneous code:
3961 ```compile_fail,E0529
3962 #![feature(slice_patterns)]
3966 [a, b] => { // error: expected an array or slice, found `f32`
3967 println!("a={}, b={}", a, b);
3972 Ensure that the pattern and the expression being matched on are of consistent
3976 #![feature(slice_patterns)]
3981 println!("a={}, b={}", a, b);
3988 An unknown field was specified into an enum's structure variant.
3990 Erroneous code example:
3992 ```compile_fail,E0559
3997 let s = Field::Fool { joke: 0 };
3998 // error: struct variant `Field::Fool` has no field named `joke`
4001 Verify you didn't misspell the field's name or that the field exists. Example:
4008 let s = Field::Fool { joke: 0 }; // ok!
4013 An unknown field was specified into a structure.
4015 Erroneous code example:
4017 ```compile_fail,E0560
4022 let s = Simba { mother: 1, father: 0 };
4023 // error: structure `Simba` has no field named `father`
4026 Verify you didn't misspell the field's name or that the field exists. Example:
4034 let s = Simba { mother: 1, father: 0 }; // ok!
4040 register_diagnostics
! {
4045 E0103
, // @GuillaumeGomez: I was unable to get this error, try your best!
4051 // E0159, // use of trait `{}` as struct constructor
4052 // E0163, // merged into E0071
4055 // E0173, // manual implementations of unboxed closure traits are experimental
4059 // E0187, // can't infer the kind of the closure
4060 // E0188, // can not cast an immutable reference to a mutable pointer
4061 // E0189, // deprecated: can only cast a boxed pointer to a boxed object
4062 // E0190, // deprecated: can only cast a &-pointer to an &-object
4063 E0196
, // cannot determine a type for this closure
4064 E0203
, // type parameter has more than one relaxed default bound,
4065 // and only one is supported
4067 // E0209, // builtin traits can only be implemented on structs or enums
4068 E0212
, // cannot extract an associated type from a higher-ranked trait bound
4069 // E0213, // associated types are not accepted in this context
4070 // E0215, // angle-bracket notation is not stable with `Fn`
4071 // E0216, // parenthetical notation is only stable with `Fn`
4072 // E0217, // ambiguous associated type, defined in multiple supertraits
4073 // E0218, // no associated type defined
4074 // E0219, // associated type defined in higher-ranked supertrait
4075 // E0222, // Error code E0045 (variadic function must have C calling
4076 // convention) duplicate
4077 E0224
, // at least one non-builtin train is required for an object type
4078 E0226
, // only a single explicit lifetime bound is permitted
4079 E0227
, // ambiguous lifetime bound, explicit lifetime bound required
4080 E0228
, // explicit lifetime bound required
4081 E0230
, // there is no type parameter on trait
4082 E0231
, // only named substitution parameters are allowed
4085 // E0235, // structure constructor specifies a structure of type but
4086 // E0236, // no lang item for range syntax
4087 // E0237, // no lang item for range syntax
4088 // E0238, // parenthesized parameters may only be used with a trait
4089 // E0239, // `next` method of `Iterator` trait has unexpected type
4093 E0245
, // not a trait
4094 // E0246, // invalid recursive type
4097 // E0319, // trait impls for defaulted traits allowed just for structs/enums
4098 E0320
, // recursive overflow during dropck
4099 E0328
, // cannot implement Unsize explicitly
4100 // E0372, // coherence not object safe
4101 E0377
, // the trait `CoerceUnsized` may only be implemented for a coercion
4102 // between structures with the same definition
4103 E0399
, // trait items need to be implemented because the associated
4104 // type `{}` was overridden
4105 E0436
, // functional record update requires a struct
4106 E0521
, // redundant default implementations of trait
4107 E0533
, // `{}` does not name a unit variant, unit struct or a constant
4108 E0562
, // `impl Trait` not allowed outside of function
4109 // and inherent method return types
4110 E0563
, // cannot determine a type for this `impl Trait`: {}
4111 E0564
, // only named lifetimes are allowed in `impl Trait`,
4112 // but `{}` was found in the type `{}`
4113 E0567
, // auto traits can not have type parameters
4114 E0568
, // auto-traits can not have predicates,