Add examples

Thanks to RalfJ for the substance of many of these.

Author: traviscross

src/const_eval.md

@@ -85,11 +85,61 @@ r[const-eval.const-expr.borrows]
   mutable borrows and shared borrows to values with interior mutability
   are not allowed to refer to [lifetime-extended temporaries in the top-level scope of a `const` or `static` initializer expression][lifetime-extension-const].
 
+  ```rust,compile_fail,E0492
+  # use core::sync::atomic::AtomicU8;
+  const C: &AtomicU8 = &AtomicU8::new(0); // ERROR not allowed
+  ```
+
+  ```rust,compile_fail,E0492
+  # use core::sync::atomic::AtomicU8;
+  const C: &mut AtomicU8 = &mut AtomicU8::new(0); // ERROR not allowed
+  ```
+
+  ```rust,compile_fail,E0492
+  # use core::sync::atomic::AtomicU8;
+  let _: &'static _ = const { &AtomicU8::new(0) }; // ERROR not allowed
+  ```
+
+  ```rust
+  # use core::sync::atomic::AtomicU8;
+  const C: () = { _ = &AtomicU8::new(0); }; // OK
+  ```
+
   In other words, they are only allowed to refer to *transient* places, to *indirect* places, or to *static* places.
   A place is *transient* if it is based on a local variable whose lifetime is strictly contained inside the current [const context].
+
+  ```rust
+  const C: () = {
+    let mut x = 0;
+    let _ = &mut x; // Reference to transient place.
+  };
+  ```
+
   A place is *indirect* if it is based on a [dereference expression][dereference operator].
+
+  ```rust
+  const C: () = {
+    let mut x = 0;
+    let x = &mut x;
+    let _ = &mut *x; // Reference to an indirect place.
+  };
+  ```
   A place is *static* if it is based on a `static` item or a [promoted expression].
 
+  ```rust
+  static mut S: u8 = 0;
+  # #[allow(static_mut_refs)]
+  const C: () = {
+    let _ = unsafe { &mut S }; // Reference to a static place.
+  };
+  ```
+
+  ```rust
+  const C: () = {
+    let _: &'static mut [i32] = &mut []; // Reference to a promoted expression.
+  };
+  ```
+
 r[const-eval.const-expr.deref]
 * The [dereference operator] except for raw pointers.