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! {
17 #### Note: this error code is no longer emitted by the compiler.
19 This error suggests that the expression arm corresponding to the noted pattern
20 will never be reached as for all possible values of the expression being
21 matched, one of the preceding patterns will match.
23 This means that perhaps some of the preceding patterns are too general, this
24 one is too specific or the ordering is incorrect.
26 For example, the following `match` block has too many arms:
30 Some(bar) => {/* ... */}
31 x => {/* ... */} // This handles the `None` case
32 _ => {/* ... */} // All possible cases have already been handled
36 `match` blocks have their patterns matched in order, so, for example, putting
37 a wildcard arm above a more specific arm will make the latter arm irrelevant.
39 Ensure the ordering of the match arm is correct and remove any superfluous
44 #### Note: this error code is no longer emitted by the compiler.
46 This error indicates that an empty match expression is invalid because the type
47 it is matching on is non-empty (there exist values of this type). In safe code
48 it is impossible to create an instance of an empty type, so empty match
49 expressions are almost never desired. This error is typically fixed by adding
50 one or more cases to the match expression.
52 An example of an empty type is `enum Empty { }`. So, the following will work:
67 fn foo(x: Option<String>) {
76 This error indicates that the compiler cannot guarantee a matching pattern for
77 one or more possible inputs to a match expression. Guaranteed matches are
78 required in order to assign values to match expressions, or alternatively,
79 determine the flow of execution. Erroneous code example:
87 let x = Terminator::HastaLaVistaBaby;
89 match x { // error: non-exhaustive patterns: `HastaLaVistaBaby` not covered
90 Terminator::TalkToMyHand => {}
94 If you encounter this error you must alter your patterns so that every possible
95 value of the input type is matched. For types with a small number of variants
96 (like enums) you should probably cover all cases explicitly. Alternatively, the
97 underscore `_` wildcard pattern can be added after all other patterns to match
98 "anything else". Example:
106 let x = Terminator::HastaLaVistaBaby;
109 Terminator::TalkToMyHand => {}
110 Terminator::HastaLaVistaBaby => {}
116 Terminator::TalkToMyHand => {}
123 Patterns used to bind names must be irrefutable, that is, they must guarantee
124 that a name will be extracted in all cases. Erroneous code example:
126 ```compile_fail,E0005
129 // error: refutable pattern in local binding: `None` not covered
132 If you encounter this error you probably need to use a `match` or `if let` to
133 deal with the possibility of failure. Example:
154 This error indicates that the bindings in a match arm would require a value to
155 be moved into more than one location, thus violating unique ownership. Code
156 like the following is invalid as it requires the entire `Option<String>` to be
157 moved into a variable called `op_string` while simultaneously requiring the
158 inner `String` to be moved into a variable called `s`.
160 ```compile_fail,E0007
161 let x = Some("s".to_string());
164 op_string @ Some(s) => {}, // error: cannot bind by-move with sub-bindings
169 See also the error E0303.
173 Names bound in match arms retain their type in pattern guards. As such, if a
174 name is bound by move in a pattern, it should also be moved to wherever it is
175 referenced in the pattern guard code. Doing so however would prevent the name
176 from being available in the body of the match arm. Consider the following:
178 ```compile_fail,E0008
179 match Some("hi".to_string()) {
180 Some(s) if s.len() == 0 => {}, // use s.
185 The variable `s` has type `String`, and its use in the guard is as a variable of
186 type `String`. The guard code effectively executes in a separate scope to the
187 body of the arm, so the value would be moved into this anonymous scope and
188 therefore becomes unavailable in the body of the arm.
190 The problem above can be solved by using the `ref` keyword.
193 match Some("hi".to_string()) {
194 Some(ref s) if s.len() == 0 => {},
199 Though this example seems innocuous and easy to solve, the problem becomes clear
200 when it encounters functions which consume the value:
202 ```compile_fail,E0008
206 fn consume(self) -> usize {
214 Some(y) if y.consume() > 0 => {}
220 In this situation, even the `ref` keyword cannot solve it, since borrowed
221 content cannot be moved. This problem cannot be solved generally. If the value
222 can be cloned, here is a not-so-specific solution:
229 fn consume(self) -> usize {
237 Some(ref y) if y.clone().consume() > 0 => {}
243 If the value will be consumed in the pattern guard, using its clone will not
244 move its ownership, so the code works.
248 In a pattern, all values that don't implement the `Copy` trait have to be bound
249 the same way. The goal here is to avoid binding simultaneously by-move and
252 This limitation may be removed in a future version of Rust.
254 Erroneous code example:
256 ```compile_fail,E0009
259 let x = Some((X { x: () }, X { x: () }));
261 Some((y, ref z)) => {}, // error: cannot bind by-move and by-ref in the
267 You have two solutions:
269 Solution #1: Bind the pattern's values the same way.
274 let x = Some((X { x: () }, X { x: () }));
276 Some((ref y, ref z)) => {},
277 // or Some((y, z)) => {}
282 Solution #2: Implement the `Copy` trait for the `X` structure.
284 However, please keep in mind that the first solution should be preferred.
287 #[derive(Clone, Copy)]
290 let x = Some((X { x: () }, X { x: () }));
292 Some((y, ref z)) => {},
299 When matching against a range, the compiler verifies that the range is
300 non-empty. Range patterns include both end-points, so this is equivalent to
301 requiring the start of the range to be less than or equal to the end of the
308 // This range is ok, albeit pointless.
310 // This range is empty, and the compiler can tell.
317 `const` and `static` mean different things. A `const` is a compile-time
318 constant, an alias for a literal value. This property means you can match it
319 directly within a pattern.
321 The `static` keyword, on the other hand, guarantees a fixed location in memory.
322 This does not always mean that the value is constant. For example, a global
323 mutex can be declared `static` as well.
325 If you want to match against a `static`, consider using a guard instead:
328 static FORTY_TWO: i32 = 42;
331 Some(x) if x == FORTY_TWO => {}
338 An if-let pattern attempts to match the pattern, and enters the body if the
339 match was successful. If the match is irrefutable (when it cannot fail to
340 match), use a regular `let`-binding instead. For instance:
342 ```compile_fail,E0162
343 struct Irrefutable(i32);
344 let irr = Irrefutable(0);
346 // This fails to compile because the match is irrefutable.
347 if let Irrefutable(x) = irr {
348 // This body will always be executed.
356 struct Irrefutable(i32);
357 let irr = Irrefutable(0);
359 let Irrefutable(x) = irr;
365 A while-let pattern attempts to match the pattern, and enters the body if the
366 match was successful. If the match is irrefutable (when it cannot fail to
367 match), use a regular `let`-binding inside a `loop` instead. For instance:
369 ```compile_fail,E0165
370 struct Irrefutable(i32);
371 let irr = Irrefutable(0);
373 // This fails to compile because the match is irrefutable.
374 while let Irrefutable(x) = irr {
382 struct Irrefutable(i32);
383 let irr = Irrefutable(0);
386 let Irrefutable(x) = irr;
393 Enum variants are qualified by default. For example, given this type:
402 You would match it using:
418 If you don't qualify the names, the code will bind new variables named "GET" and
419 "POST" instead. This behavior is likely not what you want, so `rustc` warns when
422 Qualified names are good practice, and most code works well with them. But if
423 you prefer them unqualified, you can import the variants into scope:
427 enum Method { GET, POST }
431 If you want others to be able to import variants from your module directly, use
436 pub enum Method { GET, POST }
443 #### Note: this error code is no longer emitted by the compiler.
445 Patterns used to bind names must be irrefutable. That is, they must guarantee
446 that a name will be extracted in all cases. Instead of pattern matching the
447 loop variable, consider using a `match` or `if let` inside the loop body. For
450 ```compile_fail,E0005
451 let xs : Vec<Option<i32>> = vec![Some(1), None];
453 // This fails because `None` is not covered.
459 Match inside the loop instead:
462 let xs : Vec<Option<i32>> = vec![Some(1), None];
475 let xs : Vec<Option<i32>> = vec![Some(1), None];
478 if let Some(x) = item {
486 Mutable borrows are not allowed in pattern guards, because matching cannot have
487 side effects. Side effects could alter the matched object or the environment
488 on which the match depends in such a way, that the match would not be
489 exhaustive. For instance, the following would not match any arm if mutable
490 borrows were allowed:
492 ```compile_fail,E0301
495 option if option.take().is_none() => {
496 /* impossible, option is `Some` */
498 Some(_) => { } // When the previous match failed, the option became `None`.
504 Assignments are not allowed in pattern guards, because matching cannot have
505 side effects. Side effects could alter the matched object or the environment
506 on which the match depends in such a way, that the match would not be
507 exhaustive. For instance, the following would not match any arm if assignments
510 ```compile_fail,E0302
513 option if { option = None; false } => { },
514 Some(_) => { } // When the previous match failed, the option became `None`.
520 In certain cases it is possible for sub-bindings to violate memory safety.
521 Updates to the borrow checker in a future version of Rust may remove this
522 restriction, but for now patterns must be rewritten without sub-bindings.
526 ```compile_fail,E0303
527 match Some("hi".to_string()) {
528 ref op_string_ref @ Some(s) => {},
536 match Some("hi".to_string()) {
538 let op_string_ref = &Some(s);
545 The `op_string_ref` binding has type `&Option<&String>` in both cases.
547 See also https://github.com/rust-lang/rust/issues/14587
551 The value of statics and constants must be known at compile time, and they live
552 for the entire lifetime of a program. Creating a boxed value allocates memory on
553 the heap at runtime, and therefore cannot be done at compile time. Erroneous
556 ```compile_fail,E0010
557 #![feature(box_syntax)]
559 const CON : Box<i32> = box 0;
564 Static and const variables can refer to other const variables. But a const
565 variable cannot refer to a static variable. For example, `Y` cannot refer to
568 ```compile_fail,E0013
573 To fix this, the value can be extracted as a const and then used:
582 // FIXME(#24111) Change the language here when const fn stabilizes
584 The only functions that can be called in static or constant expressions are
585 `const` functions, and struct/enum constructors. `const` functions are only
586 available on a nightly compiler. Rust currently does not support more general
587 compile-time function execution.
590 const FOO: Option<u8> = Some(1); // enum constructor
592 const BAR: Bar = Bar {x: 1}; // struct constructor
595 See [RFC 911] for more details on the design of `const fn`s.
597 [RFC 911]: https://github.com/rust-lang/rfcs/blob/master/text/0911-const-fn.md
601 References in statics and constants may only refer to immutable values.
602 Erroneous code example:
604 ```compile_fail,E0017
608 // these three are not allowed:
609 const CR: &'static mut i32 = &mut C;
610 static STATIC_REF: &'static mut i32 = &mut X;
611 static CONST_REF: &'static mut i32 = &mut C;
614 Statics are shared everywhere, and if they refer to mutable data one might
615 violate memory safety since holding multiple mutable references to shared data
618 If you really want global mutable state, try using `static mut` or a global
623 A function call isn't allowed in the const's initialization expression
624 because the expression's value must be known at compile-time. Erroneous code
633 fn test(&self) -> i32 {
639 const FOO: Test = Test::V1;
641 const A: i32 = FOO.test(); // You can't call Test::func() here!
645 Remember: you can't use a function call inside a const's initialization
646 expression! However, you can totally use it anywhere else:
654 fn func(&self) -> i32 {
660 const FOO: Test = Test::V1;
662 FOO.func(); // here is good
663 let x = FOO.func(); // or even here!
669 Unsafe code was used outside of an unsafe function or block.
671 Erroneous code example:
673 ```compile_fail,E0133
674 unsafe fn f() { return; } // This is the unsafe code
677 f(); // error: call to unsafe function requires unsafe function or block
681 Using unsafe functionality is potentially dangerous and disallowed by safety
684 * Dereferencing raw pointers
685 * Calling functions via FFI
686 * Calling functions marked unsafe
688 These safety checks can be relaxed for a section of the code by wrapping the
689 unsafe instructions with an `unsafe` block. For instance:
692 unsafe fn f() { return; }
695 unsafe { f(); } // ok!
699 See also https://doc.rust-lang.org/book/first-edition/unsafe.html
703 This error occurs when an attempt is made to use data captured by a closure,
704 when that data may no longer exist. It's most commonly seen when attempting to
707 ```compile_fail,E0373
708 fn foo() -> Box<Fn(u32) -> u32> {
714 Notice that `x` is stack-allocated by `foo()`. By default, Rust captures
715 closed-over data by reference. This means that once `foo()` returns, `x` no
716 longer exists. An attempt to access `x` within the closure would thus be
719 Another situation where this might be encountered is when spawning threads:
721 ```compile_fail,E0373
726 let thr = std::thread::spawn(|| {
732 Since our new thread runs in parallel, the stack frame containing `x` and `y`
733 may well have disappeared by the time we try to use them. Even if we call
734 `thr.join()` within foo (which blocks until `thr` has completed, ensuring the
735 stack frame won't disappear), we will not succeed: the compiler cannot prove
736 that this behaviour is safe, and so won't let us do it.
738 The solution to this problem is usually to switch to using a `move` closure.
739 This approach moves (or copies, where possible) data into the closure, rather
740 than taking references to it. For example:
743 fn foo() -> Box<Fn(u32) -> u32> {
745 Box::new(move |y| x + y)
749 Now that the closure has its own copy of the data, there's no need to worry
754 It is not allowed to use or capture an uninitialized variable. For example:
756 ```compile_fail,E0381
759 let y = x; // error, use of possibly uninitialized variable
763 To fix this, ensure that any declared variables are initialized before being
775 This error occurs when an attempt is made to use a variable after its contents
776 have been moved elsewhere. For example:
778 ```compile_fail,E0382
779 struct MyStruct { s: u32 }
782 let mut x = MyStruct{ s: 5u32 };
789 Since `MyStruct` is a type that is not marked `Copy`, the data gets moved out
790 of `x` when we set `y`. This is fundamental to Rust's ownership system: outside
791 of workarounds like `Rc`, a value cannot be owned by more than one variable.
793 Sometimes we don't need to move the value. Using a reference, we can let another
794 function borrow the value without changing its ownership. In the example below,
795 we don't actually have to move our string to `calculate_length`, we can give it
796 a reference to it with `&` instead.
800 let s1 = String::from("hello");
802 let len = calculate_length(&s1);
804 println!("The length of '{}' is {}.", s1, len);
807 fn calculate_length(s: &String) -> usize {
812 A mutable reference can be created with `&mut`.
814 Sometimes we don't want a reference, but a duplicate. All types marked `Clone`
815 can be duplicated by calling `.clone()`. Subsequent changes to a clone do not
816 affect the original variable.
818 Most types in the standard library are marked `Clone`. The example below
819 demonstrates using `clone()` on a string. `s1` is first set to "many", and then
820 copied to `s2`. Then the first character of `s1` is removed, without affecting
821 `s2`. "any many" is printed to the console.
825 let mut s1 = String::from("many");
828 println!("{} {}", s1, s2);
832 If we control the definition of a type, we can implement `Clone` on it ourselves
833 with `#[derive(Clone)]`.
835 Some types have no ownership semantics at all and are trivial to duplicate. An
836 example is `i32` and the other number types. We don't have to call `.clone()` to
837 clone them, because they are marked `Copy` in addition to `Clone`. Implicit
838 cloning is more convenient in this case. We can mark our own types `Copy` if
839 all their members also are marked `Copy`.
841 In the example below, we implement a `Point` type. Because it only stores two
842 integers, we opt-out of ownership semantics with `Copy`. Then we can
843 `let p2 = p1` without `p1` being moved.
846 #[derive(Copy, Clone)]
847 struct Point { x: i32, y: i32 }
850 let mut p1 = Point{ x: -1, y: 2 };
853 println!("p1: {}, {}", p1.x, p1.y);
854 println!("p2: {}, {}", p2.x, p2.y);
858 Alternatively, if we don't control the struct's definition, or mutable shared
859 ownership is truly required, we can use `Rc` and `RefCell`:
862 use std::cell::RefCell;
865 struct MyStruct { s: u32 }
868 let mut x = Rc::new(RefCell::new(MyStruct{ s: 5u32 }));
870 x.borrow_mut().s = 6;
871 println!("{}", x.borrow().s);
875 With this approach, x and y share ownership of the data via the `Rc` (reference
876 count type). `RefCell` essentially performs runtime borrow checking: ensuring
877 that at most one writer or multiple readers can access the data at any one time.
879 If you wish to learn more about ownership in Rust, start with the chapter in the
882 https://doc.rust-lang.org/book/first-edition/ownership.html
886 This error occurs when an attempt is made to partially reinitialize a
887 structure that is currently uninitialized.
889 For example, this can happen when a drop has taken place:
891 ```compile_fail,E0383
896 fn drop(&mut self) { /* ... */ }
899 let mut x = Foo { a: 1 };
900 drop(x); // `x` is now uninitialized
901 x.a = 2; // error, partial reinitialization of uninitialized structure `t`
904 This error can be fixed by fully reinitializing the structure in question:
911 fn drop(&mut self) { /* ... */ }
914 let mut x = Foo { a: 1 };
921 This error occurs when an attempt is made to reassign an immutable variable.
924 ```compile_fail,E0384
927 x = 5; // error, reassignment of immutable variable
931 By default, variables in Rust are immutable. To fix this error, add the keyword
932 `mut` after the keyword `let` when declaring the variable. For example:
943 This error occurs when an attempt is made to mutate the target of a mutable
944 reference stored inside an immutable container.
946 For example, this can happen when storing a `&mut` inside an immutable `Box`:
948 ```compile_fail,E0386
950 let y: Box<_> = Box::new(&mut x);
951 **y = 2; // error, cannot assign to data in an immutable container
954 This error can be fixed by making the container mutable:
958 let mut y: Box<_> = Box::new(&mut x);
962 It can also be fixed by using a type with interior mutability, such as `Cell`
969 let y: Box<Cell<_>> = Box::new(Cell::new(x));
975 This error occurs when an attempt is made to mutate or mutably reference data
976 that a closure has captured immutably. Examples of this error are shown below:
978 ```compile_fail,E0387
979 // Accepts a function or a closure that captures its environment immutably.
980 // Closures passed to foo will not be able to mutate their closed-over state.
981 fn foo<F: Fn()>(f: F) { }
983 // Attempts to mutate closed-over data. Error message reads:
984 // `cannot assign to data in a captured outer variable...`
990 // Attempts to take a mutable reference to closed-over data. Error message
991 // reads: `cannot borrow data mutably in a captured outer variable...`
994 foo(|| { let y = &mut x; });
998 The problem here is that foo is defined as accepting a parameter of type `Fn`.
999 Closures passed into foo will thus be inferred to be of type `Fn`, meaning that
1000 they capture their context immutably.
1002 If the definition of `foo` is under your control, the simplest solution is to
1003 capture the data mutably. This can be done by defining `foo` to take FnMut
1007 fn foo<F: FnMut()>(f: F) { }
1010 Alternatively, we can consider using the `Cell` and `RefCell` types to achieve
1011 interior mutability through a shared reference. Our example's `mutable`
1012 function could be redefined as below:
1015 use std::cell::Cell;
1017 fn foo<F: Fn()>(f: F) { }
1020 let x = Cell::new(0u32);
1025 You can read more about cell types in the API documentation:
1027 https://doc.rust-lang.org/std/cell/
1031 E0388 was removed and is no longer issued.
1035 An attempt was made to mutate data using a non-mutable reference. This
1036 commonly occurs when attempting to assign to a non-mutable reference of a
1037 mutable reference (`&(&mut T)`).
1039 Example of erroneous code:
1041 ```compile_fail,E0389
1047 let mut fancy = FancyNum{ num: 5 };
1048 let fancy_ref = &(&mut fancy);
1049 fancy_ref.num = 6; // error: cannot assign to data in a `&` reference
1050 println!("{}", fancy_ref.num);
1054 Here, `&mut fancy` is mutable, but `&(&mut fancy)` is not. Creating an
1055 immutable reference to a value borrows it immutably. There can be multiple
1056 references of type `&(&mut T)` that point to the same value, so they must be
1057 immutable to prevent multiple mutable references to the same value.
1059 To fix this, either remove the outer reference:
1067 let mut fancy = FancyNum{ num: 5 };
1069 let fancy_ref = &mut fancy;
1070 // `fancy_ref` is now &mut FancyNum, rather than &(&mut FancyNum)
1072 fancy_ref.num = 6; // No error!
1074 println!("{}", fancy_ref.num);
1078 Or make the outer reference mutable:
1086 let mut fancy = FancyNum{ num: 5 };
1088 let fancy_ref = &mut (&mut fancy);
1089 // `fancy_ref` is now &mut(&mut FancyNum), rather than &(&mut FancyNum)
1091 fancy_ref.num = 6; // No error!
1093 println!("{}", fancy_ref.num);
1099 A value was moved. However, its size was not known at compile time, and only
1100 values of a known size can be moved.
1102 Erroneous code example:
1105 #![feature(box_syntax)]
1108 let array: &[isize] = &[1, 2, 3];
1109 let _x: Box<[isize]> = box *array;
1110 // error: cannot move a value of type [isize]: the size of [isize] cannot
1111 // be statically determined
1115 In Rust, you can only move a value when its size is known at compile time.
1117 To work around this restriction, consider "hiding" the value behind a reference:
1118 either `&x` or `&mut x`. Since a reference has a fixed size, this lets you move
1119 it around as usual. Example:
1122 #![feature(box_syntax)]
1125 let array: &[isize] = &[1, 2, 3];
1126 let _x: Box<&[isize]> = box array; // ok!
1132 A borrow of a constant containing interior mutability was attempted. Erroneous
1135 ```compile_fail,E0492
1136 use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT};
1138 const A: AtomicUsize = ATOMIC_USIZE_INIT;
1139 static B: &'static AtomicUsize = &A;
1140 // error: cannot borrow a constant which may contain interior mutability,
1141 // create a static instead
1144 A `const` represents a constant value that should never change. If one takes
1145 a `&` reference to the constant, then one is taking a pointer to some memory
1146 location containing the value. Normally this is perfectly fine: most values
1147 can't be changed via a shared `&` pointer, but interior mutability would allow
1148 it. That is, a constant value could be mutated. On the other hand, a `static` is
1149 explicitly a single memory location, which can be mutated at will.
1151 So, in order to solve this error, either use statics which are `Sync`:
1154 use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT};
1156 static A: AtomicUsize = ATOMIC_USIZE_INIT;
1157 static B: &'static AtomicUsize = &A; // ok!
1160 You can also have this error while using a cell type:
1162 ```compile_fail,E0492
1163 use std::cell::Cell;
1165 const A: Cell<usize> = Cell::new(1);
1166 const B: &'static Cell<usize> = &A;
1167 // error: cannot borrow a constant which may contain interior mutability,
1168 // create a static instead
1171 struct C { a: Cell<usize> }
1173 const D: C = C { a: Cell::new(1) };
1174 const E: &'static Cell<usize> = &D.a; // error
1177 const F: &'static C = &D; // error
1180 This is because cell types do operations that are not thread-safe. Due to this,
1181 they don't implement Sync and thus can't be placed in statics.
1183 However, if you still wish to use these types, you can achieve this by an unsafe
1187 use std::cell::Cell;
1188 use std::marker::Sync;
1190 struct NotThreadSafe<T> {
1194 unsafe impl<T> Sync for NotThreadSafe<T> {}
1196 static A: NotThreadSafe<usize> = NotThreadSafe { value : Cell::new(1) };
1197 static B: &'static NotThreadSafe<usize> = &A; // ok!
1200 Remember this solution is unsafe! You will have to ensure that accesses to the
1201 cell are synchronized.
1205 A variable was borrowed as mutable more than once. Erroneous code example:
1207 ```compile_fail,E0499
1211 // error: cannot borrow `i` as mutable more than once at a time
1214 Please note that in rust, you can either have many immutable references, or one
1215 mutable reference. Take a look at
1216 https://doc.rust-lang.org/stable/book/references-and-borrowing.html for more
1217 information. Example:
1222 let mut x = &mut i; // ok!
1227 let b = &i; // still ok!
1228 let c = &i; // still ok!
1233 A borrowed variable was used in another closure. Example of erroneous code:
1236 fn you_know_nothing(jon_snow: &mut i32) {
1237 let nights_watch = || {
1241 *jon_snow = 3; // error: closure requires unique access to `jon_snow`
1242 // but it is already borrowed
1247 In here, `jon_snow` is already borrowed by the `nights_watch` closure, so it
1248 cannot be borrowed by the `starks` closure at the same time. To fix this issue,
1249 you can put the closure in its own scope:
1252 fn you_know_nothing(jon_snow: &mut i32) {
1254 let nights_watch = || {
1257 } // At this point, `jon_snow` is free.
1264 Or, if the type implements the `Clone` trait, you can clone it between
1268 fn you_know_nothing(jon_snow: &mut i32) {
1269 let mut jon_copy = jon_snow.clone();
1270 let nights_watch = || {
1281 This error indicates that a mutable variable is being used while it is still
1282 captured by a closure. Because the closure has borrowed the variable, it is not
1283 available for use until the closure goes out of scope.
1285 Note that a capture will either move or borrow a variable, but in this
1286 situation, the closure is borrowing the variable. Take a look at
1287 http://rustbyexample.com/fn/closures/capture.html for more information about
1290 Example of erroneous code:
1292 ```compile_fail,E0501
1293 fn inside_closure(x: &mut i32) {
1294 // Actions which require unique access
1297 fn outside_closure(x: &mut i32) {
1298 // Actions which require unique access
1301 fn foo(a: &mut i32) {
1305 outside_closure(a); // error: cannot borrow `*a` as mutable because previous
1306 // closure requires unique access.
1310 To fix this error, you can place the closure in its own scope:
1313 fn inside_closure(x: &mut i32) {}
1314 fn outside_closure(x: &mut i32) {}
1316 fn foo(a: &mut i32) {
1321 } // borrow on `a` ends.
1322 outside_closure(a); // ok!
1326 Or you can pass the variable as a parameter to the closure:
1329 fn inside_closure(x: &mut i32) {}
1330 fn outside_closure(x: &mut i32) {}
1332 fn foo(a: &mut i32) {
1333 let bar = |s: &mut i32| {
1341 It may be possible to define the closure later:
1344 fn inside_closure(x: &mut i32) {}
1345 fn outside_closure(x: &mut i32) {}
1347 fn foo(a: &mut i32) {
1357 This error indicates that you are trying to borrow a variable as mutable when it
1358 has already been borrowed as immutable.
1360 Example of erroneous code:
1362 ```compile_fail,E0502
1363 fn bar(x: &mut i32) {}
1364 fn foo(a: &mut i32) {
1365 let ref y = a; // a is borrowed as immutable.
1366 bar(a); // error: cannot borrow `*a` as mutable because `a` is also borrowed
1371 To fix this error, ensure that you don't have any other references to the
1372 variable before trying to access it mutably:
1375 fn bar(x: &mut i32) {}
1376 fn foo(a: &mut i32) {
1378 let ref y = a; // ok!
1382 For more information on the rust ownership system, take a look at
1383 https://doc.rust-lang.org/stable/book/references-and-borrowing.html.
1387 A value was used after it was mutably borrowed.
1389 Example of erroneous code:
1391 ```compile_fail,E0503
1394 // Create a mutable borrow of `value`. This borrow
1395 // lives until the end of this function.
1396 let _borrow = &mut value;
1397 let _sum = value + 1; // error: cannot use `value` because
1398 // it was mutably borrowed
1402 In this example, `value` is mutably borrowed by `borrow` and cannot be
1403 used to calculate `sum`. This is not possible because this would violate
1404 Rust's mutability rules.
1406 You can fix this error by limiting the scope of the borrow:
1411 // By creating a new block, you can limit the scope
1412 // of the reference.
1414 let _borrow = &mut value; // Use `_borrow` inside this block.
1416 // The block has ended and with it the borrow.
1417 // You can now use `value` again.
1418 let _sum = value + 1;
1422 Or by cloning `value` before borrowing it:
1427 // We clone `value`, creating a copy.
1428 let value_cloned = value.clone();
1429 // The mutable borrow is a reference to `value` and
1430 // not to `value_cloned`...
1431 let _borrow = &mut value;
1432 // ... which means we can still use `value_cloned`,
1433 let _sum = value_cloned + 1;
1434 // even though the borrow only ends here.
1438 You can find more information about borrowing in the rust-book:
1439 http://doc.rust-lang.org/stable/book/references-and-borrowing.html
1443 This error occurs when an attempt is made to move a borrowed variable into a
1446 Example of erroneous code:
1448 ```compile_fail,E0504
1454 let fancy_num = FancyNum { num: 5 };
1455 let fancy_ref = &fancy_num;
1458 println!("child function: {}", fancy_num.num);
1459 // error: cannot move `fancy_num` into closure because it is borrowed
1463 println!("main function: {}", fancy_ref.num);
1467 Here, `fancy_num` is borrowed by `fancy_ref` and so cannot be moved into
1468 the closure `x`. There is no way to move a value into a closure while it is
1469 borrowed, as that would invalidate the borrow.
1471 If the closure can't outlive the value being moved, try using a reference
1480 let fancy_num = FancyNum { num: 5 };
1481 let fancy_ref = &fancy_num;
1484 // fancy_ref is usable here because it doesn't move `fancy_num`
1485 println!("child function: {}", fancy_ref.num);
1490 println!("main function: {}", fancy_num.num);
1494 If the value has to be borrowed and then moved, try limiting the lifetime of
1495 the borrow using a scoped block:
1503 let fancy_num = FancyNum { num: 5 };
1506 let fancy_ref = &fancy_num;
1507 println!("main function: {}", fancy_ref.num);
1508 // `fancy_ref` goes out of scope here
1512 // `fancy_num` can be moved now (no more references exist)
1513 println!("child function: {}", fancy_num.num);
1520 If the lifetime of a reference isn't enough, such as in the case of threading,
1521 consider using an `Arc` to create a reference-counted value:
1532 let fancy_ref1 = Arc::new(FancyNum { num: 5 });
1533 let fancy_ref2 = fancy_ref1.clone();
1535 let x = thread::spawn(move || {
1536 // `fancy_ref1` can be moved and has a `'static` lifetime
1537 println!("child thread: {}", fancy_ref1.num);
1540 x.join().expect("child thread should finish");
1541 println!("main thread: {}", fancy_ref2.num);
1547 A value was moved out while it was still borrowed.
1549 Erroneous code example:
1551 ```compile_fail,E0505
1554 fn eat(val: Value) {}
1559 let _ref_to_val: &Value = &x;
1565 Here, the function `eat` takes the ownership of `x`. However,
1566 `x` cannot be moved because it was borrowed to `_ref_to_val`.
1567 To fix that you can do few different things:
1569 * Try to avoid moving the variable.
1570 * Release borrow before move.
1571 * Implement the `Copy` trait on the type.
1578 fn eat(val: &Value) {}
1583 let _ref_to_val: &Value = &x;
1584 eat(&x); // pass by reference, if it's possible
1594 fn eat(val: Value) {}
1599 let _ref_to_val: &Value = &x;
1601 eat(x); // release borrow and then move it.
1608 #[derive(Clone, Copy)] // implement Copy trait
1611 fn eat(val: Value) {}
1616 let _ref_to_val: &Value = &x;
1617 eat(x); // it will be copied here.
1622 You can find more information about borrowing in the rust-book:
1623 http://doc.rust-lang.org/stable/book/references-and-borrowing.html
1627 This error occurs when an attempt is made to assign to a borrowed value.
1629 Example of erroneous code:
1631 ```compile_fail,E0506
1637 let mut fancy_num = FancyNum { num: 5 };
1638 let fancy_ref = &fancy_num;
1639 fancy_num = FancyNum { num: 6 };
1640 // error: cannot assign to `fancy_num` because it is borrowed
1642 println!("Num: {}, Ref: {}", fancy_num.num, fancy_ref.num);
1646 Because `fancy_ref` still holds a reference to `fancy_num`, `fancy_num` can't
1647 be assigned to a new value as it would invalidate the reference.
1649 Alternatively, we can move out of `fancy_num` into a second `fancy_num`:
1657 let mut fancy_num = FancyNum { num: 5 };
1658 let moved_num = fancy_num;
1659 fancy_num = FancyNum { num: 6 };
1661 println!("Num: {}, Moved num: {}", fancy_num.num, moved_num.num);
1665 If the value has to be borrowed, try limiting the lifetime of the borrow using
1674 let mut fancy_num = FancyNum { num: 5 };
1677 let fancy_ref = &fancy_num;
1678 println!("Ref: {}", fancy_ref.num);
1681 // Works because `fancy_ref` is no longer in scope
1682 fancy_num = FancyNum { num: 6 };
1683 println!("Num: {}", fancy_num.num);
1687 Or by moving the reference into a function:
1695 let mut fancy_num = FancyNum { num: 5 };
1697 print_fancy_ref(&fancy_num);
1699 // Works because function borrow has ended
1700 fancy_num = FancyNum { num: 6 };
1701 println!("Num: {}", fancy_num.num);
1704 fn print_fancy_ref(fancy_ref: &FancyNum){
1705 println!("Ref: {}", fancy_ref.num);
1711 You tried to move out of a value which was borrowed. Erroneous code example:
1713 ```compile_fail,E0507
1714 use std::cell::RefCell;
1716 struct TheDarkKnight;
1718 impl TheDarkKnight {
1719 fn nothing_is_true(self) {}
1723 let x = RefCell::new(TheDarkKnight);
1725 x.borrow().nothing_is_true(); // error: cannot move out of borrowed content
1729 Here, the `nothing_is_true` method takes the ownership of `self`. However,
1730 `self` cannot be moved because `.borrow()` only provides an `&TheDarkKnight`,
1731 which is a borrow of the content owned by the `RefCell`. To fix this error,
1732 you have three choices:
1734 * Try to avoid moving the variable.
1735 * Somehow reclaim the ownership.
1736 * Implement the `Copy` trait on the type.
1741 use std::cell::RefCell;
1743 struct TheDarkKnight;
1745 impl TheDarkKnight {
1746 fn nothing_is_true(&self) {} // First case, we don't take ownership
1750 let x = RefCell::new(TheDarkKnight);
1752 x.borrow().nothing_is_true(); // ok!
1759 use std::cell::RefCell;
1761 struct TheDarkKnight;
1763 impl TheDarkKnight {
1764 fn nothing_is_true(self) {}
1768 let x = RefCell::new(TheDarkKnight);
1769 let x = x.into_inner(); // we get back ownership
1771 x.nothing_is_true(); // ok!
1778 use std::cell::RefCell;
1780 #[derive(Clone, Copy)] // we implement the Copy trait
1781 struct TheDarkKnight;
1783 impl TheDarkKnight {
1784 fn nothing_is_true(self) {}
1788 let x = RefCell::new(TheDarkKnight);
1790 x.borrow().nothing_is_true(); // ok!
1794 Moving a member out of a mutably borrowed struct will also cause E0507 error:
1796 ```compile_fail,E0507
1797 struct TheDarkKnight;
1799 impl TheDarkKnight {
1800 fn nothing_is_true(self) {}
1804 knight: TheDarkKnight
1808 let mut cave = Batcave {
1809 knight: TheDarkKnight
1811 let borrowed = &mut cave;
1813 borrowed.knight.nothing_is_true(); // E0507
1817 It is fine only if you put something back. `mem::replace` can be used for that:
1820 # struct TheDarkKnight;
1821 # impl TheDarkKnight { fn nothing_is_true(self) {} }
1822 # struct Batcave { knight: TheDarkKnight }
1825 let mut cave = Batcave {
1826 knight: TheDarkKnight
1828 let borrowed = &mut cave;
1830 mem::replace(&mut borrowed.knight, TheDarkKnight).nothing_is_true(); // ok!
1833 You can find more information about borrowing in the rust-book:
1834 http://doc.rust-lang.org/book/first-edition/references-and-borrowing.html
1838 A value was moved out of a non-copy fixed-size array.
1840 Example of erroneous code:
1842 ```compile_fail,E0508
1846 let array = [NonCopy; 1];
1847 let _value = array[0]; // error: cannot move out of type `[NonCopy; 1]`,
1848 // a non-copy fixed-size array
1852 The first element was moved out of the array, but this is not
1853 possible because `NonCopy` does not implement the `Copy` trait.
1855 Consider borrowing the element instead of moving it:
1861 let array = [NonCopy; 1];
1862 let _value = &array[0]; // Borrowing is allowed, unlike moving.
1866 Alternatively, if your type implements `Clone` and you need to own the value,
1867 consider borrowing and then cloning:
1874 let array = [NonCopy; 1];
1875 // Now you can clone the array element.
1876 let _value = array[0].clone();
1882 This error occurs when an attempt is made to move out of a value whose type
1883 implements the `Drop` trait.
1885 Example of erroneous code:
1887 ```compile_fail,E0509
1896 impl Drop for DropStruct {
1897 fn drop(&mut self) {
1898 // Destruct DropStruct, possibly using FancyNum
1903 let drop_struct = DropStruct{fancy: FancyNum{num: 5}};
1904 let fancy_field = drop_struct.fancy; // Error E0509
1905 println!("Fancy: {}", fancy_field.num);
1906 // implicit call to `drop_struct.drop()` as drop_struct goes out of scope
1910 Here, we tried to move a field out of a struct of type `DropStruct` which
1911 implements the `Drop` trait. However, a struct cannot be dropped if one or
1912 more of its fields have been moved.
1914 Structs implementing the `Drop` trait have an implicit destructor that gets
1915 called when they go out of scope. This destructor may use the fields of the
1916 struct, so moving out of the struct could make it impossible to run the
1917 destructor. Therefore, we must think of all values whose type implements the
1918 `Drop` trait as single units whose fields cannot be moved.
1920 This error can be fixed by creating a reference to the fields of a struct,
1921 enum, or tuple using the `ref` keyword:
1932 impl Drop for DropStruct {
1933 fn drop(&mut self) {
1934 // Destruct DropStruct, possibly using FancyNum
1939 let drop_struct = DropStruct{fancy: FancyNum{num: 5}};
1940 let ref fancy_field = drop_struct.fancy; // No more errors!
1941 println!("Fancy: {}", fancy_field.num);
1942 // implicit call to `drop_struct.drop()` as drop_struct goes out of scope
1946 Note that this technique can also be used in the arms of a match expression:
1957 impl Drop for DropEnum {
1958 fn drop(&mut self) {
1959 // Destruct DropEnum, possibly using FancyNum
1964 // Creates and enum of type `DropEnum`, which implements `Drop`
1965 let drop_enum = DropEnum::Fancy(FancyNum{num: 10});
1967 // Creates a reference to the inside of `DropEnum::Fancy`
1968 DropEnum::Fancy(ref fancy_field) => // No error!
1969 println!("It was fancy-- {}!", fancy_field.num),
1971 // implicit call to `drop_enum.drop()` as drop_enum goes out of scope
1977 Cannot mutate place in this match guard.
1979 When matching on a variable it cannot be mutated in the match guards, as this
1980 could cause the match to be non-exhaustive:
1982 ```compile_fail,E0510
1983 #![feature(nll, bind_by_move_pattern_guards)]
1984 let mut x = Some(0);
1987 Some(v) if { x = None; false } => (),
1988 Some(_) => (), // No longer matches
1992 Here executing `x = None` would modify the value being matched and require us
1993 to go "back in time" to the `None` arm.
1997 When matching against an exclusive range, the compiler verifies that the range
1998 is non-empty. Exclusive range patterns include the start point but not the end
1999 point, so this is equivalent to requiring the start of the range to be less
2000 than the end of the range.
2006 // This range is ok, albeit pointless.
2008 // This range is empty, and the compiler can tell.
2015 Closures cannot mutate immutable captured variables.
2017 Erroneous code example:
2019 ```compile_fail,E0595
2020 let x = 3; // error: closure cannot assign to immutable local variable `x`
2021 let mut c = || { x += 1 };
2024 Make the variable binding mutable:
2027 let mut x = 3; // ok!
2028 let mut c = || { x += 1 };
2033 This error occurs because you tried to mutably borrow a non-mutable variable.
2035 Example of erroneous code:
2037 ```compile_fail,E0596
2039 let y = &mut x; // error: cannot borrow mutably
2042 In here, `x` isn't mutable, so when we try to mutably borrow it in `y`, it
2043 fails. To fix this error, you need to make `x` mutable:
2047 let y = &mut x; // ok!
2052 This error occurs because a borrow was made inside a variable which has a
2053 greater lifetime than the borrowed one.
2055 Example of erroneous code:
2057 ```compile_fail,E0597
2062 let mut x = Foo { x: None };
2064 x.x = Some(&y); // error: `y` does not live long enough
2067 In here, `x` is created before `y` and therefore has a greater lifetime. Always
2068 keep in mind that values in a scope are dropped in the opposite order they are
2069 created. So to fix the previous example, just make the `y` lifetime greater than
2078 let mut x = Foo { x: None };
2084 This error occurs because a borrow in a generator persists across a
2087 ```compile_fail,E0626
2088 # #![feature(generators, generator_trait)]
2089 # use std::ops::Generator;
2091 let a = &String::new(); // <-- This borrow...
2092 yield (); // ...is still in scope here, when the yield occurs.
2095 unsafe { b.resume() };
2098 At present, it is not permitted to have a yield that occurs while a
2099 borrow is still in scope. To resolve this error, the borrow must
2100 either be "contained" to a smaller scope that does not overlap the
2101 yield or else eliminated in another way. So, for example, we might
2102 resolve the previous example by removing the borrow and just storing
2103 the integer by value:
2106 # #![feature(generators, generator_trait)]
2107 # use std::ops::Generator;
2113 unsafe { b.resume() };
2116 This is a very simple case, of course. In more complex cases, we may
2117 wish to have more than one reference to the value that was borrowed --
2118 in those cases, something like the `Rc` or `Arc` types may be useful.
2120 This error also frequently arises with iteration:
2122 ```compile_fail,E0626
2123 # #![feature(generators, generator_trait)]
2124 # use std::ops::Generator;
2126 let v = vec![1,2,3];
2127 for &x in &v { // <-- borrow of `v` is still in scope...
2128 yield x; // ...when this yield occurs.
2131 unsafe { b.resume() };
2134 Such cases can sometimes be resolved by iterating "by value" (or using
2135 `into_iter()`) to avoid borrowing:
2138 # #![feature(generators, generator_trait)]
2139 # use std::ops::Generator;
2141 let v = vec![1,2,3];
2142 for x in v { // <-- Take ownership of the values instead!
2143 yield x; // <-- Now yield is OK.
2146 unsafe { b.resume() };
2149 If taking ownership is not an option, using indices can work too:
2152 # #![feature(generators, generator_trait)]
2153 # use std::ops::Generator;
2155 let v = vec![1,2,3];
2156 let len = v.len(); // (*)
2158 let x = v[i]; // (*)
2159 yield x; // <-- Now yield is OK.
2162 unsafe { b.resume() };
2164 // (*) -- Unfortunately, these temporaries are currently required.
2165 // See <https://github.com/rust-lang/rust/issues/43122>.
2170 This error occurs because a borrow of a thread-local variable was made inside a
2171 function which outlived the lifetime of the function.
2173 Example of erroneous code:
2175 ```compile_fail,E0712
2177 #![feature(thread_local)]
2183 let a = &FOO; // error: thread-local variable borrowed past end of function
2185 std::thread::spawn(move || {
2193 This error occurs when an attempt is made to borrow state past the end of the
2194 lifetime of a type that implements the `Drop` trait.
2196 Example of erroneous code:
2198 ```compile_fail,E0713
2201 pub struct S<'a> { data: &'a mut String }
2203 impl<'a> Drop for S<'a> {
2204 fn drop(&mut self) { self.data.push_str("being dropped"); }
2207 fn demo<'a>(s: S<'a>) -> &'a mut String { let p = &mut *s.data; p }
2210 Here, `demo` tries to borrow the string data held within its
2211 argument `s` and then return that borrow. However, `S` is
2212 declared as implementing `Drop`.
2214 Structs implementing the `Drop` trait have an implicit destructor that
2215 gets called when they go out of scope. This destructor gets exclusive
2216 access to the fields of the struct when it runs.
2218 This means that when `s` reaches the end of `demo`, its destructor
2219 gets exclusive access to its `&mut`-borrowed string data. allowing
2220 another borrow of that string data (`p`), to exist across the drop of
2221 `s` would be a violation of the principle that `&mut`-borrows have
2222 exclusive, unaliased access to their referenced data.
2224 This error can be fixed by changing `demo` so that the destructor does
2225 not run while the string-data is borrowed; for example by taking `S`
2231 pub struct S<'a> { data: &'a mut String }
2233 impl<'a> Drop for S<'a> {
2234 fn drop(&mut self) { self.data.push_str("being dropped"); }
2237 fn demo<'a>(s: &'a mut S<'a>) -> &'a mut String { let p = &mut *(*s).data; p }
2240 Note that this approach needs a reference to S with lifetime `'a`.
2241 Nothing shorter than `'a` will suffice: a shorter lifetime would imply
2242 that after `demo` finishes excuting, something else (such as the
2243 destructor!) could access `s.data` after the end of that shorter
2244 lifetime, which would again violate the `&mut`-borrow's exclusive
2249 This error indicates that a temporary value is being dropped
2250 while a borrow is still in active use.
2252 Erroneous code example:
2254 ```compile_fail,E0716
2256 fn foo() -> i32 { 22 }
2257 fn bar(x: &i32) -> &i32 { x }
2258 let p = bar(&foo());
2259 // ------ creates a temporary
2263 Here, the expression `&foo()` is borrowing the expression
2264 `foo()`. As `foo()` is call to a function, and not the name of
2265 a variable, this creates a **temporary** -- that temporary stores
2266 the return value from `foo()` so that it can be borrowed.
2267 So you might imagine that `let p = bar(&foo())` is equivalent
2270 ```compile_fail,E0597
2271 # fn foo() -> i32 { 22 }
2272 # fn bar(x: &i32) -> &i32 { x }
2274 let tmp = foo(); // the temporary
2276 }; // <-- tmp is freed as we exit this block
2280 Whenever a temporary is created, it is automatically dropped (freed)
2281 according to fixed rules. Ordinarily, the temporary is dropped
2282 at the end of the enclosing statement -- in this case, after the `let`.
2283 This is illustrated in the example above by showing that `tmp` would
2284 be freed as we exit the block.
2286 To fix this problem, you need to create a local variable
2287 to store the value in rather than relying on a temporary.
2288 For example, you might change the original program to
2292 fn foo() -> i32 { 22 }
2293 fn bar(x: &i32) -> &i32 { x }
2294 let value = foo(); // dropped at the end of the enclosing block
2295 let p = bar(&value);
2299 By introducing the explicit `let value`, we allocate storage
2300 that will last until the end of the enclosing block (when `value`
2301 goes out of scope). When we borrow `&value`, we are borrowing a
2302 local variable that already exists, and hence no temporary is created.
2304 Temporaries are not always dropped at the end of the enclosing
2305 statement. In simple cases where the `&` expression is immediately
2306 stored into a variable, the compiler will automatically extend
2307 the lifetime of the temporary until the end of the enclosinb
2308 block. Therefore, an alternative way to fix the original
2309 program is to write `let tmp = &foo()` and not `let tmp = foo()`:
2312 fn foo() -> i32 { 22 }
2313 fn bar(x: &i32) -> &i32 { x }
2319 Here, we are still borrowing `foo()`, but as the borrow is assigned
2320 directly into a variable, the temporary will not be dropped until
2321 the end of the enclosing block. Similar rules apply when temporaries
2322 are stored into aggregate structures like a tuple or struct:
2325 // Here, two temporaries are created, but
2326 // as they are stored directly into `value`,
2327 // they are not dropped until the end of the
2329 fn foo() -> i32 { 22 }
2330 let value = (&foo(), &foo());
2336 register_diagnostics! {
2337 // E0298, // cannot compare constants
2338 // E0299, // mismatched types between arms
2339 // E0471, // constant evaluation error (in pattern)
2340 // E0385, // {} in an aliasable location
2341 E0493, // destructors cannot be evaluated at compile-time
2342 E0524, // two closures require unique access to `..` at the same time
2343 E0526, // shuffle indices are not constant
2344 E0594, // cannot assign to {}
2345 E0598, // lifetime of {} is too short to guarantee its contents can be...
2346 E0625, // thread-local statics cannot be accessed at compile-time