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
191 extern crate collections;
194 pub trait collections {
199 use foo::collections; // error: an extern crate named `collections` 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 collections as libcollections; // ok!
212 pub trait collections {
217 use foo::collections;
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 libc as std;
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 libc as other_name;
316 The name for an item declaration conflicts with an external crate's name.
318 Erroneous code example:
326 There are two possible solutions:
328 Solution #1: Rename the item.
336 Solution #2: Import the crate with a different name.
339 extern crate abc as xyz;
344 See the Declaration Statements section of the reference for more information
345 about what constitutes an Item declaration and what does not:
347 https://doc.rust-lang.org/reference.html#statements
351 Private items cannot be publicly re-exported. This error indicates that you
352 attempted to `pub use` a type or value that was not itself public.
354 Erroneous code example:
366 The solution to this problem is to ensure that the items that you are
367 re-exporting are themselves marked with `pub`:
371 pub const X: u32 = 1;
379 See the 'Use Declarations' section of the reference for more information on
382 https://doc.rust-lang.org/reference.html#use-declarations
386 Private modules cannot be publicly re-exported. This error indicates that you
387 attempted to `pub use` a module that was not itself public.
389 Erroneous code example:
391 ```compile_fail,E0365
393 pub const X: u32 = 1;
401 The solution to this problem is to ensure that the module that you are
402 re-exporting is itself marked with `pub`:
406 pub const X: u32 = 1;
414 See the 'Use Declarations' section of the reference for more information
417 https://doc.rust-lang.org/reference.html#use-declarations
421 Inner items do not inherit type parameters from the functions they are embedded
424 Erroneous code example:
426 ```compile_fail,E0401
428 fn bar(y: T) { // T is defined in the "outer" function
437 ```compile_fail,E0401
439 type MaybeT = Option<T>;
446 ```compile_fail,E0401
455 Items inside functions are basically just like top-level items, except
456 that they can only be used from the function they are in.
458 There are a couple of solutions for this.
460 If the item is a function, you may use a closure:
464 let bar = |y: T| { // explicit type annotation may not be necessary
471 For a generic item, you can copy over the parameters:
484 type MaybeT<T> = Option<T>;
488 Be sure to copy over any bounds as well:
491 fn foo<T: Copy>(x: T) {
492 fn bar<T: Copy>(y: T) {
500 fn foo<T: Copy>(x: T) {
501 struct Foo<T: Copy> {
507 This may require additional type hints in the function body.
509 In case the item is a function inside an `impl`, defining a private helper
510 function might be easier:
514 pub fn foo(&self, x: T) {
518 fn bar(&self, y: T) {
524 For default impls in traits, the private helper solution won't work, however
525 closures or copying the parameters should still work.
529 Some type parameters have the same name.
531 Erroneous code example:
533 ```compile_fail,E0403
534 fn foo<T, T>(s: T, u: T) {} // error: the name `T` is already used for a type
535 // parameter in this type parameter list
538 Please verify that none of the type parameterss are misspelled, and rename any
539 clashing parameters. Example:
542 fn foo<T, Y>(s: T, u: Y) {} // ok!
547 You tried to implement something which was not a trait on an object.
549 Erroneous code example:
551 ```compile_fail,E0404
555 impl Foo for Bar {} // error: `Foo` is not a trait
558 Please verify that you didn't misspell the trait's name or otherwise use the
559 wrong identifier. Example:
567 impl Foo for Bar { // ok!
568 // functions implementation
574 The code refers to a trait that is not in scope.
576 Erroneous code example:
578 ```compile_fail,E0405
581 impl SomeTrait for Foo {} // error: trait `SomeTrait` is not in scope
584 Please verify that the name of the trait wasn't misspelled and ensure that it
585 was imported. Example:
589 use some_file::SomeTrait;
598 impl SomeTrait for Foo { // ok!
599 // implements functions
605 A definition of a method not in the implemented trait was given in a trait
608 Erroneous code example:
610 ```compile_fail,E0407
619 fn b() {} // error: method `b` is not a member of trait `Foo`
623 Please verify you didn't misspell the method name and you used the correct
624 trait. First example:
660 An "or" pattern was used where the variable bindings are not consistently bound
663 Erroneous code example:
665 ```compile_fail,E0408
667 Some(y) | None => { /* use y */ } // error: variable `y` from pattern #1 is
668 // not bound in pattern #2
673 Here, `y` is bound to the contents of the `Some` and can be used within the
674 block corresponding to the match arm. However, in case `x` is `None`, we have
675 not specified what `y` is, and the block will use a nonexistent variable.
677 To fix this error, either split into multiple match arms:
682 Some(y) => { /* use y */ }
683 None => { /* ... */ }
687 or, bind the variable to a field of the same type in all sub-patterns of the
693 (0, y) | (y, 0) => { /* use y */}
698 In this example, if `x` matches the pattern `(0, _)`, the second field is set
699 to `y`. If it matches `(_, 0)`, the first field is set to `y`; so in all
700 cases `y` is set to some value.
704 An "or" pattern was used where the variable bindings are not consistently bound
707 Erroneous code example:
709 ```compile_fail,E0409
712 (0, ref y) | (y, 0) => { /* use y */} // error: variable `y` is bound with
713 // different mode in pattern #2
714 // than in pattern #1
719 Here, `y` is bound by-value in one case and by-reference in the other.
721 To fix this error, just use the same mode in both cases.
722 Generally using `ref` or `ref mut` where not already used will fix this:
727 (0, ref y) | (ref y, 0) => { /* use y */}
732 Alternatively, split the pattern:
737 (y, 0) => { /* use y */ }
738 (0, ref y) => { /* use y */}
745 The `Self` keyword was used outside an impl or a trait.
747 Erroneous code example:
749 ```compile_fail,E0411
750 <Self>::foo; // error: use of `Self` outside of an impl or trait
753 The `Self` keyword represents the current type, which explains why it can only
754 be used inside an impl or a trait. It gives access to the associated items of a
763 fn bar() -> Self::Bar; // like this
767 However, be careful when two types have a common associated type:
778 trait Baz : Foo + Foo2 {
779 fn bar() -> Self::Bar;
780 // error: ambiguous associated type `Bar` in bounds of `Self`
784 This problem can be solved by specifying from which trait we want to use the
796 trait Baz : Foo + Foo2 {
797 fn bar() -> <Self as Foo>::Bar; // ok!
803 The type name used is not in scope.
805 Erroneous code examples:
807 ```compile_fail,E0412
808 impl Something {} // error: type name `Something` is not in scope
813 fn bar(N); // error: type name `N` is not in scope
818 fn foo(x: T) {} // type name `T` is not in scope
821 To fix this error, please verify you didn't misspell the type name, you did
822 declare it or imported it into the scope. Examples:
827 impl Something {} // ok!
834 fn bar(Self::N); // ok!
839 fn foo<T>(x: T) {} // ok!
842 Another case that causes this error is when a type is imported into a parent
843 module. To fix this, you can follow the suggestion and use File directly or
844 `use super::File;` which will import the types from the parent namespace. An
845 example that causes this error is below:
847 ```compile_fail,E0412
851 fn some_function(f: File) {}
862 // use std::fs::File;
865 # fn main() {} // don't insert it for us; that'll break imports
870 More than one function parameter have the same name.
872 Erroneous code example:
874 ```compile_fail,E0415
875 fn foo(f: i32, f: i32) {} // error: identifier `f` is bound more than
876 // once in this parameter list
879 Please verify you didn't misspell parameters' name. Example:
882 fn foo(f: i32, g: i32) {} // ok!
887 An identifier is bound more than once in a pattern.
889 Erroneous code example:
891 ```compile_fail,E0416
893 (x, x) => {} // error: identifier `x` is bound more than once in the
898 Please verify you didn't misspell identifiers' name. Example:
906 Or maybe did you mean to unify? Consider using a guard:
910 (x, x2, see) if x == x2 => { /* A and B are equal, do one thing */ }
911 (y, z, see) => { /* A and B unequal; do another thing */ }
917 You are trying to use an identifier that is either undefined or not a struct.
918 Erroneous code example:
920 ```compile_fail,E0422
922 let x = Foo { x: 1, y: 2 };
926 In this case, `Foo` is undefined, so it inherently isn't anything, and
927 definitely not a struct.
932 let x = foo { x: 1, y: 2 };
936 In this case, `foo` is defined, but is not a struct, so Rust can't use it as
941 A `struct` variant name was used like a function name.
943 Erroneous code example:
945 ```compile_fail,E0423
946 struct Foo { a: bool };
949 // error: `Foo` is a struct variant name, but this expression uses
950 // it like a function name
953 Please verify you didn't misspell the name of what you actually wanted to use
957 fn Foo() -> u32 { 0 }
959 let f = Foo(); // ok!
964 The `self` keyword was used in a static method.
966 Erroneous code example:
968 ```compile_fail,E0424
975 self.bar(); // error: `self` is not available in a static method.
980 Please check if the method's argument list should have contained `self`,
981 `&self`, or `&mut self` (in case you didn't want to create a static
982 method), and add it if so. Example:
998 An unresolved name was used.
1000 Erroneous code examples:
1002 ```compile_fail,E0425
1003 something_that_doesnt_exist::foo;
1004 // error: unresolved name `something_that_doesnt_exist::foo`
1010 Self; // error: unresolved name `Self`
1016 let x = unknown_variable; // error: unresolved name `unknown_variable`
1019 Please verify that the name wasn't misspelled and ensure that the
1020 identifier being referred to is valid for the given situation. Example:
1023 enum something_that_does_exist {
1031 mod something_that_does_exist {
1032 pub static foo : i32 = 0i32;
1035 something_that_does_exist::foo; // ok!
1041 let unknown_variable = 12u32;
1042 let x = unknown_variable; // ok!
1045 If the item is not defined in the current module, it must be imported using a
1046 `use` statement, like so:
1053 If the item you are importing is not defined in some super-module of the
1054 current module, then it must also be declared as public (e.g., `pub fn`).
1058 An undeclared label was used.
1060 Erroneous code example:
1062 ```compile_fail,E0426
1064 break 'a; // error: use of undeclared label `'a`
1068 Please verify you spelt or declare the label correctly. Example:
1078 A type or module has been defined more than once.
1080 Erroneous code example:
1082 ```compile_fail,E0428
1084 struct Bar; // error: duplicate definition of value `Bar`
1087 Please verify you didn't misspell the type/module's name or remove/rename the
1088 duplicated one. Example:
1097 The `self` keyword cannot appear alone as the last segment in a `use`
1100 Erroneous code example:
1102 ```compile_fail,E0429
1103 use std::fmt::self; // error: `self` imports are only allowed within a { } list
1106 To use a namespace itself in addition to some of its members, `self` may appear
1107 as part of a brace-enclosed list of imports:
1110 use std::fmt::{self, Debug};
1113 If you only want to import the namespace, do so directly:
1121 The `self` import appears more than once in the list.
1123 Erroneous code example:
1125 ```compile_fail,E0430
1126 use something::{self, self}; // error: `self` import can only appear once in
1130 Please verify you didn't misspell the import name or remove the duplicated
1131 `self` import. Example:
1134 use something::self; // ok!
1139 An invalid `self` import was made.
1141 Erroneous code example:
1143 ```compile_fail,E0431
1144 use {self}; // error: `self` import can only appear in an import list with a
1148 You cannot import the current module into itself, please remove this import
1149 or verify you didn't misspell it.
1153 An import was unresolved.
1155 Erroneous code example:
1157 ```compile_fail,E0432
1158 use something::Foo; // error: unresolved import `something::Foo`.
1161 Paths in `use` statements are relative to the crate root. To import items
1162 relative to the current and parent modules, use the `self::` and `super::`
1163 prefixes, respectively. Also verify that you didn't misspell the import
1164 name and that the import exists in the module from where you tried to
1168 use self::something::Foo; // ok!
1175 Or, if you tried to use a module from an external crate, you may have missed
1176 the `extern crate` declaration (which is usually placed in the crate root):
1179 extern crate homura; // Required to use the `homura` crate
1186 An undeclared type or module was used.
1188 Erroneous code example:
1190 ```compile_fail,E0433
1191 let map = HashMap::new();
1192 // error: failed to resolve. Use of undeclared type or module `HashMap`
1195 Please verify you didn't misspell the type/module's name or that you didn't
1196 forgot to import it:
1200 use std::collections::HashMap; // HashMap has been imported.
1201 let map: HashMap<u32, u32> = HashMap::new(); // So it can be used!
1206 This error indicates that a variable usage inside an inner function is invalid
1207 because the variable comes from a dynamic environment. Inner functions do not
1208 have access to their containing environment.
1210 Erroneous code example:
1212 ```compile_fail,E0434
1216 y // error: can't capture dynamic environment in a fn item; use the
1217 // || { ... } closure form instead.
1222 Functions do not capture local variables. To fix this error, you can replace the
1223 function with a closure:
1234 or replace the captured variable with a constant or a static item:
1238 static mut X: u32 = 4;
1251 A non-constant value was used in a constant expression.
1253 Erroneous code example:
1255 ```compile_fail,E0435
1257 let a: [u8; foo]; // error: attempt to use a non-constant value in a constant
1260 To fix this error, please replace the value with a constant. Example:
1263 let a: [u8; 42]; // ok!
1269 const FOO: usize = 42;
1270 let a: [u8; FOO]; // ok!
1275 Trait implementations can only implement associated types that are members of
1276 the trait in question. This error indicates that you attempted to implement
1277 an associated type whose name does not match the name of any associated type
1280 Erroneous code example:
1282 ```compile_fail,E0437
1290 The solution to this problem is to remove the extraneous associated type:
1300 Trait implementations can only implement associated constants that are
1301 members of the trait in question. This error indicates that you
1302 attempted to implement an associated constant whose name does not
1303 match the name of any associated constant in the trait.
1305 Erroneous code example:
1307 ```compile_fail,E0438
1308 #![feature(associated_consts)]
1313 const BAR: bool = true;
1317 The solution to this problem is to remove the extraneous associated constant:
1327 Macro import declarations were malformed.
1329 Erroneous code examples:
1331 ```compile_fail,E0466
1332 #[macro_use(a_macro(another_macro))] // error: invalid import declaration
1333 extern crate core as some_crate;
1335 #[macro_use(i_want = "some_macros")] // error: invalid import declaration
1336 extern crate core as another_crate;
1339 This is a syntax error at the level of attribute declarations. The proper
1340 syntax for macro imports is the following:
1345 macro_rules! get_tacos {
1350 macro_rules! get_pimientos {
1355 #[macro_use(get_tacos, get_pimientos)] // It imports `get_tacos` and
1356 extern crate some_crate; // `get_pimientos` macros from some_crate
1359 If you would like to import all exported macros, write `macro_use` with no
1364 Macro reexport declarations were empty or malformed.
1366 Erroneous code examples:
1368 ```compile_fail,E0467
1369 #[macro_reexport] // error: no macros listed for export
1370 extern crate core as macros_for_good;
1372 #[macro_reexport(fun_macro = "foo")] // error: not a macro identifier
1373 extern crate core as other_macros_for_good;
1376 This is a syntax error at the level of attribute declarations.
1378 Currently, `macro_reexport` requires at least one macro name to be listed.
1379 Unlike `macro_use`, listing no names does not reexport all macros from the
1382 Decide which macros you would like to export and list them properly.
1384 These are proper reexport declarations:
1387 #[macro_reexport(some_macro, another_macro)]
1388 extern crate macros_for_good;
1393 A non-root module attempts to import macros from another crate.
1395 Example of erroneous code:
1397 ```compile_fail,E0468
1399 #[macro_use(helpful_macro)] // error: must be at crate root to import
1400 extern crate core; // macros from another crate
1401 helpful_macro!(...);
1405 Only `extern crate` imports at the crate root level are allowed to import
1408 Either move the macro import to crate root or do without the foreign macros.
1412 #[macro_use(helpful_macro)]
1413 extern crate some_crate;
1422 A macro listed for import was not found.
1424 Erroneous code example:
1426 ```compile_fail,E0469
1427 #[macro_use(drink, be_merry)] // error: imported macro not found
1428 extern crate collections;
1435 Either the listed macro is not contained in the imported crate, or it is not
1436 exported from the given crate.
1438 This could be caused by a typo. Did you misspell the macro's name?
1440 Double-check the names of the macros listed for import, and that the crate
1441 in question exports them.
1443 A working version would be:
1446 // In some_crate crate:
1453 macro_rules! drink {
1458 #[macro_use(eat, drink)]
1459 extern crate some_crate; //ok!
1464 A macro listed for reexport was not found.
1466 Erroneous code example:
1468 ```compile_fail,E0470
1469 #[macro_reexport(drink, be_merry)]
1470 extern crate collections;
1477 Either the listed macro is not contained in the imported crate, or it is not
1478 exported from the given crate.
1480 This could be caused by a typo. Did you misspell the macro's name?
1482 Double-check the names of the macros listed for reexport, and that the crate
1483 in question exports them.
1488 // In some_crate crate:
1495 macro_rules! drink {
1500 #[macro_reexport(eat, drink)]
1501 extern crate some_crate;
1506 A binding shadowed something it shouldn't.
1508 Erroneous code example:
1510 ```compile_fail,E0530
1511 static TEST: i32 = 0;
1513 let r: (i32, i32) = (0, 0);
1515 TEST => {} // error: match bindings cannot shadow statics
1519 To fix this error, just change the binding's name in order to avoid shadowing
1520 one of the following:
1523 * struct/enum variant
1531 static TEST: i32 = 0;
1533 let r: (i32, i32) = (0, 0);
1535 something => {} // ok!
1541 Pattern arm did not match expected kind.
1543 Erroneous code example:
1545 ```compile_fail,E0532
1551 fn print_on_failure(state: &State) {
1553 // error: expected unit struct/variant or constant, found tuple
1554 // variant `State::Failed`
1555 State::Failed => println!("Failed"),
1561 To fix this error, ensure the match arm kind is the same as the expression
1572 fn print_on_failure(state: &State) {
1574 State::Failed(ref msg) => println!("Failed with {}", msg),
1583 register_diagnostics! {
1584 // E0153, unused error code
1585 // E0157, unused error code
1588 // E0402, // cannot use an outer type parameter in this context
1589 // E0406, merged into 420
1590 // E0410, merged into 408
1591 // E0413, merged into 530
1592 // E0414, merged into 530
1593 // E0417, merged into 532
1594 // E0418, merged into 532
1595 // E0419, merged into 531
1596 // E0420, merged into 532
1597 // E0421, merged into 531
1598 E0531, // unresolved pattern path kind `name`
1599 // E0427, merged into 530