Repository: rust
Issue: Error code E0521 "escapes the closure body" is unclear and arguably unhelpful.
Labels: A-diagnostics,T-compiler,D-terse

### Code

```Rust
// pulled directly from https://doc.rust-lang.org/stable/error_codes/E0521.html#error-code-e0521
let mut list: Vec<&str> = Vec::new();

let _add = |el: &str| {
    list.push(el); // error: `el` escapes the closure body here
};
```


### Current output

```Shell
Compiling playground v0.0.1 (/playground)
error[E0521]: borrowed data escapes outside of closure
 --> src/main.rs:6:5
  |
3 | let mut list: Vec<&str> = Vec::new();
  |     -------- `list` declared here, outside of the closure body
4 |
5 | let _add = |el: &str| {
  |             -- `el` is a reference that is only valid in the closure body
6 |     list.push(el); // error: `el` escapes the closure body here
  |     ^^^^^^^^^^^^^ `el` escapes the closure body here

For more information about this error, try `rustc --explain E0521`.
error: could not compile `playground` (bin "playground") due to previous error
```


### Desired output

_No response_

### Rationale and extra context

While studying lifetimes and the different flavors of variance I came across the following error `borrowed data escapes outside of closure`. When I went to [E5021](https://doc.rust-lang.org/stable/error_codes/E0521.html#error-code-e0521) as the compiler suggested I was frustrated that explanation didn't appear to explain what the problem was. All that is explained is "A type annotation of a closure parameter implies a new lifetime declaration. Consider to drop it, the compiler is reliably able to infer them."

### My understanding of the problem:

1. The borrowed data "escapes the closure body" (I don't understand what that means)
2. This can be fixed by not being explicit about the expected argument types in the closure.

### My Issue with the docs

1. The term "escapes the closure body" is not elaborated on *at all*. "escapes" is ambiguous in this context and even if you understood what that means (the reference outlives the body? Just taking a wild guess.), why it is a problem is not even explained. References outliving bodies is not illegal in Rust AFAIK. The suggested solution of removing the type really gives no hints either. 
2. The solution seems to say that lifetimes in this context can be inferred by the compiler through the Lifetime Elision Rules. I understand what this means but it almost seems to imply that I am getting this error for being redundant, but redundancy should be a `warn` not an `error`.
3. (This one is more of a secondary complaint to my primary issue, but it lends additional weight to the general frustration) The explanation itself is very clunky. "A type annotation of a closure parameter implies a new lifetime declaration. Consider to drop it, the compiler is reliably able to infer them." "Consider to drop it" should at the very least be "Consider dropping it.". But that still doesn't help explain the problem why the compiler will not compile my code.
4. The suggested link [[Closure Type Inference and Annotation](https://doc.rust-lang.org/book/ch13-01-closures.html#closure-type-inference-and-annotation)](https://doc.rust-lang.org/book/ch13-01-closures.html#closure-type-inference-and-annotation) reiterates the explanation: About how the compiler handles args and explicit types in closures vs. functions but this again seems to amount to a stylistic issue not a code validity problem. 

### Conclusion
Overall, Rust generally has extremely helpful compiler errors and that is sort of why this error is so *baffling*. It seems inconsistent with the quality of the other errors that the `rustc` produces and is ultimately why I am writing this issue. 



### Other cases

_No response_

### Anything else?

_No response_