Add examples

Thanks to RalfJ for the substance of many of these.

Author: traviscross

src/const_eval.md

@@ -85,11 +85,71 @@ 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,E0764
+  # use core::sync::atomic::AtomicU8;
+  const C: &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 a transient place.
+  };
+  ```
+
   A place is *indirect* if it is based on a [dereference expression][dereference operator].
+
+  ```rust
+  const C: () = {
+      let x = &mut 0;
+      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: &u8 = unsafe { &mut S }; // Borrow of static item.
+  ```
+
+  ```rust
+  static mut S: u8 = 0;
+  # #[allow(static_mut_refs)]
+  const C: () = {
+      let _ = unsafe { &mut S }; // Borrow of static item.
+  };
+  ```
+
+  ```rust
+  const C: &[u8] = &mut []; // Borrow of promoted expression.
+  ```
+
+  ```rust
+  const C: () = {
+      let _: &'static mut [u8] = &mut []; // Borrow of promoted expression.
+  };
+  ```
+
 r[const-eval.const-expr.deref]
 * The [dereference operator] except for raw pointers.