Copy examples from arielb1

Author: nikomatsakis

litmus_tests/f_mut_pedantic.md

@@ -0,0 +1,16 @@
+### Example
+
+```
+fn f_mut_pedantic<'s>(&'s mut self) -> &'s mut Self {
+    let captured_self = self as *mut Self;
+    unsafe { &mut *((*captured_self).f() as *const Self as *mut Self) }
+}
+```
+
+### Explanation
+
+More explicit variation on [f_mut_should_work.md](f_mut_should_work.md).
+
+### Source
+
+https://github.com/rust-lang/rust/issues/30424#issuecomment-167009462

litmus_tests/f_mut_should_work.md

@@ -0,0 +1,26 @@
+### Example
+
+```
+fn f(&self) -> &Self { self }
+fn f_mut_should_work<'s>(&'s mut self) -> &'s mut Self {
+    let ret = unsafe { &mut *(self.f() as *const Self as *mut Self) };
+    ret // β-expansion should have no effect
+}
+```
+
+(In the case of a compiler transform, include the transformed source
+code as well.)
+
+### Explanation
+
+- `self` is borrowed only within the unsafe block
+  - on second line, both `ret` and `self` are live mutable pointers to the same place.
+  
+Could be considered UB because multiple invalid aliases are *in
+scope*, but then they are never used. See also
+[f_mut_unsure.md](f_mut_unsure.md).
+
+### Source
+
+https://github.com/rust-lang/rust/issues/30424#issuecomment-167009014
+

litmus_tests/f_mut_unsure.md

@@ -0,0 +1,28 @@
+### Example
+
+```
+fn f(&self) -> &Self { self }
+fn f_mut_unsure<'s>(&'s mut self) -> &'s mut Self {
+    let ret = unsafe { transmute::<&Self, &'s mut Self>(self.f()) };
+    ret // β-expansion should have no effect
+}
+```
+
+### Explanation
+
+- `self` is borrowed only within the unsafe block
+  - on second line, both `ret` and `self` are live mutable pointers to the same place.
+- reborrow of `self` would be another alias, alive just after the return from transmute
+  - this is what is linted against
+        
+Under "instant death" rules, both are UB, so we can't have that.
+
+Under the access-based rules, both are fine.
+
+We had a proposal flying around that &-references use instant death
+and &mut use some variant of access-based, which would make the first
+UB and the second safe.
+
+### Source
+
+https://github.com/rust-lang/rust/issues/30424#issuecomment-167009014

optimizations/move_in_place.md

@@ -0,0 +1,31 @@
+### Example
+
+```
+#[derive(Debug,Copy,Clone)]
+struct Foo {
+    bar: Bar
+}
+#[derive(Debug,Copy,Clone)]
+struct Bar {
+    // lots of data
+}
+fn doit() -> u32 {
+    let foo = Foo { bar: make_bar() };
+    debug!("{}", &foo);
+    match foo {
+        Foo { bar } => frobnicate(&mut bar)
+    };
+}
+```
+
+### Explanation
+
+In the function `doit`, we would like the compiler to be able to make
+`bar` binding point to `foo.bar` in place. But if the `debug!` macro
+should cast the `&foo` to `*const Foo` and keep a reference, it could
+observe the change. Is it allowed to do that?
+
+### Source
+
+https://github.com/rust-lang/rust/issues/30424#issuecomment-167009462
+