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
1396 Lifetime elision is a special, limited kind of inference for lifetimes in
1397 function signatures which allows you to leave out lifetimes in certain cases.
1398 For more background on lifetime elision see [the book][book-le].
1400 The lifetime elision rules require that any function signature with an elided
1401 output lifetime must either have
1403 - exactly one input lifetime
1404 - or, multiple input lifetimes, but the function must also be a method with a
1405 `&self` or `&mut self` receiver
1407 In the first case, the output lifetime is inferred to be the same as the unique
1408 input lifetime. In the second case, the lifetime is instead inferred to be the
1409 same as the lifetime on `&self` or `&mut self`.
1411 Here are some examples of elision errors:
1414 // error, no input lifetimes
1415 fn foo() -> &str { ... }
1417 // error, `x` and `y` have distinct lifetimes inferred
1418 fn bar(x: &str, y: &str) -> &str { ... }
1420 // error, `y`'s lifetime is inferred to be distinct from `x`'s
1421 fn baz<'a>(x: &'a str, y: &str) -> &str { ... }
1424 [book-le]: https://doc.rust-lang.org/nightly/book/lifetimes.html#lifetime-elision
1428 This error means that an incorrect number of lifetime parameters were provided
1429 for a type (like a struct or enum) or trait.
1431 Some basic examples include:
1434 struct Foo<'a>(&'a str);
1435 enum Bar { A, B, C }
1438 foo: Foo, // error: expected 1, found 0
1439 bar: Bar<'a>, // error: expected 0, found 1
1443 Here's an example that is currently an error, but may work in a future version
1447 struct Foo<'a>(&'a str);
1450 impl Quux for Foo { } // error: expected 1, found 0
1453 Lifetime elision in implementation headers was part of the lifetime elision
1454 RFC. It is, however, [currently unimplemented][iss15872].
1456 [iss15872]: https://github.com/rust-lang/rust/issues/15872
1460 You can only define an inherent implementation for a type in the same crate
1461 where the type was defined. For example, an `impl` block as below is not allowed
1462 since `Vec` is defined in the standard library:
1465 impl Vec<u8> { ... } // error
1468 To fix this problem, you can do either of these things:
1470 - define a trait that has the desired associated functions/types/constants and
1471 implement the trait for the type in question
1472 - define a new type wrapping the type and define an implementation on the new
1475 Note that using the `type` keyword does not work here because `type` only
1476 introduces a type alias:
1479 type Bytes = Vec<u8>;
1481 impl Bytes { ... } // error, same as above
1486 This error indicates a violation of one of Rust's orphan rules for trait
1487 implementations. The rule prohibits any implementation of a foreign trait (a
1488 trait defined in another crate) where
1490 - the type that is implementing the trait is foreign
1491 - all of the parameters being passed to the trait (if there are any) are also
1494 Here's one example of this error:
1497 impl Drop for u32 {}
1500 To avoid this kind of error, ensure that at least one local type is referenced
1504 pub struct Foo; // you define your type in your crate
1506 impl Drop for Foo { // and you can implement the trait on it!
1507 // code of trait implementation here
1510 impl From<Foo> for i32 { // or you use a type from your crate as
1512 fn from(i: Foo) -> i32 {
1518 Alternatively, define a trait locally and implement that instead:
1522 fn get(&self) -> usize;
1526 fn get(&self) -> usize { 0 }
1530 For information on the design of the orphan rules, see [RFC 1023].
1532 [RFC 1023]: https://github.com/rust-lang/rfcs/pull/1023
1536 Rust can't find a base type for an implementation you are providing, or the type
1537 cannot have an implementation. For example, only a named type or a trait can
1538 have an implementation:
1541 type NineString = [char, ..9] // This isn't a named type (struct, enum or trait)
1547 In the other, simpler case, Rust just can't find the type you are providing an
1548 impelementation for:
1551 impl SomeTypeThatDoesntExist { }
1556 There are conflicting trait implementations for the same type.
1557 Example of erroneous code:
1561 fn get(&self) -> usize;
1564 impl<T> MyTrait for T {
1565 fn get(&self) -> usize { 0 }
1572 impl MyTrait for Foo { // error: conflicting implementations of trait
1573 // `MyTrait` for type `Foo`
1574 fn get(&self) -> usize { self.value }
1578 When looking for the implementation for the trait, the compiler finds
1579 both the `impl<T> MyTrait for T` where T is all types and the `impl
1580 MyTrait for Foo`. Since a trait cannot be implemented multiple times,
1581 this is an error. So, when you write:
1584 impl<T> MyTrait for T {
1585 fn get(&self) -> usize { 0 }
1589 This makes the trait implemented on all types in the scope. So if you
1590 try to implement it on another one after that, the implementations will
1595 fn get(&self) -> usize;
1598 impl<T> MyTrait for T {
1599 fn get(&self) -> usize { 0 }
1607 f.get(); // the trait is implemented so we can use it
1613 An attempt was made to implement Drop on a trait, which is not allowed: only
1614 structs and enums can implement Drop. An example causing this error:
1619 impl Drop for MyTrait {
1620 fn drop(&mut self) {}
1624 A workaround for this problem is to wrap the trait up in a struct, and implement
1625 Drop on that. An example is shown below:
1629 struct MyWrapper<T: MyTrait> { foo: T }
1631 impl <T: MyTrait> Drop for MyWrapper<T> {
1632 fn drop(&mut self) {}
1637 Alternatively, wrapping trait objects requires something like the following:
1642 //or Box<MyTrait>, if you wanted an owned trait object
1643 struct MyWrapper<'a> { foo: &'a MyTrait }
1645 impl <'a> Drop for MyWrapper<'a> {
1646 fn drop(&mut self) {}
1652 In order to be consistent with Rust's lack of global type inference, type
1653 placeholders are disallowed by design in item signatures.
1655 Examples of this error include:
1658 fn foo() -> _ { 5 } // error, explicitly write out the return type instead
1660 static BAR: _ = "test"; // error, explicitly write out the type instead
1665 An attempt was made to add a generic constraint to a type alias. While Rust will
1666 allow this with a warning, it will not currently enforce the constraint.
1667 Consider the example below:
1672 type MyType<R: Foo> = (R, ());
1679 We're able to declare a variable of type `MyType<u32>`, despite the fact that
1680 `u32` does not implement `Foo`. As a result, one should avoid using generic
1681 constraints in concert with type aliases.
1685 You declared two fields of a struct with the same name. Erroneous code
1691 field1: i32 // error: field is already declared
1695 Please verify that the field names have been correctly spelled. Example:
1706 Type parameter defaults can only use parameters that occur before them.
1707 Erroneous code example:
1710 pub struct Foo<T=U, U=()> {
1714 // error: type parameters with a default cannot use forward declared
1718 Since type parameters are evaluated in-order, you may be able to fix this issue
1722 pub struct Foo<U=(), T=U> {
1728 Please also verify that this wasn't because of a name-clash and rename the type
1733 You declared a pattern as an argument in a foreign function declaration.
1734 Erroneous code example:
1738 fn foo((a, b): (u32, u32)); // error: patterns aren't allowed in foreign
1739 // function declarations
1743 Please replace the pattern argument with a regular one. Example:
1752 fn foo(s: SomeStruct); // ok!
1756 fn foo(a: (u32, u32)); // ok!
1762 It is not possible to define `main` with type parameters, or even with function
1763 parameters. When `main` is present, it must take no arguments and return `()`.
1764 Erroneous code example:
1767 fn main<T>() { // error: main function is not allowed to have type parameters
1773 It is not possible to declare type parameters on a function that has the `start`
1774 attribute. Such a function must have the following type signature:
1777 fn(isize, *const *const u8) -> isize;
1782 This error means that an attempt was made to match an enum variant as a
1783 struct type when the variant isn't a struct type:
1788 fn bar(foo: Foo) -> u32 {
1790 Foo::B{i} => i // error 0163
1795 Try using `()` instead:
1798 fn bar(foo: Foo) -> u32 {
1808 This error means that an attempt was made to match a struct type enum
1809 variant as a non-struct type:
1812 enum Foo { B{ i: u32 } }
1814 fn bar(foo: Foo) -> u32 {
1816 Foo::B(i) => i // error 0164
1821 Try using `{}` instead:
1824 fn bar(foo: Foo) -> u32 {
1834 This error means that the compiler found a return expression in a function
1835 marked as diverging. A function diverges if it has `!` in the place of the
1836 return type in its signature. For example:
1839 fn foo() -> ! { return; } // error
1842 For a function that diverges, every control path in the function must never
1843 return, for example with a `loop` that never breaks or a call to another
1844 diverging function (such as `panic!()`).
1848 This error means that an attempt was made to specify the type of a variable with
1849 a combination of a concrete type and a trait. Consider the following example:
1852 fn foo(bar: i32+std::fmt::Display) {}
1855 The code is trying to specify that we want to receive a signed 32-bit integer
1856 which also implements `Display`. This doesn't make sense: when we pass `i32`, a
1857 concrete type, it implicitly includes all of the traits that it implements.
1858 This includes `Display`, `Debug`, `Clone`, and a host of others.
1860 If `i32` implements the trait we desire, there's no need to specify the trait
1861 separately. If it does not, then we need to `impl` the trait for `i32` before
1862 passing it into `foo`. Either way, a fixed definition for `foo` will look like
1869 To learn more about traits, take a look at the Book:
1871 https://doc.rust-lang.org/book/traits.html
1875 In types, the `+` type operator has low precedence, so it is often necessary
1884 w: &'a Foo + Copy, // error, use &'a (Foo + Copy)
1885 x: &'a Foo + 'a, // error, use &'a (Foo + 'a)
1886 y: &'a mut Foo + 'a, // error, use &'a mut (Foo + 'a)
1887 z: fn() -> Foo + 'a, // error, use fn() -> (Foo + 'a)
1891 More details can be found in [RFC 438].
1893 [RFC 438]: https://github.com/rust-lang/rfcs/pull/438
1897 Explicitly implementing both Drop and Copy for a type is currently disallowed.
1898 This feature can make some sense in theory, but the current implementation is
1899 incorrect and can lead to memory unsafety (see [issue #20126][iss20126]), so
1900 it has been disabled for now.
1902 [iss20126]: https://github.com/rust-lang/rust/issues/20126
1906 An associated function for a trait was defined to be static, but an
1907 implementation of the trait declared the same function to be a method (i.e. to
1908 take a `self` parameter).
1910 Here's an example of this error:
1920 // error, method `foo` has a `&self` declaration in the impl, but not in
1927 An associated function for a trait was defined to be a method (i.e. to take a
1928 `self` parameter), but an implementation of the trait declared the same function
1931 Here's an example of this error:
1941 // error, method `foo` has a `&self` declaration in the trait, but not in
1949 Trait objects need to have all associated types specified. Erroneous code
1957 type Foo = Trait; // error: the value of the associated type `Bar` (from
1958 // the trait `Trait`) must be specified
1961 Please verify you specified all associated types of the trait and that you
1962 used the right trait. Example:
1969 type Foo = Trait<Bar=i32>; // ok!
1974 Negative impls are only allowed for traits with default impls. For more
1975 information see the [opt-in builtin traits RFC](https://github.com/rust-lang/
1976 rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
1980 `where` clauses must use generic type parameters: it does not make sense to use
1981 them otherwise. An example causing this error:
1988 #[derive(Copy,Clone)]
1993 impl Foo for Wrapper<u32> where Wrapper<u32>: Clone {
1998 This use of a `where` clause is strange - a more common usage would look
1999 something like the following:
2002 impl <T> Foo for Wrapper<T> where Wrapper<T>: Clone {
2007 Here, we're saying that the implementation exists on Wrapper only when the
2008 wrapped type `T` implements `Clone`. The `where` clause is important because
2009 some types will not implement `Clone`, and thus will not get this method.
2011 In our erroneous example, however, we're referencing a single concrete type.
2012 Since we know for certain that `Wrapper<u32>` implements `Clone`, there's no
2013 reason to also specify it in a `where` clause.
2017 A type parameter was declared which shadows an existing one. An example of this
2022 fn do_something(&self) -> T;
2023 fn do_something_else<T: Clone>(&self, bar: T);
2027 In this example, the trait `Foo` and the trait method `do_something_else` both
2028 define a type parameter `T`. This is not allowed: if the method wishes to
2029 define a type parameter, it must use a different name for it.
2033 Your method's lifetime parameters do not match the trait declaration.
2034 Erroneous code example:
2038 fn bar<'a,'b:'a>(x: &'a str, y: &'b str);
2043 impl Trait for Foo {
2044 fn bar<'a,'b>(x: &'a str, y: &'b str) {
2045 // error: lifetime parameters or bounds on method `bar`
2046 // do not match the trait declaration
2051 The lifetime constraint `'b` for bar() implementation does not match the
2052 trait declaration. Ensure lifetime declarations match exactly in both trait
2053 declaration and implementation. Example:
2057 fn t<'a,'b:'a>(x: &'a str, y: &'b str);
2062 impl Trait for Foo {
2063 fn t<'a,'b:'a>(x: &'a str, y: &'b str) { // ok!
2070 Inherent implementations (one that do not implement a trait but provide
2071 methods associated with a type) are always safe because they are not
2072 implementing an unsafe trait. Removing the `unsafe` keyword from the inherent
2073 implementation will resolve this error.
2078 // this will cause this error
2080 // converting it to this will fix it
2086 A negative implementation is one that excludes a type from implementing a
2087 particular trait. Not being able to use a trait is always a safe operation,
2088 so negative implementations are always safe and never need to be marked as
2094 // unsafe is unnecessary
2095 unsafe impl !Clone for Foo { }
2096 // this will compile
2097 impl !Clone for Foo { }
2102 Safe traits should not have unsafe implementations, therefore marking an
2103 implementation for a safe trait unsafe will cause a compiler error. Removing the
2104 unsafe marker on the trait noted in the error will resolve this problem.
2111 // this won't compile because Bar is safe
2112 unsafe impl Bar for Foo { }
2113 // this will compile
2114 impl Bar for Foo { }
2119 Unsafe traits must have unsafe implementations. This error occurs when an
2120 implementation for an unsafe trait isn't marked as unsafe. This may be resolved
2121 by marking the unsafe implementation as unsafe.
2126 unsafe trait Bar { }
2128 // this won't compile because Bar is unsafe and impl isn't unsafe
2129 impl Bar for Foo { }
2130 // this will compile
2131 unsafe impl Bar for Foo { }
2136 It is an error to define two associated items (like methods, associated types,
2137 associated functions, etc.) with the same identifier.
2145 fn bar(&self) -> bool { self.0 > 5 }
2146 fn bar() {} // error: duplicate associated function
2151 fn baz(&self) -> bool;
2157 fn baz(&self) -> bool { true }
2159 // error: duplicate method
2160 fn baz(&self) -> bool { self.0 > 5 }
2162 // error: duplicate associated type
2169 Inherent associated types were part of [RFC 195] but are not yet implemented.
2170 See [the tracking issue][iss8995] for the status of this implementation.
2172 [RFC 195]: https://github.com/rust-lang/rfcs/pull/195
2173 [iss8995]: https://github.com/rust-lang/rust/issues/8995
2177 An attempt to implement the `Copy` trait for a struct failed because one of the
2178 fields does not implement `Copy`. To fix this, you must implement `Copy` for the
2179 mentioned field. Note that this may not be possible, as in the example of
2186 impl Copy for Foo { }
2189 This fails because `Vec<T>` does not implement `Copy` for any `T`.
2191 Here's another example that will fail:
2200 This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
2201 differs from the behavior for `&T`, which is always `Copy`).
2205 An attempt to implement the `Copy` trait for an enum failed because one of the
2206 variants does not implement `Copy`. To fix this, you must implement `Copy` for
2207 the mentioned variant. Note that this may not be possible, as in the example of
2215 impl Copy for Foo { }
2218 This fails because `Vec<T>` does not implement `Copy` for any `T`.
2220 Here's another example that will fail:
2230 This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
2231 differs from the behavior for `&T`, which is always `Copy`).
2235 You can only implement `Copy` for a struct or enum. Both of the following
2236 examples will fail, because neither `i32` (primitive type) nor `&'static Bar`
2237 (reference to `Bar`) is a struct or enum:
2241 impl Copy for Foo { } // error
2243 #[derive(Copy, Clone)]
2245 impl Copy for &'static Bar { } // error
2250 You declared an unused type parameter when implementing a trait on an object.
2251 Erroneous code example:
2255 fn get(&self) -> usize;
2260 impl<T> MyTrait for Foo {
2261 fn get(&self) -> usize {
2267 Please check your object definition and remove unused type
2268 parameter(s). Example:
2272 fn get(&self) -> usize;
2277 impl MyTrait for Foo {
2278 fn get(&self) -> usize {
2286 This error indicates a violation of one of Rust's orphan rules for trait
2287 implementations. The rule concerns the use of type parameters in an
2288 implementation of a foreign trait (a trait defined in another crate), and
2289 states that type parameters must be "covered" by a local type. To understand
2290 what this means, it is perhaps easiest to consider a few examples.
2292 If `ForeignTrait` is a trait defined in some external crate `foo`, then the
2293 following trait `impl` is an error:
2297 use foo::ForeignTrait;
2299 impl<T> ForeignTrait for T { ... } // error
2302 To work around this, it can be covered with a local type, `MyType`:
2305 struct MyType<T>(T);
2306 impl<T> ForeignTrait for MyType<T> { ... } // Ok
2309 For another example of an error, suppose there's another trait defined in `foo`
2310 named `ForeignTrait2` that takes two type parameters. Then this `impl` results
2311 in the same rule violation:
2315 impl<T> ForeignTrait2<T, MyType<T>> for MyType2 { ... } // error
2318 The reason for this is that there are two appearances of type parameter `T` in
2319 the `impl` header, both as parameters for `ForeignTrait2`. The first appearance
2320 is uncovered, and so runs afoul of the orphan rule.
2322 Consider one more example:
2325 impl<T> ForeignTrait2<MyType<T>, T> for MyType2 { ... } // Ok
2328 This only differs from the previous `impl` in that the parameters `T` and
2329 `MyType<T>` for `ForeignTrait2` have been swapped. This example does *not*
2330 violate the orphan rule; it is permitted.
2332 To see why that last example was allowed, you need to understand the general
2333 rule. Unfortunately this rule is a bit tricky to state. Consider an `impl`:
2336 impl<P1, ..., Pm> ForeignTrait<T1, ..., Tn> for T0 { ... }
2339 where `P1, ..., Pm` are the type parameters of the `impl` and `T0, ..., Tn`
2340 are types. One of the types `T0, ..., Tn` must be a local type (this is another
2341 orphan rule, see the explanation for E0117). Let `i` be the smallest integer
2342 such that `Ti` is a local type. Then no type parameter can appear in any of the
2345 For information on the design of the orphan rules, see [RFC 1023].
2347 [RFC 1023]: https://github.com/rust-lang/rfcs/pull/1023
2351 You used a function or type which doesn't fit the requirements for where it was
2352 used. Erroneous code examples:
2355 #![feature(intrinsics)]
2357 extern "rust-intrinsic" {
2358 fn size_of<T>(); // error: intrinsic has wrong type
2363 fn main() -> i32 { 0 }
2364 // error: main function expects type: `fn() {main}`: expected (), found i32
2371 // error: mismatched types in range: expected u8, found i8
2381 fn x(self: Rc<Foo>) {}
2382 // error: mismatched self type: expected `Foo`: expected struct
2383 // `Foo`, found struct `alloc::rc::Rc`
2387 For the first code example, please check the function definition. Example:
2390 #![feature(intrinsics)]
2392 extern "rust-intrinsic" {
2393 fn size_of<T>() -> usize; // ok!
2397 The second case example is a bit particular : the main function must always
2398 have this definition:
2404 They never take parameters and never return types.
2406 For the third example, when you match, all patterns must have the same type
2407 as the type you're matching on. Example:
2412 0u8...3u8 => (), // ok!
2417 And finally, for the last example, only `Box<Self>`, `&Self`, `Self`,
2418 or `&mut Self` work as explicit self parameters. Example:
2424 fn x(self: Box<Foo>) {} // ok!
2430 A generic type was described using parentheses rather than angle brackets. For
2435 let v: Vec(&str) = vec!["foo"];
2439 This is not currently supported: `v` should be defined as `Vec<&str>`.
2440 Parentheses are currently only used with generic types when defining parameters
2441 for `Fn`-family traits.
2445 You used an associated type which isn't defined in the trait.
2446 Erroneous code example:
2453 type Foo = Trait<F=i32>; // error: associated type `F` not found for
2457 Please verify you used the right trait or you didn't misspell the
2458 associated type name. Example:
2465 type Foo = Trait<Bar=i32>; // ok!
2470 An attempt was made to retrieve an associated type, but the type was ambiguous.
2489 In this example, `Foo` defines an associated type `A`. `Bar` inherits that type
2490 from `Foo`, and defines another associated type of the same name. As a result,
2491 when we attempt to use `Self::A`, it's ambiguous whether we mean the `A` defined
2492 by `Foo` or the one defined by `Bar`.
2494 There are two options to work around this issue. The first is simply to rename
2495 one of the types. Alternatively, one can specify the intended type using the
2500 let _: <Self as Bar>::A;
2506 An attempt was made to retrieve an associated type, but the type was ambiguous.
2510 trait MyTrait {type X; }
2513 let foo: MyTrait::X;
2517 The problem here is that we're attempting to take the type of X from MyTrait.
2518 Unfortunately, the type of X is not defined, because it's only made concrete in
2519 implementations of the trait. A working version of this code might look like:
2522 trait MyTrait {type X; }
2525 impl MyTrait for MyStruct {
2530 let foo: <MyStruct as MyTrait>::X;
2534 This syntax specifies that we want the X type from MyTrait, as made concrete in
2535 MyStruct. The reason that we cannot simply use `MyStruct::X` is that MyStruct
2536 might implement two different traits with identically-named associated types.
2537 This syntax allows disambiguation between the two.
2541 You attempted to use multiple types as bounds for a closure or trait object.
2542 Rust does not currently support this. A simple example that causes this error:
2546 let _: Box<std::io::Read+std::io::Write>;
2550 Builtin traits are an exception to this rule: it's possible to have bounds of
2551 one non-builtin type, plus any number of builtin types. For example, the
2552 following compiles correctly:
2556 let _: Box<std::io::Read+Copy+Sync>;
2562 The attribute must have a value. Erroneous code example:
2565 #[rustc_on_unimplemented] // error: this attribute must have a value
2569 Please supply the missing value of the attribute. Example:
2572 #[rustc_on_unimplemented = "foo"] // ok!
2578 This error indicates that not enough type parameters were found in a type or
2581 For example, the `Foo` struct below is defined to be generic in `T`, but the
2582 type parameter is missing in the definition of `Bar`:
2585 struct Foo<T> { x: T }
2587 struct Bar { x: Foo }
2592 This error indicates that too many type parameters were found in a type or
2595 For example, the `Foo` struct below has no type parameters, but is supplied
2596 with two in the definition of `Bar`:
2599 struct Foo { x: bool }
2601 struct Bar<S, T> { x: Foo<S, T> }
2605 //NB: not currently reachable
2607 This error indicates an attempt to use a module name where a type is expected.
2615 fn do_something(x: MyMod::MySubMod) { }
2618 In this example, we're attempting to take a parameter of type `MyMod::MySubMod`
2619 in the do_something function. This is not legal: `MyMod::MySubMod` is a module
2624 This error indicates an attempt to use a value where a type is expected. For
2632 fn do_something(x: Foo::Bar) { }
2635 In this example, we're attempting to take a type of `Foo::Bar` in the
2636 do_something function. This is not legal: `Foo::Bar` is a value of type `Foo`,
2637 not a distinct static type. Likewise, it's not legal to attempt to
2638 `impl Foo::Bar`: instead, you must `impl Foo` and then pattern match to specify
2639 behavior for specific enum variants.
2643 This error indicates a constant expression for the array length was found, but
2644 it was not an integer (signed or unsigned) expression.
2646 Some examples of code that produces this error are:
2649 const A: [u32; "hello"] = []; // error
2650 const B: [u32; true] = []; // error
2651 const C: [u32; 0.0] = []; // error
2655 There was an error while evaluating the expression for the length of a fixed-
2658 Some examples of this error are:
2661 // divide by zero in the length expression
2662 const A: [u32; 1/0] = [];
2664 // Rust currently will not evaluate the function `foo` at compile time
2665 fn foo() -> usize { 12 }
2666 const B: [u32; foo()] = [];
2668 // it is an error to try to add `u8` and `f64`
2670 const C: [u32; u8::MAX + f64::EPSILON] = [];
2675 Default impls for a trait must be located in the same crate where the trait was
2676 defined. For more information see the [opt-in builtin traits RFC](https://github
2677 .com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
2681 A cross-crate opt-out trait was implemented on something which wasn't a struct
2682 or enum type. Erroneous code example:
2685 #![feature(optin_builtin_traits)]
2689 impl !Sync for Foo {}
2691 unsafe impl Send for &'static Foo {
2692 // error: cross-crate traits with a default impl, like `core::marker::Send`,
2693 // can only be implemented for a struct/enum type, not
2697 Only structs and enums are permitted to impl Send, Sync, and other opt-out
2698 trait, and the struct or enum must be local to the current crate. So, for
2699 example, `unsafe impl Send for Rc<Foo>` is not allowed.
2703 The `Sized` trait is a special trait built-in to the compiler for types with a
2704 constant size known at compile-time. This trait is automatically implemented
2705 for types as needed by the compiler, and it is currently disallowed to
2706 explicitly implement it for a type.
2710 An associated const was implemented when another trait item was expected.
2711 Erroneous code example:
2722 // error: item `N` is an associated const, which doesn't match its
2723 // trait `<Bar as Foo>`
2727 Please verify that the associated const wasn't misspelled and the correct trait
2728 was implemented. Example:
2738 type N = u32; // ok!
2747 const N : u32 = 0; // ok!
2753 A method was implemented when another trait item was expected. Erroneous
2767 // error: item `N` is an associated method, which doesn't match its
2768 // trait `<Bar as Foo>`
2772 To fix this error, please verify that the method name wasn't misspelled and
2773 verify that you are indeed implementing the correct trait items. Example:
2793 An associated type was implemented when another trait item was expected.
2794 Erroneous code example:
2805 // error: item `N` is an associated type, which doesn't match its
2806 // trait `<Bar as Foo>`
2810 Please verify that the associated type name wasn't misspelled and your
2811 implementation corresponds to the trait definition. Example:
2821 type N = u32; // ok!
2830 const N : u32 = 0; // ok!
2836 The types of any associated constants in a trait implementation must match the
2837 types in the trait definition. This error indicates that there was a mismatch.
2839 Here's an example of this error:
2849 const BAR: u32 = 5; // error, expected bool, found u32
2855 You cannot use associated items other than constant items as patterns. This
2856 includes method items. Example of erroneous code:
2862 fn bb() -> i32 { 0 }
2867 B::bb => {} // error: associated items in match patterns must
2873 Please check that you're not using a method as a pattern. Example:
2891 An attempt was made to access an associated constant through either a generic
2892 type parameter or `Self`. This is not supported yet. An example causing this
2893 error is shown below:
2902 impl Foo for MyStruct {
2903 const BAR: f64 = 0f64;
2906 fn get_bar_bad<F: Foo>(t: F) -> f64 {
2911 Currently, the value of `BAR` for a particular type can only be accessed through
2912 a concrete type, as shown below:
2915 fn get_bar_good() -> f64 {
2916 <MyStruct as Foo>::BAR
2922 An attempt was made to implement `Drop` on a concrete specialization of a
2923 generic type. An example is shown below:
2930 impl Drop for Foo<u32> {
2931 fn drop(&mut self) {}
2935 This code is not legal: it is not possible to specialize `Drop` to a subset of
2936 implementations of a generic type. One workaround for this is to wrap the
2937 generic type, as shown below:
2949 fn drop(&mut self) {}
2955 An attempt was made to implement `Drop` on a specialization of a generic type.
2956 An example is shown below:
2961 struct MyStruct<T> {
2965 impl<T: Foo> Drop for MyStruct<T> {
2966 fn drop(&mut self) {}
2970 This code is not legal: it is not possible to specialize `Drop` to a subset of
2971 implementations of a generic type. In order for this code to work, `MyStruct`
2972 must also require that `T` implements `Foo`. Alternatively, another option is
2973 to wrap the generic type in another that specializes appropriately:
2978 struct MyStruct<T> {
2982 struct MyStructWrapper<T: Foo> {
2986 impl <T: Foo> Drop for MyStructWrapper<T> {
2987 fn drop(&mut self) {}
2993 This error indicates that a binary assignment operator like `+=` or `^=` was
2994 applied to a type that doesn't support it. For example:
2997 let mut x = 12f32; // error: binary operation `<<` cannot be applied to
3003 To fix this error, please check that this type implements this binary
3007 let x = 12u32; // the `u32` type does implement the `ShlAssign` trait
3012 It is also possible to overload most operators for your own type by
3013 implementing the `[OP]Assign` traits from `std::ops`.
3015 Another problem you might be facing is this: suppose you've overloaded the `+`
3016 operator for some type `Foo` by implementing the `std::ops::Add` trait for
3017 `Foo`, but you find that using `+=` does not work, as in this example:
3027 fn add(self, rhs: Foo) -> Foo {
3033 let mut x: Foo = Foo(5);
3034 x += Foo(7); // error, `+= cannot be applied to the type `Foo`
3038 This is because `AddAssign` is not automatically implemented, so you need to
3039 manually implement it for your type.
3043 A binary operation was attempted on a type which doesn't support it.
3044 Erroneous code example:
3047 let x = 12f32; // error: binary operation `<<` cannot be applied to
3053 To fix this error, please check that this type implements this binary
3057 let x = 12u32; // the `u32` type does implement it:
3058 // https://doc.rust-lang.org/stable/std/ops/trait.Shl.html
3063 It is also possible to overload most operators for your own type by
3064 implementing traits from `std::ops`.
3068 The maximum value of an enum was reached, so it cannot be automatically
3069 set in the next enum value. Erroneous code example:
3073 X = 0x7fffffffffffffff,
3074 Y // error: enum discriminant overflowed on value after
3075 // 9223372036854775807: i64; set explicitly via
3076 // Y = -9223372036854775808 if that is desired outcome
3080 To fix this, please set manually the next enum value or put the enum variant
3081 with the maximum value at the end of the enum. Examples:
3085 X = 0x7fffffffffffffff,
3092 X = 0x7fffffffffffffff,
3098 When `Trait2` is a subtrait of `Trait1` (for example, when `Trait2` has a
3099 definition like `trait Trait2: Trait1 { ... }`), it is not allowed to implement
3100 `Trait1` for `Trait2`. This is because `Trait2` already implements `Trait1` by
3101 definition, so it is not useful to do this.
3106 trait Foo { fn foo(&self) { } }
3110 impl Bar for Baz { } // error, `Baz` implements `Bar` by definition
3111 impl Foo for Baz { } // error, `Baz` implements `Bar` which implements `Foo`
3112 impl Baz for Baz { } // error, `Baz` (trivially) implements `Baz`
3113 impl Baz for Bar { } // Note: This is OK
3118 Trait methods cannot be declared `const` by design. For more information, see
3121 [RFC 911]: https://github.com/rust-lang/rfcs/pull/911
3125 Default impls are only allowed for traits with no methods or associated items.
3126 For more information see the [opt-in builtin traits RFC](https://github.com/rust
3127 -lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
3131 You tried to implement methods for a primitive type. Erroneous code example:
3139 // error: only a single inherent implementation marked with
3140 // `#[lang = "mut_ptr"]` is allowed for the `*mut T` primitive
3143 This isn't allowed, but using a trait to implement a method is a good solution.
3155 impl Bar for *mut Foo {
3162 This error indicates that some types or traits depend on each other
3163 and therefore cannot be constructed.
3165 The following example contains a circular dependency between two traits:
3168 trait FirstTrait : SecondTrait {
3172 trait SecondTrait : FirstTrait {
3179 This error indicates that a type or lifetime parameter has been declared
3180 but not actually used. Here is an example that demonstrates the error:
3188 If the type parameter was included by mistake, this error can be fixed
3189 by simply removing the type parameter, as shown below:
3197 Alternatively, if the type parameter was intentionally inserted, it must be
3198 used. A simple fix is shown below:
3206 This error may also commonly be found when working with unsafe code. For
3207 example, when using raw pointers one may wish to specify the lifetime for
3208 which the pointed-at data is valid. An initial attempt (below) causes this
3217 We want to express the constraint that Foo should not outlive `'a`, because
3218 the data pointed to by `T` is only valid for that lifetime. The problem is
3219 that there are no actual uses of `'a`. It's possible to work around this
3220 by adding a PhantomData type to the struct, using it to tell the compiler
3221 to act as if the struct contained a borrowed reference `&'a T`:
3224 use std::marker::PhantomData;
3226 struct Foo<'a, T: 'a> {
3228 phantom: PhantomData<&'a T>
3232 PhantomData can also be used to express information about unused type
3233 parameters. You can read more about it in the API documentation:
3235 https://doc.rust-lang.org/std/marker/struct.PhantomData.html
3239 The length of the platform-intrinsic function `simd_shuffle`
3240 wasn't specified. Erroneous code example:
3243 extern "platform-intrinsic" {
3244 fn simd_shuffle<A,B>(a: A, b: A, c: [u32; 8]) -> B;
3245 // error: invalid `simd_shuffle`, needs length: `simd_shuffle`
3249 The `simd_shuffle` function needs the length of the array passed as
3250 last parameter in its name. Example:
3253 extern "platform-intrinsic" {
3254 fn simd_shuffle8<A,B>(a: A, b: A, c: [u32; 8]) -> B;
3260 A platform-specific intrinsic function has the wrong number of type
3261 parameters. Erroneous code example:
3265 struct f64x2(f64, f64);
3267 extern "platform-intrinsic" {
3268 fn x86_mm_movemask_pd<T>(x: f64x2) -> i32;
3269 // error: platform-specific intrinsic has wrong number of type
3274 Please refer to the function declaration to see if it corresponds
3275 with yours. Example:
3279 struct f64x2(f64, f64);
3281 extern "platform-intrinsic" {
3282 fn x86_mm_movemask_pd(x: f64x2) -> i32;
3288 An unknown platform-specific intrinsic function was used. Erroneous
3293 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3295 extern "platform-intrinsic" {
3296 fn x86_mm_adds_ep16(x: i16x8, y: i16x8) -> i16x8;
3297 // error: unrecognized platform-specific intrinsic function
3301 Please verify that the function name wasn't misspelled, and ensure
3302 that it is declared in the rust source code (in the file
3303 src/librustc_platform_intrinsics/x86.rs). Example:
3307 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3309 extern "platform-intrinsic" {
3310 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8; // ok!
3316 Intrinsic argument(s) and/or return value have the wrong type.
3317 Erroneous code example:
3321 struct i8x16(i8, i8, i8, i8, i8, i8, i8, i8,
3322 i8, i8, i8, i8, i8, i8, i8, i8);
3324 struct i32x4(i32, i32, i32, i32);
3326 struct i64x2(i64, i64);
3328 extern "platform-intrinsic" {
3329 fn x86_mm_adds_epi16(x: i8x16, y: i32x4) -> i64x2;
3330 // error: intrinsic arguments/return value have wrong type
3334 To fix this error, please refer to the function declaration to give
3335 it the awaited types. Example:
3339 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3341 extern "platform-intrinsic" {
3342 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8; // ok!
3348 Intrinsic argument(s) and/or return value have the wrong type.
3349 Erroneous code example:
3353 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3355 struct i64x8(i64, i64, i64, i64, i64, i64, i64, i64);
3357 extern "platform-intrinsic" {
3358 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i64x8;
3359 // error: intrinsic argument/return value has wrong type
3363 To fix this error, please refer to the function declaration to give
3364 it the awaited types. Example:
3368 struct i16x8(i16, i16, i16, i16, i16, i16, i16, i16);
3370 extern "platform-intrinsic" {
3371 fn x86_mm_adds_epi16(x: i16x8, y: i16x8) -> i16x8; // ok!
3377 A platform-specific intrinsic function has wrong number of arguments.
3378 Erroneous code example:
3382 struct f64x2(f64, f64);
3384 extern "platform-intrinsic" {
3385 fn x86_mm_movemask_pd(x: f64x2, y: f64x2, z: f64x2) -> i32;
3386 // error: platform-specific intrinsic has invalid number of arguments
3390 Please refer to the function declaration to see if it corresponds
3391 with yours. Example:
3395 struct f64x2(f64, f64);
3397 extern "platform-intrinsic" {
3398 fn x86_mm_movemask_pd(x: f64x2) -> i32; // ok!
3404 The `typeof` keyword is currently reserved but unimplemented.
3405 Erroneous code example:
3409 let x: typeof(92) = 92;
3413 Try using type inference instead. Example:
3424 register_diagnostics! {
3429 E0103, // @GuillaumeGomez: I was unable to get this error, try your best!
3435 // E0159, // use of trait `{}` as struct constructor
3438 // E0173, // manual implementations of unboxed closure traits are experimental
3439 E0174, // explicit use of unboxed closure methods are experimental
3442 // E0187, // can't infer the kind of the closure
3443 // E0188, // can not cast an immutable reference to a mutable pointer
3444 // E0189, // deprecated: can only cast a boxed pointer to a boxed object
3445 // E0190, // deprecated: can only cast a &-pointer to an &-object
3446 E0196, // cannot determine a type for this closure
3447 E0203, // type parameter has more than one relaxed default bound,
3448 // and only one is supported
3450 // E0209, // builtin traits can only be implemented on structs or enums
3451 E0212, // cannot extract an associated type from a higher-ranked trait bound
3452 // E0213, // associated types are not accepted in this context
3453 // E0215, // angle-bracket notation is not stable with `Fn`
3454 // E0216, // parenthetical notation is only stable with `Fn`
3455 // E0217, // ambiguous associated type, defined in multiple supertraits
3456 // E0218, // no associated type defined
3457 // E0219, // associated type defined in higher-ranked supertrait
3458 // E0222, // Error code E0045 (variadic function must have C calling
3459 // convention) duplicate
3460 E0224, // at least one non-builtin train is required for an object type
3461 E0226, // only a single explicit lifetime bound is permitted
3462 E0227, // ambiguous lifetime bound, explicit lifetime bound required
3463 E0228, // explicit lifetime bound required
3464 E0230, // there is no type parameter on trait
3465 E0231, // only named substitution parameters are allowed
3468 // E0235, // structure constructor specifies a structure of type but
3469 E0236, // no lang item for range syntax
3470 E0237, // no lang item for range syntax
3471 E0238, // parenthesized parameters may only be used with a trait
3472 // E0239, // `next` method of `Iterator` trait has unexpected type
3475 E0242, // internal error looking up a definition
3476 E0245, // not a trait
3477 // E0246, // invalid recursive type
3478 // E0319, // trait impls for defaulted traits allowed just for structs/enums
3479 E0320, // recursive overflow during dropck
3480 E0328, // cannot implement Unsize explicitly
3481 // E0372, // coherence not object safe
3482 E0374, // the trait `CoerceUnsized` may only be implemented for a coercion
3483 // between structures with one field being coerced, none found
3484 E0375, // the trait `CoerceUnsized` may only be implemented for a coercion
3485 // between structures with one field being coerced, but multiple
3486 // fields need coercions
3487 E0376, // the trait `CoerceUnsized` may only be implemented for a coercion
3488 // between structures
3489 E0377, // the trait `CoerceUnsized` may only be implemented for a coercion
3490 // between structures with the same definition
3491 E0393, // the type parameter `{}` must be explicitly specified in an object
3492 // type because its default value `{}` references the type `Self`"
3493 E0399, // trait items need to be implemented because the associated
3494 // type `{}` was overridden
3495 E0436, // functional record update requires a struct
3496 E0513 // no type for local variable ..