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.
27 Here the `Apple` variant has two fields, and should be matched against like so:
36 Matching with the wrong number of fields has no sensible interpretation:
46 Check how many fields the enum was declared with and ensure that your pattern
51 This error indicates that a pattern attempted to extract the fields of an enum
52 variant with no fields. Here's a tiny example of this error:
55 // This enum has two variants.
57 // This variant has no fields.
59 // This variant has one field.
63 // Assuming x is a Number we can pattern match on its contents.
70 The pattern match `Zero(inside)` is incorrect because the `Zero` variant
71 contains no fields, yet the `inside` name attempts to bind the first field of
76 Each field of a struct can only be bound once in a pattern. Erroneous code
86 let x = Foo { a:1, b:2 };
88 let Foo { a: x, a: y } = x;
89 // error: field `a` bound multiple times in the pattern
93 Each occurrence of a field name binds the value of that field, so to fix this
94 error you will have to remove or alter the duplicate uses of the field name.
95 Perhaps you misspelled another field name? Example:
104 let x = Foo { a:1, b:2 };
106 let Foo { a: x, b: y } = x; // ok!
112 This error indicates that a struct pattern attempted to extract a non-existent
113 field from a struct. Struct fields are identified by the name used before the
114 colon `:` so struct patterns should resemble the declaration of the struct type
124 let thing = Thing { x: 1, y: 2 };
126 Thing { x: xfield, y: yfield } => ...
130 If you are using shorthand field patterns but want to refer to the struct field
131 by a different name, you should rename it explicitly.
136 Thing { x, z } => ...
141 Thing { x, y: z } => ...
147 This error indicates that a pattern for a struct fails to specify a sub-pattern
148 for every one of the struct's fields. Ensure that each field from the struct's
149 definition is mentioned in the pattern, or use `..` to ignore unwanted fields.
159 let d = Dog { name: "Rusty".to_string(), age: 8 };
161 // This is incorrect.
163 Dog { age: x } => ...
166 // This is correct (explicit).
168 Dog { name: n, age: x } => ...
171 // This is also correct (ignore unused fields).
173 Dog { age: x, .. } => ...
179 In a match expression, only numbers and characters can be matched against a
180 range. This is because the compiler checks that the range is non-empty at
181 compile-time, and is unable to evaluate arbitrary comparison functions. If you
182 want to capture values of an orderable type between two end-points, you can use
186 // The ordering relation for strings can't be evaluated at compile time,
187 // so this doesn't work:
189 "hello" ... "world" => ...
193 // This is a more general version, using a guard:
195 s if s >= "hello" && s <= "world" => ...
202 This error indicates that a pointer to a trait type cannot be implicitly
203 dereferenced by a pattern. Every trait defines a type, but because the
204 size of trait implementors isn't fixed, this type has no compile-time size.
205 Therefore, all accesses to trait types must be through pointers. If you
206 encounter this error you should try to avoid dereferencing the pointer.
209 let trait_obj: &SomeTrait = ...;
211 // This tries to implicitly dereference to create an unsized local variable.
212 let &invalid = trait_obj;
214 // You can call methods without binding to the value being pointed at.
215 trait_obj.method_one();
216 trait_obj.method_two();
219 You can read more about trait objects in the Trait Object section of the
222 https://doc.rust-lang.org/reference.html#trait-objects
226 The compiler doesn't know what method to call because more than one method
227 has the same prototype. Example:
240 impl Trait1 for Test { fn foo() {} }
241 impl Trait2 for Test { fn foo() {} }
244 Test::foo() // error, which foo() to call?
248 To avoid this error, you have to keep only one of them and remove the others.
249 So let's take our example and fix it:
258 impl Trait1 for Test { fn foo() {} }
261 Test::foo() // and now that's good!
265 However, a better solution would be using fully explicit naming of type and
279 impl Trait1 for Test { fn foo() {} }
280 impl Trait2 for Test { fn foo() {} }
283 <Test as Trait1>::foo()
289 You tried to give a type parameter where it wasn't needed. Bad example:
301 x.method::<i32>(); // Error: Test::method doesn't need type parameter!
305 To fix this error, just remove the type parameter:
317 x.method(); // OK, we're good!
323 This error occurrs when you pass too many or not enough type parameters to
330 fn method<T>(&self, v: &[T]) -> usize {
339 x.method::<i32, i32>(v); // error: only one type parameter is expected!
343 To fix it, just specify a correct number of type parameters:
349 fn method<T>(&self, v: &[T]) -> usize {
358 x.method::<i32>(v); // OK, we're good!
362 Please note on the last example that we could have called `method` like this:
370 It is not allowed to manually call destructors in Rust. It is also not
371 necessary to do this since `drop` is called automatically whenever a value goes
374 Here's an example of this error:
388 let mut x = Foo { x: -7 };
389 x.drop(); // error: explicit use of destructor method
395 You can't use type parameters on foreign items. Example of erroneous code:
398 extern { fn some_func<T>(x: T); }
401 To fix this, replace the type parameter with the specializations that you
405 extern { fn some_func_i32(x: i32); }
406 extern { fn some_func_i64(x: i64); }
411 Rust only supports variadic parameters for interoperability with C code in its
412 FFI. As such, variadic parameters can only be used with functions which are
413 using the C ABI. Examples of erroneous code:
416 extern "rust-call" { fn foo(x: u8, ...); }
418 fn foo(x: u8, ...) {}
421 To fix such code, put them in an extern "C" block:
424 extern "C" fn foo (x: u8, ...);
433 Items are missing in a trait implementation. Erroneous code example:
443 // error: not all trait items implemented, missing: `foo`
446 When trying to make some type implement a trait `Foo`, you must, at minimum,
447 provide implementations for all of `Foo`'s required methods (meaning the
448 methods that do not have default implementations), as well as any required
449 trait items like associated types or constants. Example:
465 This error indicates that an attempted implementation of a trait method
466 has the wrong number of type parameters.
468 For example, the trait below has a method `foo` with a type parameter `T`,
469 but the implementation of `foo` for the type `Bar` is missing this parameter:
473 fn foo<T: Default>(x: T) -> Self;
478 // error: method `foo` has 0 type parameters but its trait declaration has 1
481 fn foo(x: bool) -> Self { Bar }
487 This error indicates that an attempted implementation of a trait method
488 has the wrong number of function parameters.
490 For example, the trait below has a method `foo` with two function parameters
491 (`&self` and `u8`), but the implementation of `foo` for the type `Bar` omits
496 fn foo(&self, x: u8) -> bool;
501 // error: method `foo` has 1 parameter but the declaration in trait `Foo::foo`
504 fn foo(&self) -> bool { true }
510 The parameters of any trait method must match between a trait implementation
511 and the trait definition.
513 Here are a couple examples of this error:
524 // error, expected u16, found i16
527 // error, values differ in mutability
528 fn bar(&mut self) { }
534 It is not allowed to cast to a bool. If you are trying to cast a numeric type
535 to a bool, you can compare it with zero instead:
541 let x_is_nonzero = x != 0;
543 // Not allowed, won't compile
544 let x_is_nonzero = x as bool;
549 During a method call, a value is automatically dereferenced as many times as
550 needed to make the value's type match the method's receiver. The catch is that
551 the compiler will only attempt to dereference a number of times up to the
552 recursion limit (which can be set via the `recursion_limit` attribute).
554 For a somewhat artificial example:
557 #![recursion_limit="2"]
569 // error, reached the recursion limit while auto-dereferencing &&Foo
574 One fix may be to increase the recursion limit. Note that it is possible to
575 create an infinite recursion of dereferencing, in which case the only fix is to
576 somehow break the recursion.
580 When invoking closures or other implementations of the function traits `Fn`,
581 `FnMut` or `FnOnce` using call notation, the number of parameters passed to the
582 function must match its definition.
584 An example using a closure:
588 let a = f(); // invalid, too few parameters
589 let b = f(4); // this works!
590 let c = f(2, 3); // invalid, too many parameters
593 A generic function must be treated similarly:
596 fn foo<F: Fn()>(f: F) {
597 f(); // this is valid, but f(3) would not work
603 The built-in function traits are generic over a tuple of the function arguments.
604 If one uses angle-bracket notation (`Fn<(T,), Output=U>`) instead of parentheses
605 (`Fn(T) -> U`) to denote the function trait, the type parameter should be a
606 tuple. Otherwise function call notation cannot be used and the trait will not be
607 implemented by closures.
609 The most likely source of this error is using angle-bracket notation without
610 wrapping the function argument type into a tuple, for example:
613 fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) }
616 It can be fixed by adjusting the trait bound like this:
619 fn foo<F: Fn<(i32,)>>(f: F) -> F::Output { f(3) }
622 Note that `(T,)` always denotes the type of a 1-tuple containing an element of
623 type `T`. The comma is necessary for syntactic disambiguation.
627 External C functions are allowed to be variadic. However, a variadic function
628 takes a minimum number of arguments. For example, consider C's variadic `printf`
633 use libc::{ c_char, c_int };
636 fn printf(_: *const c_char, ...) -> c_int;
640 Using this declaration, it must be called with at least one argument, so
641 simply calling `printf()` is invalid. But the following uses are allowed:
645 use std::ffi::CString;
647 printf(CString::new("test\n").unwrap().as_ptr());
648 printf(CString::new("number = %d\n").unwrap().as_ptr(), 3);
649 printf(CString::new("%d, %d\n").unwrap().as_ptr(), 10, 5);
655 The number of arguments passed to a function must match the number of arguments
656 specified in the function signature.
658 For example, a function like
661 fn f(a: u16, b: &str) {}
664 must always be called with exactly two arguments, e.g. `f(2, "test")`.
666 Note, that Rust does not have a notion of optional function arguments or
667 variadic functions (except for its C-FFI).
671 This error indicates that during an attempt to build a struct or struct-like
672 enum variant, one of the fields was specified more than once. Erroneous code
683 x: 0, // error: field `x` specified more than once
688 Each field should be specified exactly one time. Example:
696 let x = Foo { x: 0 }; // ok!
702 This error indicates that during an attempt to build a struct or struct-like
703 enum variant, one of the fields was not provided. Erroneous code example:
712 let x = Foo { x: 0 }; // error: missing field: `y`
716 Each field should be specified exactly once. Example:
725 let x = Foo { x: 0, y: 0 }; // ok!
731 Box placement expressions (like C++'s "placement new") do not yet support any
732 place expression except the exchange heap (i.e. `std::boxed::HEAP`).
733 Furthermore, the syntax is changing to use `in` instead of `box`. See [RFC 470]
734 and [RFC 809] for more details.
736 [RFC 470]: https://github.com/rust-lang/rfcs/pull/470
737 [RFC 809]: https://github.com/rust-lang/rfcs/pull/809
741 The left-hand side of a compound assignment expression must be an lvalue
742 expression. An lvalue expression represents a memory location and includes
743 item paths (ie, namespaced variables), dereferences, indexing expressions,
744 and field references.
746 Let's start with some bad examples:
749 use std::collections::LinkedList;
751 // Bad: assignment to non-lvalue expression
752 LinkedList::new() += 1;
756 fn some_func(i: &mut i32) {
757 i += 12; // Error : '+=' operation cannot be applied on a reference !
761 And now some good examples:
770 fn some_func(i: &mut i32) {
777 The compiler found a function whose body contains a `return;` statement but
778 whose return type is not `()`. An example of this is:
787 Since `return;` is just like `return ();`, there is a mismatch between the
788 function's return type and the value being returned.
792 The left-hand side of an assignment operator must be an lvalue expression. An
793 lvalue expression represents a memory location and can be a variable (with
794 optional namespacing), a dereference, an indexing expression or a field
797 More details can be found here:
798 https://doc.rust-lang.org/reference.html#lvalues,-rvalues-and-temporaries
800 Now, we can go further. Here are some bad examples:
807 const SOME_CONST : i32 = 12;
809 fn some_other_func() {}
812 SOME_CONST = 14; // error : a constant value cannot be changed!
813 1 = 3; // error : 1 isn't a valid lvalue!
814 some_other_func() = 4; // error : we can't assign value to a function!
815 SomeStruct.x = 12; // error : SomeStruct a structure name but it is used
820 And now let's give good examples:
827 let mut s = SomeStruct {x: 0, y: 0};
829 s.x = 3; // that's good !
833 fn some_func(x: &mut i32) {
834 *x = 12; // that's good !
840 You tried to use structure-literal syntax to create an item that is
841 not a struct-style structure or enum variant.
843 Example of erroneous code:
846 enum Foo { FirstValue(i32) };
848 let u = Foo::FirstValue { value: 0i32 }; // error: Foo::FirstValue
849 // isn't a structure!
850 // or even simpler, if the name doesn't refer to a structure at all.
851 let t = u32 { value: 4 }; // error: `u32` does not name a structure.
854 To fix this, ensure that the name was correctly spelled, and that
855 the correct form of initializer was used.
857 For example, the code above can be fixed to:
865 let u = Foo::FirstValue(0i32);
873 When defining a recursive struct or enum, any use of the type being defined
874 from inside the definition must occur behind a pointer (like `Box` or `&`).
875 This is because structs and enums must have a well-defined size, and without
876 the pointer the size of the type would need to be unbounded.
878 Consider the following erroneous definition of a type for a list of bytes:
881 // error, invalid recursive struct type
884 tail: Option<ListNode>,
888 This type cannot have a well-defined size, because it needs to be arbitrarily
889 large (since we would be able to nest `ListNode`s to any depth). Specifically,
892 size of `ListNode` = 1 byte for `head`
893 + 1 byte for the discriminant of the `Option`
897 One way to fix this is by wrapping `ListNode` in a `Box`, like so:
902 tail: Option<Box<ListNode>>,
906 This works because `Box` is a pointer, so its size is well-known.
910 You cannot define a struct (or enum) `Foo` that requires an instance of `Foo`
911 in order to make a new `Foo` value. This is because there would be no way a
912 first instance of `Foo` could be made to initialize another instance!
914 Here's an example of a struct that has this problem:
917 struct Foo { x: Box<Foo> } // error
920 One fix is to use `Option`, like so:
923 struct Foo { x: Option<Box<Foo>> }
926 Now it's possible to create at least one instance of `Foo`: `Foo { x: None }`.
930 When using the `#[simd]` attribute on a tuple struct, the components of the
931 tuple struct must all be of a concrete, nongeneric type so the compiler can
932 reason about how to use SIMD with them. This error will occur if the types
937 struct Bad<T>(T, T, T); // This will cause an error
940 struct Good(u32, u32, u32); // This will not
945 The `#[simd]` attribute can only be applied to non empty tuple structs, because
946 it doesn't make sense to try to use SIMD operations when there are no values to
951 struct Bad; // This will cause an error
954 struct Good(u32); // This will not
959 When using the `#[simd]` attribute to automatically use SIMD operations in tuple
960 struct, the types in the struct must all be of the same type, or the compiler
961 will trigger this error.
965 struct Bad(u16, u32, u32); // This will cause an error
968 struct Good(u32, u32, u32); // This will not
974 When using the `#[simd]` attribute on a tuple struct, the elements in the tuple
975 must be machine types so SIMD operations can be applied to them.
979 struct Bad(String); // This will cause an error
982 struct Good(u32, u32, u32); // This will not
987 Enum variants which contain no data can be given a custom integer
988 representation. This error indicates that the value provided is not an integer
989 literal and is therefore invalid.
991 For example, in the following code,
999 we try to set the representation to a string.
1001 There's no general fix for this; if you can work with an integer then just set
1010 however if you actually wanted a mapping between variants and non-integer
1011 objects, it may be preferable to use a method with a match instead:
1016 fn get_str(&self) -> &'static str {
1026 This error indicates that the compiler was unable to sensibly evaluate an
1027 integer expression provided as an enum discriminant. Attempting to divide by 0
1028 or causing integer overflow are two ways to induce this error. For example:
1037 Ensure that the expressions given can be evaluated as the desired integer type.
1038 See the FFI section of the Reference for more information about using a custom
1041 https://doc.rust-lang.org/reference.html#ffi-attributes
1045 Enum discriminants are used to differentiate enum variants stored in memory.
1046 This error indicates that the same value was used for two or more variants,
1047 making them impossible to tell apart.
1065 Note that variants without a manually specified discriminant are numbered from
1066 top to bottom starting from 0, so clashes can occur with seemingly unrelated
1076 Here `X` will have already been assigned the discriminant 0 by the time `Y` is
1077 encountered, so a conflict occurs.
1081 The default type for enum discriminants is `isize`, but it can be adjusted by
1082 adding the `repr` attribute to the enum declaration. This error indicates that
1083 an integer literal given as a discriminant is not a member of the discriminant
1094 Here, 1024 lies outside the valid range for `u8`, so the discriminant for `A` is
1095 invalid. You may want to change representation types to fix this, or else change
1096 invalid discriminant values so that they fit within the existing type.
1098 Note also that without a representation manually defined, the compiler will
1099 optimize by using the smallest integer type possible.
1103 At present, it's not possible to define a custom representation for an enum with
1104 a single variant. As a workaround you can add a `Dummy` variant.
1106 See: https://github.com/rust-lang/rust/issues/10292
1110 It is impossible to define an integer type to be used to represent zero-variant
1111 enum values because there are no zero-variant enum values. There is no way to
1112 construct an instance of the following type using only safe code:
1120 Too many type parameters were supplied for a function. For example:
1126 foo::<f64, bool>(); // error, expected 1 parameter, found 2 parameters
1130 The number of supplied parameters must exactly match the number of defined type
1135 You gave too many lifetime parameters. Erroneous code example:
1141 f::<'static>() // error: too many lifetime parameters provided
1145 Please check you give the right number of lifetime parameters. Example:
1155 It's also important to note that the Rust compiler can generally
1156 determine the lifetime by itself. Example:
1164 // it can be written like this
1165 fn get_value<'a>(&'a self) -> &'a str { &self.value }
1166 // but the compiler works fine with this too:
1167 fn without_lifetime(&self) -> &str { &self.value }
1171 let f = Foo { value: "hello".to_owned() };
1173 println!("{}", f.get_value());
1174 println!("{}", f.without_lifetime());
1180 Not enough type parameters were supplied for a function. For example:
1186 foo::<f64>(); // error, expected 2 parameters, found 1 parameter
1190 Note that if a function takes multiple type parameters but you want the compiler
1191 to infer some of them, you can use type placeholders:
1194 fn foo<T, U>(x: T) {}
1198 foo::<f64>(x); // error, expected 2 parameters, found 1 parameter
1199 foo::<_, f64>(x); // same as `foo::<bool, f64>(x)`
1205 You gave an unnecessary type parameter in a type alias. Erroneous code
1209 type Foo<T> = u32; // error: type parameter `T` is unused
1211 type Foo<A,B> = Box<A>; // error: type parameter `B` is unused
1214 Please check you didn't write too many type parameters. Example:
1217 type Foo = u32; // ok!
1218 type Foo<A> = Box<A>; // ok!
1223 You tried to declare an undefined atomic operation function.
1224 Erroneous code example:
1227 #![feature(intrinsics)]
1229 extern "rust-intrinsic" {
1230 fn atomic_foo(); // error: unrecognized atomic operation
1235 Please check you didn't make a mistake in the function's name. All intrinsic
1236 functions are defined in librustc_trans/trans/intrinsic.rs and in
1237 libcore/intrinsics.rs in the Rust source code. Example:
1240 #![feature(intrinsics)]
1242 extern "rust-intrinsic" {
1243 fn atomic_fence(); // ok!
1249 You declared an unknown intrinsic function. Erroneous code example:
1252 #![feature(intrinsics)]
1254 extern "rust-intrinsic" {
1255 fn foo(); // error: unrecognized intrinsic function: `foo`
1265 Please check you didn't make a mistake in the function's name. All intrinsic
1266 functions are defined in librustc_trans/trans/intrinsic.rs and in
1267 libcore/intrinsics.rs in the Rust source code. Example:
1270 #![feature(intrinsics)]
1272 extern "rust-intrinsic" {
1273 fn atomic_fence(); // ok!
1285 You gave an invalid number of type parameters to an intrinsic function.
1286 Erroneous code example:
1289 #![feature(intrinsics)]
1291 extern "rust-intrinsic" {
1292 fn size_of<T, U>() -> usize; // error: intrinsic has wrong number
1293 // of type parameters
1297 Please check that you provided the right number of lifetime parameters
1298 and verify with the function declaration in the Rust source code.
1302 #![feature(intrinsics)]
1304 extern "rust-intrinsic" {
1305 fn size_of<T>() -> usize; // ok!
1311 You hit this error because the compiler lacks the information to
1312 determine a type for this expression. Erroneous code example:
1316 let x = |_| {}; // error: cannot determine a type for this expression
1320 You have two possibilities to solve this situation:
1321 * Give an explicit definition of the expression
1322 * Infer the expression
1328 let x = |_ : u32| {}; // ok!
1337 You hit this error because the compiler lacks information to
1338 determine a type for this variable. Erroneous code example:
1341 fn demo(devil: fn () -> !) {
1342 let x: &_ = devil();
1343 // error: cannot determine a type for this local variable
1346 fn oh_no() -> ! { panic!("the devil is in the details") }
1353 To solve this situation, constrain the type of the variable.
1357 fn some_func(x: &u32) {
1361 fn demo(devil: fn () -> !) {
1362 let x: &u32 = devil();
1363 // Here we defined the type at the variable creation
1365 let x: &_ = devil();
1367 // Here, the type is determined by the function argument type
1370 fn oh_no() -> ! { panic!("the devil is in the details") }
1379 This error indicates that a lifetime is missing from a type. If it is an error
1380 inside a function signature, the problem may be with failing to adhere to the
1381 lifetime elision rules (see below).
1383 Here are some simple examples of where you'll run into this error:
1386 struct Foo { x: &bool } // error
1387 struct Foo<'a> { x: &'a bool } // correct
1389 enum Bar { A(u8), B(&bool), } // error
1390 enum Bar<'a> { A(u8), B(&'a bool), } // correct
1392 type MyStr = &str; // error
1393 type MyStr<'a> = &'a str; //correct
1397 Lifetime elision is a special, limited kind of inference for lifetimes in
1398 function signatures which allows you to leave out lifetimes in certain cases.
1399 For more background on lifetime elision see [the book][book-le].
1401 The lifetime elision rules require that any function signature with an elided
1402 output lifetime must either have
1404 - exactly one input lifetime
1405 - or, multiple input lifetimes, but the function must also be a method with a
1406 `&self` or `&mut self` receiver
1408 In the first case, the output lifetime is inferred to be the same as the unique
1409 input lifetime. In the second case, the lifetime is instead inferred to be the
1410 same as the lifetime on `&self` or `&mut self`.
1412 Here are some examples of elision errors:
1415 // error, no input lifetimes
1416 fn foo() -> &str { ... }
1418 // error, `x` and `y` have distinct lifetimes inferred
1419 fn bar(x: &str, y: &str) -> &str { ... }
1421 // error, `y`'s lifetime is inferred to be distinct from `x`'s
1422 fn baz<'a>(x: &'a str, y: &str) -> &str { ... }
1425 [book-le]: https://doc.rust-lang.org/nightly/book/lifetimes.html#lifetime-elision
1429 This error means that an incorrect number of lifetime parameters were provided
1430 for a type (like a struct or enum) or trait.
1432 Some basic examples include:
1435 struct Foo<'a>(&'a str);
1436 enum Bar { A, B, C }
1439 foo: Foo, // error: expected 1, found 0
1440 bar: Bar<'a>, // error: expected 0, found 1
1444 Here's an example that is currently an error, but may work in a future version
1448 struct Foo<'a>(&'a str);
1451 impl Quux for Foo { } // error: expected 1, found 0
1454 Lifetime elision in implementation headers was part of the lifetime elision
1455 RFC. It is, however, [currently unimplemented][iss15872].
1457 [iss15872]: https://github.com/rust-lang/rust/issues/15872
1461 You can only define an inherent implementation for a type in the same crate
1462 where the type was defined. For example, an `impl` block as below is not allowed
1463 since `Vec` is defined in the standard library:
1466 impl Vec<u8> { ... } // error
1469 To fix this problem, you can do either of these things:
1471 - define a trait that has the desired associated functions/types/constants and
1472 implement the trait for the type in question
1473 - define a new type wrapping the type and define an implementation on the new
1476 Note that using the `type` keyword does not work here because `type` only
1477 introduces a type alias:
1480 type Bytes = Vec<u8>;
1482 impl Bytes { ... } // error, same as above
1487 This error indicates a violation of one of Rust's orphan rules for trait
1488 implementations. The rule prohibits any implementation of a foreign trait (a
1489 trait defined in another crate) where
1491 - the type that is implementing the trait is foreign
1492 - all of the parameters being passed to the trait (if there are any) are also
1495 Here's one example of this error:
1498 impl Drop for u32 {}
1501 To avoid this kind of error, ensure that at least one local type is referenced
1505 pub struct Foo; // you define your type in your crate
1507 impl Drop for Foo { // and you can implement the trait on it!
1508 // code of trait implementation here
1511 impl From<Foo> for i32 { // or you use a type from your crate as
1513 fn from(i: Foo) -> i32 {
1519 Alternatively, define a trait locally and implement that instead:
1523 fn get(&self) -> usize;
1527 fn get(&self) -> usize { 0 }
1531 For information on the design of the orphan rules, see [RFC 1023].
1533 [RFC 1023]: https://github.com/rust-lang/rfcs/pull/1023
1537 Rust can't find a base type for an implementation you are providing, or the type
1538 cannot have an implementation. For example, only a named type or a trait can
1539 have an implementation:
1542 type NineString = [char, ..9] // This isn't a named type (struct, enum or trait)
1548 In the other, simpler case, Rust just can't find the type you are providing an
1549 impelementation for:
1552 impl SomeTypeThatDoesntExist { }
1557 There are conflicting trait implementations for the same type.
1558 Example of erroneous code:
1562 fn get(&self) -> usize;
1565 impl<T> MyTrait for T {
1566 fn get(&self) -> usize { 0 }
1573 impl MyTrait for Foo { // error: conflicting implementations for trait
1575 fn get(&self) -> usize { self.value }
1579 When looking for the implementation for the trait, the compiler finds
1580 both the `impl<T> MyTrait for T` where T is all types and the `impl
1581 MyTrait for Foo`. Since a trait cannot be implemented multiple times,
1582 this is an error. So, when you write:
1585 impl<T> MyTrait for T {
1586 fn get(&self) -> usize { 0 }
1590 This makes the trait implemented on all types in the scope. So if you
1591 try to implement it on another one after that, the implementations will
1596 fn get(&self) -> usize;
1599 impl<T> MyTrait for T {
1600 fn get(&self) -> usize { 0 }
1608 f.get(); // the trait is implemented so we can use it
1614 An attempt was made to implement Drop on a trait, which is not allowed: only
1615 structs and enums can implement Drop. An example causing this error:
1620 impl Drop for MyTrait {
1621 fn drop(&mut self) {}
1625 A workaround for this problem is to wrap the trait up in a struct, and implement
1626 Drop on that. An example is shown below:
1630 struct MyWrapper<T: MyTrait> { foo: T }
1632 impl <T: MyTrait> Drop for MyWrapper<T> {
1633 fn drop(&mut self) {}
1638 Alternatively, wrapping trait objects requires something like the following:
1643 //or Box<MyTrait>, if you wanted an owned trait object
1644 struct MyWrapper<'a> { foo: &'a MyTrait }
1646 impl <'a> Drop for MyWrapper<'a> {
1647 fn drop(&mut self) {}
1653 In order to be consistent with Rust's lack of global type inference, type
1654 placeholders are disallowed by design in item signatures.
1656 Examples of this error include:
1659 fn foo() -> _ { 5 } // error, explicitly write out the return type instead
1661 static BAR: _ = "test"; // error, explicitly write out the type instead
1666 An attempt was made to add a generic constraint to a type alias. While Rust will
1667 allow this with a warning, it will not currently enforce the constraint.
1668 Consider the example below:
1673 type MyType<R: Foo> = (R, ());
1680 We're able to declare a variable of type `MyType<u32>`, despite the fact that
1681 `u32` does not implement `Foo`. As a result, one should avoid using generic
1682 constraints in concert with type aliases.
1686 You declared two fields of a struct with the same name. Erroneous code
1692 field1: i32 // error: field is already declared
1696 Please verify that the field names have been correctly spelled. Example:
1707 Type parameter defaults can only use parameters that occur before them.
1708 Erroneous code example:
1711 pub struct Foo<T=U, U=()> {
1715 // error: type parameters with a default cannot use forward declared
1719 Since type parameters are evaluated in-order, you may be able to fix this issue
1723 pub struct Foo<U=(), T=U> {
1729 Please also verify that this wasn't because of a name-clash and rename the type
1734 You declared a pattern as an argument in a foreign function declaration.
1735 Erroneous code example:
1739 fn foo((a, b): (u32, u32)); // error: patterns aren't allowed in foreign
1740 // function declarations
1744 Please replace the pattern argument with a regular one. Example:
1753 fn foo(s: SomeStruct); // ok!
1757 fn foo(a: (u32, u32)); // ok!
1763 It is not possible to define `main` with type parameters, or even with function
1764 parameters. When `main` is present, it must take no arguments and return `()`.
1765 Erroneous code example:
1768 fn main<T>() { // error: main function is not allowed to have type parameters
1774 It is not possible to declare type parameters on a function that has the `start`
1775 attribute. Such a function must have the following type signature:
1778 fn(isize, *const *const u8) -> isize;
1783 This error means that an attempt was made to match an enum variant as a
1784 struct type when the variant isn't a struct type:
1789 fn bar(foo: Foo) -> u32 {
1791 Foo::B{i} => i // error 0163
1796 Try using `()` instead:
1799 fn bar(foo: Foo) -> u32 {
1809 This error means that an attempt was made to match a struct type enum
1810 variant as a non-struct type:
1813 enum Foo { B{ i: u32 } }
1815 fn bar(foo: Foo) -> u32 {
1817 Foo::B(i) => i // error 0164
1822 Try using `{}` instead:
1825 fn bar(foo: Foo) -> u32 {
1835 This error means that the compiler found a return expression in a function
1836 marked as diverging. A function diverges if it has `!` in the place of the
1837 return type in its signature. For example:
1840 fn foo() -> ! { return; } // error
1843 For a function that diverges, every control path in the function must never
1844 return, for example with a `loop` that never breaks or a call to another
1845 diverging function (such as `panic!()`).
1849 This error means that an attempt was made to specify the type of a variable with
1850 a combination of a concrete type and a trait. Consider the following example:
1853 fn foo(bar: i32+std::fmt::Display) {}
1856 The code is trying to specify that we want to receive a signed 32-bit integer
1857 which also implements `Display`. This doesn't make sense: when we pass `i32`, a
1858 concrete type, it implicitly includes all of the traits that it implements.
1859 This includes `Display`, `Debug`, `Clone`, and a host of others.
1861 If `i32` implements the trait we desire, there's no need to specify the trait
1862 separately. If it does not, then we need to `impl` the trait for `i32` before
1863 passing it into `foo`. Either way, a fixed definition for `foo` will look like
1870 To learn more about traits, take a look at the Book:
1872 https://doc.rust-lang.org/book/traits.html
1876 In types, the `+` type operator has low precedence, so it is often necessary
1885 w: &'a Foo + Copy, // error, use &'a (Foo + Copy)
1886 x: &'a Foo + 'a, // error, use &'a (Foo + 'a)
1887 y: &'a mut Foo + 'a, // error, use &'a mut (Foo + 'a)
1888 z: fn() -> Foo + 'a, // error, use fn() -> (Foo + 'a)
1892 More details can be found in [RFC 438].
1894 [RFC 438]: https://github.com/rust-lang/rfcs/pull/438
1898 Explicitly implementing both Drop and Copy for a type is currently disallowed.
1899 This feature can make some sense in theory, but the current implementation is
1900 incorrect and can lead to memory unsafety (see [issue #20126][iss20126]), so
1901 it has been disabled for now.
1903 [iss20126]: https://github.com/rust-lang/rust/issues/20126
1907 An associated function for a trait was defined to be static, but an
1908 implementation of the trait declared the same function to be a method (i.e. to
1909 take a `self` parameter).
1911 Here's an example of this error:
1921 // error, method `foo` has a `&self` declaration in the impl, but not in
1928 An associated function for a trait was defined to be a method (i.e. to take a
1929 `self` parameter), but an implementation of the trait declared the same function
1932 Here's an example of this error:
1942 // error, method `foo` has a `&self` declaration in the trait, but not in
1950 Trait objects need to have all associated types specified. Erroneous code
1958 type Foo = Trait; // error: the value of the associated type `Bar` (from
1959 // the trait `Trait`) must be specified
1962 Please verify you specified all associated types of the trait and that you
1963 used the right trait. Example:
1970 type Foo = Trait<Bar=i32>; // ok!
1975 Negative impls are only allowed for traits with default impls. For more
1976 information see the [opt-in builtin traits RFC](https://github.com/rust-lang/
1977 rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
1981 `where` clauses must use generic type parameters: it does not make sense to use
1982 them otherwise. An example causing this error:
1989 #[derive(Copy,Clone)]
1994 impl Foo for Wrapper<u32> where Wrapper<u32>: Clone {
1999 This use of a `where` clause is strange - a more common usage would look
2000 something like the following:
2003 impl <T> Foo for Wrapper<T> where Wrapper<T>: Clone {
2008 Here, we're saying that the implementation exists on Wrapper only when the
2009 wrapped type `T` implements `Clone`. The `where` clause is important because
2010 some types will not implement `Clone`, and thus will not get this method.
2012 In our erroneous example, however, we're referencing a single concrete type.
2013 Since we know for certain that `Wrapper<u32>` implements `Clone`, there's no
2014 reason to also specify it in a `where` clause.
2018 A type parameter was declared which shadows an existing one. An example of this
2023 fn do_something(&self) -> T;
2024 fn do_something_else<T: Clone>(&self, bar: T);
2028 In this example, the trait `Foo` and the trait method `do_something_else` both
2029 define a type parameter `T`. This is not allowed: if the method wishes to
2030 define a type parameter, it must use a different name for it.
2034 Your method's lifetime parameters do not match the trait declaration.
2035 Erroneous code example:
2039 fn bar<'a,'b:'a>(x: &'a str, y: &'b str);
2044 impl Trait for Foo {
2045 fn bar<'a,'b>(x: &'a str, y: &'b str) {
2046 // error: lifetime parameters or bounds on method `bar`
2047 // do not match the trait declaration
2052 The lifetime constraint `'b` for bar() implementation does not match the
2053 trait declaration. Ensure lifetime declarations match exactly in both trait
2054 declaration and implementation. Example:
2058 fn t<'a,'b:'a>(x: &'a str, y: &'b str);
2063 impl Trait for Foo {
2064 fn t<'a,'b:'a>(x: &'a str, y: &'b str) { // ok!
2071 Inherent implementations (one that do not implement a trait but provide
2072 methods associated with a type) are always safe because they are not
2073 implementing an unsafe trait. Removing the `unsafe` keyword from the inherent
2074 implementation will resolve this error.
2079 // this will cause this error
2081 // converting it to this will fix it
2087 A negative implementation is one that excludes a type from implementing a
2088 particular trait. Not being able to use a trait is always a safe operation,
2089 so negative implementations are always safe and never need to be marked as
2095 // unsafe is unnecessary
2096 unsafe impl !Clone for Foo { }
2097 // this will compile
2098 impl !Clone for Foo { }
2103 Safe traits should not have unsafe implementations, therefore marking an
2104 implementation for a safe trait unsafe will cause a compiler error. Removing the
2105 unsafe marker on the trait noted in the error will resolve this problem.
2112 // this won't compile because Bar is safe
2113 unsafe impl Bar for Foo { }
2114 // this will compile
2115 impl Bar for Foo { }
2120 Unsafe traits must have unsafe implementations. This error occurs when an
2121 implementation for an unsafe trait isn't marked as unsafe. This may be resolved
2122 by marking the unsafe implementation as unsafe.
2127 unsafe trait Bar { }
2129 // this won't compile because Bar is unsafe and impl isn't unsafe
2130 impl Bar for Foo { }
2131 // this will compile
2132 unsafe impl Bar for Foo { }
2137 It is an error to define two associated items (like methods, associated types,
2138 associated functions, etc.) with the same identifier.
2146 fn bar(&self) -> bool { self.0 > 5 }
2147 fn bar() {} // error: duplicate associated function
2152 fn baz(&self) -> bool;
2158 fn baz(&self) -> bool { true }
2160 // error: duplicate method
2161 fn baz(&self) -> bool { self.0 > 5 }
2163 // error: duplicate associated type
2170 Inherent associated types were part of [RFC 195] but are not yet implemented.
2171 See [the tracking issue][iss8995] for the status of this implementation.
2173 [RFC 195]: https://github.com/rust-lang/rfcs/pull/195
2174 [iss8995]: https://github.com/rust-lang/rust/issues/8995
2178 An attempt to implement the `Copy` trait for a struct failed because one of the
2179 fields does not implement `Copy`. To fix this, you must implement `Copy` for the
2180 mentioned field. Note that this may not be possible, as in the example of
2187 impl Copy for Foo { }
2190 This fails because `Vec<T>` does not implement `Copy` for any `T`.
2192 Here's another example that will fail:
2201 This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
2202 differs from the behavior for `&T`, which is always `Copy`).
2206 An attempt to implement the `Copy` trait for an enum failed because one of the
2207 variants does not implement `Copy`. To fix this, you must implement `Copy` for
2208 the mentioned variant. Note that this may not be possible, as in the example of
2216 impl Copy for Foo { }
2219 This fails because `Vec<T>` does not implement `Copy` for any `T`.
2221 Here's another example that will fail:
2231 This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
2232 differs from the behavior for `&T`, which is always `Copy`).
2236 You can only implement `Copy` for a struct or enum. Both of the following
2237 examples will fail, because neither `i32` (primitive type) nor `&'static Bar`
2238 (reference to `Bar`) is a struct or enum:
2242 impl Copy for Foo { } // error
2244 #[derive(Copy, Clone)]
2246 impl Copy for &'static Bar { } // error
2251 You declared an unused type parameter when implementing a trait on an object.
2252 Erroneous code example:
2256 fn get(&self) -> usize;
2261 impl<T> MyTrait for Foo {
2262 fn get(&self) -> usize {
2268 Please check your object definition and remove unused type
2269 parameter(s). Example:
2273 fn get(&self) -> usize;
2278 impl MyTrait for Foo {
2279 fn get(&self) -> usize {
2287 This error indicates a violation of one of Rust's orphan rules for trait
2288 implementations. The rule concerns the use of type parameters in an
2289 implementation of a foreign trait (a trait defined in another crate), and
2290 states that type parameters must be "covered" by a local type. To understand
2291 what this means, it is perhaps easiest to consider a few examples.
2293 If `ForeignTrait` is a trait defined in some external crate `foo`, then the
2294 following trait `impl` is an error:
2298 use foo::ForeignTrait;
2300 impl<T> ForeignTrait for T { ... } // error
2303 To work around this, it can be covered with a local type, `MyType`:
2306 struct MyType<T>(T);
2307 impl<T> ForeignTrait for MyType<T> { ... } // Ok
2310 For another example of an error, suppose there's another trait defined in `foo`
2311 named `ForeignTrait2` that takes two type parameters. Then this `impl` results
2312 in the same rule violation:
2316 impl<T> ForeignTrait2<T, MyType<T>> for MyType2 { ... } // error
2319 The reason for this is that there are two appearances of type parameter `T` in
2320 the `impl` header, both as parameters for `ForeignTrait2`. The first appearance
2321 is uncovered, and so runs afoul of the orphan rule.
2323 Consider one more example:
2326 impl<T> ForeignTrait2<MyType<T>, T> for MyType2 { ... } // Ok
2329 This only differs from the previous `impl` in that the parameters `T` and
2330 `MyType<T>` for `ForeignTrait2` have been swapped. This example does *not*
2331 violate the orphan rule; it is permitted.
2333 To see why that last example was allowed, you need to understand the general
2334 rule. Unfortunately this rule is a bit tricky to state. Consider an `impl`:
2337 impl<P1, ..., Pm> ForeignTrait<T1, ..., Tn> for T0 { ... }
2340 where `P1, ..., Pm` are the type parameters of the `impl` and `T0, ..., Tn`
2341 are types. One of the types `T0, ..., Tn` must be a local type (this is another
2342 orphan rule, see the explanation for E0117). Let `i` be the smallest integer
2343 such that `Ti` is a local type. Then no type parameter can appear in any of the
2346 For information on the design of the orphan rules, see [RFC 1023].
2348 [RFC 1023]: https://github.com/rust-lang/rfcs/pull/1023
2352 You used an intrinsic function which doesn't correspond to its
2353 definition. Erroneous code example:
2356 #![feature(intrinsics)]
2358 extern "rust-intrinsic" {
2359 fn size_of<T>(); // error: intrinsic has wrong type
2363 Please check the function definition. Example:
2366 #![feature(intrinsics)]
2368 extern "rust-intrinsic" {
2369 fn size_of<T>() -> usize;
2375 A generic type was described using parentheses rather than angle brackets. For
2380 let v: Vec(&str) = vec!["foo"];
2384 This is not currently supported: `v` should be defined as `Vec<&str>`.
2385 Parentheses are currently only used with generic types when defining parameters
2386 for `Fn`-family traits.
2390 You used an associated type which isn't defined in the trait.
2391 Erroneous code example:
2398 type Foo = Trait<F=i32>; // error: associated type `F` not found for
2402 Please verify you used the right trait or you didn't misspell the
2403 associated type name. Example:
2410 type Foo = Trait<Bar=i32>; // ok!
2415 An attempt was made to retrieve an associated type, but the type was ambiguous.
2434 In this example, `Foo` defines an associated type `A`. `Bar` inherits that type
2435 from `Foo`, and defines another associated type of the same name. As a result,
2436 when we attempt to use `Self::A`, it's ambiguous whether we mean the `A` defined
2437 by `Foo` or the one defined by `Bar`.
2439 There are two options to work around this issue. The first is simply to rename
2440 one of the types. Alternatively, one can specify the intended type using the
2445 let _: <Self as Bar>::A;
2451 An attempt was made to retrieve an associated type, but the type was ambiguous.
2455 trait MyTrait {type X; }
2458 let foo: MyTrait::X;
2462 The problem here is that we're attempting to take the type of X from MyTrait.
2463 Unfortunately, the type of X is not defined, because it's only made concrete in
2464 implementations of the trait. A working version of this code might look like:
2467 trait MyTrait {type X; }
2470 impl MyTrait for MyStruct {
2475 let foo: <MyStruct as MyTrait>::X;
2479 This syntax specifies that we want the X type from MyTrait, as made concrete in
2480 MyStruct. The reason that we cannot simply use `MyStruct::X` is that MyStruct
2481 might implement two different traits with identically-named associated types.
2482 This syntax allows disambiguation between the two.
2486 You attempted to use multiple types as bounds for a closure or trait object.
2487 Rust does not currently support this. A simple example that causes this error:
2491 let _: Box<std::io::Read+std::io::Write>;
2495 Builtin traits are an exception to this rule: it's possible to have bounds of
2496 one non-builtin type, plus any number of builtin types. For example, the
2497 following compiles correctly:
2501 let _: Box<std::io::Read+Copy+Sync>;
2507 The attribute must have a value. Erroneous code example:
2510 #[rustc_on_unimplemented] // error: this attribute must have a value
2514 Please supply the missing value of the attribute. Example:
2517 #[rustc_on_unimplemented = "foo"] // ok!
2523 This error indicates that not enough type parameters were found in a type or
2526 For example, the `Foo` struct below is defined to be generic in `T`, but the
2527 type parameter is missing in the definition of `Bar`:
2530 struct Foo<T> { x: T }
2532 struct Bar { x: Foo }
2537 This error indicates that too many type parameters were found in a type or
2540 For example, the `Foo` struct below has no type parameters, but is supplied
2541 with two in the definition of `Bar`:
2544 struct Foo { x: bool }
2546 struct Bar<S, T> { x: Foo<S, T> }
2550 //NB: not currently reachable
2552 This error indicates an attempt to use a module name where a type is expected.
2560 fn do_something(x: MyMod::MySubMod) { }
2563 In this example, we're attempting to take a parameter of type `MyMod::MySubMod`
2564 in the do_something function. This is not legal: `MyMod::MySubMod` is a module
2569 This error indicates an attempt to use a value where a type is expected. For
2577 fn do_something(x: Foo::Bar) { }
2580 In this example, we're attempting to take a type of `Foo::Bar` in the
2581 do_something function. This is not legal: `Foo::Bar` is a value of type `Foo`,
2582 not a distinct static type. Likewise, it's not legal to attempt to
2583 `impl Foo::Bar`: instead, you must `impl Foo` and then pattern match to specify
2584 behavior for specific enum variants.
2588 This error indicates a constant expression for the array length was found, but
2589 it was not an integer (signed or unsigned) expression.
2591 Some examples of code that produces this error are:
2594 const A: [u32; "hello"] = []; // error
2595 const B: [u32; true] = []; // error
2596 const C: [u32; 0.0] = []; // error
2600 There was an error while evaluating the expression for the length of a fixed-
2603 Some examples of this error are:
2606 // divide by zero in the length expression
2607 const A: [u32; 1/0] = [];
2609 // Rust currently will not evaluate the function `foo` at compile time
2610 fn foo() -> usize { 12 }
2611 const B: [u32; foo()] = [];
2613 // it is an error to try to add `u8` and `f64`
2615 const C: [u32; u8::MAX + f64::EPSILON] = [];
2620 Default impls for a trait must be located in the same crate where the trait was
2621 defined. For more information see the [opt-in builtin traits RFC](https://github
2622 .com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
2626 The `Sized` trait is a special trait built-in to the compiler for types with a
2627 constant size known at compile-time. This trait is automatically implemented
2628 for types as needed by the compiler, and it is currently disallowed to
2629 explicitly implement it for a type.
2633 An associated const was implemented when another trait item was expected.
2634 Erroneous code example:
2645 // error: item `N` is an associated const, which doesn't match its
2646 // trait `<Bar as Foo>`
2650 Please verify that the associated const wasn't misspelled and the correct trait
2651 was implemented. Example:
2661 type N = u32; // ok!
2670 const N : u32 = 0; // ok!
2676 A method was implemented when another trait item was expected. Erroneous
2690 // error: item `N` is an associated method, which doesn't match its
2691 // trait `<Bar as Foo>`
2695 To fix this error, please verify that the method name wasn't misspelled and
2696 verify that you are indeed implementing the correct trait items. Example:
2716 An associated type was implemented when another trait item was expected.
2717 Erroneous code example:
2728 // error: item `N` is an associated type, which doesn't match its
2729 // trait `<Bar as Foo>`
2733 Please verify that the associated type name wasn't misspelled and your
2734 implementation corresponds to the trait definition. Example:
2744 type N = u32; // ok!
2753 const N : u32 = 0; // ok!
2759 The types of any associated constants in a trait implementation must match the
2760 types in the trait definition. This error indicates that there was a mismatch.
2762 Here's an example of this error:
2772 const BAR: u32 = 5; // error, expected bool, found u32
2778 You cannot use associated items other than constant items as patterns. This
2779 includes method items. Example of erroneous code:
2785 fn bb() -> i32 { 0 }
2790 B::bb => {} // error: associated items in match patterns must
2796 Please check that you're not using a method as a pattern. Example:
2814 An attempt was made to access an associated constant through either a generic
2815 type parameter or `Self`. This is not supported yet. An example causing this
2816 error is shown below:
2825 impl Foo for MyStruct {
2826 const BAR: f64 = 0f64;
2829 fn get_bar_bad<F: Foo>(t: F) -> f64 {
2834 Currently, the value of `BAR` for a particular type can only be accessed through
2835 a concrete type, as shown below:
2838 fn get_bar_good() -> f64 {
2839 <MyStruct as Foo>::BAR
2845 An attempt was made to implement `Drop` on a concrete specialization of a
2846 generic type. An example is shown below:
2853 impl Drop for Foo<u32> {
2854 fn drop(&mut self) {}
2858 This code is not legal: it is not possible to specialize `Drop` to a subset of
2859 implementations of a generic type. One workaround for this is to wrap the
2860 generic type, as shown below:
2872 fn drop(&mut self) {}
2878 An attempt was made to implement `Drop` on a specialization of a generic type.
2879 An example is shown below:
2884 struct MyStruct<T> {
2888 impl<T: Foo> Drop for MyStruct<T> {
2889 fn drop(&mut self) {}
2893 This code is not legal: it is not possible to specialize `Drop` to a subset of
2894 implementations of a generic type. In order for this code to work, `MyStruct`
2895 must also require that `T` implements `Foo`. Alternatively, another option is
2896 to wrap the generic type in another that specializes appropriately:
2901 struct MyStruct<T> {
2905 struct MyStructWrapper<T: Foo> {
2909 impl <T: Foo> Drop for MyStructWrapper<T> {
2910 fn drop(&mut self) {}
2916 This error indicates that a binary assignment operator like `+=` or `^=` was
2917 applied to a type that doesn't support it. For example:
2920 let mut x = 12f32; // error: binary operation `<<` cannot be applied to
2926 To fix this error, please check that this type implements this binary
2930 let x = 12u32; // the `u32` type does implement the `ShlAssign` trait
2935 It is also possible to overload most operators for your own type by
2936 implementing the `[OP]Assign` traits from `std::ops`.
2938 Another problem you might be facing is this: suppose you've overloaded the `+`
2939 operator for some type `Foo` by implementing the `std::ops::Add` trait for
2940 `Foo`, but you find that using `+=` does not work, as in this example:
2950 fn add(self, rhs: Foo) -> Foo {
2956 let mut x: Foo = Foo(5);
2957 x += Foo(7); // error, `+= cannot be applied to the type `Foo`
2961 This is because `AddAssign` is not automatically implemented, so you need to
2962 manually implement it for your type.
2966 A binary operation was attempted on a type which doesn't support it.
2967 Erroneous code example:
2970 let x = 12f32; // error: binary operation `<<` cannot be applied to
2976 To fix this error, please check that this type implements this binary
2980 let x = 12u32; // the `u32` type does implement it:
2981 // https://doc.rust-lang.org/stable/std/ops/trait.Shl.html
2986 It is also possible to overload most operators for your own type by
2987 implementing traits from `std::ops`.
2991 The maximum value of an enum was reached, so it cannot be automatically
2992 set in the next enum value. Erroneous code example:
2996 X = 0x7fffffffffffffff,
2997 Y // error: enum discriminant overflowed on value after
2998 // 9223372036854775807: i64; set explicitly via
2999 // Y = -9223372036854775808 if that is desired outcome
3003 To fix this, please set manually the next enum value or put the enum variant
3004 with the maximum value at the end of the enum. Examples:
3008 X = 0x7fffffffffffffff,
3015 X = 0x7fffffffffffffff,
3021 When `Trait2` is a subtrait of `Trait1` (for example, when `Trait2` has a
3022 definition like `trait Trait2: Trait1 { ... }`), it is not allowed to implement
3023 `Trait1` for `Trait2`. This is because `Trait2` already implements `Trait1` by
3024 definition, so it is not useful to do this.
3029 trait Foo { fn foo(&self) { } }
3033 impl Bar for Baz { } // error, `Baz` implements `Bar` by definition
3034 impl Foo for Baz { } // error, `Baz` implements `Bar` which implements `Foo`
3035 impl Baz for Baz { } // error, `Baz` (trivially) implements `Baz`
3036 impl Baz for Bar { } // Note: This is OK
3041 Trying to implement a trait for a trait object (as in `impl Trait1 for
3042 Trait2 { ... }`) does not work if the trait is not object-safe. Please see the
3043 [RFC 255] for more details on object safety rules.
3045 [RFC 255]: https://github.com/rust-lang/rfcs/pull/255
3049 Trait methods cannot be declared `const` by design. For more information, see
3052 [RFC 911]: https://github.com/rust-lang/rfcs/pull/911
3056 Default impls are only allowed for traits with no methods or associated items.
3057 For more information see the [opt-in builtin traits RFC](https://github.com/rust
3058 -lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
3062 You tried to implement methods for a primitive type. Erroneous code example:
3070 // error: only a single inherent implementation marked with
3071 // `#[lang = "mut_ptr"]` is allowed for the `*mut T` primitive
3074 This isn't allowed, but using a trait to implement a method is a good solution.
3086 impl Bar for *mut Foo {
3093 This error indicates that some types or traits depend on each other
3094 and therefore cannot be constructed.
3096 The following example contains a circular dependency between two traits:
3099 trait FirstTrait : SecondTrait {
3103 trait SecondTrait : FirstTrait {
3110 This error indicates that a type or lifetime parameter has been declared
3111 but not actually used. Here is an example that demonstrates the error:
3119 If the type parameter was included by mistake, this error can be fixed
3120 by simply removing the type parameter, as shown below:
3128 Alternatively, if the type parameter was intentionally inserted, it must be
3129 used. A simple fix is shown below:
3137 This error may also commonly be found when working with unsafe code. For
3138 example, when using raw pointers one may wish to specify the lifetime for
3139 which the pointed-at data is valid. An initial attempt (below) causes this
3148 We want to express the constraint that Foo should not outlive `'a`, because
3149 the data pointed to by `T` is only valid for that lifetime. The problem is
3150 that there are no actual uses of `'a`. It's possible to work around this
3151 by adding a PhantomData type to the struct, using it to tell the compiler
3152 to act as if the struct contained a borrowed reference `&'a T`:
3155 use std::marker::PhantomData;
3157 struct Foo<'a, T: 'a> {
3159 phantom: PhantomData<&'a T>
3163 PhantomData can also be used to express information about unused type
3164 parameters. You can read more about it in the API documentation:
3166 https://doc.rust-lang.org/std/marker/struct.PhantomData.html
3170 The length of the platform-intrinsic function `simd_shuffle`
3171 wasn't specified. Erroneous code example:
3174 extern "platform-intrinsic" {
3175 fn simd_shuffle<A,B>(a: A, b: A, c: [u32; 8]) -> B;
3176 // error: invalid `simd_shuffle`, needs length: `simd_shuffle`
3180 The `simd_shuffle` function needs the length of the array passed as
3181 last parameter in its name. Example:
3184 extern "platform-intrinsic" {
3185 fn simd_shuffle8<A,B>(a: A, b: A, c: [u32; 8]) -> B;
3191 A platform-specific intrinsic function has the wrong number of type
3192 parameters. Erroneous code example:
3196 struct f64x2(f64, f64);
3198 extern "platform-intrinsic" {
3199 fn x86_mm_movemask_pd<T>(x: f64x2) -> i32;
3200 // error: platform-specific intrinsic has wrong number of type
3205 Please refer to the function declaration to see if it corresponds
3206 with yours. Example:
3210 struct f64x2(f64, f64);
3212 extern "platform-intrinsic" {
3213 fn x86_mm_movemask_pd(x: f64x2) -> i32;
3219 An unknown platform-specific intrinsic function was used. Erroneous
3224 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3226 extern "platform-intrinsic" {
3227 fn x86_mm_adds_ep16(x: i16x8, y: i16x8) -> i16x8;
3228 // error: unrecognized platform-specific intrinsic function
3232 Please verify that the function name wasn't misspelled, and ensure
3233 that it is declared in the rust source code (in the file
3234 src/librustc_platform_intrinsics/x86.rs). Example:
3238 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3240 extern "platform-intrinsic" {
3241 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8; // ok!
3247 Intrinsic argument(s) and/or return value have the wrong type.
3248 Erroneous code example:
3252 struct i8x16(i8, i8, i8, i8, i8, i8, i8, i8,
3253 i8, i8, i8, i8, i8, i8, i8, i8);
3255 struct i32x4(i32, i32, i32, i32);
3257 struct i64x2(i64, i64);
3259 extern "platform-intrinsic" {
3260 fn x86_mm_adds_epi16(x: i8x16, y: i32x4) -> i64x2;
3261 // error: intrinsic arguments/return value have wrong type
3265 To fix this error, please refer to the function declaration to give
3266 it the awaited types. Example:
3270 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3272 extern "platform-intrinsic" {
3273 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8; // ok!
3279 Intrinsic argument(s) and/or return value have the wrong type.
3280 Erroneous code example:
3284 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3286 struct i64x8(i64, i64, i64, i64, i64, i64, i64, i64);
3288 extern "platform-intrinsic" {
3289 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i64x8;
3290 // error: intrinsic argument/return value has wrong type
3294 To fix this error, please refer to the function declaration to give
3295 it the awaited types. Example:
3299 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3301 extern "platform-intrinsic" {
3302 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8; // ok!
3308 A platform-specific intrinsic function has wrong number of arguments.
3309 Erroneous code example:
3313 struct f64x2(f64, f64);
3315 extern "platform-intrinsic" {
3316 fn x86_mm_movemask_pd(x: f64x2, y: f64x2, z: f64x2) -> i32;
3317 // error: platform-specific intrinsic has invalid number of arguments
3321 Please refer to the function declaration to see if it corresponds
3322 with yours. Example:
3326 struct f64x2(f64, f64);
3328 extern "platform-intrinsic" {
3329 fn x86_mm_movemask_pd(x: f64x2) -> i32; // ok!
3336 register_diagnostics! {
3341 E0103, // @GuillaumeGomez: I was unable to get this error, try your best!
3347 // E0159, // use of trait `{}` as struct constructor
3350 // E0173, // manual implementations of unboxed closure traits are experimental
3351 E0174, // explicit use of unboxed closure methods are experimental
3354 // E0187, // can't infer the kind of the closure
3355 // E0188, // can not cast an immutable reference to a mutable pointer
3356 // E0189, // deprecated: can only cast a boxed pointer to a boxed object
3357 // E0190, // deprecated: can only cast a &-pointer to an &-object
3358 E0196, // cannot determine a type for this closure
3359 E0203, // type parameter has more than one relaxed default bound,
3360 // and only one is supported
3362 // E0209, // builtin traits can only be implemented on structs or enums
3363 E0212, // cannot extract an associated type from a higher-ranked trait bound
3364 // E0213, // associated types are not accepted in this context
3365 // E0215, // angle-bracket notation is not stable with `Fn`
3366 // E0216, // parenthetical notation is only stable with `Fn`
3367 // E0217, // ambiguous associated type, defined in multiple supertraits
3368 // E0218, // no associated type defined
3369 // E0219, // associated type defined in higher-ranked supertrait
3370 // E0222, // Error code E0045 (variadic function must have C calling
3371 // convention) duplicate
3372 E0224, // at least one non-builtin train is required for an object type
3373 E0226, // only a single explicit lifetime bound is permitted
3374 E0227, // ambiguous lifetime bound, explicit lifetime bound required
3375 E0228, // explicit lifetime bound required
3376 E0230, // there is no type parameter on trait
3377 E0231, // only named substitution parameters are allowed
3380 // E0235, // structure constructor specifies a structure of type but
3381 E0236, // no lang item for range syntax
3382 E0237, // no lang item for range syntax
3383 E0238, // parenthesized parameters may only be used with a trait
3384 // E0239, // `next` method of `Iterator` trait has unexpected type
3387 E0242, // internal error looking up a definition
3388 E0245, // not a trait
3389 // E0246, // invalid recursive type
3390 // E0319, // trait impls for defaulted traits allowed just for structs/enums
3391 E0320, // recursive overflow during dropck
3392 E0321, // extended coherence rules for defaulted traits violated
3393 E0328, // cannot implement Unsize explicitly
3394 E0374, // the trait `CoerceUnsized` may only be implemented for a coercion
3395 // between structures with one field being coerced, none found
3396 E0375, // the trait `CoerceUnsized` may only be implemented for a coercion
3397 // between structures with one field being coerced, but multiple
3398 // fields need coercions
3399 E0376, // the trait `CoerceUnsized` may only be implemented for a coercion
3400 // between structures
3401 E0377, // the trait `CoerceUnsized` may only be implemented for a coercion
3402 // between structures with the same definition
3403 E0393, // the type parameter `{}` must be explicitly specified in an object
3404 // type because its default value `{}` references the type `Self`"
3405 E0399, // trait items need to be implemented because the associated
3406 // type `{}` was overridden
3407 E0436, // functional record update requires a struct
3408 E0513 // no type for local variable ..