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. Each occurrence of a
77 field name binds the value of that field, so to fix this error you will have to
78 remove or alter the duplicate uses of the field name. Perhaps you misspelt
83 This error indicates that a struct pattern attempted to extract a non-existant
84 field from a struct. Struct fields are identified by the name used before the
85 colon `:` so struct patterns should resemble the declaration of the struct type
95 let thing = Thing { x: 1, y: 2 };
97 Thing { x: xfield, y: yfield } => ...
101 If you are using shorthand field patterns but want to refer to the struct field
102 by a different name, you should rename it explicitly.
107 Thing { x, z } => ...
112 Thing { x, y: z } => ...
118 This error indicates that a pattern for a struct fails to specify a sub-pattern
119 for every one of the struct's fields. Ensure that each field from the struct's
120 definition is mentioned in the pattern, or use `..` to ignore unwanted fields.
130 let d = Dog { name: "Rusty".to_string(), age: 8 };
132 // This is incorrect.
134 Dog { age: x } => ...
137 // This is correct (explicit).
139 Dog { name: n, age: x } => ...
142 // This is also correct (ignore unused fields).
144 Dog { age: x, .. } => ...
150 In a match expression, only numbers and characters can be matched against a
151 range. This is because the compiler checks that the range is non-empty at
152 compile-time, and is unable to evaluate arbitrary comparison functions. If you
153 want to capture values of an orderable type between two end-points, you can use
157 // The ordering relation for strings can't be evaluated at compile time,
158 // so this doesn't work:
160 "hello" ... "world" => ...
164 // This is a more general version, using a guard:
166 s if s >= "hello" && s <= "world" => ...
173 When matching against a range, the compiler verifies that the range is
174 non-empty. Range patterns include both end-points, so this is equivalent to
175 requiring the start of the range to be less than or equal to the end of the
182 // This range is ok, albeit pointless.
184 // This range is empty, and the compiler can tell.
191 This error indicates that a pointer to a trait type cannot be implicitly
192 dereferenced by a pattern. Every trait defines a type, but because the
193 size of trait implementors isn't fixed, this type has no compile-time size.
194 Therefore, all accesses to trait types must be through pointers. If you
195 encounter this error you should try to avoid dereferencing the pointer.
198 let trait_obj: &SomeTrait = ...;
200 // This tries to implicitly dereference to create an unsized local variable.
201 let &invalid = trait_obj;
203 // You can call methods without binding to the value being pointed at.
204 trait_obj.method_one();
205 trait_obj.method_two();
208 You can read more about trait objects in the Trait Object section of the
211 http://doc.rust-lang.org/reference.html#trait-objects
215 The compiler doesn't know what method to call because more than one method
216 has the same prototype. Example:
229 impl Trait1 for Test { fn foo() {} }
230 impl Trait2 for Test { fn foo() {} }
233 Test::foo() // error, which foo() to call?
237 To avoid this error, you have to keep only one of them and remove the others.
238 So let's take our example and fix it:
247 impl Trait1 for Test { fn foo() {} }
250 Test::foo() // and now that's good!
254 However, a better solution would be using fully explicit naming of type and
268 impl Trait1 for Test { fn foo() {} }
269 impl Trait2 for Test { fn foo() {} }
272 <Test as Trait1>::foo()
278 You tried to give a type parameter where it wasn't needed. Bad example:
290 x.method::<i32>(); // Error: Test::method doesn't need type parameter!
294 To fix this error, just remove the type parameter:
306 x.method(); // OK, we're good!
312 This error occurrs when you pass too many or not enough type parameters to
319 fn method<T>(&self, v: &[T]) -> usize {
328 x.method::<i32, i32>(v); // error: only one type parameter is expected!
332 To fix it, just specify a correct number of type parameters:
338 fn method<T>(&self, v: &[T]) -> usize {
347 x.method::<i32>(v); // OK, we're good!
351 Please note on the last example that we could have called `method` like this:
359 It is not allowed to manually call destructors in Rust. It is also not
360 necessary to do this since `drop` is called automatically whenever a value goes
363 Here's an example of this error:
377 let mut x = Foo { x: -7 };
378 x.drop(); // error: explicit use of destructor method
384 You can't use type parameters on foreign items. Example of erroneous code:
387 extern { fn some_func<T>(x: T); }
390 To fix this, replace the type parameter with the specializations that you
394 extern { fn some_func_i32(x: i32); }
395 extern { fn some_func_i64(x: i64); }
400 Rust only supports variadic parameters for interoperability with C code in its
401 FFI. As such, variadic parameters can only be used with functions which are
402 using the C ABI. Examples of erroneous code:
405 extern "rust-call" { fn foo(x: u8, ...); }
407 fn foo(x: u8, ...) {}
410 To fix such code, put them in an extern "C" block:
413 extern "C" fn foo (x: u8, ...);
422 When trying to make some type implement a trait `Foo`, you must, at minimum,
423 provide implementations for all of `Foo`'s required methods (meaning the
424 methods that do not have default implementations), as well as any required
425 trait items like associated types or constants.
429 This error indicates that an attempted implementation of a trait method
430 has the wrong number of type parameters.
432 For example, the trait below has a method `foo` with a type parameter `T`,
433 but the implementation of `foo` for the type `Bar` is missing this parameter:
437 fn foo<T: Default>(x: T) -> Self;
442 // error: method `foo` has 0 type parameters but its trait declaration has 1
445 fn foo(x: bool) -> Self { Bar }
451 This error indicates that an attempted implementation of a trait method
452 has the wrong number of function parameters.
454 For example, the trait below has a method `foo` with two function parameters
455 (`&self` and `u8`), but the implementation of `foo` for the type `Bar` omits
460 fn foo(&self, x: u8) -> bool;
465 // error: method `foo` has 1 parameter but the declaration in trait `Foo::foo`
468 fn foo(&self) -> bool { true }
474 The parameters of any trait method must match between a trait implementation
475 and the trait definition.
477 Here are a couple examples of this error:
488 // error, expected u16, found i16
491 // error, values differ in mutability
492 fn bar(&mut self) { }
498 It is not allowed to cast to a bool. If you are trying to cast a numeric type
499 to a bool, you can compare it with zero instead:
505 let x_is_nonzero = x != 0;
507 // Not allowed, won't compile
508 let x_is_nonzero = x as bool;
513 During a method call, a value is automatically dereferenced as many times as
514 needed to make the value's type match the method's receiver. The catch is that
515 the compiler will only attempt to dereference a number of times up to the
516 recursion limit (which can be set via the `recursion_limit` attribute).
518 For a somewhat artificial example:
521 #![recursion_limit="2"]
533 // error, reached the recursion limit while auto-dereferencing &&Foo
538 One fix may be to increase the recursion limit. Note that it is possible to
539 create an infinite recursion of dereferencing, in which case the only fix is to
540 somehow break the recursion.
544 When invoking closures or other implementations of the function traits `Fn`,
545 `FnMut` or `FnOnce` using call notation, the number of parameters passed to the
546 function must match its definition.
548 An example using a closure:
552 let a = f(); // invalid, too few parameters
553 let b = f(4); // this works!
554 let c = f(2, 3); // invalid, too many parameters
557 A generic function must be treated similarly:
560 fn foo<F: Fn()>(f: F) {
561 f(); // this is valid, but f(3) would not work
567 The built-in function traits are generic over a tuple of the function arguments.
568 If one uses angle-bracket notation (`Fn<(T,), Output=U>`) instead of parentheses
569 (`Fn(T) -> U`) to denote the function trait, the type parameter should be a
570 tuple. Otherwise function call notation cannot be used and the trait will not be
571 implemented by closures.
573 The most likely source of this error is using angle-bracket notation without
574 wrapping the function argument type into a tuple, for example:
577 fn foo<F: Fn<i32>>(f: F) -> F::Output { f(3) }
580 It can be fixed by adjusting the trait bound like this:
583 fn foo<F: Fn<(i32,)>>(f: F) -> F::Output { f(3) }
586 Note that `(T,)` always denotes the type of a 1-tuple containing an element of
587 type `T`. The comma is necessary for syntactic disambiguation.
591 External C functions are allowed to be variadic. However, a variadic function
592 takes a minimum number of arguments. For example, consider C's variadic `printf`
597 use libc::{ c_char, c_int };
600 fn printf(_: *const c_char, ...) -> c_int;
604 Using this declaration, it must be called with at least one argument, so
605 simply calling `printf()` is illegal. But the following uses are allowed:
609 use std::ffi::CString;
611 printf(CString::new("test\n").unwrap().as_ptr());
612 printf(CString::new("number = %d\n").unwrap().as_ptr(), 3);
613 printf(CString::new("%d, %d\n").unwrap().as_ptr(), 10, 5);
619 The number of arguments passed to a function must match the number of arguments
620 specified in the function signature.
622 For example, a function like
625 fn f(a: u16, b: &str) {}
628 must always be called with exactly two arguments, e.g. `f(2, "test")`.
630 Note, that Rust does not have a notion of optional function arguments or
631 variadic functions (except for its C-FFI).
635 This error indicates that during an attempt to build a struct or struct-like
636 enum variant, one of the fields was specified more than once. Each field should
637 be specified exactly one time.
641 This error indicates that during an attempt to build a struct or struct-like
642 enum variant, one of the fields was not provided. Each field should be
643 specified exactly once.
647 Box placement expressions (like C++'s "placement new") do not yet support any
648 place expression except the exchange heap (i.e. `std::boxed::HEAP`).
649 Furthermore, the syntax is changing to use `in` instead of `box`. See [RFC 470]
650 and [RFC 809] for more details.
652 [RFC 470]: https://github.com/rust-lang/rfcs/pull/470
653 [RFC 809]: https://github.com/rust-lang/rfcs/pull/809
657 The left-hand side of a compound assignment expression must be an lvalue
658 expression. An lvalue expression represents a memory location and includes
659 item paths (ie, namespaced variables), dereferences, indexing expressions,
660 and field references.
662 Let's start with some bad examples:
664 use std::collections::LinkedList;
666 // Bad: assignment to non-lvalue expression
667 LinkedList::new() += 1;
671 fn some_func(i: &mut i32) {
672 i += 12; // Error : '+=' operation cannot be applied on a reference !
675 And now some good examples:
683 fn some_func(i: &mut i32) {
691 The compiler found a function whose body contains a `return;` statement but
692 whose return type is not `()`. An example of this is:
701 Since `return;` is just like `return ();`, there is a mismatch between the
702 function's return type and the value being returned.
706 The left-hand side of an assignment operator must be an lvalue expression. An
707 lvalue expression represents a memory location and can be a variable (with
708 optional namespacing), a dereference, an indexing expression or a field
711 More details can be found here:
712 https://doc.rust-lang.org/reference.html#lvalues,-rvalues-and-temporaries
714 Now, we can go further. Here are some bad examples:
720 const SOME_CONST : i32 = 12;
722 fn some_other_func() {}
725 SOME_CONST = 14; // error : a constant value cannot be changed!
726 1 = 3; // error : 1 isn't a valid lvalue!
727 some_other_func() = 4; // error : we can't assign value to a function!
728 SomeStruct.x = 12; // error : SomeStruct a structure name but it is used
733 And now let's give good examples:
740 let mut s = SomeStruct {x: 0, y: 0};
742 s.x = 3; // that's good !
746 fn some_func(x: &mut i32) {
747 *x = 12; // that's good !
753 You tried to use a structure initialization with a non-structure type.
754 Example of erroneous code:
757 enum Foo { FirstValue };
759 let u = Foo::FirstValue { value: 0i32 }; // error: Foo::FirstValue
760 // isn't a structure!
761 // or even simpler, if the structure wasn't defined at all:
762 let u = RandomName { random_field: 0i32 }; // error: RandomName
763 // isn't a structure!
766 To fix this, please check:
767 * Did you spell it right?
768 * Did you accidentaly used an enum as a struct?
769 * Did you accidentaly make an enum when you intended to use a struct?
771 Here is the previous code with all missing information:
783 let u = Foo::FirstValue(Inner { value: 0i32 });
785 let t = Inner { value: 0i32 };
791 When defining a recursive struct or enum, any use of the type being defined
792 from inside the definition must occur behind a pointer (like `Box` or `&`).
793 This is because structs and enums must have a well-defined size, and without
794 the pointer the size of the type would need to be unbounded.
796 Consider the following erroneous definition of a type for a list of bytes:
799 // error, illegal recursive struct type
802 tail: Option<ListNode>,
806 This type cannot have a well-defined size, because it needs to be arbitrarily
807 large (since we would be able to nest `ListNode`s to any depth). Specifically,
810 size of `ListNode` = 1 byte for `head`
811 + 1 byte for the discriminant of the `Option`
815 One way to fix this is by wrapping `ListNode` in a `Box`, like so:
820 tail: Option<Box<ListNode>>,
824 This works because `Box` is a pointer, so its size is well-known.
828 You cannot define a struct (or enum) `Foo` that requires an instance of `Foo`
829 in order to make a new `Foo` value. This is because there would be no way a
830 first instance of `Foo` could be made to initialize another instance!
832 Here's an example of a struct that has this problem:
835 struct Foo { x: Box<Foo> } // error
838 One fix is to use `Option`, like so:
841 struct Foo { x: Option<Box<Foo>> }
844 Now it's possible to create at least one instance of `Foo`: `Foo { x: None }`.
848 Enum discriminants are used to differentiate enum variants stored in memory.
849 This error indicates that the same value was used for two or more variants,
850 making them impossible to tell apart.
868 Note that variants without a manually specified discriminant are numbered from
869 top to bottom starting from 0, so clashes can occur with seemingly unrelated
879 Here `X` will have already been assigned the discriminant 0 by the time `Y` is
880 encountered, so a conflict occurs.
884 The default type for enum discriminants is `isize`, but it can be adjusted by
885 adding the `repr` attribute to the enum declaration. This error indicates that
886 an integer literal given as a discriminant is not a member of the discriminant
897 Here, 1024 lies outside the valid range for `u8`, so the discriminant for `A` is
898 invalid. You may want to change representation types to fix this, or else change
899 invalid discriminant values so that they fit within the existing type.
901 Note also that without a representation manually defined, the compiler will
902 optimize by using the smallest integer type possible.
906 At present, it's not possible to define a custom representation for an enum with
907 a single variant. As a workaround you can add a `Dummy` variant.
909 See: https://github.com/rust-lang/rust/issues/10292
913 It is impossible to define an integer type to be used to represent zero-variant
914 enum values because there are no zero-variant enum values. There is no way to
915 construct an instance of the following type using only safe code:
923 Too many type parameters were supplied for a function. For example:
929 foo::<f64, bool>(); // error, expected 1 parameter, found 2 parameters
933 The number of supplied parameters much exactly match the number of defined type
938 You gave too many lifetime parameters. Erroneous code example:
944 f::<'static>() // error: too many lifetime parameters provided
948 Please check you give the right number of lifetime parameters. Example:
958 It's also important to note that the Rust compiler can generally
959 determine the lifetime by itself. Example:
967 // it can be written like this
968 fn get_value<'a>(&'a self) -> &'a str { &self.value }
969 // but the compiler works fine with this too:
970 fn without_lifetime(&self) -> &str { &self.value }
974 let f = Foo { value: "hello".to_owned() };
976 println!("{}", f.get_value());
977 println!("{}", f.without_lifetime());
983 Not enough type parameters were supplied for a function. For example:
989 foo::<f64>(); // error, expected 2 parameters, found 1 parameter
993 Note that if a function takes multiple type parameters but you want the compiler
994 to infer some of them, you can use type placeholders:
997 fn foo<T, U>(x: T) {}
1001 foo::<f64>(x); // error, expected 2 parameters, found 1 parameter
1002 foo::<_, f64>(x); // same as `foo::<bool, f64>(x)`
1008 You gave an unnecessary type parameter in a type alias. Erroneous code
1012 type Foo<T> = u32; // error: type parameter `T` is unused
1014 type Foo<A,B> = Box<A>; // error: type parameter `B` is unused
1017 Please check you didn't write too many type parameters. Example:
1020 type Foo = u32; // ok!
1021 type Foo<A> = Box<A>; // ok!
1026 You tried to declare an undefined atomic operation function.
1027 Erroneous code example:
1030 #![feature(intrinsics)]
1032 extern "rust-intrinsic" {
1033 fn atomic_foo(); // error: unrecognized atomic operation
1038 Please check you didn't make a mistake in the function's name. All intrinsic
1039 functions are defined in librustc_trans/trans/intrinsic.rs and in
1040 libcore/intrinsics.rs in the Rust source code. Example:
1043 #![feature(intrinsics)]
1045 extern "rust-intrinsic" {
1046 fn atomic_fence(); // ok!
1052 You declared an unknown intrinsic function. Erroneous code example:
1055 #![feature(intrinsics)]
1057 extern "rust-intrinsic" {
1058 fn foo(); // error: unrecognized intrinsic function: `foo`
1068 Please check you didn't make a mistake in the function's name. All intrinsic
1069 functions are defined in librustc_trans/trans/intrinsic.rs and in
1070 libcore/intrinsics.rs in the Rust source code. Example:
1073 #![feature(intrinsics)]
1075 extern "rust-intrinsic" {
1076 fn atomic_fence(); // ok!
1088 You gave an invalid number of type parameters to an intrinsic function.
1089 Erroneous code example:
1092 #![feature(intrinsics)]
1094 extern "rust-intrinsic" {
1095 fn size_of<T, U>() -> usize; // error: intrinsic has wrong number
1096 // of type parameters
1100 Please check that you provided the right number of lifetime parameters
1101 and verify with the function declaration in the Rust source code.
1105 #![feature(intrinsics)]
1107 extern "rust-intrinsic" {
1108 fn size_of<T>() -> usize; // ok!
1114 You hit this error because the compiler the compiler lacks information
1115 to determine a type for this expression. Erroneous code example:
1119 let x = |_| {}; // error: cannot determine a type for this expression
1123 You have two possibilities to solve this situation:
1124 * Give an explicit definition of the expression
1125 * Infer the expression
1131 let x = |_ : u32| {}; // ok!
1140 This error indicates that a lifetime is missing from a type. If it is an error
1141 inside a function signature, the problem may be with failing to adhere to the
1142 lifetime elision rules (see below).
1144 Here are some simple examples of where you'll run into this error:
1147 struct Foo { x: &bool } // error
1148 struct Foo<'a> { x: &'a bool } // correct
1150 enum Bar { A(u8), B(&bool), } // error
1151 enum Bar<'a> { A(u8), B(&'a bool), } // correct
1153 type MyStr = &str; // error
1154 type MyStr<'a> = &'a str; //correct
1158 Lifetime elision is a special, limited kind of inference for lifetimes in
1159 function signatures which allows you to leave out lifetimes in certain cases.
1160 For more background on lifetime elision see [the book][book-le].
1162 The lifetime elision rules require that any function signature with an elided
1163 output lifetime must either have
1165 - exactly one input lifetime
1166 - or, multiple input lifetimes, but the function must also be a method with a
1167 `&self` or `&mut self` receiver
1169 In the first case, the output lifetime is inferred to be the same as the unique
1170 input lifetime. In the second case, the lifetime is instead inferred to be the
1171 same as the lifetime on `&self` or `&mut self`.
1173 Here are some examples of elision errors:
1176 // error, no input lifetimes
1177 fn foo() -> &str { ... }
1179 // error, `x` and `y` have distinct lifetimes inferred
1180 fn bar(x: &str, y: &str) -> &str { ... }
1182 // error, `y`'s lifetime is inferred to be distinct from `x`'s
1183 fn baz<'a>(x: &'a str, y: &str) -> &str { ... }
1186 [book-le]: http://doc.rust-lang.org/nightly/book/lifetimes.html#lifetime-elision
1190 This error means that an incorrect number of lifetime parameters were provided
1191 for a type (like a struct or enum) or trait.
1193 Some basic examples include:
1196 struct Foo<'a>(&'a str);
1197 enum Bar { A, B, C }
1200 foo: Foo, // error: expected 1, found 0
1201 bar: Bar<'a>, // error: expected 0, found 1
1205 Here's an example that is currently an error, but may work in a future version
1209 struct Foo<'a>(&'a str);
1212 impl Quux for Foo { } // error: expected 1, found 0
1215 Lifetime elision in implementation headers was part of the lifetime elision
1216 RFC. It is, however, [currently unimplemented][iss15872].
1218 [iss15872]: https://github.com/rust-lang/rust/issues/15872
1222 You can only define an inherent implementation for a type in the same crate
1223 where the type was defined. For example, an `impl` block as below is not allowed
1224 since `Vec` is defined in the standard library:
1227 impl Vec<u8> { ... } // error
1230 To fix this problem, you can do either of these things:
1232 - define a trait that has the desired associated functions/types/constants and
1233 implement the trait for the type in question
1234 - define a new type wrapping the type and define an implementation on the new
1237 Note that using the `type` keyword does not work here because `type` only
1238 introduces a type alias:
1241 type Bytes = Vec<u8>;
1243 impl Bytes { ... } // error, same as above
1248 You got this error because because you tried to implement a foreign
1249 trait for a foreign type (with maybe a foreign type parameter). Erroneous
1253 impl Drop for u32 {}
1256 The type, trait or the type parameter (or all of them) has to be defined
1257 in your crate. Example:
1260 pub struct Foo; // you define your type in your crate
1262 impl Drop for Foo { // and you can implement the trait on it!
1263 // code of trait implementation here
1266 trait Bar { // or define your trait in your crate
1267 fn get(&self) -> usize;
1270 impl Bar for u32 { // and then you implement it on a foreign type
1271 fn get(&self) -> usize { 0 }
1274 impl From<Foo> for i32 { // or you use a type from your crate as
1276 fn from(i: Foo) -> i32 {
1284 There are conflicting trait implementations for the same type.
1285 Erroneous code example:
1289 fn get(&self) -> usize;
1292 impl<T> MyTrait for T {
1293 fn get(&self) -> usize { 0 }
1300 impl MyTrait for Foo { // error: conflicting implementations for trait
1302 fn get(&self) -> usize { self.value }
1309 impl<T> MyTrait for T {
1310 fn get(&self) -> usize { 0 }
1314 This makes the trait implemented on all types in the scope. So if you
1315 try to implement it on another one after that, the implementations will
1320 fn get(&self) -> usize;
1323 impl<T> MyTrait for T {
1324 fn get(&self) -> usize { 0 }
1332 f.get(); // the trait is implemented so we can use it
1338 In order to be consistent with Rust's lack of global type inference, type
1339 placeholders are disallowed by design in item signatures.
1341 Examples of this error include:
1344 fn foo() -> _ { 5 } // error, explicitly write out the return type instead
1346 static BAR: _ = "test"; // error, explicitly write out the type instead
1351 You declared two fields of a struct with the same name. Erroneous code
1357 field1: i32 // error: field is already declared
1361 Please verify that the field names have been correctly spelled. Example:
1372 Type parameter defaults can only use parameters that occur before them.
1373 Erroneous code example:
1376 pub struct Foo<T=U, U=()> {
1380 // error: type parameters with a default cannot use forward declared
1384 Since type parameters are evaluated in-order, you may be able to fix this issue
1388 pub struct Foo<U=(), T=U> {
1394 Please also verify that this wasn't because of a name-clash and rename the type
1399 You declared a pattern as an argument in a foreign function declaration.
1400 Erroneous code example:
1404 fn foo((a, b): (u32, u32)); // error: patterns aren't allowed in foreign
1405 // function declarations
1409 Please replace the pattern argument with a regular one. Example:
1418 fn foo(s: SomeStruct); // ok!
1422 fn foo(a: (u32, u32)); // ok!
1428 It is not possible to define `main` with type parameters, or even with function
1429 parameters. When `main` is present, it must take no arguments and return `()`.
1433 It is not possible to declare type parameters on a function that has the `start`
1434 attribute. Such a function must have the following type signature:
1437 fn(isize, *const *const u8) -> isize
1442 You tried to use a trait as a struct constructor. Erroneous code example:
1445 trait TraitNotAStruct {}
1447 TraitNotAStruct{ value: 0 }; // error: use of trait `TraitNotAStruct` as a
1448 // struct constructor
1451 Please verify you used the correct type name or please implement the trait
1452 on a struct and use this struct constructor. Example:
1455 trait TraitNotAStruct {}
1461 Foo{ value: 0 }; // ok!
1466 This error means that the compiler found a return expression in a function
1467 marked as diverging. A function diverges if it has `!` in the place of the
1468 return type in its signature. For example:
1471 fn foo() -> ! { return; } // error
1474 For a function that diverges, every control path in the function must never
1475 return, for example with a `loop` that never breaks or a call to another
1476 diverging function (such as `panic!()`).
1480 In types, the `+` type operator has low precedence, so it is often necessary
1489 w: &'a Foo + Copy, // error, use &'a (Foo + Copy)
1490 x: &'a Foo + 'a, // error, use &'a (Foo + 'a)
1491 y: &'a mut Foo + 'a, // error, use &'a mut (Foo + 'a)
1492 z: fn() -> Foo + 'a, // error, use fn() -> (Foo + 'a)
1496 More details can be found in [RFC 438].
1498 [RFC 438]: https://github.com/rust-lang/rfcs/pull/438
1502 Explicitly implementing both Drop and Copy for a type is currently disallowed.
1503 This feature can make some sense in theory, but the current implementation is
1504 incorrect and can lead to memory unsafety (see [issue #20126][iss20126]), so
1505 it has been disabled for now.
1507 [iss20126]: https://github.com/rust-lang/rust/issues/20126
1511 An associated function for a trait was defined to be static, but an
1512 implementation of the trait declared the same function to be a method (i.e. to
1513 take a `self` parameter).
1515 Here's an example of this error:
1525 // error, method `foo` has a `&self` declaration in the impl, but not in
1532 An associated function for a trait was defined to be a method (i.e. to take a
1533 `self` parameter), but an implementation of the trait declared the same function
1536 Here's an example of this error:
1546 // error, method `foo` has a `&self` declaration in the trait, but not in
1554 Trait objects need to have all associated types specified. Erroneous code
1562 type Foo = Trait; // error: the value of the associated type `Bar` (from
1563 // the trait `Trait`) must be specified
1566 Please verify you specified all associated types of the trait and that you
1567 used the right trait. Example:
1574 type Foo = Trait<Bar=i32>; // ok!
1579 Negative impls are only allowed for traits with default impls. For more
1580 information see the [opt-in builtin traits RFC](https://github.com/rust-lang/
1581 rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
1585 Your method's lifetime parameters do not match the trait declaration.
1586 Erroneous code example:
1590 fn bar<'a,'b:'a>(x: &'a str, y: &'b str);
1595 impl Trait for Foo {
1596 fn bar<'a,'b>(x: &'a str, y: &'b str) {
1597 // error: lifetime parameters or bounds on method `bar`
1598 // do not match the trait declaration
1603 The lifetime constraint `'b` for bar() implementation does not match the
1604 trait declaration. Ensure lifetime declarations match exactly in both trait
1605 declaration and implementation. Example:
1609 fn t<'a,'b:'a>(x: &'a str, y: &'b str);
1614 impl Trait for Foo {
1615 fn t<'a,'b:'a>(x: &'a str, y: &'b str) { // ok!
1622 Inherent implementations (one that do not implement a trait but provide
1623 methods associated with a type) are always safe because they are not
1624 implementing an unsafe trait. Removing the `unsafe` keyword from the inherent
1625 implementation will resolve this error.
1630 // this will cause this error
1632 // converting it to this will fix it
1639 A negative implementation is one that excludes a type from implementing a
1640 particular trait. Not being able to use a trait is always a safe operation,
1641 so negative implementations are always safe and never need to be marked as
1647 // unsafe is unnecessary
1648 unsafe impl !Clone for Foo { }
1649 // this will compile
1650 impl !Clone for Foo { }
1656 Safe traits should not have unsafe implementations, therefore marking an
1657 implementation for a safe trait unsafe will cause a compiler error. Removing the
1658 unsafe marker on the trait noted in the error will resolve this problem.
1665 // this won't compile because Bar is safe
1666 unsafe impl Bar for Foo { }
1667 // this will compile
1668 impl Bar for Foo { }
1674 Unsafe traits must have unsafe implementations. This error occurs when an
1675 implementation for an unsafe trait isn't marked as unsafe. This may be resolved
1676 by marking the unsafe implementation as unsafe.
1681 unsafe trait Bar { }
1683 // this won't compile because Bar is unsafe and impl isn't unsafe
1684 impl Bar for Foo { }
1685 // this will compile
1686 unsafe impl Bar for Foo { }
1692 It is an error to define an associated function more than once.
1700 fn bar(&self) -> bool { self.0 > 5 }
1702 // error: duplicate associated function
1707 fn baz(&self) -> bool;
1711 fn baz(&self) -> bool { true }
1713 // error: duplicate method
1714 fn baz(&self) -> bool { self.0 > 5 }
1720 Inherent associated types were part of [RFC 195] but are not yet implemented.
1721 See [the tracking issue][iss8995] for the status of this implementation.
1723 [RFC 195]: https://github.com/rust-lang/rfcs/pull/195
1724 [iss8995]: https://github.com/rust-lang/rust/issues/8995
1728 An attempt to implement the `Copy` trait for a struct failed because one of the
1729 fields does not implement `Copy`. To fix this, you must implement `Copy` for the
1730 mentioned field. Note that this may not be possible, as in the example of
1737 impl Copy for Foo { }
1740 This fails because `Vec<T>` does not implement `Copy` for any `T`.
1742 Here's another example that will fail:
1751 This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
1752 differs from the behavior for `&T`, which is always `Copy`).
1756 An attempt to implement the `Copy` trait for an enum failed because one of the
1757 variants does not implement `Copy`. To fix this, you must implement `Copy` for
1758 the mentioned variant. Note that this may not be possible, as in the example of
1766 impl Copy for Foo { }
1769 This fails because `Vec<T>` does not implement `Copy` for any `T`.
1771 Here's another example that will fail:
1781 This fails because `&mut T` is not `Copy`, even when `T` is `Copy` (this
1782 differs from the behavior for `&T`, which is always `Copy`).
1786 You can only implement `Copy` for a struct or enum. Both of the following
1787 examples will fail, because neither `i32` (primitive type) nor `&'static Bar`
1788 (reference to `Bar`) is a struct or enum:
1792 impl Copy for Foo { } // error
1794 #[derive(Copy, Clone)]
1796 impl Copy for &'static Bar { } // error
1801 You declared an unused type parameter when implementing a trait on an object.
1802 Erroneous code example:
1806 fn get(&self) -> usize;
1811 impl<T> MyTrait for Foo {
1812 fn get(&self) -> usize {
1818 Please check your object definition and remove unused type
1819 parameter(s). Example:
1823 fn get(&self) -> usize;
1828 impl MyTrait for Foo {
1829 fn get(&self) -> usize {
1837 You used an intrinsic function which doesn't correspond to its
1838 definition. Erroneous code example:
1841 #![feature(intrinsics)]
1843 extern "rust-intrinsic" {
1844 fn size_of<T>(); // error: intrinsic has wrong type
1848 Please check the function definition. Example:
1851 #![feature(intrinsics)]
1853 extern "rust-intrinsic" {
1854 fn size_of<T>() -> usize;
1860 You used an associated type which isn't defined in the trait.
1861 Erroneous code example:
1868 type Foo = Trait<F=i32>; // error: associated type `F` not found for
1872 Please verify you used the right trait or you didn't misspell the
1873 associated type name. Example:
1880 type Foo = Trait<Bar=i32>; // ok!
1885 The attribute must have a value. Erroneous code example:
1888 #[rustc_on_unimplemented] // error: this attribute must have a value
1892 Please supply the missing value of the attribute. Example:
1895 #[rustc_on_unimplemented = "foo"] // ok!
1901 This error indicates that not enough type parameters were found in a type or
1904 For example, the `Foo` struct below is defined to be generic in `T`, but the
1905 type parameter is missing in the definition of `Bar`:
1908 struct Foo<T> { x: T }
1910 struct Bar { x: Foo }
1915 This error indicates that too many type parameters were found in a type or
1918 For example, the `Foo` struct below has no type parameters, but is supplied
1919 with two in the definition of `Bar`:
1922 struct Foo { x: bool }
1924 struct Bar<S, T> { x: Foo<S, T> }
1929 This error indicates a constant expression for the array length was found, but
1930 it was not an integer (signed or unsigned) expression.
1932 Some examples of code that produces this error are:
1935 const A: [u32; "hello"] = []; // error
1936 const B: [u32; true] = []; // error
1937 const C: [u32; 0.0] = []; // error
1941 There was an error while evaluating the expression for the length of a fixed-
1944 Some examples of this error are:
1947 // divide by zero in the length expression
1948 const A: [u32; 1/0] = [];
1950 // Rust currently will not evaluate the function `foo` at compile time
1951 fn foo() -> usize { 12 }
1952 const B: [u32; foo()] = [];
1954 // it is an error to try to add `u8` and `f64`
1956 const C: [u32; u8::MAX + f64::EPSILON] = [];
1961 Default impls for a trait must be located in the same crate where the trait was
1962 defined. For more information see the [opt-in builtin traits RFC](https://github
1963 .com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
1967 The `Sized` trait is a special trait built-in to the compiler for types with a
1968 constant size known at compile-time. This trait is automatically implemented
1969 for types as needed by the compiler, and it is currently disallowed to
1970 explicitly implement it for a type.
1974 The types of any associated constants in a trait implementation must match the
1975 types in the trait definition. This error indicates that there was a mismatch.
1977 Here's an example of this error:
1987 const BAR: u32 = 5; // error, expected bool, found u32
1993 You cannot use associated items other than constant items as patterns. This
1994 includes method items. Example of erroneous code:
2000 fn bb() -> i32 { 0 }
2005 B::bb => {} // error: associated items in match patterns must
2011 Please check that you're not using a method as a pattern. Example:
2029 This error indicates that a binary assignment operator like `+=` or `^=` was
2030 applied to the wrong types. For example:
2034 x ^= true; // error, `^=` cannot be applied to types `u16` and `bool`
2035 x += (); // error, `+=` cannot be applied to types `u16` and `()`
2038 Another problem you might be facing is this: suppose you've overloaded the `+`
2039 operator for some type `Foo` by implementing the `std::ops::Add` trait for
2040 `Foo`, but you find that using `+=` does not work, as in this example:
2050 fn add(self, rhs: Foo) -> Foo {
2056 let mut x: Foo = Foo(5);
2057 x += Foo(7); // error, `+= cannot be applied to types `Foo` and `Foo`
2061 This is because the binary assignment operators currently do not work off of
2062 traits, so it is not possible to overload them. See [RFC 953] for a proposal
2065 [RFC 953]: https://github.com/rust-lang/rfcs/pull/953
2069 When `Trait2` is a subtrait of `Trait1` (for example, when `Trait2` has a
2070 definition like `trait Trait2: Trait1 { ... }`), it is not allowed to implement
2071 `Trait1` for `Trait2`. This is because `Trait2` already implements `Trait1` by
2072 definition, so it is not useful to do this.
2077 trait Foo { fn foo(&self) { } }
2081 impl Bar for Baz { } // error, `Baz` implements `Bar` by definition
2082 impl Foo for Baz { } // error, `Baz` implements `Bar` which implements `Foo`
2083 impl Baz for Baz { } // error, `Baz` (trivially) implements `Baz`
2084 impl Baz for Bar { } // Note: This is OK
2089 Trying to implement a trait for a trait object (as in `impl Trait1 for
2090 Trait2 { ... }`) does not work if the trait is not object-safe. Please see the
2091 [RFC 255] for more details on object safety rules.
2093 [RFC 255]: https://github.com/rust-lang/rfcs/pull/255
2097 Trait methods cannot be declared `const` by design. For more information, see
2100 [RFC 911]: https://github.com/rust-lang/rfcs/pull/911
2104 Default impls are only allowed for traits with no methods or associated items.
2105 For more information see the [opt-in builtin traits RFC](https://github.com/rust
2106 -lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md).
2111 register_diagnostics! {
2135 E0173, // manual implementations of unboxed closure traits are experimental
2136 E0174, // explicit use of unboxed closure methods are experimental
2139 E0187, // can't infer the kind of the closure
2140 E0188, // can not cast a immutable reference to a mutable pointer
2141 E0189, // deprecated: can only cast a boxed pointer to a boxed object
2142 E0190, // deprecated: can only cast a &-pointer to an &-object
2143 E0193, // cannot bound type where clause bounds may only be attached to types
2144 // involving type parameters
2146 E0196, // cannot determine a type for this closure
2147 E0203, // type parameter has more than one relaxed default bound,
2148 // and only one is supported
2150 E0209, // builtin traits can only be implemented on structs or enums
2151 E0210, // type parameter is not constrained by any local type
2152 E0212, // cannot extract an associated type from a higher-ranked trait bound
2153 E0213, // associated types are not accepted in this context
2154 E0214, // parenthesized parameters may only be used with a trait
2155 E0215, // angle-bracket notation is not stable with `Fn`
2156 E0216, // parenthetical notation is only stable with `Fn`
2157 E0217, // ambiguous associated type, defined in multiple supertraits
2158 E0218, // no associated type defined
2159 E0219, // associated type defined in higher-ranked supertrait
2160 E0221, // ambiguous associated type in bounds
2161 //E0222, // Error code E0045 (variadic function must have C calling
2162 // convention) duplicate
2163 E0223, // ambiguous associated type
2164 E0224, // at least one non-builtin train is required for an object type
2165 E0225, // only the builtin traits can be used as closure or object bounds
2166 E0226, // only a single explicit lifetime bound is permitted
2167 E0227, // ambiguous lifetime bound, explicit lifetime bound required
2168 E0228, // explicit lifetime bound required
2169 E0229, // associated type bindings are not allowed here
2170 E0230, // there is no type parameter on trait
2171 E0231, // only named substitution parameters are allowed
2174 E0235, // structure constructor specifies a structure of type but
2175 E0236, // no lang item for range syntax
2176 E0237, // no lang item for range syntax
2177 E0238, // parenthesized parameters may only be used with a trait
2178 E0239, // `next` method of `Iterator` trait has unexpected type
2181 E0242, // internal error looking up a definition
2182 E0245, // not a trait
2183 E0246, // illegal recursive type
2184 E0247, // found module name used as a type
2185 E0248, // found value name used as a type
2186 E0319, // trait impls for defaulted traits allowed just for structs/enums
2187 E0320, // recursive overflow during dropck
2188 E0321, // extended coherence rules for defaulted traits violated
2189 E0323, // implemented an associated const when another trait item expected
2190 E0324, // implemented a method when another trait item expected
2191 E0325, // implemented an associated type when another trait item expected
2192 E0328, // cannot implement Unsize explicitly
2193 E0329, // associated const depends on type parameter or Self.
2194 E0366, // dropck forbid specialization to concrete type or region
2195 E0367, // dropck forbid specialization to predicate not in struct/enum
2196 E0369, // binary operation `<op>` cannot be applied to types
2197 E0374, // the trait `CoerceUnsized` may only be implemented for a coercion
2198 // between structures with one field being coerced, none found
2199 E0375, // the trait `CoerceUnsized` may only be implemented for a coercion
2200 // between structures with one field being coerced, but multiple
2201 // fields need coercions
2202 E0376, // the trait `CoerceUnsized` may only be implemented for a coercion
2203 // between structures
2204 E0377, // the trait `CoerceUnsized` may only be implemented for a coercion
2205 // between structures with the same definition
2206 E0390, // only a single inherent implementation marked with
2207 // `#[lang = \"{}\"]` is allowed for the `{}` primitive
2208 E0391, // unsupported cyclic reference between types/traits detected
2209 E0392, // parameter `{}` is never used
2210 E0393, // the type parameter `{}` must be explicitly specified in an object
2211 // type because its default value `{}` references the type `Self`"
2212 E0399 // trait items need to be implemented because the associated
2213 // type `{}` was overridden