Add back the E0008 error code long explanation

Author: GuillaumeGomez

src/librustc_error_codes/error_codes.rs

@@ -14,6 +14,7 @@ E0003: include_str!("./error_codes/E0003.md"),
 E0004: include_str!("./error_codes/E0004.md"),
 E0005: include_str!("./error_codes/E0005.md"),
 E0007: include_str!("./error_codes/E0007.md"),
+E0008: include_str!("./error_codes/E0008.md"),
 E0009: include_str!("./error_codes/E0009.md"),
 E0010: include_str!("./error_codes/E0010.md"),
 E0013: include_str!("./error_codes/E0013.md"),
@@ -413,7 +414,6 @@ E0744: include_str!("./error_codes/E0744.md"),
 E0745: include_str!("./error_codes/E0745.md"),
 ;
 //  E0006, // merged with E0005
-//  E0008, // cannot bind by-move into a pattern guard
 //  E0035, merged into E0087/E0089
 //  E0036, merged into E0087/E0089
 //  E0068,

src/librustc_error_codes/error_codes/E0008.md

@@ -0,0 +1,73 @@
+#### Note: this error code is no longer emitted by the compiler.
+
+Names bound in match arms retain their type in pattern guards. As such, if a
+name is bound by move in a pattern, it should also be moved to wherever it is
+referenced in the pattern guard code. Doing so however would prevent the name
+from being available in the body of the match arm. Consider the following:
+
+```
+match Some("hi".to_string()) {
+    Some(s) if s.len() == 0 => {}, // use s.
+    _ => {},
+}
+```
+
+The variable `s` has type `String`, and its use in the guard is as a variable of
+type `String`. The guard code effectively executes in a separate scope to the
+body of the arm, so the value would be moved into this anonymous scope and
+therefore becomes unavailable in the body of the arm.
+The problem above can be solved by using the `ref` keyword.
+
+```
+match Some("hi".to_string()) {
+    Some(ref s) if s.len() == 0 => {},
+    _ => {},
+}
+```
+
+Though this example seems innocuous and easy to solve, the problem becomes clear
+when it encounters functions which consume the value:
+
+```compile_fail,E0507
+struct A {}
+
+impl A {
+    fn consume(self) -> usize {
+        0
+    }
+}
+
+fn main() {
+    let a = Some(A{});
+    match a {
+        Some(y) if y.consume() > 0 => {}
+        _ => {}
+    }
+}
+```
+
+In this situation, even the `ref` keyword cannot solve it, since borrowed
+content cannot be moved. This problem cannot be solved generally. If the value
+can be cloned, here is a not-so-specific solution:
+
+```
+#[derive(Clone)]
+struct A {}
+
+impl A {
+    fn consume(self) -> usize {
+        0
+    }
+}
+
+fn main() {
+    let a = Some(A{});
+    match a{
+        Some(ref y) if y.clone().consume() > 0 => {}
+        _ => {}
+    }
+}
+```
+
+If the value will be consumed in the pattern guard, using its clone will not
+move its ownership, so the code works.