1 // Copyright 2015 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 Constants can only be initialized by a constant value or, in a future
17 version of Rust, a call to a const function. This error indicates the use
18 of a path (like a::b, or x) denoting something other than one of these
19 allowed items. Erroneous code xample:
22 const FOO: i32 = { let x = 0; x }; // 'x' isn't a constant nor a function!
25 To avoid it, you have to replace the non-constant value:
28 const FOO: i32 = { const X : i32 = 0; X };
30 const FOO2: i32 = { 0 }; // but brackets are useless here
35 When matching against a range, the compiler verifies that the range is
36 non-empty. Range patterns include both end-points, so this is equivalent to
37 requiring the start of the range to be less than or equal to the end of the
44 // This range is ok, albeit pointless.
46 // This range is empty, and the compiler can tell.
53 You declared a pattern as an argument in a foreign function declaration.
54 Erroneous code example:
58 fn foo((a, b): (u32, u32)); // error: patterns aren't allowed in foreign
59 // function declarations
63 Please replace the pattern argument with a regular one. Example:
72 fn foo(s: SomeStruct); // ok!
80 fn foo(a: (u32, u32)); // ok!
86 A value was moved. However, its size was not known at compile time, and only
87 values of a known size can be moved.
89 Erroneous code example:
92 #![feature(box_syntax)]
95 let array: &[isize] = &[1, 2, 3];
96 let _x: Box<[isize]> = box *array;
97 // error: cannot move a value of type [isize]: the size of [isize] cannot
98 // be statically determined
102 In Rust, you can only move a value when its size is known at compile time.
104 To work around this restriction, consider "hiding" the value behind a reference:
105 either `&x` or `&mut x`. Since a reference has a fixed size, this lets you move
106 it around as usual. Example:
109 #![feature(box_syntax)]
112 let array: &[isize] = &[1, 2, 3];
113 let _x: Box<&[isize]> = box array; // ok!
119 This error indicates that a static or constant references itself.
120 All statics and constants need to resolve to a value in an acyclic manner.
122 For example, neither of the following can be sensibly compiled:
124 ```compile_fail,E0265
128 ```compile_fail,E0265
135 This error indicates the use of a loop keyword (`break` or `continue`) inside a
136 closure but outside of any loop. Erroneous code example:
138 ```compile_fail,E0267
139 let w = || { break; }; // error: `break` inside of a closure
142 `break` and `continue` keywords can be used as normal inside closures as long as
143 they are also contained within a loop. To halt the execution of a closure you
144 should instead use a return statement. Example:
158 This error indicates the use of a loop keyword (`break` or `continue`) outside
159 of a loop. Without a loop to break out of or continue in, no sensible action can
160 be taken. Erroneous code example:
162 ```compile_fail,E0268
164 break; // error: `break` outside of loop
168 Please verify that you are using `break` and `continue` only in loops. Example:
180 Trait methods cannot be declared `const` by design. For more information, see
183 [RFC 911]: https://github.com/rust-lang/rfcs/pull/911
187 A visibility qualifier was used when it was unnecessary. Erroneous code
197 pub impl Bar {} // error: unnecessary visibility qualifier
199 pub impl Foo for Bar { // error: unnecessary visibility qualifier
200 pub fn foo() {} // error: unnecessary visibility qualifier
204 To fix this error, please remove the visibility qualifier when it is not
214 // Directly implemented methods share the visibility of the type itself,
215 // so `pub` is unnecessary here
218 // Trait methods share the visibility of the trait, so `pub` is
219 // unnecessary in either case
220 pub impl Foo for Bar {
228 When matching against an exclusive range, the compiler verifies that the range
229 is non-empty. Exclusive range patterns include the start point but not the end
230 point, so this is equivalent to requiring the start of the range to be less
231 than the end of the range.
237 // This range is ok, albeit pointless.
239 // This range is empty, and the compiler can tell.
246 `break` or `continue` must include a label when used in the condition of a
249 Example of erroneous code:
255 To fix this, add a label specifying which loop is being broken out of:
257 `foo: while break `foo {}
262 register_diagnostics! {
263 E0226, // only a single explicit lifetime bound is permitted
264 E0472, // asm! is unsupported on this target
265 E0561, // patterns aren't allowed in function pointer types
266 E0571, // `break` with a value in a non-`loop`-loop