From 1b846bfbccbb3780ca1a9830f0ab72061f52ebb8 Mon Sep 17 00:00:00 2001
From: Camelid <camelidcamel@gmail.com>
Date: Fri, 27 Nov 2020 17:18:29 -0800
Subject: [PATCH] Slightly improve code samples in E0591

* Improve formatting
* Don't hide `unsafe` block - it's important!
---
 .../src/error_codes/E0591.md                  | 20 ++++++++++++-------
 src/test/ui/explain.stdout                    | 18 ++++++++++++-----
 2 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/compiler/rustc_error_codes/src/error_codes/E0591.md b/compiler/rustc_error_codes/src/error_codes/E0591.md
index 7f68815b1c21..f49805d9b4e1 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0591.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0591.md
@@ -1,14 +1,20 @@
 Per [RFC 401][rfc401], if you have a function declaration `foo`:
 
 ```
+struct S;
+
 // For the purposes of this explanation, all of these
 // different kinds of `fn` declarations are equivalent:
-struct S;
+
 fn foo(x: S) { /* ... */ }
 # #[cfg(for_demonstration_only)]
-extern "C" { fn foo(x: S); }
+extern "C" {
+    fn foo(x: S);
+}
 # #[cfg(for_demonstration_only)]
-impl S { fn foo(self) { /* ... */ } }
+impl S {
+    fn foo(self) { /* ... */ }
+}
 ```
 
 the type of `foo` is **not** `fn(S)`, as one might expect.
@@ -40,10 +46,10 @@ extern "C" fn foo(userdata: Box<i32>) {
 
 # fn callback(_: extern "C" fn(*mut i32)) {}
 # use std::mem::transmute;
-# unsafe {
-let f: extern "C" fn(*mut i32) = transmute(foo);
-callback(f);
-# }
+unsafe {
+    let f: extern "C" fn(*mut i32) = transmute(foo);
+    callback(f);
+}
 ```
 
 Here, transmute is being used to convert the types of the fn arguments.
diff --git a/src/test/ui/explain.stdout b/src/test/ui/explain.stdout
index c50c46ee5641..62f1a7f98ea1 100644
--- a/src/test/ui/explain.stdout
+++ b/src/test/ui/explain.stdout
@@ -1,12 +1,18 @@
 Per [RFC 401][rfc401], if you have a function declaration `foo`:
 
 ```
+struct S;
+
 // For the purposes of this explanation, all of these
 // different kinds of `fn` declarations are equivalent:
-struct S;
+
 fn foo(x: S) { /* ... */ }
-extern "C" { fn foo(x: S); }
-impl S { fn foo(self) { /* ... */ } }
+extern "C" {
+    fn foo(x: S);
+}
+impl S {
+    fn foo(self) { /* ... */ }
+}
 ```
 
 the type of `foo` is **not** `fn(S)`, as one might expect.
@@ -34,8 +40,10 @@ extern "C" fn foo(userdata: Box<i32>) {
     /* ... */
 }
 
-let f: extern "C" fn(*mut i32) = transmute(foo);
-callback(f);
+unsafe {
+    let f: extern "C" fn(*mut i32) = transmute(foo);
+    callback(f);
+}
 ```
 
 Here, transmute is being used to convert the types of the fn arguments.