#![warn(clippy::redundant_closure, clippy::redundant_closure_for_method_calls)] #![allow(unused)] #![allow( clippy::needless_borrow, clippy::needless_pass_by_value, clippy::no_effect, clippy::option_map_unit_fn, clippy::redundant_closure_call, clippy::uninlined_format_args, clippy::useless_vec, clippy::unnecessary_map_on_constructor )] use std::path::{Path, PathBuf}; macro_rules! mac { () => { foobar() }; } macro_rules! closure_mac { () => { |n| foo(n) }; } fn main() { let a = Some(1u8).map(|a| foo(a)); let c = Some(1u8).map(|a| {1+2; foo}(a)); true.then(|| mac!()); // don't lint function in macro expansion Some(1).map(closure_mac!()); // don't lint closure in macro expansion let _: Option> = true.then(|| vec![]); // special case vec! let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted? all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted unsafe { Some(1u8).map(|a| unsafe_fn(a)); // unsafe fn } // See #815 let e = Some(1u8).map(|a| divergent(a)); let e = Some(1u8).map(|a| generic(a)); let e = Some(1u8).map(generic); // See #515 let a: Option)>> = Some(vec![1i32, 2]).map(|v| -> Box)> { Box::new(v) }); // issue #7224 let _: Option> = Some(0).map(|_| vec![]); // issue #10684 fn test(x: impl Fn(usize, usize) -> T) -> T { x(1, 2) } test(|start, end| start..=end); } trait TestTrait { fn trait_foo(self) -> bool; fn trait_foo_ref(&self) -> bool; } struct TestStruct<'a> { some_ref: &'a i32, } impl<'a> TestStruct<'a> { fn foo(self) -> bool { false } unsafe fn foo_unsafe(self) -> bool { true } } impl<'a> TestTrait for TestStruct<'a> { fn trait_foo(self) -> bool { false } fn trait_foo_ref(&self) -> bool { false } } impl<'a> std::ops::Deref for TestStruct<'a> { type Target = char; fn deref(&self) -> &char { &'a' } } fn test_redundant_closures_containing_method_calls() { let i = 10; let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo()); let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo()); let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo_ref()); let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear()); unsafe { let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo_unsafe()); } let e = Some("str").map(|s| s.to_string()); let e = Some('a').map(|s| s.to_uppercase()); let e: std::vec::Vec = vec!['a', 'b', 'c'].iter().map(|c| c.len_utf8()).collect(); let e: std::vec::Vec = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect(); let e = Some(PathBuf::new()).as_ref().and_then(|s| s.to_str()); let c = Some(TestStruct { some_ref: &i }) .as_ref() .map(|c| c.to_ascii_uppercase()); fn test_different_borrow_levels(t: &[&T]) where T: TestTrait, { t.iter().filter(|x| x.trait_foo_ref()); t.iter().map(|x| x.trait_foo_ref()); } } struct Thunk(Box T>); impl Thunk { fn new T>(f: F) -> Thunk { let mut option = Some(f); // This should not trigger redundant_closure (#1439) Thunk(Box::new(move || option.take().unwrap()())) } fn unwrap(self) -> T { let Thunk(mut f) = self; f() } } fn foobar() { let thunk = Thunk::new(|| println!("Hello, world!")); thunk.unwrap() } fn foo(_: u8) {} fn foo2(_: u8) -> u8 { 1u8 } fn all(x: &[X], y: &X, f: F) -> bool where F: Fn(&X, &X) -> bool, { x.iter().all(|e| f(e, y)) } fn below(x: &u8, y: &u8) -> bool { x < y } unsafe fn unsafe_fn(_: u8) {} fn divergent(_: u8) -> ! { unimplemented!() } fn generic(_: T) -> u8 { 0 } fn passes_fn_mut(mut x: Box) { requires_fn_once(|| x()); } fn requires_fn_once(_: T) {} fn test_redundant_closure_with_function_pointer() { type FnPtrType = fn(u8); let foo_ptr: FnPtrType = foo; let a = Some(1u8).map(|a| foo_ptr(a)); } fn test_redundant_closure_with_another_closure() { let closure = |a| println!("{}", a); let a = Some(1u8).map(|a| closure(a)); } fn make_lazy(f: impl Fn() -> fn(u8) -> u8) -> impl Fn(u8) -> u8 { // Currently f is called when result of make_lazy is called. // If the closure is removed, f will be called when make_lazy itself is // called. This changes semantics, so the closure must stay. Box::new(move |x| f()(x)) } fn call String>(f: F) -> String { f(&mut "Hello".to_owned()) } fn test_difference_in_mutability() { call(|s| s.clone()); } struct Bar; impl std::ops::Deref for Bar { type Target = str; fn deref(&self) -> &str { "hi" } } fn test_deref_with_trait_method() { let _ = [Bar].iter().map(|s| s.to_string()).collect::>(); } fn mutable_closure_used_again(x: Vec, y: Vec, z: Vec) { let mut res = Vec::new(); let mut add_to_res = |n| res.push(n); x.into_iter().for_each(|x| add_to_res(x)); y.into_iter().for_each(|x| add_to_res(x)); z.into_iter().for_each(|x| add_to_res(x)); } fn mutable_closure_in_loop() { let mut value = 0; let mut closure = |n| value += n; for _ in 0..5 { Some(1).map(|n| closure(n)); let mut value = 0; let mut in_loop = |n| value += n; Some(1).map(|n| in_loop(n)); } } fn late_bound_lifetimes() { fn take_asref_path>(path: P) {} fn map_str(thunk: F) where F: FnOnce(&str), { } fn map_str_to_path(thunk: F) where F: FnOnce(&str) -> &Path, { } map_str(|s| take_asref_path(s)); map_str_to_path(|s| s.as_ref()); } mod type_param_bound { trait Trait { fn fun(); } fn take(_: T) {} fn test() { // don't lint, but it's questionable that rust requires a cast take(|| X::fun()); take(X::fun as fn()); } } // #8073 Don't replace closure with `Arc` or `Rc` fn arc_fp() { let rc = std::rc::Rc::new(|| 7); let arc = std::sync::Arc::new(|n| n + 1); let ref_arc = &std::sync::Arc::new(|_| 5); true.then(|| rc()); (0..5).map(|n| arc(n)); Some(4).map(|n| ref_arc(n)); } // #8460 Don't replace closures with params bounded as `ref` mod bind_by_ref { struct A; struct B; impl From<&A> for B { fn from(A: &A) -> Self { B } } fn test() { // should not lint Some(A).map(|a| B::from(&a)); // should not lint Some(A).map(|ref a| B::from(a)); } } // #7812 False positive on coerced closure fn coerced_closure() { fn function_returning_unit(f: F) {} function_returning_unit(|x| std::process::exit(x)); fn arr() -> &'static [u8; 0] { &[] } fn slice_fn(_: impl FnOnce() -> &'static [u8]) {} slice_fn(|| arr()); } // https://github.com/rust-lang/rust-clippy/issues/7861 fn box_dyn() { fn f(_: impl Fn(usize) -> Box) {} f(|x| Box::new(x)); } // https://github.com/rust-lang/rust-clippy/issues/5939 fn not_general_enough() { fn f(_: impl FnMut(&Path) -> std::io::Result<()>) {} f(|path| std::fs::remove_file(path)); } // https://github.com/rust-lang/rust-clippy/issues/9369 pub fn mutable_impl_fn_mut(mut f: impl FnMut(), mut f_used_once: impl FnMut()) -> impl FnMut() { fn takes_fn_mut(_: impl FnMut()) {} takes_fn_mut(|| f()); fn takes_fn_once(_: impl FnOnce()) {} takes_fn_once(|| f()); f(); move || takes_fn_mut(|| f_used_once()) } impl dyn TestTrait + '_ { fn method_on_dyn(&self) -> bool { false } } // https://github.com/rust-lang/rust-clippy/issues/7746 fn angle_brackets_and_args() { let array_opt: Option<&[u8; 3]> = Some(&[4, 8, 7]); array_opt.map(|a| a.as_slice()); let slice_opt: Option<&[u8]> = Some(b"slice"); slice_opt.map(|s| s.len()); let ptr_opt: Option<*const usize> = Some(&487); ptr_opt.map(|p| p.is_null()); let test_struct = TestStruct { some_ref: &487 }; let dyn_opt: Option<&dyn TestTrait> = Some(&test_struct); dyn_opt.map(|d| d.method_on_dyn()); } // https://github.com/rust-lang/rust-clippy/issues/12199 fn track_caller_fp() { struct S; impl S { #[track_caller] fn add_location(self) {} } #[track_caller] fn add_location() {} fn foo(_: fn()) {} fn foo2(_: fn(S)) {} foo(|| add_location()); foo2(|s| s.add_location()); } fn _late_bound_to_early_bound_regions() { struct Foo<'a>(&'a u32); impl<'a> Foo<'a> { fn f(x: &'a u32) -> Self { Foo(x) } } fn f(f: impl for<'a> Fn(&'a u32) -> Foo<'a>) -> Foo<'static> { f(&0) } let _ = f(|x| Foo::f(x)); struct Bar; impl<'a> From<&'a u32> for Bar { fn from(x: &'a u32) -> Bar { Bar } } fn f2(f: impl for<'a> Fn(&'a u32) -> Bar) -> Bar { f(&0) } let _ = f2(|x| ::from(x)); struct Baz<'a>(&'a u32); fn f3(f: impl Fn(&u32) -> Baz<'_>) -> Baz<'static> { f(&0) } let _ = f3(|x| Baz(x)); } fn _mixed_late_bound_and_early_bound_regions() { fn f(t: T, f: impl Fn(T, &u32) -> u32) -> u32 { f(t, &0) } fn f2<'a, T: 'a>(_: &'a T, y: &u32) -> u32 { *y } let _ = f(&0, |x, y| f2(x, y)); } fn _closure_with_types() { fn f(x: T) -> T { x } fn f2(f: impl Fn(T) -> T) -> T { f(T::default()) } let _ = f2(|x: u32| f(x)); let _ = f2(|x| -> u32 { f(x) }); } /// https://github.com/rust-lang/rust-clippy/issues/10854 /// This is to verify that redundant_closure_for_method_calls resolves suggested paths to relative. mod issue_10854 { pub mod test_mod { pub struct Test; impl Test { pub fn method(self) -> i32 { 0 } } pub fn calls_test(test: Option) -> Option { test.map(|t| t.method()) } pub fn calls_outer(test: Option) -> Option { test.map(|t| t.method()) } } pub struct Outer; impl Outer { pub fn method(self) -> i32 { 0 } } pub fn calls_into_mod(test: Option) -> Option { test.map(|t| t.method()) } mod a { pub mod b { pub mod c { pub fn extreme_nesting(test: Option) -> Option { test.map(|t| t.method()) } } } } mod d { pub struct Test; impl Test { pub fn method(self) -> i32 { 0 } } } }