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 A visibility qualifier was used when it was unnecessary. Erroneous code
190 pub impl Bar {} // error: unnecessary visibility qualifier
192 pub impl Foo for Bar { // error: unnecessary visibility qualifier
193 pub fn foo() {} // error: unnecessary visibility qualifier
197 To fix this error, please remove the visibility qualifier when it is not
207 // Directly implemented methods share the visibility of the type itself,
208 // so `pub` is unnecessary here
211 // Trait methods share the visibility of the trait, so `pub` is
212 // unnecessary in either case
213 pub impl Foo for Bar {
221 register_diagnostics! {
222 E0472, // asm! is unsupported on this target
223 E0561, // patterns aren't allowed in function pointer types