#![warn(clippy::redundant_pattern_matching)]
#![allow(deprecated)]
#![allow(
    clippy::if_same_then_else,
    clippy::match_like_matches_macro,
    clippy::needless_bool,
    clippy::needless_ifs,
    clippy::uninlined_format_args,
    clippy::unnecessary_wraps
)]

fn main() {
    let result: Result<usize, usize> = Err(5);
    if result.is_ok() {}
    //~^ redundant_pattern_matching

    if Ok::<i32, i32>(42).is_ok() {}
    //~^ redundant_pattern_matching

    if Err::<i32, i32>(42).is_err() {}
    //~^ redundant_pattern_matching

    while Ok::<i32, i32>(10).is_ok() {}
    //~^ redundant_pattern_matching

    while Ok::<i32, i32>(10).is_err() {}
    //~^ redundant_pattern_matching

    if Ok::<i32, i32>(42).is_ok() {}

    if Err::<i32, i32>(42).is_err() {}

    if let Ok(x) = Ok::<i32, i32>(42) {
        println!("{}", x);
    }

    Ok::<i32, i32>(42).is_ok();

    Ok::<i32, i32>(42).is_err();

    Err::<i32, i32>(42).is_err();

    Err::<i32, i32>(42).is_ok();

    let _ = if Ok::<usize, ()>(4).is_ok() { true } else { false };
    //~^ redundant_pattern_matching

    issue5504();
    issue6067();
    issue6065();
    issue10726();
    issue10803();

    let _ = if gen_res().is_ok() {
        //~^ redundant_pattern_matching
        1
    } else if gen_res().is_err() {
        //~^ redundant_pattern_matching
        2
    } else {
        3
    };
}

fn gen_res() -> Result<(), ()> {
    Ok(())
}

macro_rules! m {
    () => {
        Some(42u32)
    };
}

fn issue5504() {
    fn result_opt() -> Result<Option<i32>, i32> {
        Err(42)
    }

    fn try_result_opt() -> Result<i32, i32> {
        while r#try!(result_opt()).is_some() {}
        //~^ redundant_pattern_matching
        if r#try!(result_opt()).is_some() {}
        //~^ redundant_pattern_matching
        Ok(42)
    }

    try_result_opt();

    if m!().is_some() {}
    //~^ redundant_pattern_matching
    while m!().is_some() {}
    //~^ redundant_pattern_matching
}

fn issue6065() {
    macro_rules! if_let_in_macro {
        ($pat:pat, $x:expr) => {
            if let Some($pat) = $x {}
        };
    }

    // shouldn't be linted
    if_let_in_macro!(_, Some(42));
}

// Methods that are unstable const should not be suggested within a const context, see issue #5697.
// However, in Rust 1.48.0 the methods `is_ok` and `is_err` of `Result` were stabilized as const,
// so the following should be linted.
const fn issue6067() {
    if Ok::<i32, i32>(42).is_ok() {}
    //~^ redundant_pattern_matching

    if Err::<i32, i32>(42).is_err() {}
    //~^ redundant_pattern_matching

    while Ok::<i32, i32>(10).is_ok() {}
    //~^ redundant_pattern_matching

    while Ok::<i32, i32>(10).is_err() {}
    //~^ redundant_pattern_matching

    Ok::<i32, i32>(42).is_ok();

    Err::<i32, i32>(42).is_err();
}

fn issue10726() {
    // This is optional, but it makes the examples easier
    let x: Result<i32, i32> = Ok(42);

    x.is_ok();

    x.is_err();

    x.is_err();

    x.is_ok();

    // Don't lint
    match x {
        Err(16) => false,
        _ => true,
    };

    // Don't lint
    match x {
        Ok(16) => false,
        _ => true,
    };
}

fn issue10803() {
    let x: Result<i32, i32> = Ok(42);

    let _ = x.is_ok();
    //~^ redundant_pattern_matching

    let _ = x.is_err();
    //~^ redundant_pattern_matching

    // Don't lint
    let _ = matches!(x, Ok(16));

    // Don't lint
    let _ = matches!(x, Err(16));
}

fn wrongly_unmangled_macros() {
    macro_rules! test_expr {
        ($val:expr) => {
            Ok::<i32, i32>($val)
        };
    }

    let _ = test_expr!(42).is_ok();

    macro_rules! test_guard {
        ($val:expr) => {
            ($val + 1) > 0
        };
    }

    let x: Result<i32, ()> = Ok(42);
    let _ = x.is_ok() && test_guard!(42);
    //~^ redundant_pattern_matching
}
