Add checking for unnecessary delims in closure body

Author: chenyukang

compiler/rustc_lint/src/unused.rs

@@ -3,7 +3,7 @@ use std::ops::ControlFlow;
 
 use rustc_ast as ast;
 use rustc_ast::util::{classify, parser};
-use rustc_ast::{ExprKind, StmtKind};
+use rustc_ast::{ExprKind, FnRetTy, StmtKind};
 use rustc_errors::{MultiSpan, pluralize};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::DefId;
@@ -594,6 +594,7 @@ enum UnusedDelimsCtx {
     AnonConst,
     MatchArmExpr,
     IndexExpr,
+    ClosureBody,
 }
 
 impl From<UnusedDelimsCtx> for &'static str {
@@ -615,6 +616,7 @@ impl From<UnusedDelimsCtx> for &'static str {
             UnusedDelimsCtx::ArrayLenExpr | UnusedDelimsCtx::AnonConst => "const expression",
             UnusedDelimsCtx::MatchArmExpr => "match arm expression",
             UnusedDelimsCtx::IndexExpr => "index expression",
+            UnusedDelimsCtx::ClosureBody => "closure body",
         }
     }
 }
@@ -933,6 +935,18 @@ trait UnusedDelimLint {
                 let (args_to_check, ctx) = match *call_or_other {
                     Call(_, ref args) => (&args[..], UnusedDelimsCtx::FunctionArg),
                     MethodCall(ref call) => (&call.args[..], UnusedDelimsCtx::MethodArg),
+                    Closure(ref closure)
+                        if matches!(closure.fn_decl.output, FnRetTy::Default(_))
+                            // skip `#[core::contracts::requires(...)]` and `#[core::contracts::ensures(...)]` which generate closure
+                            && !cx
+                                .sess()
+                                .source_map()
+                                .span_to_snippet(closure.fn_decl_span)
+                                .unwrap_or_default()
+                                .contains("core::contracts") =>
+                    {
+                        (&[closure.body.clone()][..], UnusedDelimsCtx::ClosureBody)
+                    }
                     // actual catch-all arm
                     _ => {
                         return;

tests/ui/closures/issue-10682.rs

@@ -8,5 +8,5 @@ fn foo<F:FnOnce()>(_: F) {}
 
 pub fn main() {
   let a = Box::new(1);
-  foo(move|| { foo(move|| { work(a) }) })
+  foo(move|| foo(move|| work(a) ) )
 }

tests/ui/closures/issue-5239-2.rs

@@ -1,9 +1,8 @@
 //@ run-pass
 // Regression test for issue #5239
 
-
 pub fn main() {
-    let _f = |ref x: isize| { *x };
+    let _f = |ref x: isize| *x;
     let foo = 10;
     assert_eq!(_f(foo), 10);
 }

tests/ui/closures/issue-868.rs

@@ -1,5 +1,6 @@
 //@ run-pass
 #![allow(unused_parens)]
+#![allow(unused_braces)]
 #![allow(unit_bindings)]
 
 fn f<T, F>(g: F) -> T where F: FnOnce() -> T { g() }

tests/ui/coercion/coerce-expect-unsized.rs

@@ -12,14 +12,14 @@ pub fn main() {
     let _: Box<[isize]> = Box::new({ [1, 2, 3] });
     let _: Box<[isize]> = Box::new(if true { [1, 2, 3] } else { [1, 3, 4] });
     let _: Box<[isize]> = Box::new(match true { true => [1, 2, 3], false => [1, 3, 4] });
-    let _: Box<dyn Fn(isize) -> _> = Box::new({ |x| (x as u8) });
+    let _: Box<dyn Fn(isize) -> _> = Box::new({ |x| x as u8 });
     let _: Box<dyn Debug> = Box::new(if true { false } else { true });
     let _: Box<dyn Debug> = Box::new(match true { true => 'a', false => 'b' });
 
     let _: &[isize] = &{ [1, 2, 3] };
     let _: &[isize] = &if true { [1, 2, 3] } else { [1, 3, 4] };
     let _: &[isize] = &match true { true => [1, 2, 3], false => [1, 3, 4] };
-    let _: &dyn Fn(isize) -> _ = &{ |x| (x as u8) };
+    let _: &dyn Fn(isize) -> _ = &{ |x| x as u8 };
     let _: &dyn Debug = &if true { false } else { true };
     let _: &dyn Debug = &match true { true => 'a', false => 'b' };
 
@@ -31,13 +31,13 @@ pub fn main() {
     };
 
     let _: Box<[isize]> = Box::new([1, 2, 3]);
-    let _: Box<dyn Fn(isize) -> _> = Box::new(|x| (x as u8));
+    let _: Box<dyn Fn(isize) -> _> = Box::new(|x| x as u8);
 
     let _: Rc<RefCell<[isize]>> = Rc::new(RefCell::new([1, 2, 3]));
-    let _: Rc<RefCell<dyn FnMut(isize) -> _>> = Rc::new(RefCell::new(|x| (x as u8)));
+    let _: Rc<RefCell<dyn FnMut(isize) -> _>> = Rc::new(RefCell::new(|x| x as u8));
 
     let _: Vec<Box<dyn Fn(isize) -> _>> = vec![
-        Box::new(|x| (x as u8)),
-        Box::new(|x| (x as i16 as u8)),
+        Box::new(|x| x as u8),
+        Box::new(|x| x as i16 as u8),
     ];
 }

tests/ui/consts/issue-27890.rs

@@ -1,5 +1,5 @@
 //@ run-pass
-static PLUS_ONE: &'static (dyn Fn(i32) -> i32 + Sync) = (&|x: i32| { x + 1 })
+static PLUS_ONE: &'static (dyn Fn(i32) -> i32 + Sync) = (&|x: i32| x + 1)
     as &'static (dyn Fn(i32) -> i32 + Sync);
 
 fn main() {

tests/ui/coroutine/smoke.rs

@@ -150,7 +150,7 @@ fn send_and_sync() {
 
 #[test]
 fn send_over_threads() {
-    let mut foo = #[coroutine] || { yield };
+    let mut foo = #[coroutine] || yield;
     thread::spawn(move || {
         match Pin::new(&mut foo).resume(()) {
             CoroutineState::Yielded(()) => {}
@@ -163,7 +163,7 @@ fn send_over_threads() {
     }).join().unwrap();
 
     let a = String::from("a");
-    let mut foo = #[coroutine] || { yield a };
+    let mut foo = #[coroutine] || yield a;
     thread::spawn(move || {
         match Pin::new(&mut foo).resume(()) {
             CoroutineState::Yielded(ref s) if *s == "a" => {}

tests/ui/functions-closures/closure-to-fn-coercion.rs

@@ -1,7 +1,7 @@
 //@ run-pass
 use std::mem;
 
-const FOO: fn(u8) -> u8 = |v: u8| { v };
+const FOO: fn(u8) -> u8 = |v: u8| v;
 
 const BAR: [fn(&mut u32); 5] = [
     |_: &mut u32| {},
@@ -21,7 +21,7 @@ fn generic<T>(_: T) -> fn() -> usize {
 fn main() {
     // Items
     assert_eq!(func_specific()(), 42);
-    let foo: fn(u8) -> u8 = |v: u8| { v };
+    let foo: fn(u8) -> u8 = |v: u8| v;
     assert_eq!(foo(31), 31);
     // Constants
     assert_eq!(FOO(31), 31);

tests/ui/impl-trait/closure-in-impl-trait-arg.rs

@@ -1,6 +1,6 @@
 //@ run-pass
 #![allow(unused_must_use)]
-fn bug(_: impl Iterator<Item = [(); { |x: u32| { x }; 4 }]>) {}
+fn bug(_: impl Iterator<Item = [(); { |x: u32| x ; 4 }]>) {}
 
 fn main() {
     bug(std::iter::empty());

tests/ui/impl-trait/closure-in-impl-trait.rs

@@ -1,10 +1,10 @@
 //@ run-pass
 #![allow(unused_must_use)]
-fn bug<T>() -> impl Iterator<Item = [(); { |x: u32| { x }; 4 }]> {
+fn bug<T>() -> impl Iterator<Item = [(); { |x: u32| x; 4 }]> {
     std::iter::empty()
 }
 
-fn ok<T>() -> Box<dyn Iterator<Item = [(); { |x: u32| { x }; 4 }]>> {
+fn ok<T>() -> Box<dyn Iterator<Item = [(); { |x: u32| x; 4 }]>> {
     Box::new(std::iter::empty())
 }