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 Imports (`use` statements) are not allowed after non-item statements, such as
20 variable declarations and expression statements.
22 Here is an example that demonstrates the error:
26 // Variable declaration before import
33 The solution is to declare the imports at the top of the block, function, or
36 Here is the previous example again, with the correct order:
46 See the Declaration Statements section of the reference for more information
47 about what constitutes an Item declaration and what does not:
49 https://doc.rust-lang.org/reference.html#statements
53 Two items of the same name cannot be imported without rebinding one of the
54 items under a new local name.
56 An example of this error:
60 use bar::*; // error, do `use foo::baz as quux` instead on the previous line
75 Two items of the same name cannot be imported without rebinding one of the
76 items under a new local name.
78 An example of this error:
82 use bar::baz; // error, do `use bar::baz as quux` instead
97 Attempt was made to import an unimportable value. This can happen when
98 trying to import a method from a trait. An example of this error:
106 use foo::MyTrait::do_something;
109 It's invalid to directly import methods belonging to a trait or concrete type.
113 You can't import a value whose name is the same as another value defined in the
116 An example of this error:
119 use bar::foo; // error, do `use bar::foo as baz` instead
132 You can't import a type or module when the name of the item being imported is
133 the same as another type or submodule defined in the module.
135 An example of this error:
138 use foo::Bar; // error
151 The name chosen for an external crate conflicts with another external crate that
152 has been imported into the current module.
158 extern crate crate_a as a;
161 The solution is to choose a different name that doesn't conflict with any
162 external crate imported into the current module.
168 extern crate crate_a as other_name;
173 The name for an item declaration conflicts with an external crate's name.
183 There are two possible solutions:
185 Solution #1: Rename the item.
193 Solution #2: Import the crate with a different name.
196 extern crate abc as xyz;
201 See the Declaration Statements section of the reference for more information
202 about what constitutes an Item declaration and what does not:
204 https://doc.rust-lang.org/reference.html#statements
208 User-defined types or type parameters cannot shadow the primitive types.
209 This error indicates you tried to define a type, struct or enum with the same
210 name as an existing primitive type.
212 See the Types section of the reference for more information about the primitive
215 https://doc.rust-lang.org/reference.html#types
219 Private items cannot be publicly re-exported. This error indicates that
220 you attempted to `pub use` a type or value that was not itself public.
222 Here is an example that demonstrates the error:
231 The solution to this problem is to ensure that the items that you are
232 re-exporting are themselves marked with `pub`:
236 pub const X: u32 = 1;
241 See the 'Use Declarations' section of the reference for more information
244 https://doc.rust-lang.org/reference.html#use-declarations
248 Private modules cannot be publicly re-exported. This error indicates
249 that you attempted to `pub use` a module that was not itself public.
251 Here is an example that demonstrates the error:
255 pub const X: u32 = 1;
260 The solution to this problem is to ensure that the module that you are
261 re-exporting is itself marked with `pub`:
265 pub const X: u32 = 1;
270 See the 'Use Declarations' section of the reference for more information
273 https://doc.rust-lang.org/reference.html#use-declarations
277 Inner functions do not inherit type parameters from the functions they are
278 embedded in. For example, this will not compile:
282 fn bar(y: T) { // T is defined in the "outer" function
289 Functions inside functions are basically just like top-level functions, except
290 that they can only be called from the function they are in.
292 There are a couple of solutions for this.
294 You can use a closure:
298 let bar = |y: T| { // explicit type annotation may not be necessary
305 or copy over the parameters:
316 Be sure to copy over any bounds as well:
319 fn foo<T: Copy>(x: T) {
320 fn bar<T: Copy>(y: T) {
327 This may require additional type hints in the function body.
329 In case the function is in an `impl`, defining a private helper function might
334 pub fn foo(&self, x: T) {
337 fn bar(&self, y: T) {
343 For default impls in traits, the private helper solution won't work, however
344 closures or copying the parameters should still work.
348 Some type parameters have the same name. Example of erroneous code:
351 fn foo<T, T>(s: T, u: T) {} // error: the name `T` is already used for a type
352 // parameter in this type parameter list
355 Please verify that none of the type parameterss are misspelled, and rename any
356 clashing parameters. Example:
359 fn foo<T, Y>(s: T, u: Y) {} // ok!
364 You tried to implement something which was not a trait on an object. Example of
371 impl Foo for Bar {} // error: `Foo` is not a trait
374 Please verify that you didn't misspell the trait's name or otherwise use the
375 wrong identifier. Example:
383 impl Foo for Bar { // ok!
384 // functions implementation
390 An unknown trait was implemented. Example of erroneous code:
395 impl SomeTrait for Foo {} // error: use of undeclared trait name `SomeTrait`
398 Please verify that the name of the trait wasn't misspelled and ensure that it
399 was imported. Example:
403 use some_file::SomeTrait;
412 impl SomeTrait for Foo { // ok!
413 // implements functions
419 A definition of a method not in the implemented trait was given in a trait
420 implementation. Example of erroneous code:
431 fn b() {} // error: method `b` is not a member of trait `Foo`
435 Please verify you didn't misspell the method name and you used the correct
436 trait. First example:
472 The `Self` keyword was used outside an impl or a trait. Erroneous
476 <Self>::foo; // error: use of `Self` outside of an impl or trait
479 The `Self` keyword represents the current type, which explains why it
480 can only be used inside an impl or a trait. It gives access to the
481 associated items of a type:
489 fn bar() -> Self::Bar; // like this
493 However, be careful when two types has a common associated type:
504 trait Baz : Foo + Foo2 {
505 fn bar() -> Self::Bar;
506 // error: ambiguous associated type `Bar` in bounds of `Self`
510 This problem can be solved by specifying from which trait we want
511 to use the `Bar` type:
514 trait Baz : Foo + Foo2 {
515 fn bar() -> <Self as Foo>::Bar; // ok!
521 An undeclared type name was used. Example of erroneous codes:
524 impl Something {} // error: use of undeclared type name `Something`
527 fn bar(N); // error: use of undeclared type name `N`
530 fn foo(x: T) {} // error: use of undeclared type name `T`
533 To fix this error, please verify you didn't misspell the type name,
534 you did declare it or imported it into the scope. Examples:
539 impl Something {} // ok!
544 fn bar(Self::N); // ok!
547 fn foo<T>(x: T) {} // ok!
552 A declaration shadows an enum variant or unit-like struct in scope.
553 Example of erroneous code:
558 let Foo = 12i32; // error: declaration of `Foo` shadows an enum variant or
559 // unit-like struct in scope
563 To fix this error, rename the variable such that it doesn't shadow any enum
564 variable or structure in scope. Example:
569 let foo = 12i32; // ok!
577 let Foo = 12i32; // ok!
580 The goal here is to avoid a conflict of names.
584 More than one function parameter have the same name. Example of erroneous
588 fn foo(f: i32, f: i32) {} // error: identifier `f` is bound more than
589 // once in this parameter list
592 Please verify you didn't misspell parameters' name. Example:
595 fn foo(f: i32, g: i32) {} // ok!
600 An identifier is bound more than once in a pattern. Example of erroneous
605 (x, x) => {} // error: identifier `x` is bound more than once in the
610 Please verify you didn't misspell identifiers' name. Example:
618 Or maybe did you mean to unify? Consider using a guard:
622 (x, x2, see) if x == x2 => { /* A and B are equal, do one thing */ }
623 (y, z, see) => { /* A and B unequal; do another thing */ }
629 A static variable was referenced in a pattern. Example of erroneous code:
632 static FOO : i32 = 0;
635 FOO => {} // error: static variables cannot be referenced in a
636 // pattern, use a `const` instead
641 The compiler needs to know the value of the pattern at compile time;
642 compile-time patterns can defined via const or enum items. Please verify
643 that the identifier is spelled correctly, and if so, use a const instead
644 of static to define it. Example:
657 An unknown enum variant, struct or const was used. Example of
662 Something::Foo => {} // error: unresolved enum variant, struct
667 Please verify you didn't misspell it and the enum variant, struct or const has
668 been declared and imported into scope. Example:
676 match Something::NotFoo {
677 Something::Foo => {} // ok!
684 You are trying to use an identifier that is either undefined or not a
685 struct. For instance:
688 let x = Foo { x: 1, y: 2 };
692 In this case, `Foo` is undefined, so it inherently isn't anything, and
693 definitely not a struct.
698 let x = foo { x: 1, y: 2 };
702 In this case, `foo` is defined, but is not a struct, so Rust can't use
707 A `struct` variant name was used like a function name. Example of
711 struct Foo { a: bool};
714 // error: `Foo` is a struct variant name, but this expression uses
715 // it like a function name
718 Please verify you didn't misspell the name of what you actually wanted
719 to use here. Example:
722 fn Foo() -> u32 { 0 }
724 let f = Foo(); // ok!
729 The `self` keyword was used in a static method. Example of erroneous code:
738 self.bar(); // error: `self` is not available in a static method.
743 Please check if the method's argument list should have contained `self`,
744 `&self`, or `&mut self` (in case you didn't want to create a static
745 method), and add it if so. Example:
761 An unresolved name was used. Example of erroneous codes:
764 something_that_doesnt_exist::foo;
765 // error: unresolved name `something_that_doesnt_exist::foo`
770 Self; // error: unresolved name `Self`
775 let x = unknown_variable; // error: unresolved name `unknown_variable`
778 Please verify that the name wasn't misspelled and ensure that the
779 identifier being referred to is valid for the given situation. Example:
782 enum something_that_does_exist {
787 mod something_that_does_exist {
788 pub static foo : i32 = 0i32;
791 something_that_does_exist::foo; // ok!
794 let unknown_variable = 12u32;
795 let x = unknown_variable; // ok!
800 An undeclared label was used. Example of erroneous code:
804 break 'a; // error: use of undeclared label `'a`
808 Please verify you spelt or declare the label correctly. Example:
818 A type or module has been defined more than once. Example of erroneous
823 struct Bar; // error: duplicate definition of value `Bar`
826 Please verify you didn't misspell the type/module's name or remove/rename the
827 duplicated one. Example:
836 The `self` import appears more than once in the list. Erroneous code example:
839 use something::{self, self}; // error: `self` import can only appear once in
843 Please verify you didn't misspell the import name or remove the duplicated
844 `self` import. Example:
847 use something::self; // ok!
852 `self` import was made. Erroneous code example:
855 use {self}; // error: `self` import can only appear in an import list with a
859 You cannot import the current module into itself, please remove this import
860 or verify you didn't misspell it.
864 An import was unresolved. Erroneous code example:
867 use something::Foo; // error: unresolved import `something::Foo`.
870 Please verify you didn't misspell the import name or the import does exist
871 in the module from where you tried to import it. Example:
874 use something::Foo; // ok!
881 Or, if you tried to use a module from an external crate, you may have missed
882 the `extern crate` declaration:
885 extern crate homura; // Required to use the `homura` crate
892 Invalid import. Example of erroneous code:
895 use something_which_doesnt_exist;
896 // error: unresolved import `something_which_doesnt_exist`
899 Please verify you didn't misspell the import's name.
903 A non-constant value was used to initialise a constant. Example of erroneous
908 const FOO : u32 = foo; // error: attempt to use a non-constant value in a
912 To fix this error, please replace the value with a constant. Example:
915 const FOO : u32 = 42u32; // ok!
918 const OTHER_FOO : u32 = 42u32;
919 const FOO : u32 = OTHER_FOO; // ok!
924 Trait implementations can only implement associated types that are members of
925 the trait in question. This error indicates that you attempted to implement
926 an associated type whose name does not match the name of any associated type
929 Here is an example that demonstrates the error:
939 The solution to this problem is to remove the extraneous associated type:
949 Trait implementations can only implement associated constants that are
950 members of the trait in question. This error indicates that you
951 attempted to implement an associated constant whose name does not
952 match the name of any associated constant in the trait.
954 Here is an example that demonstrates the error:
957 #![feature(associated_consts)]
962 const BAR: bool = true;
966 The solution to this problem is to remove the extraneous associated constant:
977 register_diagnostics
! {
978 // E0153, unused error code
979 // E0157, unused error code
980 E0254
, // import conflicts with imported crate in this module
983 E0402
, // cannot use an outer type parameter in this context
984 E0406
, // undeclared associated type
985 E0408
, // variable from pattern #1 is not bound in pattern #
986 E0409
, // variable is bound with different mode in pattern # than in
988 E0410
, // variable from pattern is not bound in pattern 1
989 E0414
, // only irrefutable patterns allowed here
990 E0418
, // is not an enum variant, struct or const
991 E0420
, // is not an associated const
992 E0421
, // unresolved associated const
993 E0427
, // cannot use `ref` binding mode with ...
994 E0429
, // `self` imports are only allowed within a { } list
995 E0434
, // can't capture dynamic environment in a fn item