1 syntax::register_diagnostics! {
4 Constants can only be initialized by a constant value or, in a future
5 version of Rust, a call to a const function. This error indicates the use
6 of a path (like a::b, or x) denoting something other than one of these
7 allowed items. Erroneous code xample:
10 const FOO: i32 = { let x = 0; x }; // 'x' isn't a constant nor a function!
13 To avoid it, you have to replace the non-constant value:
16 const FOO: i32 = { const X : i32 = 0; X };
18 const FOO2: i32 = { 0 }; // but brackets are useless here
24 You declared a pattern as an argument in a foreign function declaration.
25 Erroneous code example:
29 fn foo((a, b): (u32, u32)); // error: patterns aren't allowed in foreign
30 // function declarations
34 Please replace the pattern argument with a regular one. Example:
43 fn foo(s: SomeStruct); // ok!
51 fn foo(a: (u32, u32)); // ok!
56 // This shouldn't really ever trigger since the repeated value error comes first
58 A binary can only have one entry point, and by default that entry point is the
59 function `main()`. If there are multiple such functions, please rename one.
63 More than one function was declared with the `#[main]` attribute.
65 Erroneous code example:
74 fn f() {} // error: multiple functions with a `#[main]` attribute
77 This error indicates that the compiler found multiple functions with the
78 `#[main]` attribute. This is an error because there must be a unique entry
79 point into a Rust program. Example:
90 More than one function was declared with the `#[start]` attribute.
92 Erroneous code example:
98 fn foo(argc: isize, argv: *const *const u8) -> isize {}
101 fn f(argc: isize, argv: *const *const u8) -> isize {}
102 // error: multiple 'start' functions
105 This error indicates that the compiler found multiple functions with the
106 `#[start]` attribute. This is an error because there must be a unique entry
107 point into a Rust program. Example:
113 fn foo(argc: isize, argv: *const *const u8) -> isize { 0 } // ok!
118 Inherent implementations (one that do not implement a trait but provide
119 methods associated with a type) are always safe because they are not
120 implementing an unsafe trait. Removing the `unsafe` keyword from the inherent
121 implementation will resolve this error.
123 ```compile_fail,E0197
126 // this will cause this error
128 // converting it to this will fix it
134 A negative implementation is one that excludes a type from implementing a
135 particular trait. Not being able to use a trait is always a safe operation,
136 so negative implementations are always safe and never need to be marked as
140 #![feature(optin_builtin_traits)]
144 // unsafe is unnecessary
145 unsafe impl !Clone for Foo { }
150 ```ignore (ignore auto_trait future compatibility warning)
151 #![feature(optin_builtin_traits)]
155 auto trait Enterprise {}
157 impl !Enterprise for Foo { }
160 Please note that negative impls are only allowed for auto traits.
164 This error indicates the use of a loop keyword (`break` or `continue`) inside a
165 closure but outside of any loop. Erroneous code example:
167 ```compile_fail,E0267
168 let w = || { break; }; // error: `break` inside of a closure
171 `break` and `continue` keywords can be used as normal inside closures as long as
172 they are also contained within a loop. To halt the execution of a closure you
173 should instead use a return statement. Example:
187 This error indicates the use of a loop keyword (`break` or `continue`) outside
188 of a loop. Without a loop to break out of or continue in, no sensible action can
189 be taken. Erroneous code example:
191 ```compile_fail,E0268
193 break; // error: `break` outside of a loop
197 Please verify that you are using `break` and `continue` only in loops. Example:
209 Trait methods cannot be declared `const` by design. For more information, see
212 [RFC 911]: https://github.com/rust-lang/rfcs/pull/911
216 Auto traits cannot have methods or associated items.
217 For more information see the [opt-in builtin traits RFC][RFC 19].
219 [RFC 19]: https://github.com/rust-lang/rfcs/blob/master/text/0019-opt-in-builtin-traits.md
223 A visibility qualifier was used when it was unnecessary. Erroneous code
226 ```compile_fail,E0449
233 pub impl Bar {} // error: unnecessary visibility qualifier
235 pub impl Foo for Bar { // error: unnecessary visibility qualifier
236 pub fn foo() {} // error: unnecessary visibility qualifier
240 To fix this error, please remove the visibility qualifier when it is not
250 // Directly implemented methods share the visibility of the type itself,
251 // so `pub` is unnecessary here
254 // Trait methods share the visibility of the trait, so `pub` is
255 // unnecessary in either case
263 Transmute with two differently sized types was attempted. Erroneous code
266 ```compile_fail,E0512
267 fn takes_u8(_: u8) {}
270 unsafe { takes_u8(::std::mem::transmute(0u16)); }
271 // error: cannot transmute between types of different sizes,
272 // or dependently-sized types
276 Please use types with same size or use the expected type directly. Example:
279 fn takes_u8(_: u8) {}
282 unsafe { takes_u8(::std::mem::transmute(0i8)); } // ok!
284 unsafe { takes_u8(0u8); } // ok!
290 A `break` statement with an argument appeared in a non-`loop` loop.
292 Example of erroneous code:
294 ```compile_fail,E0571
296 # fn satisfied(n: usize) -> bool { n % 23 == 0 }
297 let result = while true {
299 break 2*i; // error: `break` with value from a `while` loop
305 The `break` statement can take an argument (which will be the value of the loop
306 expression if the `break` statement is executed) in `loop` loops, but not
307 `for`, `while`, or `while let` loops.
309 Make sure `break value;` statements only occur in `loop` loops:
313 # fn satisfied(n: usize) -> bool { n % 23 == 0 }
314 let result = loop { // ok!
324 `break` or `continue` must include a label when used in the condition of a
327 Example of erroneous code:
333 To fix this, add a label specifying which loop is being broken out of:
335 'foo: while break 'foo {}
340 Per [RFC 401][rfc401], if you have a function declaration `foo`:
343 // For the purposes of this explanation, all of these
344 // different kinds of `fn` declarations are equivalent:
346 fn foo(x: S) { /* ... */ }
347 # #[cfg(for_demonstration_only)]
348 extern "C" { fn foo(x: S); }
349 # #[cfg(for_demonstration_only)]
350 impl S { fn foo(self) { /* ... */ } }
353 the type of `foo` is **not** `fn(S)`, as one might expect.
354 Rather, it is a unique, zero-sized marker type written here as `typeof(foo)`.
355 However, `typeof(foo)` can be _coerced_ to a function pointer `fn(S)`,
356 so you rarely notice this:
361 let x: fn(S) = foo; // OK, coerces
364 The reason that this matter is that the type `fn(S)` is not specific to
365 any particular function: it's a function _pointer_. So calling `x()` results
366 in a virtual call, whereas `foo()` is statically dispatched, because the type
367 of `foo` tells us precisely what function is being called.
369 As noted above, coercions mean that most code doesn't have to be
370 concerned with this distinction. However, you can tell the difference
371 when using **transmute** to convert a fn item into a fn pointer.
373 This is sometimes done as part of an FFI:
375 ```compile_fail,E0591
376 extern "C" fn foo(userdata: Box<i32>) {
380 # fn callback(_: extern "C" fn(*mut i32)) {}
381 # use std::mem::transmute;
383 let f: extern "C" fn(*mut i32) = transmute(foo);
388 Here, transmute is being used to convert the types of the fn arguments.
389 This pattern is incorrect because, because the type of `foo` is a function
390 **item** (`typeof(foo)`), which is zero-sized, and the target type (`fn()`)
391 is a function pointer, which is not zero-sized.
392 This pattern should be rewritten. There are a few possible ways to do this:
394 - change the original fn declaration to match the expected signature,
395 and do the cast in the fn body (the preferred option)
396 - cast the fn item fo a fn pointer before calling transmute, as shown here:
399 # extern "C" fn foo(_: Box<i32>) {}
400 # use std::mem::transmute;
402 let f: extern "C" fn(*mut i32) = transmute(foo as extern "C" fn(_));
403 let f: extern "C" fn(*mut i32) = transmute(foo as usize); // works too
407 The same applies to transmutes to `*mut fn()`, which were observed in practice.
408 Note though that use of this type is generally incorrect.
409 The intention is typically to describe a function pointer, but just `fn()`
410 alone suffices for that. `*mut fn()` is a pointer to a fn pointer.
411 (Since these values are typically just passed to C code, however, this rarely
412 makes a difference in practice.)
414 [rfc401]: https://github.com/rust-lang/rfcs/blob/master/text/0401-coercions.md
418 No `main` function was found in a binary crate. To fix this error, add a
419 `main` function. For example:
423 // Your program will start here.
424 println!("Hello world!");
428 If you don't know the basics of Rust, you can go look to the Rust Book to get
429 started: https://doc.rust-lang.org/book/
433 Trait methods currently cannot take patterns as arguments.
435 Example of erroneous code:
437 ```compile_fail,E0642
439 fn foo((x, y): (i32, i32)); // error: patterns aren't allowed
444 You can instead use a single name for the argument:
448 fn foo(x_and_y: (i32, i32)); // ok!
454 A `break` statement without a label appeared inside a labeled block.
456 Example of erroneous code:
458 ```compile_fail,E0695
459 # #![feature(label_break_value)]
467 Make sure to always label the `break`:
470 # #![feature(label_break_value)]
478 Or if you want to `break` the labeled block:
481 # #![feature(label_break_value)]
492 Rust 2015 does not permit the use of `async fn`.
494 Example of erroneous code:
496 ```compile_fail,E0670
500 Switch to the Rust 2018 edition to use `async fn`.
504 E0226, // only a single explicit lifetime bound is permitted
505 E0472, // asm! is unsupported on this target
506 E0561, // patterns aren't allowed in function pointer types
507 E0567, // auto traits can not have generic parameters
508 E0568, // auto traits can not have super traits
509 E0666, // nested `impl Trait` is illegal
510 E0667, // `impl Trait` in projections
511 E0696, // `continue` pointing to a labeled block
512 E0706, // `async fn` in trait