From c17f1a66f97ec26cdf746992f240aaf640c0fd20 Mon Sep 17 00:00:00 2001
From: "Zack M. Davis" <code@zackmdavis.net>
Date: Sun, 12 Jun 2016 12:57:05 -0700
Subject: [PATCH 1/2] add long explanation for E0453, lint attribute overruled
 by outer forbid

This is a subtask of #32777.
---
 src/librustc/diagnostics.rs | 46 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 45 insertions(+), 1 deletion(-)

diff --git a/src/librustc/diagnostics.rs b/src/librustc/diagnostics.rs
index 30dcca833f84..8d936086de53 100644
--- a/src/librustc/diagnostics.rs
+++ b/src/librustc/diagnostics.rs
@@ -1444,6 +1444,51 @@ fn foo<'a>(arg: &Box<SomeTrait+'a>) { ... }
 ```
 "##,
 
+E0453: r##"
+A lint check attribute was overruled by a `forbid` directive set as an
+attribute on an enclosing scope, or on the command line with the `-F` option.
+
+Example of erroneous code:
+
+```compile_fail
+#![forbid(non_snake_case)]
+
+#[allow(non_snake_case)]
+fn main() {
+    let MyNumber = 2; // error: allow(non_snake_case) overruled by outer
+                      // forbid(non_snake_case)
+}
+```
+
+The `forbid` lint setting makes code that fails the lint check result in a
+compilation-terminating error (like `deny`), but also prevents itself from
+being overridden by inner attributes.
+
+You can change `forbid` to `deny` (or use `-D` instead of `-F` if the `forbid`
+setting was given as a command-line option) to allow the inner lint check
+attribute:
+
+```
+#![deny(non_snake_case)]
+
+#[allow(non_snake_case)]
+fn main() {
+    let MyNumber = 2; // ok!
+}
+```
+
+Alternatively, edit the code to pass the lint check, and remove the overruled
+attribute:
+
+```
+#![forbid(non_snake_case)]
+
+fn main() {
+    let my_number = 2;
+}
+```
+"##,
+
 E0496: r##"
 A lifetime name is shadowing another lifetime name. Erroneous code example:
 
@@ -1628,7 +1673,6 @@ fn cookie() -> ! { // error: definition of an unknown language item: `cookie`
     E0314, // closure outlives stack frame
     E0315, // cannot invoke closure outside of its lifetime
     E0316, // nested quantification of lifetimes
-    E0453, // overruled by outer forbid
     E0473, // dereference of reference outside its lifetime
     E0474, // captured variable `..` does not outlive the enclosing closure
     E0475, // index of slice outside its lifetime

From e4c566ccefacfac4f5883b1719e400c3a239c742 Mon Sep 17 00:00:00 2001
From: "Zack M. Davis" <code@zackmdavis.net>
Date: Sun, 12 Jun 2016 20:55:36 -0700
Subject: [PATCH 2/2] edit E0453 long explanation for style, clarity, and
 citizenship
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

It turns out that the subsequent lines of the error message comment
should be aligned like this.

The "turns the corresponding compiler warning" language may not be
strictly the most accurate—a lint check isn't the same as a compiler
warning; it emits a compiler warning if it's set to the `warn` level—
but it may be worth glossing over such distinctions in favor of simple,
familar phrasings for the sake of pedagogy; thanks to Guillaume Gomez
for the wording suggestion.

Let's also fix up the introductory clauses of the sentences about how to
fix the error to put a little more emphasis on the fact that the
`forbid` setting was probably there for a reason.
---
 src/librustc/diagnostics.rs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/librustc/diagnostics.rs b/src/librustc/diagnostics.rs
index 8d936086de53..eb51043fcd02 100644
--- a/src/librustc/diagnostics.rs
+++ b/src/librustc/diagnostics.rs
@@ -1456,17 +1456,17 @@ fn foo<'a>(arg: &Box<SomeTrait+'a>) { ... }
 #[allow(non_snake_case)]
 fn main() {
     let MyNumber = 2; // error: allow(non_snake_case) overruled by outer
-                      // forbid(non_snake_case)
+                      //        forbid(non_snake_case)
 }
 ```
 
-The `forbid` lint setting makes code that fails the lint check result in a
-compilation-terminating error (like `deny`), but also prevents itself from
-being overridden by inner attributes.
+The `forbid` lint setting, like `deny`, turns the corresponding compiler
+warning into a hard error. Unlike `deny`, `forbid` prevents itself from being
+overridden by inner attributes.
 
-You can change `forbid` to `deny` (or use `-D` instead of `-F` if the `forbid`
-setting was given as a command-line option) to allow the inner lint check
-attribute:
+If you're sure you want to override the lint check, you can change `forbid` to
+`deny` (or use `-D` instead of `-F` if the `forbid` setting was given as a
+command-line option) to allow the inner lint check attribute:
 
 ```
 #![deny(non_snake_case)]
@@ -1477,7 +1477,7 @@ fn main() {
 }
 ```
 
-Alternatively, edit the code to pass the lint check, and remove the overruled
+Otherwise, edit the code to pass the lint check, and remove the overruled
 attribute:
 
 ```