src/tools/clippy/tests/ui/map_unwrap_or_fixable.fixed

//@aux-build:option_helpers.rs

#![warn(clippy::map_unwrap_or)]

#[macro_use]
extern crate option_helpers;

use std::collections::HashMap;

#[rustfmt::skip]
fn option_methods() {
    let opt = Some(1);

    // Check for `option.map(_).unwrap_or_else(_)` use.
    // single line case
    let _ = opt.map_or_else(|| 0, |x| x + 1);

    // Macro case.
    // Should not lint.
    let _ = opt_map!(opt, |x| x + 1).unwrap_or_else(|| 0);

    // Issue #4144
    {
        let mut frequencies = HashMap::new();
        let word = "foo";

        frequencies
            .get_mut(word)
            .map(|count| {
                *count += 1;
            })
            .unwrap_or_else(|| {
                frequencies.insert(word.to_owned(), 1);
            });
    }
}

#[rustfmt::skip]
fn result_methods() {
    let res: Result<i32, ()> = Ok(1);

    // Check for `result.map(_).unwrap_or_else(_)` use.
    // single line case
    let _ = res.map_or_else(|_e| 0, |x| x + 1);

    // macro case
    let _ = opt_map!(res, |x| x + 1).unwrap_or_else(|_e| 0); // should not lint
}

fn main() {}

fn issue15714() {
    let o: Option<i32> = Some(3);
    let r: Result<i32, ()> = Ok(3);
    println!("{}", o.map_or(3, |y| y + 1));
    //~^ map_unwrap_or
    println!("{}", o.map_or_else(|| 3, |y| y + 1));
    //~^ map_unwrap_or
    println!("{}", r.map_or(3, |y| y + 1));
    //~^ map_unwrap_or
    println!("{}", r.map_or_else(|()| 3, |y| y + 1));
    //~^ map_unwrap_or

    println!("{}", r.is_ok_and(|y| y == 1));
    //~^ map_unwrap_or
}

fn issue15713() {
    let x = &Some(3);
    println!("{}", x.map_or(3, |y| y + 1));
    //~^ map_unwrap_or

    let x: &Result<i32, ()> = &Ok(3);
    println!("{}", x.map_or(3, |y| y + 1));
    //~^ map_unwrap_or

    let x = &Some(3);
    println!("{}", x.map_or_else(|| 3, |y| y + 1));
    //~^ map_unwrap_or

    let x: &Result<i32, ()> = &Ok(3);
    println!("{}", x.map_or_else(|_| 3, |y| y + 1));
    //~^ map_unwrap_or
}

// Support `map(_).unwrap_or_default()` pattern
mod pr17644 {
    macro_rules! identity {
        // Inner bracket is necessary to detect macro expansion
        ( $e:expr ) => {{ $e }};
    }

    #[clippy::msrv = "1.98"]
    mod unwrap_or_default {
        fn option(opt: Option<i32>) {
            let _ = opt.map_or_default(|x| x * x); //~ map_unwrap_or
            let _ = opt.map_or_default(|x| vec![x]); //~ map_unwrap_or
            let _ = identity!(opt.map_or_default(|x| x + 1)); //~ map_unwrap_or
            let _ = identity!(opt.map(|x| x + 1)).unwrap_or_default();
            let _ = identity!(opt).map(|x| x + 1).unwrap_or_default();
        }
        fn result(res: Result<i32, ()>) {
            let _ = res.map_or_default(|x| x * x); //~ map_unwrap_or
            let _ = res.map_or_default(|x| vec![x]); //~ map_unwrap_or
            let _ = identity!(res.map_or_default(|x| x + 1)); //~ map_unwrap_or
            let _ = identity!(res.map(|x| x + 1)).unwrap_or_default();
            let _ = identity!(res).map(|x| x + 1).unwrap_or_default();
        }
    }

    #[clippy::msrv = "1.97"]
    mod unwrap_or_default_before_msrv {
        fn option(opt: Option<i32>) {
            let _ = opt.map(|x| x * x).unwrap_or_default();
            let _ = opt.map(|x| vec![x]).unwrap_or_default();
            let _ = identity!(opt.map(|x| x + 1).unwrap_or_default());
            let _ = identity!(opt.map(|x| x + 1)).unwrap_or_default();
            let _ = identity!(opt).map(|x| x + 1).unwrap_or_default();
        }
        fn result(res: Result<i32, ()>) {
            let _ = res.map(|x| x * x).unwrap_or_default();
            let _ = res.map(|x| vec![x]).unwrap_or_default();
            let _ = identity!(res.map(|x| x + 1).unwrap_or_default());
            let _ = identity!(res.map(|x| x + 1)).unwrap_or_default();
            let _ = identity!(res).map(|x| x + 1).unwrap_or_default();
        }
    }
}