Move `unsafe` inside closures

What it does

Rust currently allows the following code:

let foo = unsafe { || bar(someArg) + 1 };
foo();

I believe that this suboptimal, but foo it feels like calling foo should require another unsafe block. Of course, since the Fn, FnMut, and FnOnce traits do not allow unsafe methods, foo can be called with unsafe.

To better reflect this behavior, I believe the above code should be written as such instead:

let foo = || unsafe { bar(someArg) + 1 };
foo();

This more clearly communicates that a caller of foo does not need unsafe.

This also extends to closures with arguments. Since the closure cannot be unsafe, any input arguments must not result in UB. A similar argument can be made for captures, since they can be thought of as implicit arguments.

Advantage

• The code more closely represents the actual call behavior of the closure.

Drawbacks

• None that I can think of right now.

Example

let foo = unsafe { || bar(someArg) + 1 };

Could be written as:

let foo = || unsafe { bar(someArg) + 1 };

The issue names no files, tests, or entry points. Start by understanding Rust's closure and unsafe semantics in the two examples, then locate the Clippy lint area that handles closure safety; done means the proposed placement of unsafe is consistently diagnosed and covered by tests.