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

#![warn(clippy::match_single_binding)]
#![allow(
    unused,
    clippy::let_unit_value,
    clippy::no_effect,
    clippy::toplevel_ref_arg,
    clippy::useless_vec
)]

struct Point {
    x: i32,
    y: i32,
}

fn coords() -> Point {
    Point { x: 1, y: 2 }
}

macro_rules! foo {
    ($param:expr) => {
        match $param {
            _ => println!("whatever"),
        }
    };
}

fn main() {
    let a = 1;
    let b = 2;
    let c = 3;
    // Lint
    let (x, y, z) = (a, b, c);
    {
        println!("{x} {y} {z}");
    }
    // Lint
    let (x, y, z) = (a, b, c);
    println!("{x} {y} {z}");
    // Ok
    foo!(a);
    // Ok
    match a {
        2 => println!("2"),
        _ => println!("Not 2"),
    }
    // Ok
    let d = Some(5);
    match d {
        Some(d) => println!("{d}"),
        _ => println!("None"),
    }
    // Lint
    println!("whatever");
    // Lint
    {
        let x = 29;
        println!("x has a value of {x}");
    }
    // Lint
    {
        let e = 5 * a;
        if e >= 5 {
            println!("e is superior to 5");
        }
    }
    // Lint
    let p = Point { x: 0, y: 7 };
    let Point { x, y } = p;
    println!("Coords: ({x}, {y})");
    // Lint
    let Point { x: x1, y: y1 } = p;
    println!("Coords: ({x1}, {y1})");
    // Lint
    let x = 5;
    let ref r = x;
    println!("Got a reference to {r}");
    // Lint
    let mut x = 5;
    let ref mut mr = x;
    println!("Got a mutable reference to {mr}");
    // Lint
    let Point { x, y } = coords();
    let product = x * y;
    // Lint
    let v = vec![Some(1), Some(2), Some(3), Some(4)];
    #[allow(clippy::let_and_return)]
    let _ = v
        .iter()
        .map(|i| {
            let unwrapped = i.unwrap();
            unwrapped
        })
        .collect::<Vec<u8>>();
    // Ok
    let x = 1;
    match x {
        #[cfg(disabled_feature)]
        0 => println!("Disabled branch"),
        _ => println!("Enabled branch"),
    }

    // Ok
    let x = 1;
    let y = 1;
    match match y {
        0 => 1,
        _ => 2,
    } {
        #[cfg(disabled_feature)]
        0 => println!("Array index start"),
        _ => println!("Not an array index start"),
    }

    // Lint
    let x = 1;
    println!("Not an array index start")
}

fn issue_8723() {
    let (mut val, idx) = ("a b", 1);

    let (pre, suf) = val.split_at(idx);
    val = {
        println!("{pre}");
        suf
    };

    let _ = val;
}

fn side_effects() {}

fn issue_9575() {
    let _ = || {
        side_effects();
        println!("Needs curlies")
    };
}

fn issue_9725(r: Option<u32>) {
    let x = r;
    match x {
        Some(_) => {
            println!("Some");
        },
        None => {
            println!("None");
        },
    };
}

fn issue_10447() -> usize {
    ();

    let a = ();

    side_effects();

    let b = side_effects();

    println!("1");

    let c = println!("1");

    let in_expr = [
        (),
        side_effects(),
        println!("1"),
    ];

    2
}

fn issue14634() {
    macro_rules! id {
        ($i:ident) => {
            $i
        };
    }
    dbg!(3);
    println!("here");
    //~^^^ match_single_binding
    let id!(a) = dbg!(3);
    println!("found {a}");
    //~^^^ match_single_binding
    let id!(b) = dbg!(3);
    let id!(_a) = dbg!(b + 1);
    //~^^^ match_single_binding
}

mod issue14991 {
    struct AnnoConstWOBlock {
        inner: [(); {
            let _n = 1;
            42
        }],
    }

    struct AnnoConstWBlock {
        inner: [(); {
            let _n = 1;
            42
        }],
    }
}

mod issue15018 {
    fn used_later(a: i32, b: i32, c: i32) {
        let x = 1;
        {
            let (x, y, z) = (a, b, c);
            println!("{x} {y} {z}");
        }
        println!("x = {x}");
    }

    fn not_used_later(a: i32, b: i32, c: i32) {
        let (x, y, z) = (a, b, c);
        println!("{x} {y} {z}")
    }

    #[allow(irrefutable_let_patterns)]
    fn not_used_later_but_shadowed(a: i32, b: i32, c: i32) {
        let (x, y, z) = (a, b, c);
        println!("{x} {y} {z}");
        let x = 1;
        println!("x = {x}");
    }

    #[allow(irrefutable_let_patterns)]
    fn not_used_later_but_shadowed_nested(a: i32, b: i32, c: i32) {
        let (x, y, z) = (a, b, c);
        println!("{x} {x} {y}");
        if let (x, y, z) = (a, b, c) {
            println!("{x} {y} {z}")
        }

        {
            let x: i32 = 1;
            {
                let (x, y, z) = (a, b, c);
                println!("{x} {y} {z}");
            }
            if let (x, y, z) = (a, x, c) {
                println!("{x} {y} {z}")
            }
        }

        {
            let (x, y, z) = (a, b, c);
            println!("{x} {y} {z}");
            let fn_ = |y| {
                println!("{a} {b} {y}");
            };
            fn_(c);
        }
    }
}

#[allow(clippy::short_circuit_statement)]
fn issue15269(a: usize, b: usize, c: usize) -> bool {
    a < b
        && b < c;

    a < b
        && b < c
}

#[allow(
    irrefutable_let_patterns,
    clippy::blocks_in_conditions,
    clippy::unused_unit,
    clippy::let_unit_value,
    clippy::unit_arg,
    clippy::unnecessary_operation
)]
fn issue15537(a: i32) -> ((), (), ()) {
    let y = (
        { todo!() },
        {
            { a };
            ()
        },
        (),
    );

    let y = [
        { todo!() },
        {
            { a };
            ()
        },
        (),
    ];

    fn call(x: (), y: (), z: ()) {}
    let y = call(
        { todo!() },
        {
            { a };
            ()
        },
        (),
    );

    struct Foo;
    impl Foo {
        fn method(&self, x: (), y: (), z: ()) {}
    }
    let x = Foo;
    x.method(
        { todo!() },
        {
            { a };
            ()
        },
        (),
    );

    -{
        { a };
        1
    };

    _ = { a };
    1;

    if let x = {
        { a };
        1
    } {}

    if {
        { a };
        true
    } {
        todo!()
    }

    [1, 2, 3][{
        { a };
        1usize
    }];

    todo!()
}