can't forget non-lexical lifetimes!

Author: steveklabnik

src/SUMMARY.md

@@ -36,6 +36,7 @@
       - [No more anonymous parameters](rust-2018/trait-system/no-anon-params.md)
     - [Slice patterns](rust-2018/slice-patterns.md)
     - [Ownership and lifetimes](rust-2018/ownership-and-lifetimes/index.md)
+      - [Non-lexical lifetimes](rust-2018/ownership-and-lifetimes/non-lexical-lifetimes.md)
       - [Default `match` bindings](rust-2018/ownership-and-lifetimes/default-match-bindings.md)
       - [`'_`, the anonymous lifetime](rust-2018/ownership-and-lifetimes/the-anonymous-lifetime.md)
       - [Lifetime elision in `impl`](rust-2018/ownership-and-lifetimes/lifetime-elision-in-impl.md)

src/rust-2018/ownership-and-lifetimes/non-lexical-lifetimes.md

@@ -0,0 +1,83 @@
+# Non-lexical lifetimes
+
+![Minimum Rust version: beta](https://img.shields.io/badge/Minimum%20Rust%20Version-beta-orange.svg)
+
+The borrow checker has been enhanced to accept more code, via a mechanism
+called "non-lexial lifetimes." Consider this example:
+
+```rust,ignore
+fn main() {
+    let mut x = 5;
+
+    let y = &x;
+
+    let z = &mut x;
+}
+```
+
+In older Rust, this is a compile-time error:
+
+```text
+error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
+ --> src/main.rs:5:18
+  |
+4 |     let y = &x;
+  |              - immutable borrow occurs here
+5 |     let z = &mut x;
+  |                  ^ mutable borrow occurs here
+6 | }
+  | - immutable borrow ends here
+```
+
+This is because lifetimes follow "lexical scope"; that is, the borrow from `y` is
+considered to be held until `y` goes out of scope at the end of `main`, even though
+we never use `y` again. This code is fine, but the borrow checker could not handle it.
+
+Today, this code will compile just fine.
+
+## Better errors
+
+What if we did use `y`, like this?
+
+```rust,ignore
+fn main() {
+    let mut x = 5;
+    let y = &x;
+    let z = &mut x;
+    
+    println!("y: {}", y);
+}
+```
+
+Here's the error:
+
+```text
+error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
+ --> src/main.rs:5:18
+  |
+4 |     let y = &x;
+  |              - immutable borrow occurs here
+5 |     let z = &mut x;
+  |                  ^ mutable borrow occurs here
+...
+8 | }
+  | - immutable borrow ends here
+```
+
+With non-lexial lifetime, the error changes slightly:
+
+```text
+error[E0502]: cannot borrow `x` as mutable because it is also borrowed as immutable
+ --> src/main.rs:5:13
+  |
+4 |     let y = &x;
+  |             -- immutable borrow occurs here
+5 |     let z = &mut x;
+  |             ^^^^^^ mutable borrow occurs here
+6 |     
+7 |     println!("y: {}", y);
+  |                       - borrow later used here
+```
+
+instead of pointing to where `y` goes out of scope, it insteads shows you where
+the conflicting borrow occurs. This makes these sorts of errors *far* easier to debug.