#![warn(clippy::option_if_let_else)] #![allow( unused_tuple_struct_fields, clippy::ref_option_ref, clippy::equatable_if_let, clippy::let_unit_value, clippy::redundant_locals )] fn bad1(string: Option<&str>) -> (bool, &str) { string.map_or((false, "hello"), |x| (true, x)) } fn else_if_option(string: Option<&str>) -> Option<(bool, &str)> { if string.is_none() { None } else if let Some(x) = string { Some((true, x)) } else { Some((false, "")) } } fn unop_bad(string: &Option<&str>, mut num: Option) { let _ = string.map_or(0, |s| s.len()); let _ = num.as_ref().map_or(&0, |s| s); let _ = num.as_mut().map_or(&0, |s| { *s += 1; s }); let _ = num.as_ref().map_or(&0, |s| s); let _ = num.map_or(0, |mut s| { s += 1; s }); let _ = num.as_mut().map_or(&0, |s| { *s += 1; s }); } fn longer_body(arg: Option) -> u32 { arg.map_or(13, |x| { let y = x * x; y * y }) } fn impure_else(arg: Option) { let side_effect = || { println!("return 1"); 1 }; let _ = arg.map_or_else(side_effect, |x| x); } fn test_map_or_else(arg: Option) { let _ = arg.map_or_else(|| { let mut y = 1; y = (y + 2 / y) / 2; y = (y + 2 / y) / 2; y }, |x| x * x * x * x); } fn negative_tests(arg: Option) -> u32 { let _ = if let Some(13) = arg { "unlucky" } else { "lucky" }; for _ in 0..10 { let _ = if let Some(x) = arg { x } else { continue; }; } let _ = if let Some(x) = arg { return x; } else { 5 }; 7 } // #7973 fn pattern_to_vec(pattern: &str) -> Vec { pattern .trim_matches('/') .split('/') .flat_map(|s| { s.find('.').map_or_else(|| vec![s.to_string()], |idx| vec![s[..idx].to_string(), s[idx..].to_string()]) }) .collect::>() } // #10335 fn test_result_impure_else(variable: Result) { variable.map_or_else(|_| { println!("Err"); }, |binding| { println!("Ok {binding}"); }) } enum DummyEnum { One(u8), Two, } // should not warn since there is a complex subpat // see #7991 fn complex_subpat() -> DummyEnum { let x = Some(DummyEnum::One(1)); let _ = if let Some(_one @ DummyEnum::One(..)) = x { 1 } else { 2 }; DummyEnum::Two } fn main() { let optional = Some(5); let _ = optional.map_or(5, |x| x + 2); let _ = bad1(None); let _ = else_if_option(None); unop_bad(&None, None); let _ = longer_body(None); test_map_or_else(None); test_result_impure_else(Ok(42)); let _ = negative_tests(None); let _ = impure_else(None); let _ = Some(0).map_or(0, |x| loop { if x == 0 { break x; } }); // #7576 const fn _f(x: Option) -> u32 { // Don't lint, `map_or` isn't const if let Some(x) = x { x } else { 10 } } // #5822 let s = String::new(); // Don't lint, `Some` branch consumes `s`, but else branch uses `s` let _ = if let Some(x) = Some(0) { let s = s; s.len() + x } else { s.len() }; let s = String::new(); // Lint, both branches immutably borrow `s`. let _ = Some(0).map_or(s.len(), |x| s.len() + x); let s = String::new(); // Lint, `Some` branch consumes `s`, but else branch doesn't use `s`. let _ = Some(0).map_or(1, |x| { let s = s; s.len() + x }); let s = Some(String::new()); // Don't lint, `Some` branch borrows `s`, but else branch consumes `s` let _ = if let Some(x) = &s { x.len() } else { let _s = s; 10 }; let mut s = Some(String::new()); // Don't lint, `Some` branch mutably borrows `s`, but else branch also borrows `s` let _ = if let Some(x) = &mut s { x.push_str("test"); x.len() } else { let _s = &s; 10 }; async fn _f1(x: u32) -> u32 { x } async fn _f2() { // Don't lint. `await` can't be moved into a closure. let _ = if let Some(x) = Some(0) { _f1(x).await } else { 0 }; } let _ = pattern_to_vec("hello world"); let _ = complex_subpat(); // issue #8492 let _ = s.map_or(1, |string| string.len()); let _ = Some(10).map_or(5, |a| a + 1); let res: Result = Ok(5); let _ = res.map_or(1, |a| a + 1); let _ = res.map_or(1, |a| a + 1); let _ = res.map_or(5, |a| a + 1); } #[allow(dead_code)] fn issue9742() -> Option<&'static str> { // should not lint because of guards match Some("foo ") { Some(name) if name.starts_with("foo") => Some(name.trim()), _ => None, } } mod issue10729 { #![allow(clippy::unit_arg, dead_code)] pub fn reproduce(initial: &Option) { // 👇 needs `.as_ref()` because initial is an `&Option<_>` initial.as_ref().map_or({}, |value| do_something(value)) } pub fn reproduce2(initial: &mut Option) { initial.as_mut().map_or({}, |value| do_something2(value)) } fn do_something(_value: &str) {} fn do_something2(_value: &mut str) {} } fn issue11429() { use std::collections::HashMap; macro_rules! new_map { () => {{ HashMap::new() }}; } let opt: Option> = None; let mut _hashmap = opt.as_ref().map_or_else(HashMap::new, |hm| hm.clone()); let mut _hm = opt.as_ref().map_or_else(|| new_map!(), |hm| hm.clone()); }