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.
229 ```compile_fail,E0033
230 # trait SomeTrait { fn method_one(&self){} fn method_two(&self){} }
231 # impl<T> SomeTrait for T {}
232 let trait_obj: &SomeTrait = &"some_value";
234 // This tries to implicitly dereference to create an unsized local variable.
235 let &invalid = trait_obj;
237 // You can call methods without binding to the value being pointed at.
238 trait_obj.method_one();
239 trait_obj.method_two();
242 You can read more about trait objects in the Trait Object section of the
245 https://doc.rust-lang.org/reference.html#trait-objects
249 The compiler doesn't know what method to call because more than one method
250 has the same prototype. Erroneous code example:
252 ```compile_fail,E0034
263 impl Trait1 for Test { fn foo() {} }
264 impl Trait2 for Test { fn foo() {} }
267 Test::foo() // error, which foo() to call?
271 To avoid this error, you have to keep only one of them and remove the others.
272 So let's take our example and fix it:
281 impl Trait1 for Test { fn foo() {} }
284 Test::foo() // and now that's good!
288 However, a better solution would be using fully explicit naming of type and
302 impl Trait1 for Test { fn foo() {} }
303 impl Trait2 for Test { fn foo() {} }
306 <Test as Trait1>::foo()
323 impl F for X { fn m(&self) { println!("I am F"); } }
324 impl G for X { fn m(&self) { println!("I am G"); } }
329 F::m(&f); // it displays "I am F"
330 G::m(&f); // it displays "I am G"
336 You tried to give a type parameter where it wasn't needed. Erroneous code
339 ```compile_fail,E0035
349 x.method::<i32>(); // Error: Test::method doesn't need type parameter!
353 To fix this error, just remove the type parameter:
365 x.method(); // OK, we're good!
371 This error occurrs when you pass too many or not enough type parameters to
372 a method. Erroneous code example:
374 ```compile_fail,E0036
378 fn method<T>(&self, v: &[T]) -> usize {
387 x.method::<i32, i32>(v); // error: only one type parameter is expected!
391 To fix it, just specify a correct number of type parameters:
397 fn method<T>(&self, v: &[T]) -> usize {
406 x.method::<i32>(v); // OK, we're good!
410 Please note on the last example that we could have called `method` like this:
414 # impl Test { fn method<T>(&self, v: &[T]) -> usize { v.len() } }
422 It is not allowed to manually call destructors in Rust. It is also not
423 necessary to do this since `drop` is called automatically whenever a value goes
426 Here's an example of this error:
428 ```compile_fail,E0040
440 let mut x = Foo { x: -7 };
441 x.drop(); // error: explicit use of destructor method
447 You can't use type parameters on foreign items. Example of erroneous code:
449 ```compile_fail,E0044
450 extern { fn some_func<T>(x: T); }
453 To fix this, replace the type parameter with the specializations that you
457 extern { fn some_func_i32(x: i32); }
458 extern { fn some_func_i64(x: i64); }
463 Rust only supports variadic parameters for interoperability with C code in its
464 FFI. As such, variadic parameters can only be used with functions which are
465 using the C ABI. Examples of erroneous code:
468 #![feature(unboxed_closures)]
470 extern "rust-call" { fn foo(x: u8, ...); }
474 fn foo(x: u8, ...) {}
477 To fix such code, put them in an extern "C" block:
487 Items are missing in a trait implementation. Erroneous code example:
489 ```compile_fail,E0046
497 // error: not all trait items implemented, missing: `foo`
500 When trying to make some type implement a trait `Foo`, you must, at minimum,
501 provide implementations for all of `Foo`'s required methods (meaning the
502 methods that do not have default implementations), as well as any required
503 trait items like associated types or constants. Example:
519 This error indicates that an attempted implementation of a trait method
520 has the wrong number of type parameters.
522 For example, the trait below has a method `foo` with a type parameter `T`,
523 but the implementation of `foo` for the type `Bar` is missing this parameter:
525 ```compile_fail,E0049
527 fn foo<T: Default>(x: T) -> Self;
532 // error: method `foo` has 0 type parameters but its trait declaration has 1
535 fn foo(x: bool) -> Self { Bar }
541 This error indicates that an attempted implementation of a trait method
542 has the wrong number of function parameters.
544 For example, the trait below has a method `foo` with two function parameters
545 (`&self` and `u8`), but the implementation of `foo` for the type `Bar` omits
548 ```compile_fail,E0050
550 fn foo(&self, x: u8) -> bool;
555 // error: method `foo` has 1 parameter but the declaration in trait `Foo::foo`
558 fn foo(&self) -> bool { true }
564 The parameters of any trait method must match between a trait implementation
565 and the trait definition.
567 Here are a couple examples of this error:
569 ```compile_fail,E0053
578 // error, expected u16, found i16
581 // error, types differ in mutability
582 fn bar(&mut self) { }
588 It is not allowed to cast to a bool. If you are trying to cast a numeric type
589 to a bool, you can compare it with zero instead:
591 ```compile_fail,E0054
594 // Not allowed, won't compile
595 let x_is_nonzero = x as bool;
602 let x_is_nonzero = x != 0;
607 During a method call, a value is automatically dereferenced as many times as
608 needed to make the value's type match the method's receiver. The catch is that
609 the compiler will only attempt to dereference a number of times up to the
610 recursion limit (which can be set via the `recursion_limit` attribute).
612 For a somewhat artificial example:
614 ```compile_fail,E0055
615 #![recursion_limit="2"]
627 // error, reached the recursion limit while auto-dereferencing &&Foo
632 One fix may be to increase the recursion limit. Note that it is possible to
633 create an infinite recursion of dereferencing, in which case the only fix is to
634 somehow break the recursion.
638 When invoking closures or other implementations of the function traits `Fn`,
639 `FnMut` or `FnOnce` using call notation, the number of parameters passed to the
640 function must match its definition.
642 An example using a closure:
644 ```compile_fail,E0057
646 let a = f(); // invalid, too few parameters
647 let b = f(4); // this works!
648 let c = f(2, 3); // invalid, too many parameters
651 A generic function must be treated similarly:
654 fn foo<F: Fn()>(f: F) {
655 f(); // this is valid, but f(3) would not work
661 The built-in function traits are generic over a tuple of the function arguments.
662 If one uses angle-bracket notation (`Fn<(T,), Output=U>`) instead of parentheses
663 (`Fn(T) -> U`) to denote the function trait, the type parameter should be a
664 tuple. Otherwise function call notation cannot be used and the trait will not be
665 implemented by closures.
667 The most likely source of this error is using angle-bracket notation without
668 wrapping the function argument type into a tuple, for example:
670 ```compile_fail,E0059
671 #![feature(unboxed_closures)]
673 fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) }
676 It can be fixed by adjusting the trait bound like this:
679 #![feature(unboxed_closures)]
681 fn foo<F: Fn<(i32,)>>(f: F) -> F::Output { f(3) }
684 Note that `(T,)` always denotes the type of a 1-tuple containing an element of
685 type `T`. The comma is necessary for syntactic disambiguation.
689 External C functions are allowed to be variadic. However, a variadic function
690 takes a minimum number of arguments. For example, consider C's variadic `printf`
694 use std::os::raw::{c_char, c_int};
697 fn printf(_: *const c_char, ...) -> c_int;
701 Using this declaration, it must be called with at least one argument, so
702 simply calling `printf()` is invalid. But the following uses are allowed:
705 # #![feature(static_nobundle)]
706 # use std::os::raw::{c_char, c_int};
707 # #[cfg_attr(all(windows, target_env = "msvc"),
708 # link(name = "legacy_stdio_definitions", kind = "static-nobundle"))]
709 # extern "C" { fn printf(_: *const c_char, ...) -> c_int; }
712 use std::ffi::CString;
714 let fmt = CString::new("test\n").unwrap();
715 printf(fmt.as_ptr());
717 let fmt = CString::new("number = %d\n").unwrap();
718 printf(fmt.as_ptr(), 3);
720 let fmt = CString::new("%d, %d\n").unwrap();
721 printf(fmt.as_ptr(), 10, 5);
726 // ^ Note: On MSVC 2015, the `printf` function is "inlined" in the C code, and
727 // the C runtime does not contain the `printf` definition. This leads to linker
728 // error from the doc test (issue #42830).
729 // This can be fixed by linking to the static library
730 // `legacy_stdio_definitions.lib` (see https://stackoverflow.com/a/36504365/).
731 // If this compatibility library is removed in the future, consider changing
732 // `printf` in this example to another well-known variadic function.
735 The number of arguments passed to a function must match the number of arguments
736 specified in the function signature.
738 For example, a function like:
741 fn f(a: u16, b: &str) {}
744 Must always be called with exactly two arguments, e.g. `f(2, "test")`.
746 Note that Rust does not have a notion of optional function arguments or
747 variadic functions (except for its C-FFI).
751 This error indicates that during an attempt to build a struct or struct-like
752 enum variant, one of the fields was specified more than once. Erroneous code
755 ```compile_fail,E0062
763 x: 0, // error: field `x` specified more than once
768 Each field should be specified exactly one time. Example:
776 let x = Foo { x: 0 }; // ok!
782 This error indicates that during an attempt to build a struct or struct-like
783 enum variant, one of the fields was not provided. Erroneous code example:
785 ```compile_fail,E0063
792 let x = Foo { x: 0 }; // error: missing field: `y`
796 Each field should be specified exactly once. Example:
805 let x = Foo { x: 0, y: 0 }; // ok!
811 Box placement expressions (like C++'s "placement new") do not yet support any
812 place expression except the exchange heap (i.e. `std::boxed::HEAP`).
813 Furthermore, the syntax is changing to use `in` instead of `box`. See [RFC 470]
814 and [RFC 809] for more details.
816 [RFC 470]: https://github.com/rust-lang/rfcs/pull/470
817 [RFC 809]: https://github.com/rust-lang/rfcs/blob/master/text/0809-box-and-in-for-stdlib.md
821 The left-hand side of a compound assignment expression must be an lvalue
822 expression. An lvalue expression represents a memory location and includes
823 item paths (ie, namespaced variables), dereferences, indexing expressions,
824 and field references.
826 Let's start with some erroneous code examples:
828 ```compile_fail,E0067
829 use std::collections::LinkedList;
831 // Bad: assignment to non-lvalue expression
832 LinkedList::new() += 1;
836 fn some_func(i: &mut i32) {
837 i += 12; // Error : '+=' operation cannot be applied on a reference !
841 And now some working examples:
850 fn some_func(i: &mut i32) {
857 The compiler found a function whose body contains a `return;` statement but
858 whose return type is not `()`. An example of this is:
860 ```compile_fail,E0069
867 Since `return;` is just like `return ();`, there is a mismatch between the
868 function's return type and the value being returned.
872 The left-hand side of an assignment operator must be an lvalue expression. An
873 lvalue expression represents a memory location and can be a variable (with
874 optional namespacing), a dereference, an indexing expression or a field
877 More details can be found here:
878 https://doc.rust-lang.org/reference.html#lvalues-rvalues-and-temporaries
880 Now, we can go further. Here are some erroneous code examples:
882 ```compile_fail,E0070
888 const SOME_CONST : i32 = 12;
890 fn some_other_func() {}
893 SOME_CONST = 14; // error : a constant value cannot be changed!
894 1 = 3; // error : 1 isn't a valid lvalue!
895 some_other_func() = 4; // error : we can't assign value to a function!
896 SomeStruct.x = 12; // error : SomeStruct a structure name but it is used
901 And now let's give working examples:
908 let mut s = SomeStruct {x: 0, y: 0};
910 s.x = 3; // that's good !
914 fn some_func(x: &mut i32) {
915 *x = 12; // that's good !
921 You tried to use structure-literal syntax to create an item that is
922 not a structure or enum variant.
924 Example of erroneous code:
926 ```compile_fail,E0071
928 let t = U32 { value: 4 }; // error: expected struct, variant or union type,
929 // found builtin type `u32`
932 To fix this, ensure that the name was correctly spelled, and that
933 the correct form of initializer was used.
935 For example, the code above can be fixed to:
943 let u = Foo::FirstValue(0i32);
951 #### Note: this error code is no longer emitted by the compiler.
953 You cannot define a struct (or enum) `Foo` that requires an instance of `Foo`
954 in order to make a new `Foo` value. This is because there would be no way a
955 first instance of `Foo` could be made to initialize another instance!
957 Here's an example of a struct that has this problem:
960 struct Foo { x: Box<Foo> } // error
963 One fix is to use `Option`, like so:
966 struct Foo { x: Option<Box<Foo>> }
969 Now it's possible to create at least one instance of `Foo`: `Foo { x: None }`.
973 #### Note: this error code is no longer emitted by the compiler.
975 When using the `#[simd]` attribute on a tuple struct, the components of the
976 tuple struct must all be of a concrete, nongeneric type so the compiler can
977 reason about how to use SIMD with them. This error will occur if the types
980 This will cause an error:
983 #![feature(repr_simd)]
986 struct Bad<T>(T, T, T);
992 #![feature(repr_simd)]
995 struct Good(u32, u32, u32);
1000 The `#[simd]` attribute can only be applied to non empty tuple structs, because
1001 it doesn't make sense to try to use SIMD operations when there are no values to
1004 This will cause an error:
1006 ```compile_fail,E0075
1007 #![feature(repr_simd)]
1016 #![feature(repr_simd)]
1024 When using the `#[simd]` attribute to automatically use SIMD operations in tuple
1025 struct, the types in the struct must all be of the same type, or the compiler
1026 will trigger this error.
1028 This will cause an error:
1030 ```compile_fail,E0076
1031 #![feature(repr_simd)]
1034 struct Bad(u16, u32, u32);
1040 #![feature(repr_simd)]
1043 struct Good(u32, u32, u32);
1048 When using the `#[simd]` attribute on a tuple struct, the elements in the tuple
1049 must be machine types so SIMD operations can be applied to them.
1051 This will cause an error:
1053 ```compile_fail,E0077
1054 #![feature(repr_simd)]
1063 #![feature(repr_simd)]
1066 struct Good(u32, u32, u32);
1071 Enum discriminants are used to differentiate enum variants stored in memory.
1072 This error indicates that the same value was used for two or more variants,
1073 making them impossible to tell apart.
1075 ```compile_fail,E0081
1093 Note that variants without a manually specified discriminant are numbered from
1094 top to bottom starting from 0, so clashes can occur with seemingly unrelated
1097 ```compile_fail,E0081
1104 Here `X` will have already been specified the discriminant 0 by the time `Y` is
1105 encountered, so a conflict occurs.
1109 #### Note: this error code is no longer emitted by the compiler.
1111 When you specify enum discriminants with `=`, the compiler expects `isize`
1112 values by default. Or you can add the `repr` attibute to the enum declaration
1113 for an explicit choice of the discriminant type. In either cases, the
1114 discriminant values must fall within a valid range for the expected type;
1115 otherwise this error is raised. For example:
1118 # #![deny(overflowing_literals)]
1126 Here, 1024 lies outside the valid range for `u8`, so the discriminant for `A` is
1127 invalid. Here is another, more subtle example which depends on target word size:
1129 ```compile_fail,E0080
1131 enum DependsOnPointerSize {
1136 Here, `1 << 32` is interpreted as an `isize` value. So it is invalid for 32 bit
1137 target (`target_pointer_width = "32"`) but valid for 64 bit target.
1139 You may want to change representation types to fix this, or else change invalid
1140 discriminant values so that they fit within the existing type.
1144 An unsupported representation was attempted on a zero-variant enum.
1146 Erroneous code example:
1148 ```compile_fail,E0084
1150 enum NightsWatch {} // error: unsupported representation for zero-variant enum
1153 It is impossible to define an integer type to be used to represent zero-variant
1154 enum values because there are no zero-variant enum values. There is no way to
1155 construct an instance of the following type using only safe code. So you have
1156 two solutions. Either you add variants in your enum:
1166 or you remove the integer represention of your enum:
1174 Too many type parameters were supplied for a function. For example:
1176 ```compile_fail,E0087
1180 foo::<f64, bool>(); // error, expected 1 parameter, found 2 parameters
1184 The number of supplied parameters must exactly match the number of defined type
1189 You gave too many lifetime parameters. Erroneous code example:
1191 ```compile_fail,E0088
1195 f::<'static>() // error: too many lifetime parameters provided
1199 Please check you give the right number of lifetime parameters. Example:
1209 It's also important to note that the Rust compiler can generally
1210 determine the lifetime by itself. Example:
1218 // it can be written like this
1219 fn get_value<'a>(&'a self) -> &'a str { &self.value }
1220 // but the compiler works fine with this too:
1221 fn without_lifetime(&self) -> &str { &self.value }
1225 let f = Foo { value: "hello".to_owned() };
1227 println!("{}", f.get_value());
1228 println!("{}", f.without_lifetime());
1234 Not enough type parameters were supplied for a function. For example:
1236 ```compile_fail,E0089
1240 foo::<f64>(); // error, expected 2 parameters, found 1 parameter
1244 Note that if a function takes multiple type parameters but you want the compiler
1245 to infer some of them, you can use type placeholders:
1247 ```compile_fail,E0089
1248 fn foo<T, U>(x: T) {}
1252 foo::<f64>(x); // error, expected 2 parameters, found 1 parameter
1253 foo::<_, f64>(x); // same as `foo::<bool, f64>(x)`
1259 You gave too few lifetime parameters. Example:
1261 ```compile_fail,E0090
1262 fn foo<'a: 'b, 'b: 'a>() {}
1265 foo::<'static>(); // error, expected 2 lifetime parameters
1269 Please check you give the right number of lifetime parameters. Example:
1272 fn foo<'a: 'b, 'b: 'a>() {}
1275 foo::<'static, 'static>();
1281 You gave an unnecessary type parameter in a type alias. Erroneous code
1284 ```compile_fail,E0091
1285 type Foo<T> = u32; // error: type parameter `T` is unused
1287 type Foo<A,B> = Box<A>; // error: type parameter `B` is unused
1290 Please check you didn't write too many type parameters. Example:
1293 type Foo = u32; // ok!
1294 type Foo2<A> = Box<A>; // ok!
1299 You tried to declare an undefined atomic operation function.
1300 Erroneous code example:
1302 ```compile_fail,E0092
1303 #![feature(intrinsics)]
1305 extern "rust-intrinsic" {
1306 fn atomic_foo(); // error: unrecognized atomic operation
1311 Please check you didn't make a mistake in the function's name. All intrinsic
1312 functions are defined in librustc_trans/trans/intrinsic.rs and in
1313 libcore/intrinsics.rs in the Rust source code. Example:
1316 #![feature(intrinsics)]
1318 extern "rust-intrinsic" {
1319 fn atomic_fence(); // ok!
1325 You declared an unknown intrinsic function. Erroneous code example:
1327 ```compile_fail,E0093
1328 #![feature(intrinsics)]
1330 extern "rust-intrinsic" {
1331 fn foo(); // error: unrecognized intrinsic function: `foo`
1341 Please check you didn't make a mistake in the function's name. All intrinsic
1342 functions are defined in librustc_trans/trans/intrinsic.rs and in
1343 libcore/intrinsics.rs in the Rust source code. Example:
1346 #![feature(intrinsics)]
1348 extern "rust-intrinsic" {
1349 fn atomic_fence(); // ok!
1361 You gave an invalid number of type parameters to an intrinsic function.
1362 Erroneous code example:
1364 ```compile_fail,E0094
1365 #![feature(intrinsics)]
1367 extern "rust-intrinsic" {
1368 fn size_of<T, U>() -> usize; // error: intrinsic has wrong number
1369 // of type parameters
1373 Please check that you provided the right number of type parameters
1374 and verify with the function declaration in the Rust source code.
1378 #![feature(intrinsics)]
1380 extern "rust-intrinsic" {
1381 fn size_of<T>() -> usize; // ok!
1387 This error means that an incorrect number of lifetime parameters were provided
1388 for a type (like a struct or enum) or trait:
1390 ```compile_fail,E0107
1391 struct Foo<'a, 'b>(&'a str, &'b str);
1392 enum Bar { A, B, C }
1395 foo: Foo<'a>, // error: expected 2, found 1
1396 bar: Bar<'a>, // error: expected 0, found 1
1402 You tried to give a type parameter to a type which doesn't need it. Erroneous
1405 ```compile_fail,E0109
1406 type X = u32<i32>; // error: type parameters are not allowed on this type
1409 Please check that you used the correct type and recheck its definition. Perhaps
1410 it doesn't need the type parameter.
1415 type X = u32; // this compiles
1418 Note that type parameters for enum-variant constructors go after the variant,
1419 not after the enum (`Option::None::<u32>`, not `Option::<u32>::None`).
1423 You tried to give a lifetime parameter to a type which doesn't need it.
1424 Erroneous code example:
1426 ```compile_fail,E0110
1427 type X = u32<'static>; // error: lifetime parameters are not allowed on
1431 Please check that the correct type was used and recheck its definition; perhaps
1432 it doesn't need the lifetime parameter. Example:
1435 type X = u32; // ok!
1440 You can only define an inherent implementation for a type in the same crate
1441 where the type was defined. For example, an `impl` block as below is not allowed
1442 since `Vec` is defined in the standard library:
1444 ```compile_fail,E0116
1445 impl Vec<u8> { } // error
1448 To fix this problem, you can do either of these things:
1450 - define a trait that has the desired associated functions/types/constants and
1451 implement the trait for the type in question
1452 - define a new type wrapping the type and define an implementation on the new
1455 Note that using the `type` keyword does not work here because `type` only
1456 introduces a type alias:
1458 ```compile_fail,E0116
1459 type Bytes = Vec<u8>;
1461 impl Bytes { } // error, same as above
1466 This error indicates a violation of one of Rust's orphan rules for trait
1467 implementations. The rule prohibits any implementation of a foreign trait (a
1468 trait defined in another crate) where
1470 - the type that is implementing the trait is foreign
1471 - all of the parameters being passed to the trait (if there are any) are also
1474 Here's one example of this error:
1476 ```compile_fail,E0117
1477 impl Drop for u32 {}
1480 To avoid this kind of error, ensure that at least one local type is referenced
1484 pub struct Foo; // you define your type in your crate
1486 impl Drop for Foo { // and you can implement the trait on it!
1487 // code of trait implementation here
1488 # fn drop(&mut self) { }
1491 impl From<Foo> for i32 { // or you use a type from your crate as
1493 fn from(i: Foo) -> i32 {
1499 Alternatively, define a trait locally and implement that instead:
1503 fn get(&self) -> usize;
1507 fn get(&self) -> usize { 0 }
1511 For information on the design of the orphan rules, see [RFC 1023].
1513 [RFC 1023]: https://github.com/rust-lang/rfcs/blob/master/text/1023-rebalancing-coherence.md
1517 You're trying to write an inherent implementation for something which isn't a
1518 struct nor an enum. Erroneous code example:
1520 ```compile_fail,E0118
1521 impl (u8, u8) { // error: no base type found for inherent implementation
1522 fn get_state(&self) -> String {
1528 To fix this error, please implement a trait on the type or wrap it in a struct.
1532 // we create a trait here
1533 trait LiveLongAndProsper {
1534 fn get_state(&self) -> String;
1537 // and now you can implement it on (u8, u8)
1538 impl LiveLongAndProsper for (u8, u8) {
1539 fn get_state(&self) -> String {
1540 "He's dead, Jim!".to_owned()
1545 Alternatively, you can create a newtype. A newtype is a wrapping tuple-struct.
1546 For example, `NewType` is a newtype over `Foo` in `struct NewType(Foo)`.
1550 struct TypeWrapper((u8, u8));
1553 fn get_state(&self) -> String {
1554 "Fascinating!".to_owned()
1561 An attempt was made to implement Drop on a trait, which is not allowed: only
1562 structs and enums can implement Drop. An example causing this error:
1564 ```compile_fail,E0120
1567 impl Drop for MyTrait {
1568 fn drop(&mut self) {}
1572 A workaround for this problem is to wrap the trait up in a struct, and implement
1573 Drop on that. An example is shown below:
1577 struct MyWrapper<T: MyTrait> { foo: T }
1579 impl <T: MyTrait> Drop for MyWrapper<T> {
1580 fn drop(&mut self) {}
1585 Alternatively, wrapping trait objects requires something like the following:
1590 //or Box<MyTrait>, if you wanted an owned trait object
1591 struct MyWrapper<'a> { foo: &'a MyTrait }
1593 impl <'a> Drop for MyWrapper<'a> {
1594 fn drop(&mut self) {}
1600 In order to be consistent with Rust's lack of global type inference, type
1601 placeholders are disallowed by design in item signatures.
1603 Examples of this error include:
1605 ```compile_fail,E0121
1606 fn foo() -> _ { 5 } // error, explicitly write out the return type instead
1608 static BAR: _ = "test"; // error, explicitly write out the type instead
1613 An attempt was made to add a generic constraint to a type alias. While Rust will
1614 allow this with a warning, it will not currently enforce the constraint.
1615 Consider the example below:
1620 type MyType<R: Foo> = (R, ());
1627 We're able to declare a variable of type `MyType<u32>`, despite the fact that
1628 `u32` does not implement `Foo`. As a result, one should avoid using generic
1629 constraints in concert with type aliases.
1633 You declared two fields of a struct with the same name. Erroneous code
1636 ```compile_fail,E0124
1639 field1: i32, // error: field is already declared
1643 Please verify that the field names have been correctly spelled. Example:
1654 It is not possible to define `main` with type parameters, or even with function
1655 parameters. When `main` is present, it must take no arguments and return `()`.
1656 Erroneous code example:
1658 ```compile_fail,E0131
1659 fn main<T>() { // error: main function is not allowed to have type parameters
1665 A function with the `start` attribute was declared with type parameters.
1667 Erroneous code example:
1669 ```compile_fail,E0132
1676 It is not possible to declare type parameters on a function that has the `start`
1677 attribute. Such a function must have the following type signature (for more
1678 information: http://doc.rust-lang.org/stable/book/first-edition/no-stdlib.html):
1682 fn(isize, *const *const u8) -> isize;
1691 fn my_start(argc: isize, argv: *const *const u8) -> isize {
1698 This error means that an attempt was made to match a struct type enum
1699 variant as a non-struct type:
1701 ```compile_fail,E0164
1702 enum Foo { B { i: u32 } }
1704 fn bar(foo: Foo) -> u32 {
1706 Foo::B(i) => i, // error E0164
1711 Try using `{}` instead:
1714 enum Foo { B { i: u32 } }
1716 fn bar(foo: Foo) -> u32 {
1725 You bound an associated type in an expression path which is not
1728 Erroneous code example:
1730 ```compile_fail,E0182
1736 impl Foo for isize {
1738 fn bar() -> isize { 42 }
1741 // error: unexpected binding of associated item in expression path
1742 let x: isize = Foo::<A=usize>::bar();
1745 To give a concrete type when using the Universal Function Call Syntax,
1746 use "Type as Trait". Example:
1754 impl Foo for isize {
1756 fn bar() -> isize { 42 }
1759 let x: isize = <isize as Foo>::bar(); // ok!
1764 Explicitly implementing both Drop and Copy for a type is currently disallowed.
1765 This feature can make some sense in theory, but the current implementation is
1766 incorrect and can lead to memory unsafety (see [issue #20126][iss20126]), so
1767 it has been disabled for now.
1769 [iss20126]: https://github.com/rust-lang/rust/issues/20126
1773 An associated function for a trait was defined to be static, but an
1774 implementation of the trait declared the same function to be a method (i.e. to
1775 take a `self` parameter).
1777 Here's an example of this error:
1779 ```compile_fail,E0185
1787 // error, method `foo` has a `&self` declaration in the impl, but not in
1795 An associated function for a trait was defined to be a method (i.e. to take a
1796 `self` parameter), but an implementation of the trait declared the same function
1799 Here's an example of this error:
1801 ```compile_fail,E0186
1809 // error, method `foo` has a `&self` declaration in the trait, but not in
1817 Trait objects need to have all associated types specified. Erroneous code
1820 ```compile_fail,E0191
1825 type Foo = Trait; // error: the value of the associated type `Bar` (from
1826 // the trait `Trait`) must be specified
1829 Please verify you specified all associated types of the trait and that you
1830 used the right trait. Example:
1837 type Foo = Trait<Bar=i32>; // ok!
1842 Negative impls are only allowed for traits with default impls. For more
1843 information see the [opt-in builtin traits RFC][RFC 19].
1845 [RFC 19]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md
1849 #### Note: this error code is no longer emitted by the compiler.
1851 `where` clauses must use generic type parameters: it does not make sense to use
1852 them otherwise. An example causing this error:
1859 #[derive(Copy,Clone)]
1864 impl Foo for Wrapper<u32> where Wrapper<u32>: Clone {
1869 This use of a `where` clause is strange - a more common usage would look
1870 something like the following:
1877 #[derive(Copy,Clone)]
1881 impl <T> Foo for Wrapper<T> where Wrapper<T>: Clone {
1886 Here, we're saying that the implementation exists on Wrapper only when the
1887 wrapped type `T` implements `Clone`. The `where` clause is important because
1888 some types will not implement `Clone`, and thus will not get this method.
1890 In our erroneous example, however, we're referencing a single concrete type.
1891 Since we know for certain that `Wrapper<u32>` implements `Clone`, there's no
1892 reason to also specify it in a `where` clause.
1896 A type parameter was declared which shadows an existing one. An example of this
1899 ```compile_fail,E0194
1901 fn do_something(&self) -> T;
1902 fn do_something_else<T: Clone>(&self, bar: T);
1906 In this example, the trait `Foo` and the trait method `do_something_else` both
1907 define a type parameter `T`. This is not allowed: if the method wishes to
1908 define a type parameter, it must use a different name for it.
1912 Your method's lifetime parameters do not match the trait declaration.
1913 Erroneous code example:
1915 ```compile_fail,E0195
1917 fn bar<'a,'b:'a>(x: &'a str, y: &'b str);
1922 impl Trait for Foo {
1923 fn bar<'a,'b>(x: &'a str, y: &'b str) {
1924 // error: lifetime parameters or bounds on method `bar`
1925 // do not match the trait declaration
1930 The lifetime constraint `'b` for bar() implementation does not match the
1931 trait declaration. Ensure lifetime declarations match exactly in both trait
1932 declaration and implementation. Example:
1936 fn t<'a,'b:'a>(x: &'a str, y: &'b str);
1941 impl Trait for Foo {
1942 fn t<'a,'b:'a>(x: &'a str, y: &'b str) { // ok!
1949 Inherent implementations (one that do not implement a trait but provide
1950 methods associated with a type) are always safe because they are not
1951 implementing an unsafe trait. Removing the `unsafe` keyword from the inherent
1952 implementation will resolve this error.
1954 ```compile_fail,E0197
1957 // this will cause this error
1959 // converting it to this will fix it
1965 A negative implementation is one that excludes a type from implementing a
1966 particular trait. Not being able to use a trait is always a safe operation,
1967 so negative implementations are always safe and never need to be marked as
1971 #![feature(optin_builtin_traits)]
1975 // unsafe is unnecessary
1976 unsafe impl !Clone for Foo { }
1982 #![feature(optin_builtin_traits)]
1988 impl Enterprise for .. { }
1990 impl !Enterprise for Foo { }
1993 Please note that negative impls are only allowed for traits with default impls.
1997 Safe traits should not have unsafe implementations, therefore marking an
1998 implementation for a safe trait unsafe will cause a compiler error. Removing
1999 the unsafe marker on the trait noted in the error will resolve this problem.
2001 ```compile_fail,E0199
2006 // this won't compile because Bar is safe
2007 unsafe impl Bar for Foo { }
2008 // this will compile
2009 impl Bar for Foo { }
2014 Unsafe traits must have unsafe implementations. This error occurs when an
2015 implementation for an unsafe trait isn't marked as unsafe. This may be resolved
2016 by marking the unsafe implementation as unsafe.
2018 ```compile_fail,E0200
2021 unsafe trait Bar { }
2023 // this won't compile because Bar is unsafe and impl isn't unsafe
2024 impl Bar for Foo { }
2025 // this will compile
2026 unsafe impl Bar for Foo { }
2031 It is an error to define two associated items (like methods, associated types,
2032 associated functions, etc.) with the same identifier.
2036 ```compile_fail,E0201
2040 fn bar(&self) -> bool { self.0 > 5 }
2041 fn bar() {} // error: duplicate associated function
2046 fn baz(&self) -> bool;
2052 fn baz(&self) -> bool { true }
2054 // error: duplicate method
2055 fn baz(&self) -> bool { self.0 > 5 }
2057 // error: duplicate associated type
2062 Note, however, that items with the same name are allowed for inherent `impl`
2063 blocks that don't overlap:
2069 fn bar(&self) -> bool { self.0 > 5 }
2073 fn bar(&self) -> bool { self.0 }
2079 Inherent associated types were part of [RFC 195] but are not yet implemented.
2080 See [the tracking issue][iss8995] for the status of this implementation.
2082 [RFC 195]: https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-items.md
2083 [iss8995]: https://github.com/rust-lang/rust/issues/8995
2087 An attempt to implement the `Copy` trait for a struct failed because one of the
2088 fields does not implement `Copy`. To fix this, you must implement `Copy` for the
2089 mentioned field. Note that this may not be possible, as in the example of
2091 ```compile_fail,E0204
2096 impl Copy for Foo { }
2099 This fails because `Vec<T>` does not implement `Copy` for any `T`.
2101 Here's another example that will fail:
2103 ```compile_fail,E0204
2110 This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
2111 differs from the behavior for `&T`, which is always `Copy`).
2116 An attempt to implement the `Copy` trait for an enum failed because one of the
2117 variants does not implement `Copy`. To fix this, you must implement `Copy` for
2118 the mentioned variant. Note that this may not be possible, as in the example of
2120 ```compile_fail,E0205
2126 impl Copy for Foo { }
2129 This fails because `Vec<T>` does not implement `Copy` for any `T`.
2131 Here's another example that will fail:
2133 ```compile_fail,E0205
2141 This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
2142 differs from the behavior for `&T`, which is always `Copy`).
2147 You can only implement `Copy` for a struct or enum. Both of the following
2148 examples will fail, because neither `i32` (primitive type) nor `&'static Bar`
2149 (reference to `Bar`) is a struct or enum:
2151 ```compile_fail,E0206
2153 impl Copy for Foo { } // error
2155 #[derive(Copy, Clone)]
2157 impl Copy for &'static Bar { } // error
2162 Any type parameter or lifetime parameter of an `impl` must meet at least one of
2163 the following criteria:
2165 - it appears in the self type of the impl
2166 - for a trait impl, it appears in the trait reference
2167 - it is bound as an associated type
2171 Suppose we have a struct `Foo` and we would like to define some methods for it.
2172 The following definition leads to a compiler error:
2174 ```compile_fail,E0207
2177 impl<T: Default> Foo {
2178 // error: the type parameter `T` is not constrained by the impl trait, self
2179 // type, or predicates [E0207]
2180 fn get(&self) -> T {
2181 <T as Default>::default()
2186 The problem is that the parameter `T` does not appear in the self type (`Foo`)
2187 of the impl. In this case, we can fix the error by moving the type parameter
2188 from the `impl` to the method `get`:
2194 // Move the type parameter from the impl to the method
2196 fn get<T: Default>(&self) -> T {
2197 <T as Default>::default()
2204 As another example, suppose we have a `Maker` trait and want to establish a
2205 type `FooMaker` that makes `Foo`s:
2207 ```compile_fail,E0207
2210 fn make(&mut self) -> Self::Item;
2219 impl<T: Default> Maker for FooMaker {
2220 // error: the type parameter `T` is not constrained by the impl trait, self
2221 // type, or predicates [E0207]
2224 fn make(&mut self) -> Foo<T> {
2225 Foo { foo: <T as Default>::default() }
2230 This fails to compile because `T` does not appear in the trait or in the
2233 One way to work around this is to introduce a phantom type parameter into
2234 `FooMaker`, like so:
2237 use std::marker::PhantomData;
2241 fn make(&mut self) -> Self::Item;
2248 // Add a type parameter to `FooMaker`
2249 struct FooMaker<T> {
2250 phantom: PhantomData<T>,
2253 impl<T: Default> Maker for FooMaker<T> {
2256 fn make(&mut self) -> Foo<T> {
2258 foo: <T as Default>::default(),
2264 Another way is to do away with the associated type in `Maker` and use an input
2265 type parameter instead:
2268 // Use a type parameter instead of an associated type here
2270 fn make(&mut self) -> Item;
2279 impl<T: Default> Maker<Foo<T>> for FooMaker {
2280 fn make(&mut self) -> Foo<T> {
2281 Foo { foo: <T as Default>::default() }
2286 ### Additional information
2288 For more information, please see [RFC 447].
2290 [RFC 447]: https://github.com/rust-lang/rfcs/blob/master/text/0447-no-unused-impl-parameters.md
2294 This error indicates a violation of one of Rust's orphan rules for trait
2295 implementations. The rule concerns the use of type parameters in an
2296 implementation of a foreign trait (a trait defined in another crate), and
2297 states that type parameters must be "covered" by a local type. To understand
2298 what this means, it is perhaps easiest to consider a few examples.
2300 If `ForeignTrait` is a trait defined in some external crate `foo`, then the
2301 following trait `impl` is an error:
2303 ```compile_fail,E0210
2304 # #[cfg(for_demonstration_only)]
2306 # #[cfg(for_demonstration_only)]
2307 use foo::ForeignTrait;
2308 # use std::panic::UnwindSafe as ForeignTrait;
2310 impl<T> ForeignTrait for T { } // error
2314 To work around this, it can be covered with a local type, `MyType`:
2317 # use std::panic::UnwindSafe as ForeignTrait;
2318 struct MyType<T>(T);
2319 impl<T> ForeignTrait for MyType<T> { } // Ok
2322 Please note that a type alias is not sufficient.
2324 For another example of an error, suppose there's another trait defined in `foo`
2325 named `ForeignTrait2` that takes two type parameters. Then this `impl` results
2326 in the same rule violation:
2328 ```ignore (cannot-doctest-multicrate-project)
2330 impl<T> ForeignTrait2<T, MyType<T>> for MyType2 { } // error
2333 The reason for this is that there are two appearances of type parameter `T` in
2334 the `impl` header, both as parameters for `ForeignTrait2`. The first appearance
2335 is uncovered, and so runs afoul of the orphan rule.
2337 Consider one more example:
2339 ```ignore (cannot-doctest-multicrate-project)
2340 impl<T> ForeignTrait2<MyType<T>, T> for MyType2 { } // Ok
2343 This only differs from the previous `impl` in that the parameters `T` and
2344 `MyType<T>` for `ForeignTrait2` have been swapped. This example does *not*
2345 violate the orphan rule; it is permitted.
2347 To see why that last example was allowed, you need to understand the general
2348 rule. Unfortunately this rule is a bit tricky to state. Consider an `impl`:
2350 ```ignore (only-for-syntax-highlight)
2351 impl<P1, ..., Pm> ForeignTrait<T1, ..., Tn> for T0 { ... }
2354 where `P1, ..., Pm` are the type parameters of the `impl` and `T0, ..., Tn`
2355 are types. One of the types `T0, ..., Tn` must be a local type (this is another
2356 orphan rule, see the explanation for E0117). Let `i` be the smallest integer
2357 such that `Ti` is a local type. Then no type parameter can appear in any of the
2360 For information on the design of the orphan rules, see [RFC 1023].
2362 [RFC 1023]: https://github.com/rust-lang/rfcs/blob/master/text/1023-rebalancing-coherence.md
2367 You used a function or type which doesn't fit the requirements for where it was
2368 used. Erroneous code examples:
2371 #![feature(intrinsics)]
2373 extern "rust-intrinsic" {
2374 fn size_of<T>(); // error: intrinsic has wrong type
2379 fn main() -> i32 { 0 }
2380 // error: main function expects type: `fn() {main}`: expected (), found i32
2387 // error: mismatched types in range: expected u8, found i8
2397 fn x(self: Rc<Foo>) {}
2398 // error: mismatched self type: expected `Foo`: expected struct
2399 // `Foo`, found struct `alloc::rc::Rc`
2403 For the first code example, please check the function definition. Example:
2406 #![feature(intrinsics)]
2408 extern "rust-intrinsic" {
2409 fn size_of<T>() -> usize; // ok!
2413 The second case example is a bit particular : the main function must always
2414 have this definition:
2420 They never take parameters and never return types.
2422 For the third example, when you match, all patterns must have the same type
2423 as the type you're matching on. Example:
2429 0u8...3u8 => (), // ok!
2434 And finally, for the last example, only `Box<Self>`, `&Self`, `Self`,
2435 or `&mut Self` work as explicit self parameters. Example:
2441 fn x(self: Box<Foo>) {} // ok!
2448 A generic type was described using parentheses rather than angle brackets. For
2451 ```compile_fail,E0214
2453 let v: Vec(&str) = vec!["foo"];
2457 This is not currently supported: `v` should be defined as `Vec<&str>`.
2458 Parentheses are currently only used with generic types when defining parameters
2459 for `Fn`-family traits.
2463 You used an associated type which isn't defined in the trait.
2464 Erroneous code example:
2466 ```compile_fail,E0220
2471 type Foo = T1<F=i32>; // error: associated type `F` not found for `T1`
2478 // error: Baz is used but not declared
2479 fn return_bool(&self, &Self::Bar, &Self::Baz) -> bool;
2483 Make sure that you have defined the associated type in the trait body.
2484 Also, verify that you used the right trait or you didn't misspell the
2485 associated type name. Example:
2492 type Foo = T1<Bar=i32>; // ok!
2498 type Baz; // we declare `Baz` in our trait.
2500 // and now we can use it here:
2501 fn return_bool(&self, &Self::Bar, &Self::Baz) -> bool;
2507 An attempt was made to retrieve an associated type, but the type was ambiguous.
2510 ```compile_fail,E0221
2526 In this example, `Foo` defines an associated type `A`. `Bar` inherits that type
2527 from `Foo`, and defines another associated type of the same name. As a result,
2528 when we attempt to use `Self::A`, it's ambiguous whether we mean the `A` defined
2529 by `Foo` or the one defined by `Bar`.
2531 There are two options to work around this issue. The first is simply to rename
2532 one of the types. Alternatively, one can specify the intended type using the
2546 let _: <Self as Bar>::A;
2553 An attempt was made to retrieve an associated type, but the type was ambiguous.
2556 ```compile_fail,E0223
2557 trait MyTrait {type X; }
2560 let foo: MyTrait::X;
2564 The problem here is that we're attempting to take the type of X from MyTrait.
2565 Unfortunately, the type of X is not defined, because it's only made concrete in
2566 implementations of the trait. A working version of this code might look like:
2569 trait MyTrait {type X; }
2572 impl MyTrait for MyStruct {
2577 let foo: <MyStruct as MyTrait>::X;
2581 This syntax specifies that we want the X type from MyTrait, as made concrete in
2582 MyStruct. The reason that we cannot simply use `MyStruct::X` is that MyStruct
2583 might implement two different traits with identically-named associated types.
2584 This syntax allows disambiguation between the two.
2588 You attempted to use multiple types as bounds for a closure or trait object.
2589 Rust does not currently support this. A simple example that causes this error:
2591 ```compile_fail,E0225
2593 let _: Box<std::io::Read + std::io::Write>;
2597 Send and Sync are an exception to this rule: it's possible to have bounds of
2598 one non-builtin trait, plus either or both of Send and Sync. For example, the
2599 following compiles correctly:
2603 let _: Box<std::io::Read + Send + Sync>;
2609 An associated type binding was done outside of the type parameter declaration
2610 and `where` clause. Erroneous code example:
2612 ```compile_fail,E0229
2615 fn boo(&self) -> <Self as Foo>::A;
2620 impl Foo for isize {
2622 fn boo(&self) -> usize { 42 }
2625 fn baz<I>(x: &<I as Foo<A=Bar>>::A) {}
2626 // error: associated type bindings are not allowed here
2629 To solve this error, please move the type bindings in the type parameter
2634 # trait Foo { type A; }
2635 fn baz<I: Foo<A=Bar>>(x: &<I as Foo>::A) {} // ok!
2638 Or in the `where` clause:
2642 # trait Foo { type A; }
2643 fn baz<I>(x: &<I as Foo>::A) where I: Foo<A=Bar> {}
2648 The trait has more type parameters specified than appear in its definition.
2650 Erroneous example code:
2652 ```compile_fail,E0230
2653 #![feature(on_unimplemented)]
2654 #[rustc_on_unimplemented = "Trait error on `{Self}` with `<{A},{B},{C}>`"]
2655 // error: there is no type parameter C on trait TraitWithThreeParams
2656 trait TraitWithThreeParams<A,B>
2660 Include the correct number of type parameters and the compilation should
2664 #![feature(on_unimplemented)]
2665 #[rustc_on_unimplemented = "Trait error on `{Self}` with `<{A},{B},{C}>`"]
2666 trait TraitWithThreeParams<A,B,C> // ok!
2672 The attribute must have a value. Erroneous code example:
2674 ```compile_fail,E0232
2675 #![feature(on_unimplemented)]
2677 #[rustc_on_unimplemented] // error: this attribute must have a value
2681 Please supply the missing value of the attribute. Example:
2684 #![feature(on_unimplemented)]
2686 #[rustc_on_unimplemented = "foo"] // ok!
2692 This error indicates that not enough type parameters were found in a type or
2695 For example, the `Foo` struct below is defined to be generic in `T`, but the
2696 type parameter is missing in the definition of `Bar`:
2698 ```compile_fail,E0243
2699 struct Foo<T> { x: T }
2701 struct Bar { x: Foo }
2706 This error indicates that too many type parameters were found in a type or
2709 For example, the `Foo` struct below has no type parameters, but is supplied
2710 with two in the definition of `Bar`:
2712 ```compile_fail,E0244
2713 struct Foo { x: bool }
2715 struct Bar<S, T> { x: Foo<S, T> }
2720 If an impl has a generic parameter with the `#[may_dangle]` attribute, then
2721 that impl must be declared as an `unsafe impl. For example:
2723 ```compile_fail,E0569
2724 #![feature(generic_param_attrs)]
2725 #![feature(dropck_eyepatch)]
2728 impl<#[may_dangle] X> Drop for Foo<X> {
2729 fn drop(&mut self) { }
2733 In this example, we are asserting that the destructor for `Foo` will not
2734 access any data of type `X`, and require this assertion to be true for
2735 overall safety in our program. The compiler does not currently attempt to
2736 verify this assertion; therefore we must tag this `impl` as unsafe.
2740 Default impls for a trait must be located in the same crate where the trait was
2741 defined. For more information see the [opt-in builtin traits RFC][RFC 19].
2743 [RFC 19]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md
2747 A cross-crate opt-out trait was implemented on something which wasn't a struct
2748 or enum type. Erroneous code example:
2750 ```compile_fail,E0321
2751 #![feature(optin_builtin_traits)]
2755 impl !Sync for Foo {}
2757 unsafe impl Send for &'static Foo {}
2758 // error: cross-crate traits with a default impl, like `core::marker::Send`,
2759 // can only be implemented for a struct/enum type, not
2763 Only structs and enums are permitted to impl Send, Sync, and other opt-out
2764 trait, and the struct or enum must be local to the current crate. So, for
2765 example, `unsafe impl Send for Rc<Foo>` is not allowed.
2769 The `Sized` trait is a special trait built-in to the compiler for types with a
2770 constant size known at compile-time. This trait is automatically implemented
2771 for types as needed by the compiler, and it is currently disallowed to
2772 explicitly implement it for a type.
2776 An associated const was implemented when another trait item was expected.
2777 Erroneous code example:
2779 ```compile_fail,E0323
2780 #![feature(associated_consts)]
2790 // error: item `N` is an associated const, which doesn't match its
2791 // trait `<Bar as Foo>`
2795 Please verify that the associated const wasn't misspelled and the correct trait
2796 was implemented. Example:
2806 type N = u32; // ok!
2813 #![feature(associated_consts)]
2822 const N : u32 = 0; // ok!
2828 A method was implemented when another trait item was expected. Erroneous
2831 ```compile_fail,E0324
2832 #![feature(associated_consts)]
2844 // error: item `N` is an associated method, which doesn't match its
2845 // trait `<Bar as Foo>`
2849 To fix this error, please verify that the method name wasn't misspelled and
2850 verify that you are indeed implementing the correct trait items. Example:
2853 #![feature(associated_consts)]
2872 An associated type was implemented when another trait item was expected.
2873 Erroneous code example:
2875 ```compile_fail,E0325
2876 #![feature(associated_consts)]
2886 // error: item `N` is an associated type, which doesn't match its
2887 // trait `<Bar as Foo>`
2891 Please verify that the associated type name wasn't misspelled and your
2892 implementation corresponds to the trait definition. Example:
2902 type N = u32; // ok!
2909 #![feature(associated_consts)]
2918 const N : u32 = 0; // ok!
2924 The types of any associated constants in a trait implementation must match the
2925 types in the trait definition. This error indicates that there was a mismatch.
2927 Here's an example of this error:
2929 ```compile_fail,E0326
2930 #![feature(associated_consts)]
2939 const BAR: u32 = 5; // error, expected bool, found u32
2945 The Unsize trait should not be implemented directly. All implementations of
2946 Unsize are provided automatically by the compiler.
2948 Erroneous code example:
2950 ```compile_fail,E0328
2953 use std::marker::Unsize;
2957 impl<T> Unsize<T> for MyType {}
2960 If you are defining your own smart pointer type and would like to enable
2961 conversion from a sized to an unsized type with the
2962 [DST coercion system][RFC 982], use [`CoerceUnsized`] instead.
2965 #![feature(coerce_unsized)]
2967 use std::ops::CoerceUnsized;
2969 pub struct MyType<T: ?Sized> {
2970 field_with_unsized_type: T,
2973 impl<T, U> CoerceUnsized<MyType<U>> for MyType<T>
2974 where T: CoerceUnsized<U> {}
2977 [RFC 982]: https://github.com/rust-lang/rfcs/blob/master/text/0982-dst-coercion.md
2978 [`CoerceUnsized`]: https://doc.rust-lang.org/std/ops/trait.CoerceUnsized.html
2982 // Associated consts can now be accessed through generic type parameters, and
2983 // this error is no longer emitted.
2985 // FIXME: consider whether to leave it in the error index, or remove it entirely
2986 // as associated consts is not stabilized yet.
2989 An attempt was made to access an associated constant through either a generic
2990 type parameter or `Self`. This is not supported yet. An example causing this
2991 error is shown below:
2994 #![feature(associated_consts)]
3002 impl Foo for MyStruct {
3003 const BAR: f64 = 0f64;
3006 fn get_bar_bad<F: Foo>(t: F) -> f64 {
3011 Currently, the value of `BAR` for a particular type can only be accessed
3012 through a concrete type, as shown below:
3015 #![feature(associated_consts)]
3023 fn get_bar_good() -> f64 {
3024 <MyStruct as Foo>::BAR
3031 An attempt was made to implement `Drop` on a concrete specialization of a
3032 generic type. An example is shown below:
3034 ```compile_fail,E0366
3039 impl Drop for Foo<u32> {
3040 fn drop(&mut self) {}
3044 This code is not legal: it is not possible to specialize `Drop` to a subset of
3045 implementations of a generic type. One workaround for this is to wrap the
3046 generic type, as shown below:
3058 fn drop(&mut self) {}
3064 An attempt was made to implement `Drop` on a specialization of a generic type.
3065 An example is shown below:
3067 ```compile_fail,E0367
3070 struct MyStruct<T> {
3074 impl<T: Foo> Drop for MyStruct<T> {
3075 fn drop(&mut self) {}
3079 This code is not legal: it is not possible to specialize `Drop` to a subset of
3080 implementations of a generic type. In order for this code to work, `MyStruct`
3081 must also require that `T` implements `Foo`. Alternatively, another option is
3082 to wrap the generic type in another that specializes appropriately:
3087 struct MyStruct<T> {
3091 struct MyStructWrapper<T: Foo> {
3095 impl <T: Foo> Drop for MyStructWrapper<T> {
3096 fn drop(&mut self) {}
3102 This error indicates that a binary assignment operator like `+=` or `^=` was
3103 applied to a type that doesn't support it. For example:
3105 ```compile_fail,E0368
3106 let mut x = 12f32; // error: binary operation `<<` cannot be applied to
3112 To fix this error, please check that this type implements this binary
3116 let mut x = 12u32; // the `u32` type does implement the `ShlAssign` trait
3121 It is also possible to overload most operators for your own type by
3122 implementing the `[OP]Assign` traits from `std::ops`.
3124 Another problem you might be facing is this: suppose you've overloaded the `+`
3125 operator for some type `Foo` by implementing the `std::ops::Add` trait for
3126 `Foo`, but you find that using `+=` does not work, as in this example:
3128 ```compile_fail,E0368
3136 fn add(self, rhs: Foo) -> Foo {
3142 let mut x: Foo = Foo(5);
3143 x += Foo(7); // error, `+= cannot be applied to the type `Foo`
3147 This is because `AddAssign` is not automatically implemented, so you need to
3148 manually implement it for your type.
3152 A binary operation was attempted on a type which doesn't support it.
3153 Erroneous code example:
3155 ```compile_fail,E0369
3156 let x = 12f32; // error: binary operation `<<` cannot be applied to
3162 To fix this error, please check that this type implements this binary
3166 let x = 12u32; // the `u32` type does implement it:
3167 // https://doc.rust-lang.org/stable/std/ops/trait.Shl.html
3172 It is also possible to overload most operators for your own type by
3173 implementing traits from `std::ops`.
3175 String concatenation appends the string on the right to the string on the
3176 left and may require reallocation. This requires ownership of the string
3177 on the left. If something should be added to a string literal, move the
3178 literal to the heap by allocating it with `to_owned()` like in
3179 `"Your text".to_owned()`.
3184 The maximum value of an enum was reached, so it cannot be automatically
3185 set in the next enum value. Erroneous code example:
3188 #[deny(overflowing_literals)]
3190 X = 0x7fffffffffffffff,
3191 Y, // error: enum discriminant overflowed on value after
3192 // 9223372036854775807: i64; set explicitly via
3193 // Y = -9223372036854775808 if that is desired outcome
3197 To fix this, please set manually the next enum value or put the enum variant
3198 with the maximum value at the end of the enum. Examples:
3202 X = 0x7fffffffffffffff,
3212 X = 0x7fffffffffffffff,
3218 When `Trait2` is a subtrait of `Trait1` (for example, when `Trait2` has a
3219 definition like `trait Trait2: Trait1 { ... }`), it is not allowed to implement
3220 `Trait1` for `Trait2`. This is because `Trait2` already implements `Trait1` by
3221 definition, so it is not useful to do this.
3225 ```compile_fail,E0371
3226 trait Foo { fn foo(&self) { } }
3230 impl Bar for Baz { } // error, `Baz` implements `Bar` by definition
3231 impl Foo for Baz { } // error, `Baz` implements `Bar` which implements `Foo`
3232 impl Baz for Baz { } // error, `Baz` (trivially) implements `Baz`
3233 impl Baz for Bar { } // Note: This is OK
3238 A struct without a field containing an unsized type cannot implement
3240 [unsized type](https://doc.rust-lang.org/book/first-edition/unsized-types.html)
3241 is any type that the compiler doesn't know the length or alignment of at
3242 compile time. Any struct containing an unsized type is also unsized.
3244 Example of erroneous code:
3246 ```compile_fail,E0374
3247 #![feature(coerce_unsized)]
3248 use std::ops::CoerceUnsized;
3250 struct Foo<T: ?Sized> {
3254 // error: Struct `Foo` has no unsized fields that need `CoerceUnsized`.
3255 impl<T, U> CoerceUnsized<Foo<U>> for Foo<T>
3256 where T: CoerceUnsized<U> {}
3259 `CoerceUnsized` is used to coerce one struct containing an unsized type
3260 into another struct containing a different unsized type. If the struct
3261 doesn't have any fields of unsized types then you don't need explicit
3262 coercion to get the types you want. To fix this you can either
3263 not try to implement `CoerceUnsized` or you can add a field that is
3264 unsized to the struct.
3269 #![feature(coerce_unsized)]
3270 use std::ops::CoerceUnsized;
3272 // We don't need to impl `CoerceUnsized` here.
3277 // We add the unsized type field to the struct.
3278 struct Bar<T: ?Sized> {
3283 // The struct has an unsized field so we can implement
3284 // `CoerceUnsized` for it.
3285 impl<T, U> CoerceUnsized<Bar<U>> for Bar<T>
3286 where T: CoerceUnsized<U> {}
3289 Note that `CoerceUnsized` is mainly used by smart pointers like `Box`, `Rc`
3290 and `Arc` to be able to mark that they can coerce unsized types that they
3295 A struct with more than one field containing an unsized type cannot implement
3296 `CoerceUnsized`. This only occurs when you are trying to coerce one of the
3297 types in your struct to another type in the struct. In this case we try to
3298 impl `CoerceUnsized` from `T` to `U` which are both types that the struct
3299 takes. An [unsized type] is any type that the compiler doesn't know the length
3300 or alignment of at compile time. Any struct containing an unsized type is also
3303 Example of erroneous code:
3305 ```compile_fail,E0375
3306 #![feature(coerce_unsized)]
3307 use std::ops::CoerceUnsized;
3309 struct Foo<T: ?Sized, U: ?Sized> {
3315 // error: Struct `Foo` has more than one unsized field.
3316 impl<T, U> CoerceUnsized<Foo<U, T>> for Foo<T, U> {}
3319 `CoerceUnsized` only allows for coercion from a structure with a single
3320 unsized type field to another struct with a single unsized type field.
3321 In fact Rust only allows for a struct to have one unsized type in a struct
3322 and that unsized type must be the last field in the struct. So having two
3323 unsized types in a single struct is not allowed by the compiler. To fix this
3324 use only one field containing an unsized type in the struct and then use
3325 multiple structs to manage each unsized type field you need.
3330 #![feature(coerce_unsized)]
3331 use std::ops::CoerceUnsized;
3333 struct Foo<T: ?Sized> {
3338 impl <T, U> CoerceUnsized<Foo<U>> for Foo<T>
3339 where T: CoerceUnsized<U> {}
3341 fn coerce_foo<T: CoerceUnsized<U>, U>(t: T) -> Foo<U> {
3342 Foo { a: 12i32, b: t } // we use coercion to get the `Foo<U>` type we need
3346 [unsized type]: https://doc.rust-lang.org/book/first-edition/unsized-types.html
3350 The type you are trying to impl `CoerceUnsized` for is not a struct.
3351 `CoerceUnsized` can only be implemented for a struct. Unsized types are
3352 already able to be coerced without an implementation of `CoerceUnsized`
3353 whereas a struct containing an unsized type needs to know the unsized type
3354 field it's containing is able to be coerced. An
3355 [unsized type](https://doc.rust-lang.org/book/first-edition/unsized-types.html)
3356 is any type that the compiler doesn't know the length or alignment of at
3357 compile time. Any struct containing an unsized type is also unsized.
3359 Example of erroneous code:
3361 ```compile_fail,E0376
3362 #![feature(coerce_unsized)]
3363 use std::ops::CoerceUnsized;
3365 struct Foo<T: ?Sized> {
3369 // error: The type `U` is not a struct
3370 impl<T, U> CoerceUnsized<U> for Foo<T> {}
3373 The `CoerceUnsized` trait takes a struct type. Make sure the type you are
3374 providing to `CoerceUnsized` is a struct with only the last field containing an
3380 #![feature(coerce_unsized)]
3381 use std::ops::CoerceUnsized;
3387 // The `Foo<U>` is a struct so `CoerceUnsized` can be implemented
3388 impl<T, U> CoerceUnsized<Foo<U>> for Foo<T> where T: CoerceUnsized<U> {}
3391 Note that in Rust, structs can only contain an unsized type if the field
3392 containing the unsized type is the last and only unsized type field in the
3397 Default impls are only allowed for traits with no methods or associated items.
3398 For more information see the [opt-in builtin traits RFC][RFC 19].
3400 [RFC 19]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md
3404 You tried to implement methods for a primitive type. Erroneous code example:
3406 ```compile_fail,E0390
3412 // error: only a single inherent implementation marked with
3413 // `#[lang = "mut_ptr"]` is allowed for the `*mut T` primitive
3416 This isn't allowed, but using a trait to implement a method is a good solution.
3428 impl Bar for *mut Foo {
3435 This error indicates that a type or lifetime parameter has been declared
3436 but not actually used. Here is an example that demonstrates the error:
3438 ```compile_fail,E0392
3444 If the type parameter was included by mistake, this error can be fixed
3445 by simply removing the type parameter, as shown below:
3453 Alternatively, if the type parameter was intentionally inserted, it must be
3454 used. A simple fix is shown below:
3462 This error may also commonly be found when working with unsafe code. For
3463 example, when using raw pointers one may wish to specify the lifetime for
3464 which the pointed-at data is valid. An initial attempt (below) causes this
3467 ```compile_fail,E0392
3473 We want to express the constraint that Foo should not outlive `'a`, because
3474 the data pointed to by `T` is only valid for that lifetime. The problem is
3475 that there are no actual uses of `'a`. It's possible to work around this
3476 by adding a PhantomData type to the struct, using it to tell the compiler
3477 to act as if the struct contained a borrowed reference `&'a T`:
3480 use std::marker::PhantomData;
3482 struct Foo<'a, T: 'a> {
3484 phantom: PhantomData<&'a T>
3488 PhantomData can also be used to express information about unused type
3489 parameters. You can read more about it in the API documentation:
3491 https://doc.rust-lang.org/std/marker/struct.PhantomData.html
3495 A type parameter which references `Self` in its default value was not specified.
3496 Example of erroneous code:
3498 ```compile_fail,E0393
3501 fn together_we_will_rule_the_galaxy(son: &A) {}
3502 // error: the type parameter `T` must be explicitly specified in an
3503 // object type because its default value `Self` references the
3507 A trait object is defined over a single, fully-defined trait. With a regular
3508 default parameter, this parameter can just be substituted in. However, if the
3509 default parameter is `Self`, the trait changes for each concrete type; i.e.
3510 `i32` will be expected to implement `A<i32>`, `bool` will be expected to
3511 implement `A<bool>`, etc... These types will not share an implementation of a
3512 fully-defined trait; instead they share implementations of a trait with
3513 different parameters substituted in for each implementation. This is
3514 irreconcilable with what we need to make a trait object work, and is thus
3515 disallowed. Making the trait concrete by explicitly specifying the value of the
3516 defaulted parameter will fix this issue. Fixed example:
3521 fn together_we_will_rule_the_galaxy(son: &A<i32>) {} // Ok!
3526 You implemented a trait, overriding one or more of its associated types but did
3527 not reimplement its default methods.
3529 Example of erroneous code:
3531 ```compile_fail,E0399
3532 #![feature(associated_type_defaults)]
3540 // error - the following trait items need to be reimplemented as
3541 // `Assoc` was overridden: `bar`
3546 To fix this, add an implementation for each default method from the trait:
3549 #![feature(associated_type_defaults)]
3558 fn bar(&self) {} // ok!
3564 The length of the platform-intrinsic function `simd_shuffle`
3565 wasn't specified. Erroneous code example:
3567 ```compile_fail,E0439
3568 #![feature(platform_intrinsics)]
3570 extern "platform-intrinsic" {
3571 fn simd_shuffle<A,B>(a: A, b: A, c: [u32; 8]) -> B;
3572 // error: invalid `simd_shuffle`, needs length: `simd_shuffle`
3576 The `simd_shuffle` function needs the length of the array passed as
3577 last parameter in its name. Example:
3580 #![feature(platform_intrinsics)]
3582 extern "platform-intrinsic" {
3583 fn simd_shuffle8<A,B>(a: A, b: A, c: [u32; 8]) -> B;
3589 A platform-specific intrinsic function has the wrong number of type
3590 parameters. Erroneous code example:
3592 ```compile_fail,E0440
3593 #![feature(repr_simd)]
3594 #![feature(platform_intrinsics)]
3597 struct f64x2(f64, f64);
3599 extern "platform-intrinsic" {
3600 fn x86_mm_movemask_pd<T>(x: f64x2) -> i32;
3601 // error: platform-specific intrinsic has wrong number of type
3606 Please refer to the function declaration to see if it corresponds
3607 with yours. Example:
3610 #![feature(repr_simd)]
3611 #![feature(platform_intrinsics)]
3614 struct f64x2(f64, f64);
3616 extern "platform-intrinsic" {
3617 fn x86_mm_movemask_pd(x: f64x2) -> i32;
3623 An unknown platform-specific intrinsic function was used. Erroneous
3626 ```compile_fail,E0441
3627 #![feature(repr_simd)]
3628 #![feature(platform_intrinsics)]
3631 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3633 extern "platform-intrinsic" {
3634 fn x86_mm_adds_ep16(x: i16x8, y: i16x8) -> i16x8;
3635 // error: unrecognized platform-specific intrinsic function
3639 Please verify that the function name wasn't misspelled, and ensure
3640 that it is declared in the rust source code (in the file
3641 src/librustc_platform_intrinsics/x86.rs). Example:
3644 #![feature(repr_simd)]
3645 #![feature(platform_intrinsics)]
3648 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3650 extern "platform-intrinsic" {
3651 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8; // ok!
3657 Intrinsic argument(s) and/or return value have the wrong type.
3658 Erroneous code example:
3660 ```compile_fail,E0442
3661 #![feature(repr_simd)]
3662 #![feature(platform_intrinsics)]
3665 struct i8x16(i8, i8, i8, i8, i8, i8, i8, i8,
3666 i8, i8, i8, i8, i8, i8, i8, i8);
3668 struct i32x4(i32, i32, i32, i32);
3670 struct i64x2(i64, i64);
3672 extern "platform-intrinsic" {
3673 fn x86_mm_adds_epi16(x: i8x16, y: i32x4) -> i64x2;
3674 // error: intrinsic arguments/return value have wrong type
3678 To fix this error, please refer to the function declaration to give
3679 it the awaited types. Example:
3682 #![feature(repr_simd)]
3683 #![feature(platform_intrinsics)]
3686 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3688 extern "platform-intrinsic" {
3689 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8; // ok!
3695 Intrinsic argument(s) and/or return value have the wrong type.
3696 Erroneous code example:
3698 ```compile_fail,E0443
3699 #![feature(repr_simd)]
3700 #![feature(platform_intrinsics)]
3703 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3705 struct i64x8(i64, i64, i64, i64, i64, i64, i64, i64);
3707 extern "platform-intrinsic" {
3708 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i64x8;
3709 // error: intrinsic argument/return value has wrong type
3713 To fix this error, please refer to the function declaration to give
3714 it the awaited types. Example:
3717 #![feature(repr_simd)]
3718 #![feature(platform_intrinsics)]
3721 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3723 extern "platform-intrinsic" {
3724 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8; // ok!
3730 A platform-specific intrinsic function has wrong number of arguments.
3731 Erroneous code example:
3733 ```compile_fail,E0444
3734 #![feature(repr_simd)]
3735 #![feature(platform_intrinsics)]
3738 struct f64x2(f64, f64);
3740 extern "platform-intrinsic" {
3741 fn x86_mm_movemask_pd(x: f64x2, y: f64x2, z: f64x2) -> i32;
3742 // error: platform-specific intrinsic has invalid number of arguments
3746 Please refer to the function declaration to see if it corresponds
3747 with yours. Example:
3750 #![feature(repr_simd)]
3751 #![feature(platform_intrinsics)]
3754 struct f64x2(f64, f64);
3756 extern "platform-intrinsic" {
3757 fn x86_mm_movemask_pd(x: f64x2) -> i32; // ok!
3763 The `typeof` keyword is currently reserved but unimplemented.
3764 Erroneous code example:
3766 ```compile_fail,E0516
3768 let x: typeof(92) = 92;
3772 Try using type inference instead. Example:
3782 A non-default implementation was already made on this type so it cannot be
3783 specialized further. Erroneous code example:
3785 ```compile_fail,E0520
3786 #![feature(specialization)]
3793 impl<T> SpaceLlama for T {
3794 default fn fly(&self) {}
3798 // applies to all `Clone` T and overrides the previous impl
3799 impl<T: Clone> SpaceLlama for T {
3803 // since `i32` is clone, this conflicts with the previous implementation
3804 impl SpaceLlama for i32 {
3805 default fn fly(&self) {}
3806 // error: item `fly` is provided by an `impl` that specializes
3807 // another, but the item in the parent `impl` is not marked
3808 // `default` and so it cannot be specialized.
3812 Specialization only allows you to override `default` functions in
3815 To fix this error, you need to mark all the parent implementations as default.
3819 #![feature(specialization)]
3826 impl<T> SpaceLlama for T {
3827 default fn fly(&self) {} // This is a parent implementation.
3830 // applies to all `Clone` T; overrides the previous impl
3831 impl<T: Clone> SpaceLlama for T {
3832 default fn fly(&self) {} // This is a parent implementation but was
3833 // previously not a default one, causing the error
3836 // applies to i32, overrides the previous two impls
3837 impl SpaceLlama for i32 {
3838 fn fly(&self) {} // And now that's ok!
3844 The number of elements in an array or slice pattern differed from the number of
3845 elements in the array being matched.
3847 Example of erroneous code:
3849 ```compile_fail,E0527
3850 #![feature(slice_patterns)]
3852 let r = &[1, 2, 3, 4];
3854 &[a, b] => { // error: pattern requires 2 elements but array
3856 println!("a={}, b={}", a, b);
3861 Ensure that the pattern is consistent with the size of the matched
3862 array. Additional elements can be matched with `..`:
3865 #![feature(slice_patterns)]
3867 let r = &[1, 2, 3, 4];
3869 &[a, b, ..] => { // ok!
3870 println!("a={}, b={}", a, b);
3877 An array or slice pattern required more elements than were present in the
3880 Example of erroneous code:
3882 ```compile_fail,E0528
3883 #![feature(slice_patterns)]
3887 &[a, b, c, rest..] => { // error: pattern requires at least 3
3888 // elements but array has 2
3889 println!("a={}, b={}, c={} rest={:?}", a, b, c, rest);
3894 Ensure that the matched array has at least as many elements as the pattern
3895 requires. You can match an arbitrary number of remaining elements with `..`:
3898 #![feature(slice_patterns)]
3900 let r = &[1, 2, 3, 4, 5];
3902 &[a, b, c, rest..] => { // ok!
3903 // prints `a=1, b=2, c=3 rest=[4, 5]`
3904 println!("a={}, b={}, c={} rest={:?}", a, b, c, rest);
3911 An array or slice pattern was matched against some other type.
3913 Example of erroneous code:
3915 ```compile_fail,E0529
3916 #![feature(slice_patterns)]
3920 [a, b] => { // error: expected an array or slice, found `f32`
3921 println!("a={}, b={}", a, b);
3926 Ensure that the pattern and the expression being matched on are of consistent
3930 #![feature(slice_patterns)]
3935 println!("a={}, b={}", a, b);
3942 An unknown field was specified into an enum's structure variant.
3944 Erroneous code example:
3946 ```compile_fail,E0559
3951 let s = Field::Fool { joke: 0 };
3952 // error: struct variant `Field::Fool` has no field named `joke`
3955 Verify you didn't misspell the field's name or that the field exists. Example:
3962 let s = Field::Fool { joke: 0 }; // ok!
3967 An unknown field was specified into a structure.
3969 Erroneous code example:
3971 ```compile_fail,E0560
3976 let s = Simba { mother: 1, father: 0 };
3977 // error: structure `Simba` has no field named `father`
3980 Verify you didn't misspell the field's name or that the field exists. Example:
3988 let s = Simba { mother: 1, father: 0 }; // ok!
3993 Abstract return types (written `impl Trait` for some trait `Trait`) are only
3994 allowed as function return types.
3996 Erroneous code example:
3998 ```compile_fail,E0562
3999 #![feature(conservative_impl_trait)]
4002 let count_to_ten: impl Iterator<Item=usize> = 0..10;
4003 // error: `impl Trait` not allowed outside of function and inherent method
4005 for i in count_to_ten {
4011 Make sure `impl Trait` only appears in return-type position.
4014 #![feature(conservative_impl_trait)]
4016 fn count_to_n(n: usize) -> impl Iterator<Item=usize> {
4021 for i in count_to_n(10) { // ok!
4027 See [RFC 1522] for more details.
4029 [RFC 1522]: https://github.com/rust-lang/rfcs/blob/master/text/1522-conservative-impl-trait.md
4033 The requested ABI is unsupported by the current target.
4035 The rust compiler maintains for each target a blacklist of ABIs unsupported on
4036 that target. If an ABI is present in such a list this usually means that the
4037 target / ABI combination is currently unsupported by llvm.
4039 If necessary, you can circumvent this check using custom target specifications.
4043 A return statement was found outside of a function body.
4045 Erroneous code example:
4047 ```compile_fail,E0572
4048 const FOO: u32 = return 0; // error: return statement outside of function body
4053 To fix this issue, just remove the return keyword or move the expression into a
4059 fn some_fn() -> u32 {
4070 In a `fn` type, a lifetime appears only in the return type,
4071 and not in the arguments types.
4073 Erroneous code example:
4075 ```compile_fail,E0581
4077 // Here, `'a` appears only in the return type:
4078 let x: for<'a> fn() -> &'a i32;
4082 To fix this issue, either use the lifetime in the arguments, or use
4087 // Here, `'a` appears only in the return type:
4088 let x: for<'a> fn(&'a i32) -> &'a i32;
4089 let y: fn() -> &'static i32;
4093 Note: The examples above used to be (erroneously) accepted by the
4094 compiler, but this was since corrected. See [issue #33685] for more
4097 [issue #33685]: https://github.com/rust-lang/rust/issues/33685
4101 A lifetime appears only in an associated-type binding,
4102 and not in the input types to the trait.
4104 Erroneous code example:
4106 ```compile_fail,E0582
4108 // No type can satisfy this requirement, since `'a` does not
4109 // appear in any of the input types (here, `i32`):
4110 where F: for<'a> Fn(i32) -> Option<&'a i32>
4117 To fix this issue, either use the lifetime in the inputs, or use
4121 fn bar<F, G>(t: F, u: G)
4122 where F: for<'a> Fn(&'a i32) -> Option<&'a i32>,
4123 G: Fn(i32) -> Option<&'static i32>,
4130 Note: The examples above used to be (erroneously) accepted by the
4131 compiler, but this was since corrected. See [issue #33685] for more
4134 [issue #33685]: https://github.com/rust-lang/rust/issues/33685
4138 ```compile_fail,E0599
4142 x.chocolate(); // error: no method named `chocolate` found for type `Mouth`
4143 // in the current scope
4148 An unary operator was used on a type which doesn't implement it.
4150 Example of erroneous code:
4152 ```compile_fail,E0600
4158 !Question::Yes; // error: cannot apply unary operator `!` to type `Question`
4161 In this case, `Question` would need to implement the `std::ops::Not` trait in
4162 order to be able to use `!` on it. Let's implement it:
4172 // We implement the `Not` trait on the enum.
4173 impl Not for Question {
4176 fn not(self) -> bool {
4178 Question::Yes => false, // If the `Answer` is `Yes`, then it
4180 Question::No => true, // And here we do the opposite.
4185 assert_eq!(!Question::Yes, false);
4186 assert_eq!(!Question::No, true);
4191 An attempt to index into a type which doesn't implement the `std::ops::Index`
4192 trait was performed.
4194 Erroneous code example:
4196 ```compile_fail,E0608
4197 0u8[2]; // error: cannot index into a value of type `u8`
4200 To be able to index into a type it needs to implement the `std::ops::Index`
4204 let v: Vec<u8> = vec![0, 1, 2, 3];
4206 // The `Vec` type implements the `Index` trait so you can do:
4207 println!("{}", v[2]);
4212 A cast to `char` was attempted on a type other than `u8`.
4214 Erroneous code example:
4216 ```compile_fail,E0604
4217 0u32 as char; // error: only `u8` can be cast as `char`, not `u32`
4220 As the error message indicates, only `u8` can be cast into `char`. Example:
4223 let c = 86u8 as char; // ok!
4227 For more information about casts, take a look at The Book:
4228 https://doc.rust-lang.org/book/first-edition/casting-between-types.html
4232 An invalid cast was attempted.
4234 Erroneous code examples:
4236 ```compile_fail,E0605
4238 x as Vec<u8>; // error: non-primitive cast: `u8` as `std::vec::Vec<u8>`
4242 let v = 0 as *const u8; // So here, `v` is a `*const u8`.
4243 v as &u8; // error: non-primitive cast: `*const u8` as `&u8`
4246 Only primitive types can be cast into each other. Examples:
4252 let v = 0 as *const u8;
4253 v as *const i8; // ok!
4256 For more information about casts, take a look at The Book:
4257 https://doc.rust-lang.org/book/first-edition/casting-between-types.html
4261 An incompatible cast was attempted.
4263 Erroneous code example:
4265 ```compile_fail,E0606
4266 let x = &0u8; // Here, `x` is a `&u8`.
4267 let y: u32 = x as u32; // error: casting `&u8` as `u32` is invalid
4270 When casting, keep in mind that only primitive types can be cast into each
4275 let y: u32 = *x as u32; // We dereference it first and then cast it.
4278 For more information about casts, take a look at The Book:
4279 https://doc.rust-lang.org/book/first-edition/casting-between-types.html
4283 A cast between a thin and a fat pointer was attempted.
4285 Erroneous code example:
4287 ```compile_fail,E0607
4288 let v = 0 as *const u8;
4292 First: what are thin and fat pointers?
4294 Thin pointers are "simple" pointers: they are purely a reference to a memory
4297 Fat pointers are pointers referencing Dynamically Sized Types (also called DST).
4298 DST don't have a statically known size, therefore they can only exist behind
4299 some kind of pointers that contain additional information. Slices and trait
4300 objects are DSTs. In the case of slices, the additional information the fat
4301 pointer holds is their size.
4303 To fix this error, don't try to cast directly between thin and fat pointers.
4305 For more information about casts, take a look at The Book:
4306 https://doc.rust-lang.org/book/first-edition/casting-between-types.html
4310 Attempted to access a non-existent field in a struct.
4312 Erroneous code example:
4314 ```compile_fail,E0609
4315 struct StructWithFields {
4319 let s = StructWithFields { x: 0 };
4320 println!("{}", s.foo); // error: no field `foo` on type `StructWithFields`
4323 To fix this error, check that you didn't misspell the field's name or that the
4324 field actually exists. Example:
4327 struct StructWithFields {
4331 let s = StructWithFields { x: 0 };
4332 println!("{}", s.x); // ok!
4337 Attempted to access a field on a primitive type.
4339 Erroneous code example:
4341 ```compile_fail,E0610
4343 println!("{}", x.foo); // error: `{integer}` is a primitive type, therefore
4344 // doesn't have fields
4347 Primitive types are the most basic types available in Rust and don't have
4348 fields. To access data via named fields, struct types are used. Example:
4351 // We declare struct called `Foo` containing two fields:
4357 // We create an instance of this struct:
4358 let variable = Foo { x: 0, y: -12 };
4359 // And we can now access its fields:
4360 println!("x: {}, y: {}", variable.x, variable.y);
4363 For more information see The Rust Book: https://doc.rust-lang.org/book/
4367 Attempted to access a private field on a tuple-struct.
4369 Erroneous code example:
4371 ```compile_fail,E0611
4373 pub struct Foo(u32);
4376 pub fn new() -> Foo { Foo(0) }
4380 let y = some_module::Foo::new();
4381 println!("{}", y.0); // error: field `0` of tuple-struct `some_module::Foo`
4385 Since the field is private, you have two solutions:
4387 1) Make the field public:
4391 pub struct Foo(pub u32); // The field is now public.
4394 pub fn new() -> Foo { Foo(0) }
4398 let y = some_module::Foo::new();
4399 println!("{}", y.0); // So we can access it directly.
4402 2) Add a getter function to keep the field private but allow for accessing its
4407 pub struct Foo(u32);
4410 pub fn new() -> Foo { Foo(0) }
4412 // We add the getter function.
4413 pub fn get(&self) -> &u32 { &self.0 }
4417 let y = some_module::Foo::new();
4418 println!("{}", y.get()); // So we can get the value through the function.
4423 Attempted out-of-bounds tuple index.
4425 Erroneous code example:
4427 ```compile_fail,E0612
4431 println!("{}", y.1); // error: attempted out-of-bounds tuple index `1`
4435 If a tuple/tuple-struct type has n fields, you can only try to access these n
4436 fields from 0 to (n - 1). So in this case, you can only index `0`. Example:
4442 println!("{}", y.0); // ok!
4447 Attempted tuple index on a type which isn't a tuple nor a tuple-struct.
4449 Erroneous code example:
4451 ```compile_fail,E0613
4455 println!("{}", y.1); // error: attempted to access tuple index `1` on type
4456 // `Foo`, but the type was not a tuple or tuple
4460 Only tuple and tuple-struct types can be indexed this way. Example:
4463 // Let's create a tuple first:
4464 let x: (u32, u32, u32, u32) = (0, 1, 1, 2);
4465 // You can index its fields this way:
4466 println!("({}, {}, {}, {})", x.0, x.1, x.2, x.3);
4468 // Now let's declare a tuple-struct:
4469 struct TupleStruct(u32, u32, u32, u32);
4470 // Let's instantiate it:
4471 let x = TupleStruct(0, 1, 1, 2);
4472 // And just like the tuple:
4473 println!("({}, {}, {}, {})", x.0, x.1, x.2, x.3);
4476 If you want to index into an array, use `[]` instead:
4479 let x = &[0, 1, 1, 2];
4480 println!("[{}, {}, {}, {}]", x[0], x[1], x[2], x[3]);
4483 If you want to access a field of a struct, check the field's name wasn't
4492 let s = SomeStruct {
4496 println!("x: {} y: {}", s.x, s.y);
4501 Attempted to dereference a variable which cannot be dereferenced.
4503 Erroneous code example:
4505 ```compile_fail,E0614
4507 *y; // error: type `u32` cannot be dereferenced
4510 Only types implementing `std::ops::Deref` can be dereferenced (such as `&T`).
4516 // So here, `x` is a `&u32`, so we can dereference it:
4522 Attempted to access a method like a field.
4524 Erroneous code example:
4526 ```compile_fail,E0615
4535 let f = Foo { x: 0 };
4536 f.method; // error: attempted to take value of method `method` on type `Foo`
4539 If you want to use a method, add `()` after it:
4542 # struct Foo { x: u32 }
4543 # impl Foo { fn method(&self) {} }
4544 # let f = Foo { x: 0 };
4548 However, if you wanted to access a field of a struct check that the field name
4549 is spelled correctly. Example:
4552 # struct Foo { x: u32 }
4553 # impl Foo { fn method(&self) {} }
4554 # let f = Foo { x: 0 };
4555 println!("{}", f.x);
4560 Attempted to access a private field on a struct.
4562 Erroneous code example:
4564 ```compile_fail,E0616
4567 x: u32, // So `x` is private in here.
4571 pub fn new() -> Foo { Foo { x: 0 } }
4575 let f = some_module::Foo::new();
4576 println!("{}", f.x); // error: field `x` of struct `some_module::Foo` is private
4579 If you want to access this field, you have two options:
4581 1) Set the field public:
4586 pub x: u32, // `x` is now public.
4590 pub fn new() -> Foo { Foo { x: 0 } }
4594 let f = some_module::Foo::new();
4595 println!("{}", f.x); // ok!
4598 2) Add a getter function:
4603 x: u32, // So `x` is still private in here.
4607 pub fn new() -> Foo { Foo { x: 0 } }
4609 // We create the getter function here:
4610 pub fn get_x(&self) -> &u32 { &self.x }
4614 let f = some_module::Foo::new();
4615 println!("{}", f.get_x()); // ok!
4620 Attempted to pass an invalid type of variable into a variadic function.
4622 Erroneous code example:
4624 ```compile_fail,E0617
4626 fn printf(c: *const i8, ...);
4630 printf(::std::ptr::null(), 0f32);
4631 // error: can't pass an `f32` to variadic function, cast to `c_double`
4635 To fix this error, you need to pass variables corresponding to C types as much
4636 as possible. For better explanations, see The Rust Book:
4637 https://doc.rust-lang.org/book/
4641 Attempted to call something which isn't a function nor a method.
4643 Erroneous code examples:
4645 ```compile_fail,E0618
4650 X::Entry(); // error: expected function, found `X::Entry`
4654 x(); // error: expected function, found `i32`
4657 Only functions and methods can be called using `()`. Example:
4660 // We declare a function:
4661 fn i_am_a_function() {}
4669 The type-checker needed to know the type of an expression, but that type had not
4672 Erroneous code example:
4674 ```compile_fail,E0619
4678 // Here, the type of `v` is not (yet) known, so we
4679 // cannot resolve this method call:
4680 v.to_uppercase(); // error: the type of this value must be known in
4687 Type inference typically proceeds from the top of the function to the bottom,
4688 figuring out types as it goes. In some cases -- notably method calls and
4689 overloadable operators like `*` -- the type checker may not have enough
4690 information *yet* to make progress. This can be true even if the rest of the
4691 function provides enough context (because the type-checker hasn't looked that
4692 far ahead yet). In this case, type annotations can be used to help it along.
4694 To fix this error, just specify the type of the variable. Example:
4697 let mut x: Vec<String> = vec![]; // We precise the type of the vec elements.
4700 v.to_uppercase(); // Since rustc now knows the type of the vec elements,
4701 // we can use `v`'s methods.
4709 A cast to an unsized type was attempted.
4711 Erroneous code example:
4713 ```compile_fail,E0620
4714 let x = &[1_usize, 2] as [usize]; // error: cast to unsized type: `&[usize; 2]`
4718 In Rust, some types don't have a known size at compile-time. For example, in a
4719 slice type like `[u32]`, the number of elements is not known at compile-time and
4720 hence the overall size cannot be computed. As a result, such types can only be
4721 manipulated through a reference (e.g., `&T` or `&mut T`) or other pointer-type
4722 (e.g., `Box` or `Rc`). Try casting to a reference instead:
4725 let x = &[1_usize, 2] as &[usize]; // ok!
4730 An intrinsic was declared without being a function.
4732 Erroneous code example:
4734 ```compile_fail,E0622
4735 #![feature(intrinsics)]
4736 extern "rust-intrinsic" {
4737 pub static breakpoint : unsafe extern "rust-intrinsic" fn();
4738 // error: intrinsic must be a function
4741 fn main() { unsafe { breakpoint(); } }
4744 An intrinsic is a function available for use in a given programming language
4745 whose implementation is handled specially by the compiler. In order to fix this
4746 error, just declare a function.
4751 register_diagnostics! {
4761 // E0159, // use of trait `{}` as struct constructor
4762 // E0163, // merged into E0071
4765 // E0172, // non-trait found in a type sum, moved to resolve
4766 // E0173, // manual implementations of unboxed closure traits are experimental
4769 // E0187, // can't infer the kind of the closure
4770 // E0188, // can not cast an immutable reference to a mutable pointer
4771 // E0189, // deprecated: can only cast a boxed pointer to a boxed object
4772 // E0190, // deprecated: can only cast a &-pointer to an &-object
4773 // E0196, // cannot determine a type for this closure
4774 E0203, // type parameter has more than one relaxed default bound,
4775 // and only one is supported
4777 // E0209, // builtin traits can only be implemented on structs or enums
4778 E0212, // cannot extract an associated type from a higher-ranked trait bound
4779 // E0213, // associated types are not accepted in this context
4780 // E0215, // angle-bracket notation is not stable with `Fn`
4781 // E0216, // parenthetical notation is only stable with `Fn`
4782 // E0217, // ambiguous associated type, defined in multiple supertraits
4783 // E0218, // no associated type defined
4784 // E0219, // associated type defined in higher-ranked supertrait
4785 // E0222, // Error code E0045 (variadic function must have C or cdecl calling
4786 // convention) duplicate
4787 E0224, // at least one non-builtin train is required for an object type
4788 E0227, // ambiguous lifetime bound, explicit lifetime bound required
4789 E0228, // explicit lifetime bound required
4790 E0231, // only named substitution parameters are allowed
4793 // E0235, // structure constructor specifies a structure of type but
4794 // E0236, // no lang item for range syntax
4795 // E0237, // no lang item for range syntax
4796 // E0238, // parenthesized parameters may only be used with a trait
4797 // E0239, // `next` method of `Iterator` trait has unexpected type
4801 E0245, // not a trait
4802 // E0246, // invalid recursive type
4804 // E0248, // value used as a type, now reported earlier during resolution as E0412
4806 // E0319, // trait impls for defaulted traits allowed just for structs/enums
4807 // E0372, // coherence not object safe
4808 E0377, // the trait `CoerceUnsized` may only be implemented for a coercion
4809 // between structures with the same definition
4810 E0436, // functional record update requires a struct
4811 E0521, // redundant default implementations of trait
4812 E0533, // `{}` does not name a unit variant, unit struct or a constant
4813 E0563, // cannot determine a type for this `impl Trait`: {}
4814 E0564, // only named lifetimes are allowed in `impl Trait`,
4815 // but `{}` was found in the type `{}`
4816 E0567, // auto traits can not have type parameters
4817 E0568, // auto-traits can not have predicates,
4818 E0588, // packed struct cannot transitively contain a `[repr(align)]` struct
4819 E0592, // duplicate definitions with name `{}`