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 // Error messages for EXXXX errors. Each message should start and end with a
14 // new line, and be wrapped to 80 characters. In vim you can `:set tw=80` and
15 // use `gq` to wrap paragraphs. Use `:set tw=0` to disable.
16 register_long_diagnostics! {
19 Type parameter defaults can only use parameters that occur before them.
20 Erroneous code example:
23 struct Foo<T=U, U=()> {
27 // error: type parameters with a default cannot use forward declared
31 Since type parameters are evaluated in-order, you may be able to fix this issue
35 struct Foo<U=(), T=U> {
41 Please also verify that this wasn't because of a name-clash and rename the type
46 #### Note: this error code is no longer emitted by the compiler.
48 Imports (`use` statements) are not allowed after non-item statements, such as
49 variable declarations and expression statements.
51 Here is an example that demonstrates the error:
55 // Variable declaration before import
62 The solution is to declare the imports at the top of the block, function, or
65 Here is the previous example again, with the correct order:
75 See the Declaration Statements section of the reference for more information
76 about what constitutes an Item declaration and what does not:
78 https://doc.rust-lang.org/reference.html#statements
82 #### Note: this error code is no longer emitted by the compiler.
84 Two items of the same name cannot be imported without rebinding one of the
85 items under a new local name.
87 An example of this error:
91 use bar::*; // error, do `use foo::baz as quux` instead on the previous line
106 Two items of the same name cannot be imported without rebinding one of the
107 items under a new local name.
109 Erroneous code example:
111 ```compile_fail,E0252
113 use bar::baz; // error, do `use bar::baz as quux` instead
126 You can use aliases in order to fix this error. Example:
129 use foo::baz as foo_baz;
143 Or you can reference the item with its parent:
149 let x = foo::baz; // ok!
163 Attempt was made to import an unimportable value. This can happen when trying
164 to import a method from a trait.
166 Erroneous code example:
168 ```compile_fail,E0253
175 use foo::MyTrait::do_something;
176 // error: `do_something` is not directly importable
181 It's invalid to directly import methods belonging to a trait or concrete type.
185 Attempt was made to import an item whereas an extern crate with this name has
186 already been imported.
188 Erroneous code example:
190 ```compile_fail,E0254
199 use foo::core; // error: an extern crate named `core` has already
200 // been imported in this module
205 To fix issue issue, you have to rename at least one of the two imports.
209 extern crate core as libcore; // ok!
224 You can't import a value whose name is the same as another value defined in the
227 Erroneous code example:
229 ```compile_fail,E0255
230 use bar::foo; // error: an item named `foo` is already in scope
241 You can use aliases in order to fix this error. Example:
244 use bar::foo as bar_foo; // ok!
255 Or you can reference the item with its parent:
265 bar::foo(); // we get the item by referring to its parent
271 #### Note: this error code is no longer emitted by the compiler.
273 You can't import a type or module when the name of the item being imported is
274 the same as another type or submodule defined in the module.
276 An example of this error:
279 use foo::Bar; // error
292 The name chosen for an external crate conflicts with another external crate
293 that has been imported into the current module.
295 Erroneous code example:
297 ```compile_fail,E0259
300 extern crate libc as core;
305 The solution is to choose a different name that doesn't conflict with any
306 external crate imported into the current module.
313 extern crate libc as other_name;
320 The name for an item declaration conflicts with an external crate's name.
322 Erroneous code example:
324 ```compile_fail,E0260
332 There are two possible solutions:
334 Solution #1: Rename the item.
342 Solution #2: Import the crate with a different name.
345 extern crate core as xyz;
350 See the Declaration Statements section of the reference for more information
351 about what constitutes an Item declaration and what does not:
353 https://doc.rust-lang.org/reference.html#statements
357 Private items cannot be publicly re-exported. This error indicates that you
358 attempted to `pub use` a type or value that was not itself public.
360 Erroneous code example:
372 The solution to this problem is to ensure that the items that you are
373 re-exporting are themselves marked with `pub`:
377 pub const X: u32 = 1;
385 See the 'Use Declarations' section of the reference for more information on
388 https://doc.rust-lang.org/reference.html#use-declarations
392 Private modules cannot be publicly re-exported. This error indicates that you
393 attempted to `pub use` a module that was not itself public.
395 Erroneous code example:
397 ```compile_fail,E0365
399 pub const X: u32 = 1;
407 The solution to this problem is to ensure that the module that you are
408 re-exporting is itself marked with `pub`:
412 pub const X: u32 = 1;
420 See the 'Use Declarations' section of the reference for more information
423 https://doc.rust-lang.org/reference.html#use-declarations
427 Inner items do not inherit type parameters from the functions they are embedded
430 Erroneous code example:
432 ```compile_fail,E0401
434 fn bar(y: T) { // T is defined in the "outer" function
443 ```compile_fail,E0401
445 type MaybeT = Option<T>;
452 ```compile_fail,E0401
461 Items inside functions are basically just like top-level items, except
462 that they can only be used from the function they are in.
464 There are a couple of solutions for this.
466 If the item is a function, you may use a closure:
470 let bar = |y: T| { // explicit type annotation may not be necessary
477 For a generic item, you can copy over the parameters:
490 type MaybeT<T> = Option<T>;
494 Be sure to copy over any bounds as well:
497 fn foo<T: Copy>(x: T) {
498 fn bar<T: Copy>(y: T) {
506 fn foo<T: Copy>(x: T) {
507 struct Foo<T: Copy> {
513 This may require additional type hints in the function body.
515 In case the item is a function inside an `impl`, defining a private helper
516 function might be easier:
521 pub fn foo(&self, x: T) {
525 fn bar(&self, y: T) {
531 For default impls in traits, the private helper solution won't work, however
532 closures or copying the parameters should still work.
536 Some type parameters have the same name.
538 Erroneous code example:
540 ```compile_fail,E0403
541 fn foo<T, T>(s: T, u: T) {} // error: the name `T` is already used for a type
542 // parameter in this type parameter list
545 Please verify that none of the type parameters are misspelled, and rename any
546 clashing parameters. Example:
549 fn foo<T, Y>(s: T, u: Y) {} // ok!
554 You tried to use something which is not a trait in a trait position, such as
557 Erroneous code example:
559 ```compile_fail,E0404
563 impl Foo for Bar {} // error: `Foo` is not a trait
566 Another erroneous code example:
568 ```compile_fail,E0404
571 fn bar<T: Foo>(t: T) {} // error: `Foo` is not a trait
574 Please verify that you didn't misspell the trait's name or otherwise use the
575 wrong identifier. Example:
583 impl Foo for Bar { // ok!
584 // functions implementation
595 fn bar<T: Foo>(t: T) {} // ok!
601 The code refers to a trait that is not in scope.
603 Erroneous code example:
605 ```compile_fail,E0405
608 impl SomeTrait for Foo {} // error: trait `SomeTrait` is not in scope
611 Please verify that the name of the trait wasn't misspelled and ensure that it
612 was imported. Example:
615 # #[cfg(for_demonstration_only)]
617 use some_file::SomeTrait;
626 impl SomeTrait for Foo { // ok!
627 // implements functions
633 A definition of a method not in the implemented trait was given in a trait
636 Erroneous code example:
638 ```compile_fail,E0407
647 fn b() {} // error: method `b` is not a member of trait `Foo`
651 Please verify you didn't misspell the method name and you used the correct
652 trait. First example:
688 An "or" pattern was used where the variable bindings are not consistently bound
691 Erroneous code example:
693 ```compile_fail,E0408
695 Some(y) | None => { /* use y */ } // error: variable `y` from pattern #1 is
696 // not bound in pattern #2
701 Here, `y` is bound to the contents of the `Some` and can be used within the
702 block corresponding to the match arm. However, in case `x` is `None`, we have
703 not specified what `y` is, and the block will use a nonexistent variable.
705 To fix this error, either split into multiple match arms:
710 Some(y) => { /* use y */ }
711 None => { /* ... */ }
715 or, bind the variable to a field of the same type in all sub-patterns of the
721 (0, y) | (y, 0) => { /* use y */}
726 In this example, if `x` matches the pattern `(0, _)`, the second field is set
727 to `y`. If it matches `(_, 0)`, the first field is set to `y`; so in all
728 cases `y` is set to some value.
732 An "or" pattern was used where the variable bindings are not consistently bound
735 Erroneous code example:
737 ```compile_fail,E0409
740 (0, ref y) | (y, 0) => { /* use y */} // error: variable `y` is bound with
741 // different mode in pattern #2
742 // than in pattern #1
747 Here, `y` is bound by-value in one case and by-reference in the other.
749 To fix this error, just use the same mode in both cases.
750 Generally using `ref` or `ref mut` where not already used will fix this:
755 (0, ref y) | (ref y, 0) => { /* use y */}
760 Alternatively, split the pattern:
765 (y, 0) => { /* use y */ }
766 (0, ref y) => { /* use y */}
773 The `Self` keyword was used outside an impl, trait, or type definition.
775 Erroneous code example:
777 ```compile_fail,E0411
778 <Self>::foo; // error: use of `Self` outside of an impl, trait, or type
782 The `Self` keyword represents the current type, which explains why it can only
783 be used inside an impl, trait, or type definition. It gives access to the
784 associated items of a type:
792 fn bar() -> Self::Bar; // like this
796 However, be careful when two types have a common associated type:
807 trait Baz : Foo + Foo2 {
808 fn bar() -> Self::Bar;
809 // error: ambiguous associated type `Bar` in bounds of `Self`
813 This problem can be solved by specifying from which trait we want to use the
825 trait Baz : Foo + Foo2 {
826 fn bar() -> <Self as Foo>::Bar; // ok!
832 The type name used is not in scope.
834 Erroneous code examples:
836 ```compile_fail,E0412
837 impl Something {} // error: type name `Something` is not in scope
842 fn bar(N); // error: type name `N` is not in scope
847 fn foo(x: T) {} // type name `T` is not in scope
850 To fix this error, please verify you didn't misspell the type name, you did
851 declare it or imported it into the scope. Examples:
856 impl Something {} // ok!
863 fn bar(_: Self::N); // ok!
868 fn foo<T>(x: T) {} // ok!
871 Another case that causes this error is when a type is imported into a parent
872 module. To fix this, you can follow the suggestion and use File directly or
873 `use super::File;` which will import the types from the parent namespace. An
874 example that causes this error is below:
876 ```compile_fail,E0412
880 fn some_function(f: File) {}
891 // use std::fs::File;
894 # fn main() {} // don't insert it for us; that'll break imports
899 More than one function parameter have the same name.
901 Erroneous code example:
903 ```compile_fail,E0415
904 fn foo(f: i32, f: i32) {} // error: identifier `f` is bound more than
905 // once in this parameter list
908 Please verify you didn't misspell parameters' name. Example:
911 fn foo(f: i32, g: i32) {} // ok!
916 An identifier is bound more than once in a pattern.
918 Erroneous code example:
920 ```compile_fail,E0416
922 (x, x) => {} // error: identifier `x` is bound more than once in the
927 Please verify you didn't misspell identifiers' name. Example:
935 Or maybe did you mean to unify? Consider using a guard:
938 # let (A, B, C) = (1, 2, 3);
940 (x, x2, see) if x == x2 => { /* A and B are equal, do one thing */ }
941 (y, z, see) => { /* A and B unequal; do another thing */ }
947 You are trying to use an identifier that is either undefined or not a struct.
948 Erroneous code example:
950 ```compile_fail,E0422
952 let x = Foo { x: 1, y: 2 };
956 In this case, `Foo` is undefined, so it inherently isn't anything, and
957 definitely not a struct.
962 let x = foo { x: 1, y: 2 };
966 In this case, `foo` is defined, but is not a struct, so Rust can't use it as
971 An identifier was used like a function name or a value was expected and the
972 identifier exists but it belongs to a different namespace.
974 For (an erroneous) example, here a `struct` variant name were used as a
977 ```compile_fail,E0423
978 struct Foo { a: bool };
981 // error: expected function, found `Foo`
982 // `Foo` is a struct name, but this expression uses it like a function name
985 Please verify you didn't misspell the name of what you actually wanted to use
989 fn Foo() -> u32 { 0 }
991 let f = Foo(); // ok!
994 It is common to forget the trailing `!` on macro invocations, which would also
997 ```compile_fail,E0423
999 // error: expected function, found macro `println`
1000 // did you mean `println!(...)`? (notice the trailing `!`)
1003 Another case where this error is emitted is when a value is expected, but
1004 something else is found:
1006 ```compile_fail,E0423
1008 pub const I: i32 = 1;
1013 //~^ ERROR expected value, found module `a`
1014 // did you mean `a::I`?
1020 The `self` keyword was used in a static method.
1022 Erroneous code example:
1024 ```compile_fail,E0424
1031 self.bar(); // error: `self` is not available in a static method.
1036 Please check if the method's argument list should have contained `self`,
1037 `&self`, or `&mut self` (in case you didn't want to create a static
1038 method), and add it if so. Example:
1054 An unresolved name was used.
1056 Erroneous code examples:
1058 ```compile_fail,E0425
1059 something_that_doesnt_exist::foo;
1060 // error: unresolved name `something_that_doesnt_exist::foo`
1066 Self; // error: unresolved name `Self`
1072 let x = unknown_variable; // error: unresolved name `unknown_variable`
1075 Please verify that the name wasn't misspelled and ensure that the
1076 identifier being referred to is valid for the given situation. Example:
1079 enum something_that_does_exist {
1087 mod something_that_does_exist {
1088 pub static foo : i32 = 0i32;
1091 something_that_does_exist::foo; // ok!
1097 let unknown_variable = 12u32;
1098 let x = unknown_variable; // ok!
1101 If the item is not defined in the current module, it must be imported using a
1102 `use` statement, like so:
1105 # mod foo { pub fn bar() {} }
1112 If the item you are importing is not defined in some super-module of the
1113 current module, then it must also be declared as public (e.g., `pub fn`).
1117 An undeclared label was used.
1119 Erroneous code example:
1121 ```compile_fail,E0426
1123 break 'a; // error: use of undeclared label `'a`
1127 Please verify you spelt or declare the label correctly. Example:
1137 A type or module has been defined more than once.
1139 Erroneous code example:
1141 ```compile_fail,E0428
1143 struct Bar; // error: duplicate definition of value `Bar`
1146 Please verify you didn't misspell the type/module's name or remove/rename the
1147 duplicated one. Example:
1156 The `self` keyword cannot appear alone as the last segment in a `use`
1159 Erroneous code example:
1161 ```compile_fail,E0429
1162 use std::fmt::self; // error: `self` imports are only allowed within a { } list
1165 To use a namespace itself in addition to some of its members, `self` may appear
1166 as part of a brace-enclosed list of imports:
1169 use std::fmt::{self, Debug};
1172 If you only want to import the namespace, do so directly:
1180 The `self` import appears more than once in the list.
1182 Erroneous code example:
1184 ```compile_fail,E0430
1185 use something::{self, self}; // error: `self` import can only appear once in
1189 Please verify you didn't misspell the import name or remove the duplicated
1190 `self` import. Example:
1195 use something::{self}; // ok!
1201 An invalid `self` import was made.
1203 Erroneous code example:
1205 ```compile_fail,E0431
1206 use {self}; // error: `self` import can only appear in an import list with a
1210 You cannot import the current module into itself, please remove this import
1211 or verify you didn't misspell it.
1215 An import was unresolved.
1217 Erroneous code example:
1219 ```compile_fail,E0432
1220 use something::Foo; // error: unresolved import `something::Foo`.
1223 Paths in `use` statements are relative to the crate root. To import items
1224 relative to the current and parent modules, use the `self::` and `super::`
1225 prefixes, respectively. Also verify that you didn't misspell the import
1226 name and that the import exists in the module from where you tried to
1230 use self::something::Foo; // ok!
1238 Or, if you tried to use a module from an external crate, you may have missed
1239 the `extern crate` declaration (which is usually placed in the crate root):
1242 extern crate core; // Required to use the `core` crate
1250 An undeclared type or module was used.
1252 Erroneous code example:
1254 ```compile_fail,E0433
1255 let map = HashMap::new();
1256 // error: failed to resolve: use of undeclared type or module `HashMap`
1259 Please verify you didn't misspell the type/module's name or that you didn't
1260 forget to import it:
1264 use std::collections::HashMap; // HashMap has been imported.
1265 let map: HashMap<u32, u32> = HashMap::new(); // So it can be used!
1270 This error indicates that a variable usage inside an inner function is invalid
1271 because the variable comes from a dynamic environment. Inner functions do not
1272 have access to their containing environment.
1274 Erroneous code example:
1276 ```compile_fail,E0434
1280 y // error: can't capture dynamic environment in a fn item; use the
1281 // || { ... } closure form instead.
1286 Functions do not capture local variables. To fix this error, you can replace the
1287 function with a closure:
1298 or replace the captured variable with a constant or a static item:
1302 static mut X: u32 = 4;
1315 A non-constant value was used in a constant expression.
1317 Erroneous code example:
1319 ```compile_fail,E0435
1321 let a: [u8; foo]; // error: attempt to use a non-constant value in a constant
1324 To fix this error, please replace the value with a constant. Example:
1327 let a: [u8; 42]; // ok!
1333 const FOO: usize = 42;
1334 let a: [u8; FOO]; // ok!
1339 Trait implementations can only implement associated types that are members of
1340 the trait in question. This error indicates that you attempted to implement
1341 an associated type whose name does not match the name of any associated type
1344 Erroneous code example:
1346 ```compile_fail,E0437
1354 The solution to this problem is to remove the extraneous associated type:
1364 Trait implementations can only implement associated constants that are
1365 members of the trait in question. This error indicates that you
1366 attempted to implement an associated constant whose name does not
1367 match the name of any associated constant in the trait.
1369 Erroneous code example:
1371 ```compile_fail,E0438
1375 const BAR: bool = true;
1379 The solution to this problem is to remove the extraneous associated constant:
1389 Macro import declarations were malformed.
1391 Erroneous code examples:
1393 ```compile_fail,E0466
1394 #[macro_use(a_macro(another_macro))] // error: invalid import declaration
1395 extern crate core as some_crate;
1397 #[macro_use(i_want = "some_macros")] // error: invalid import declaration
1398 extern crate core as another_crate;
1401 This is a syntax error at the level of attribute declarations. The proper
1402 syntax for macro imports is the following:
1404 ```ignore (cannot-doctest-multicrate-project)
1407 macro_rules! get_tacos {
1412 macro_rules! get_pimientos {
1417 #[macro_use(get_tacos, get_pimientos)] // It imports `get_tacos` and
1418 extern crate some_crate; // `get_pimientos` macros from some_crate
1421 If you would like to import all exported macros, write `macro_use` with no
1426 A non-root module attempts to import macros from another crate.
1428 Example of erroneous code:
1430 ```compile_fail,E0468
1432 #[macro_use(debug_assert)] // error: must be at crate root to import
1433 extern crate core; // macros from another crate
1434 fn run_macro() { debug_assert!(true); }
1438 Only `extern crate` imports at the crate root level are allowed to import
1441 Either move the macro import to crate root or do without the foreign macros.
1445 #[macro_use(debug_assert)]
1449 fn run_macro() { debug_assert!(true); }
1456 A macro listed for import was not found.
1458 Erroneous code example:
1460 ```compile_fail,E0469
1461 #[macro_use(drink, be_merry)] // error: imported macro not found
1469 Either the listed macro is not contained in the imported crate, or it is not
1470 exported from the given crate.
1472 This could be caused by a typo. Did you misspell the macro's name?
1474 Double-check the names of the macros listed for import, and that the crate
1475 in question exports them.
1477 A working version would be:
1479 ```ignore (cannot-doctest-multicrate-project)
1480 // In some_crate crate:
1487 macro_rules! drink {
1492 #[macro_use(eat, drink)]
1493 extern crate some_crate; //ok!
1498 A binding shadowed something it shouldn't.
1500 Erroneous code example:
1502 ```compile_fail,E0530
1503 static TEST: i32 = 0;
1505 let r: (i32, i32) = (0, 0);
1507 TEST => {} // error: match bindings cannot shadow statics
1511 To fix this error, just change the binding's name in order to avoid shadowing
1512 one of the following:
1515 * struct/enum variant
1523 static TEST: i32 = 0;
1525 let r: (i32, i32) = (0, 0);
1527 something => {} // ok!
1533 Pattern arm did not match expected kind.
1535 Erroneous code example:
1537 ```compile_fail,E0532
1543 fn print_on_failure(state: &State) {
1545 // error: expected unit struct/variant or constant, found tuple
1546 // variant `State::Failed`
1547 State::Failed => println!("Failed"),
1553 To fix this error, ensure the match arm kind is the same as the expression
1564 fn print_on_failure(state: &State) {
1566 State::Failed(ref msg) => println!("Failed with {}", msg),
1574 A private item was used outside its scope.
1576 Erroneous code example:
1578 ```compile_fail,E0603
1580 const PRIVATE: u32 = 0x_a_bad_1dea_u32; // This const is private, so we
1581 // can't use it outside of the
1582 // `SomeModule` module.
1585 println!("const value: {}", SomeModule::PRIVATE); // error: constant `PRIVATE`
1589 In order to fix this error, you need to make the item public by using the `pub`
1594 pub const PRIVATE: u32 = 0x_a_bad_1dea_u32; // We set it public by using the
1598 println!("const value: {}", SomeModule::PRIVATE); // ok!
1603 An item usage is ambiguous.
1605 Erroneous code example:
1607 ```compile_fail,E0659
1622 collider::foo(); // ERROR: `foo` is ambiguous
1626 This error generally appears when two items with the same name are imported into
1627 a module. Here, the `foo` functions are imported and reexported from the
1628 `collider` module and therefore, when we're using `collider::foo()`, both
1631 To solve this error, the best solution is generally to keep the path before the
1632 item when using it. Example:
1649 collider::moon::foo(); // ok!
1650 collider::earth::foo(); // ok!
1657 register_diagnostics! {
1658 // E0153, unused error code
1659 // E0157, unused error code
1662 // E0402, // cannot use an outer type parameter in this context
1663 // E0406, merged into 420
1664 // E0410, merged into 408
1665 // E0413, merged into 530
1666 // E0414, merged into 530
1667 // E0417, merged into 532
1668 // E0418, merged into 532
1669 // E0419, merged into 531
1670 // E0420, merged into 532
1671 // E0421, merged into 531
1672 E0531, // unresolved pattern path kind `name`
1673 // E0427, merged into 530