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
299 extern crate std as core;
304 The solution is to choose a different name that doesn't conflict with any
305 external crate imported into the current module.
311 extern crate std as other_name;
318 The name for an item declaration conflicts with an external crate's name.
320 Erroneous code example:
322 ```compile_fail,E0260
330 There are two possible solutions:
332 Solution #1: Rename the item.
340 Solution #2: Import the crate with a different name.
343 extern crate core as xyz;
348 See the Declaration Statements section of the reference for more information
349 about what constitutes an Item declaration and what does not:
351 https://doc.rust-lang.org/reference.html#statements
355 Private items cannot be publicly re-exported. This error indicates that you
356 attempted to `pub use` a type or value that was not itself public.
358 Erroneous code example:
370 The solution to this problem is to ensure that the items that you are
371 re-exporting are themselves marked with `pub`:
375 pub const X: u32 = 1;
383 See the 'Use Declarations' section of the reference for more information on
386 https://doc.rust-lang.org/reference.html#use-declarations
390 Private modules cannot be publicly re-exported. This error indicates that you
391 attempted to `pub use` a module that was not itself public.
393 Erroneous code example:
395 ```compile_fail,E0365
397 pub const X: u32 = 1;
405 The solution to this problem is to ensure that the module that you are
406 re-exporting is itself marked with `pub`:
410 pub const X: u32 = 1;
418 See the 'Use Declarations' section of the reference for more information
421 https://doc.rust-lang.org/reference.html#use-declarations
425 Inner items do not inherit type parameters from the functions they are embedded
428 Erroneous code example:
430 ```compile_fail,E0401
432 fn bar(y: T) { // T is defined in the "outer" function
441 ```compile_fail,E0401
443 type MaybeT = Option<T>;
450 ```compile_fail,E0401
459 Items inside functions are basically just like top-level items, except
460 that they can only be used from the function they are in.
462 There are a couple of solutions for this.
464 If the item is a function, you may use a closure:
468 let bar = |y: T| { // explicit type annotation may not be necessary
475 For a generic item, you can copy over the parameters:
488 type MaybeT<T> = Option<T>;
492 Be sure to copy over any bounds as well:
495 fn foo<T: Copy>(x: T) {
496 fn bar<T: Copy>(y: T) {
504 fn foo<T: Copy>(x: T) {
505 struct Foo<T: Copy> {
511 This may require additional type hints in the function body.
513 In case the item is a function inside an `impl`, defining a private helper
514 function might be easier:
519 pub fn foo(&self, x: T) {
523 fn bar(&self, y: T) {
529 For default impls in traits, the private helper solution won't work, however
530 closures or copying the parameters should still work.
534 Some type parameters have the same name.
536 Erroneous code example:
538 ```compile_fail,E0403
539 fn foo<T, T>(s: T, u: T) {} // error: the name `T` is already used for a type
540 // parameter in this type parameter list
543 Please verify that none of the type parameters are misspelled, and rename any
544 clashing parameters. Example:
547 fn foo<T, Y>(s: T, u: Y) {} // ok!
552 You tried to use something which is not a trait in a trait position, such as
555 Erroneous code example:
557 ```compile_fail,E0404
561 impl Foo for Bar {} // error: `Foo` is not a trait
564 Another erroneous code example:
566 ```compile_fail,E0404
569 fn bar<T: Foo>(t: T) {} // error: `Foo` is not a trait
572 Please verify that you didn't misspell the trait's name or otherwise use the
573 wrong identifier. Example:
581 impl Foo for Bar { // ok!
582 // functions implementation
593 fn bar<T: Foo>(t: T) {} // ok!
599 The code refers to a trait that is not in scope.
601 Erroneous code example:
603 ```compile_fail,E0405
606 impl SomeTrait for Foo {} // error: trait `SomeTrait` is not in scope
609 Please verify that the name of the trait wasn't misspelled and ensure that it
610 was imported. Example:
613 # #[cfg(for_demonstration_only)]
615 use some_file::SomeTrait;
624 impl SomeTrait for Foo { // ok!
625 // implements functions
631 A definition of a method not in the implemented trait was given in a trait
634 Erroneous code example:
636 ```compile_fail,E0407
645 fn b() {} // error: method `b` is not a member of trait `Foo`
649 Please verify you didn't misspell the method name and you used the correct
650 trait. First example:
686 An "or" pattern was used where the variable bindings are not consistently bound
689 Erroneous code example:
691 ```compile_fail,E0408
693 Some(y) | None => { /* use y */ } // error: variable `y` from pattern #1 is
694 // not bound in pattern #2
699 Here, `y` is bound to the contents of the `Some` and can be used within the
700 block corresponding to the match arm. However, in case `x` is `None`, we have
701 not specified what `y` is, and the block will use a nonexistent variable.
703 To fix this error, either split into multiple match arms:
708 Some(y) => { /* use y */ }
709 None => { /* ... */ }
713 or, bind the variable to a field of the same type in all sub-patterns of the
719 (0, y) | (y, 0) => { /* use y */}
724 In this example, if `x` matches the pattern `(0, _)`, the second field is set
725 to `y`. If it matches `(_, 0)`, the first field is set to `y`; so in all
726 cases `y` is set to some value.
730 An "or" pattern was used where the variable bindings are not consistently bound
733 Erroneous code example:
735 ```compile_fail,E0409
738 (0, ref y) | (y, 0) => { /* use y */} // error: variable `y` is bound with
739 // different mode in pattern #2
740 // than in pattern #1
745 Here, `y` is bound by-value in one case and by-reference in the other.
747 To fix this error, just use the same mode in both cases.
748 Generally using `ref` or `ref mut` where not already used will fix this:
753 (0, ref y) | (ref y, 0) => { /* use y */}
758 Alternatively, split the pattern:
763 (y, 0) => { /* use y */ }
764 (0, ref y) => { /* use y */}
771 The `Self` keyword was used outside an impl, trait, or type definition.
773 Erroneous code example:
775 ```compile_fail,E0411
776 <Self>::foo; // error: use of `Self` outside of an impl, trait, or type
780 The `Self` keyword represents the current type, which explains why it can only
781 be used inside an impl, trait, or type definition. It gives access to the
782 associated items of a type:
790 fn bar() -> Self::Bar; // like this
794 However, be careful when two types have a common associated type:
805 trait Baz : Foo + Foo2 {
806 fn bar() -> Self::Bar;
807 // error: ambiguous associated type `Bar` in bounds of `Self`
811 This problem can be solved by specifying from which trait we want to use the
823 trait Baz : Foo + Foo2 {
824 fn bar() -> <Self as Foo>::Bar; // ok!
830 The type name used is not in scope.
832 Erroneous code examples:
834 ```compile_fail,E0412
835 impl Something {} // error: type name `Something` is not in scope
840 fn bar(N); // error: type name `N` is not in scope
845 fn foo(x: T) {} // type name `T` is not in scope
848 To fix this error, please verify you didn't misspell the type name, you did
849 declare it or imported it into the scope. Examples:
854 impl Something {} // ok!
861 fn bar(_: Self::N); // ok!
866 fn foo<T>(x: T) {} // ok!
869 Another case that causes this error is when a type is imported into a parent
870 module. To fix this, you can follow the suggestion and use File directly or
871 `use super::File;` which will import the types from the parent namespace. An
872 example that causes this error is below:
874 ```compile_fail,E0412
878 fn some_function(f: File) {}
889 // use std::fs::File;
892 # fn main() {} // don't insert it for us; that'll break imports
897 More than one function parameter have the same name.
899 Erroneous code example:
901 ```compile_fail,E0415
902 fn foo(f: i32, f: i32) {} // error: identifier `f` is bound more than
903 // once in this parameter list
906 Please verify you didn't misspell parameters' name. Example:
909 fn foo(f: i32, g: i32) {} // ok!
914 An identifier is bound more than once in a pattern.
916 Erroneous code example:
918 ```compile_fail,E0416
920 (x, x) => {} // error: identifier `x` is bound more than once in the
925 Please verify you didn't misspell identifiers' name. Example:
933 Or maybe did you mean to unify? Consider using a guard:
936 # let (A, B, C) = (1, 2, 3);
938 (x, x2, see) if x == x2 => { /* A and B are equal, do one thing */ }
939 (y, z, see) => { /* A and B unequal; do another thing */ }
945 You are trying to use an identifier that is either undefined or not a struct.
946 Erroneous code example:
948 ```compile_fail,E0422
950 let x = Foo { x: 1, y: 2 };
954 In this case, `Foo` is undefined, so it inherently isn't anything, and
955 definitely not a struct.
960 let x = foo { x: 1, y: 2 };
964 In this case, `foo` is defined, but is not a struct, so Rust can't use it as
969 An identifier was used like a function name or a value was expected and the
970 identifier exists but it belongs to a different namespace.
972 For (an erroneous) example, here a `struct` variant name were used as a
975 ```compile_fail,E0423
976 struct Foo { a: bool };
979 // error: expected function, found `Foo`
980 // `Foo` is a struct name, but this expression uses it like a function name
983 Please verify you didn't misspell the name of what you actually wanted to use
987 fn Foo() -> u32 { 0 }
989 let f = Foo(); // ok!
992 It is common to forget the trailing `!` on macro invocations, which would also
995 ```compile_fail,E0423
997 // error: expected function, found macro `println`
998 // did you mean `println!(...)`? (notice the trailing `!`)
1001 Another case where this error is emitted is when a value is expected, but
1002 something else is found:
1004 ```compile_fail,E0423
1006 pub const I: i32 = 1;
1011 //~^ ERROR expected value, found module `a`
1012 // did you mean `a::I`?
1018 The `self` keyword was used in a static method.
1020 Erroneous code example:
1022 ```compile_fail,E0424
1029 self.bar(); // error: `self` is not available in a static method.
1034 Please check if the method's argument list should have contained `self`,
1035 `&self`, or `&mut self` (in case you didn't want to create a static
1036 method), and add it if so. Example:
1052 An unresolved name was used.
1054 Erroneous code examples:
1056 ```compile_fail,E0425
1057 something_that_doesnt_exist::foo;
1058 // error: unresolved name `something_that_doesnt_exist::foo`
1064 Self; // error: unresolved name `Self`
1070 let x = unknown_variable; // error: unresolved name `unknown_variable`
1073 Please verify that the name wasn't misspelled and ensure that the
1074 identifier being referred to is valid for the given situation. Example:
1077 enum something_that_does_exist {
1085 mod something_that_does_exist {
1086 pub static foo : i32 = 0i32;
1089 something_that_does_exist::foo; // ok!
1095 let unknown_variable = 12u32;
1096 let x = unknown_variable; // ok!
1099 If the item is not defined in the current module, it must be imported using a
1100 `use` statement, like so:
1103 # mod foo { pub fn bar() {} }
1110 If the item you are importing is not defined in some super-module of the
1111 current module, then it must also be declared as public (e.g., `pub fn`).
1115 An undeclared label was used.
1117 Erroneous code example:
1119 ```compile_fail,E0426
1121 break 'a; // error: use of undeclared label `'a`
1125 Please verify you spelt or declare the label correctly. Example:
1135 A type or module has been defined more than once.
1137 Erroneous code example:
1139 ```compile_fail,E0428
1141 struct Bar; // error: duplicate definition of value `Bar`
1144 Please verify you didn't misspell the type/module's name or remove/rename the
1145 duplicated one. Example:
1154 The `self` keyword cannot appear alone as the last segment in a `use`
1157 Erroneous code example:
1159 ```compile_fail,E0429
1160 use std::fmt::self; // error: `self` imports are only allowed within a { } list
1163 To use a namespace itself in addition to some of its members, `self` may appear
1164 as part of a brace-enclosed list of imports:
1167 use std::fmt::{self, Debug};
1170 If you only want to import the namespace, do so directly:
1178 The `self` import appears more than once in the list.
1180 Erroneous code example:
1182 ```compile_fail,E0430
1183 use something::{self, self}; // error: `self` import can only appear once in
1187 Please verify you didn't misspell the import name or remove the duplicated
1188 `self` import. Example:
1193 use something::{self}; // ok!
1199 An invalid `self` import was made.
1201 Erroneous code example:
1203 ```compile_fail,E0431
1204 use {self}; // error: `self` import can only appear in an import list with a
1208 You cannot import the current module into itself, please remove this import
1209 or verify you didn't misspell it.
1213 An import was unresolved.
1215 Erroneous code example:
1217 ```compile_fail,E0432
1218 use something::Foo; // error: unresolved import `something::Foo`.
1221 Paths in `use` statements are relative to the crate root. To import items
1222 relative to the current and parent modules, use the `self::` and `super::`
1223 prefixes, respectively. Also verify that you didn't misspell the import
1224 name and that the import exists in the module from where you tried to
1228 use self::something::Foo; // ok!
1236 Or, if you tried to use a module from an external crate, you may have missed
1237 the `extern crate` declaration (which is usually placed in the crate root):
1240 extern crate core; // Required to use the `core` crate
1248 An undeclared type or module was used.
1250 Erroneous code example:
1252 ```compile_fail,E0433
1253 let map = HashMap::new();
1254 // error: failed to resolve: use of undeclared type or module `HashMap`
1257 Please verify you didn't misspell the type/module's name or that you didn't
1258 forget to import it:
1262 use std::collections::HashMap; // HashMap has been imported.
1263 let map: HashMap<u32, u32> = HashMap::new(); // So it can be used!
1268 This error indicates that a variable usage inside an inner function is invalid
1269 because the variable comes from a dynamic environment. Inner functions do not
1270 have access to their containing environment.
1272 Erroneous code example:
1274 ```compile_fail,E0434
1278 y // error: can't capture dynamic environment in a fn item; use the
1279 // || { ... } closure form instead.
1284 Functions do not capture local variables. To fix this error, you can replace the
1285 function with a closure:
1296 or replace the captured variable with a constant or a static item:
1300 static mut X: u32 = 4;
1313 A non-constant value was used in a constant expression.
1315 Erroneous code example:
1317 ```compile_fail,E0435
1319 let a: [u8; foo]; // error: attempt to use a non-constant value in a constant
1322 To fix this error, please replace the value with a constant. Example:
1325 let a: [u8; 42]; // ok!
1331 const FOO: usize = 42;
1332 let a: [u8; FOO]; // ok!
1337 Trait implementations can only implement associated types that are members of
1338 the trait in question. This error indicates that you attempted to implement
1339 an associated type whose name does not match the name of any associated type
1342 Erroneous code example:
1344 ```compile_fail,E0437
1352 The solution to this problem is to remove the extraneous associated type:
1362 Trait implementations can only implement associated constants that are
1363 members of the trait in question. This error indicates that you
1364 attempted to implement an associated constant whose name does not
1365 match the name of any associated constant in the trait.
1367 Erroneous code example:
1369 ```compile_fail,E0438
1373 const BAR: bool = true;
1377 The solution to this problem is to remove the extraneous associated constant:
1387 Macro import declarations were malformed.
1389 Erroneous code examples:
1391 ```compile_fail,E0466
1392 #[macro_use(a_macro(another_macro))] // error: invalid import declaration
1393 extern crate core as some_crate;
1395 #[macro_use(i_want = "some_macros")] // error: invalid import declaration
1396 extern crate core as another_crate;
1399 This is a syntax error at the level of attribute declarations. The proper
1400 syntax for macro imports is the following:
1402 ```ignore (cannot-doctest-multicrate-project)
1405 macro_rules! get_tacos {
1410 macro_rules! get_pimientos {
1415 #[macro_use(get_tacos, get_pimientos)] // It imports `get_tacos` and
1416 extern crate some_crate; // `get_pimientos` macros from some_crate
1419 If you would like to import all exported macros, write `macro_use` with no
1424 A non-root module attempts to import macros from another crate.
1426 Example of erroneous code:
1428 ```compile_fail,E0468
1430 #[macro_use(debug_assert)] // error: must be at crate root to import
1431 extern crate core; // macros from another crate
1432 fn run_macro() { debug_assert!(true); }
1436 Only `extern crate` imports at the crate root level are allowed to import
1439 Either move the macro import to crate root or do without the foreign macros.
1443 #[macro_use(debug_assert)]
1447 fn run_macro() { debug_assert!(true); }
1454 A macro listed for import was not found.
1456 Erroneous code example:
1458 ```compile_fail,E0469
1459 #[macro_use(drink, be_merry)] // error: imported macro not found
1467 Either the listed macro is not contained in the imported crate, or it is not
1468 exported from the given crate.
1470 This could be caused by a typo. Did you misspell the macro's name?
1472 Double-check the names of the macros listed for import, and that the crate
1473 in question exports them.
1475 A working version would be:
1477 ```ignore (cannot-doctest-multicrate-project)
1478 // In some_crate crate:
1485 macro_rules! drink {
1490 #[macro_use(eat, drink)]
1491 extern crate some_crate; //ok!
1496 A binding shadowed something it shouldn't.
1498 Erroneous code example:
1500 ```compile_fail,E0530
1501 static TEST: i32 = 0;
1503 let r: (i32, i32) = (0, 0);
1505 TEST => {} // error: match bindings cannot shadow statics
1509 To fix this error, just change the binding's name in order to avoid shadowing
1510 one of the following:
1513 * struct/enum variant
1521 static TEST: i32 = 0;
1523 let r: (i32, i32) = (0, 0);
1525 something => {} // ok!
1531 Pattern arm did not match expected kind.
1533 Erroneous code example:
1535 ```compile_fail,E0532
1541 fn print_on_failure(state: &State) {
1543 // error: expected unit struct/variant or constant, found tuple
1544 // variant `State::Failed`
1545 State::Failed => println!("Failed"),
1551 To fix this error, ensure the match arm kind is the same as the expression
1562 fn print_on_failure(state: &State) {
1564 State::Failed(ref msg) => println!("Failed with {}", msg),
1572 A private item was used outside its scope.
1574 Erroneous code example:
1576 ```compile_fail,E0603
1578 const PRIVATE: u32 = 0x_a_bad_1dea_u32; // This const is private, so we
1579 // can't use it outside of the
1580 // `SomeModule` module.
1583 println!("const value: {}", SomeModule::PRIVATE); // error: constant `PRIVATE`
1587 In order to fix this error, you need to make the item public by using the `pub`
1592 pub const PRIVATE: u32 = 0x_a_bad_1dea_u32; // We set it public by using the
1596 println!("const value: {}", SomeModule::PRIVATE); // ok!
1601 An item usage is ambiguous.
1603 Erroneous code example:
1605 ```compile_fail,E0659
1620 collider::foo(); // ERROR: `foo` is ambiguous
1624 This error generally appears when two items with the same name are imported into
1625 a module. Here, the `foo` functions are imported and reexported from the
1626 `collider` module and therefore, when we're using `collider::foo()`, both
1629 To solve this error, the best solution is generally to keep the path before the
1630 item when using it. Example:
1647 collider::moon::foo(); // ok!
1648 collider::earth::foo(); // ok!
1655 register_diagnostics! {
1656 // E0153, unused error code
1657 // E0157, unused error code
1660 // E0402, // cannot use an outer type parameter in this context
1661 // E0406, merged into 420
1662 // E0410, merged into 408
1663 // E0413, merged into 530
1664 // E0414, merged into 530
1665 // E0417, merged into 532
1666 // E0418, merged into 532
1667 // E0419, merged into 531
1668 // E0420, merged into 532
1669 // E0421, merged into 531
1670 E0531, // unresolved pattern path kind `name`
1671 // E0427, merged into 530