about summary refs log tree commit diff
path: root/src/tools/clippy/tests/ui/needless_option_as_deref.rs
blob: cbf7935794b317b7fc1f97e18db8a8c4f8c7c31f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
#![allow(unused)]
#![warn(clippy::needless_option_as_deref)]
#![allow(clippy::useless_vec)]

fn main() {
    // should lint
    let _: Option<&usize> = Some(&1).as_deref();
    //~^ needless_option_as_deref
    let _: Option<&mut usize> = Some(&mut 1).as_deref_mut();
    //~^ needless_option_as_deref

    let mut y = 0;
    let mut x = Some(&mut y);
    let _ = x.as_deref_mut();
    //~^ needless_option_as_deref

    // should not lint
    let _ = Some(Box::new(1)).as_deref();
    let _ = Some(Box::new(1)).as_deref_mut();

    let mut y = 0;
    let mut x = Some(&mut y);
    for _ in 0..3 {
        let _ = x.as_deref_mut();
    }

    let mut y = 0;
    let mut x = Some(&mut y);
    let mut closure = || {
        let _ = x.as_deref_mut();
    };
    closure();
    closure();

    // #7846
    let mut i = 0;
    let mut opt_vec = vec![Some(&mut i)];
    opt_vec[0].as_deref_mut().unwrap();

    let mut i = 0;
    let x = &mut Some(&mut i);
    (*x).as_deref_mut();

    // #8047
    let mut y = 0;
    let mut x = Some(&mut y);
    x.as_deref_mut();
    dbg!(x);
}

struct S<'a> {
    opt: Option<&'a mut usize>,
}

fn from_field<'a>(s: &'a mut S<'a>) -> Option<&'a mut usize> {
    s.opt.as_deref_mut()
}

mod issue_non_copy_13077 {
    pub fn something(mut maybe_side_effect: Option<&mut String>) {
        for _ in 0..10 {
            let _ = S {
                field: other(maybe_side_effect.as_deref_mut()),
            };
        }
    }

    fn other(_maybe_side_effect: Option<&mut String>) {
        unimplemented!()
    }

    pub struct S {
        pub field: (),
    }
}

mod issue14148 {
    pub trait SomeTrait {
        fn something(&self, mut maybe_side_effect: Option<&mut String>) {
            other(maybe_side_effect.as_deref_mut());
            other(maybe_side_effect);
        }
    }

    fn other(_maybe_side_effect: Option<&mut String>) {
        unimplemented!()
    }
}