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

#![warn(clippy::manual_map)]
#![expect(clippy::toplevel_ref_arg)]

fn main() {
    // Lint. `y` is declared within the arm, so it isn't captured by the map closure
    let _ = Some(0).map(|x| {
            let y = (String::new(), String::new());
            (x, y.0)
        });

    // Don't lint. `s` is borrowed until partway through the arm, but needs to be captured by the map
    // closure
    let s = Some(String::new());
    let _ = match &s {
        Some(x) => Some((x.clone(), s)),
        None => None,
    };

    // Don't lint. `s` is borrowed until partway through the arm, but needs to be captured by the map
    // closure
    let s = Some(String::new());
    let _ = match &s {
        Some(x) => Some({
            let clone = x.clone();
            let s = || s;
            (clone, s())
        }),
        None => None,
    };

    // Don't lint. `s` is borrowed until partway through the arm, but needs to be captured as a mutable
    // reference by the map closure
    let mut s = Some(String::new());
    let _ = match &s {
        Some(x) => Some({
            let clone = x.clone();
            let ref mut s = s;
            (clone, s)
        }),
        None => None,
    };

    let s = Some(String::new());
    // Lint. `s` is captured by reference, so no lifetime issues.
    let _ = s.as_ref().map(|x| { if let Some(ref s) = s { (x.clone(), s) } else { panic!() } });
    // Don't lint this, type of `s` is coercioned from `&String` to `&str`
    let x: Option<(String, &str)> = match &s {
        Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
        None => None,
    };

    // Issue #7820
    unsafe fn f(x: u32) -> u32 {
        x
    }
    unsafe {
        let _ = Some(0).map(|x| f(x));
    }
    let _ = Some(0).map(|x| unsafe { f(x) });
    let _ = Some(0).map(|x| unsafe { f(x) });
}

// issue #12659
mod with_type_coercion {
    trait DummyTrait {}

    fn foo<T: DummyTrait, F: Fn() -> Result<T, ()>>(f: F) {
        // Don't lint
        let _: Option<Result<Box<dyn DummyTrait>, ()>> = match Some(0) {
            Some(_) => Some(match f() {
                Ok(res) => Ok(Box::new(res)),
                _ => Err(()),
            }),
            None => None,
        };

        let _: Option<Box<&[u8]>> = match Some(()) {
            Some(_) => Some(Box::new(b"1234")),
            None => None,
        };

        let x = String::new();
        let _: Option<Box<&str>> = match Some(()) {
            Some(_) => Some(Box::new(&x)),
            None => None,
        };

        let _: Option<&str> = match Some(()) {
            Some(_) => Some(&x),
            None => None,
        };

        let _ = Some(0).map(|_| match f() {
                Ok(res) => Ok(Box::new(res)),
                _ => Err(()),
            });
    }

    #[allow(clippy::redundant_allocation)]
    fn bar() {
        fn f(_: Option<Box<&[u8]>>) {}
        fn g(b: &[u8]) -> Box<&[u8]> {
            Box::new(b)
        }

        let x: &[u8; 4] = b"1234";
        f(match Some(()) {
            Some(_) => Some(Box::new(x)),
            None => None,
        });

        let _: Option<Box<&[u8]>> = Some(0).map(|_| g(x));
    }

    fn with_fn_ret(s: &Option<String>) -> Option<(String, &str)> {
        // Don't lint, `map` doesn't work as the return type is adjusted.
        match s {
            Some(x) => Some({ if let Some(s) = s { (x.clone(), s) } else { panic!() } }),
            None => None,
        }
    }

    fn with_fn_ret_2(s: &Option<String>) -> Option<(String, &str)> {
        if true {
            // Don't lint, `map` doesn't work as the return type is adjusted.
            return match s {
                Some(x) => Some({ if let Some(s) = s { (x.clone(), s) } else { panic!() } }),
                None => None,
            };
        }
        None
    }

    #[allow(clippy::needless_late_init)]
    fn with_fn_ret_3<'a>(s: &'a Option<String>) -> Option<(String, &'a str)> {
        let x: Option<(String, &'a str)>;
        x = {
            match s {
                Some(x) => Some({ if let Some(s) = s { (x.clone(), s) } else { panic!() } }),
                None => None,
            }
        };
        x
    }
}