about summary refs log tree commit diff
path: root/src/tools/clippy/tests/ui/manual_split_once.fixed
blob: 76dfb99b787d22b33ab10a61c93e3f83b433e46c (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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
#![warn(clippy::manual_split_once)]
#![allow(unused, clippy::iter_skip_next, clippy::iter_nth_zero)]

extern crate itertools;

#[allow(unused_imports)]
use itertools::Itertools;

fn main() {
    let _ = "key=value".splitn(2, '=').nth(2);
    let _ = "key=value".split_once('=').unwrap().1;
    //~^ manual_split_once
    let _ = "key=value".split_once('=').unwrap().1;
    //~^ manual_split_once
    let (_, _) = "key=value".split_once('=').unwrap();
    //~^ manual_split_once

    let s = String::from("key=value");
    let _ = s.split_once('=').unwrap().1;
    //~^ manual_split_once

    let s = Box::<str>::from("key=value");
    let _ = s.split_once('=').unwrap().1;
    //~^ manual_split_once

    let s = &"key=value";
    let _ = s.split_once('=').unwrap().1;
    //~^ manual_split_once

    fn _f(s: &str) -> Option<&str> {
        let _ = s.split_once('=')?.1;
        //~^ manual_split_once
        let _ = s.split_once('=')?.1;
        //~^ manual_split_once
        let _ = s.rsplit_once('=')?.0;
        //~^ manual_split_once
        let _ = s.rsplit_once('=')?.0;
        //~^ manual_split_once
        None
    }

    // Don't lint, slices don't have `split_once`
    let _ = [0, 1, 2].splitn(2, |&x| x == 1).nth(1).unwrap();

    // `rsplitn` gives the results in the reverse order of `rsplit_once`
    let _ = "key=value".rsplit_once('=').unwrap().0;
    //~^ manual_split_once
    let (_, _) = "key=value".rsplit_once('=').map(|(x, y)| (y, x)).unwrap();
    //~^ manual_split_once
    let _ = s.rsplit_once('=').map(|x| x.0);
    //~^ manual_split_once
}

fn indirect() -> Option<()> {
    let (l, r) = "a.b.c".split_once('.').unwrap();
    //~^ manual_split_once
    
    

    let (l, r) = "a.b.c".split_once('.')?;
    //~^ manual_split_once
    
    

    let (l, r) = "a.b.c".rsplit_once('.').unwrap();
    //~^ manual_split_once
    
    

    let (l, r) = "a.b.c".rsplit_once('.')?;
    //~^ manual_split_once
    
    

    // could lint, currently doesn't

    let mut iter = "a.b.c".splitn(2, '.');
    let other = 1;
    let l = iter.next()?;
    let r = iter.next()?;

    let mut iter = "a.b.c".splitn(2, '.');
    let mut mut_binding = iter.next()?;
    let r = iter.next()?;

    let mut iter = "a.b.c".splitn(2, '.');
    let tuple = (iter.next()?, iter.next()?);

    // should not lint

    let mut missing_unwrap = "a.b.c".splitn(2, '.');
    let l = missing_unwrap.next();
    let r = missing_unwrap.next();

    let mut mixed_unrap = "a.b.c".splitn(2, '.');
    let unwrap = mixed_unrap.next().unwrap();
    let question_mark = mixed_unrap.next()?;

    let mut iter = "a.b.c".splitn(2, '.');
    let same_name = iter.next()?;
    let same_name = iter.next()?;

    let mut iter = "a.b.c".splitn(2, '.');
    let shadows_existing = "d";
    let shadows_existing = iter.next()?;
    let r = iter.next()?;

    let mut iter = "a.b.c".splitn(2, '.');
    let becomes_shadowed = iter.next()?;
    let becomes_shadowed = "d";
    let r = iter.next()?;

    let mut iter = "a.b.c".splitn(2, '.');
    let l = iter.next()?;
    let r = iter.next()?;
    let third_usage = iter.next()?;

    let mut n_three = "a.b.c".splitn(3, '.');
    let l = n_three.next()?;
    let r = n_three.next()?;

    let mut iter = "a.b.c".splitn(2, '.');
    {
        let in_block = iter.next()?;
    }
    let r = iter.next()?;

    let mut lacks_binding = "a.b.c".splitn(2, '.');
    let _ = lacks_binding.next()?;
    let r = lacks_binding.next()?;

    let mut mapped = "a.b.c".splitn(2, '.').map(|_| "~");
    let l = iter.next()?;
    let r = iter.next()?;

    let mut assigned = "";
    let mut iter = "a.b.c".splitn(2, '.');
    let l = iter.next()?;
    assigned = iter.next()?;

    None
}

#[clippy::msrv = "1.51"]
fn _msrv_1_51() {
    // `str::split_once` was stabilized in 1.52. Do not lint this
    let _ = "key=value".splitn(2, '=').nth(1).unwrap();

    let mut iter = "a.b.c".splitn(2, '.');
    let a = iter.next().unwrap();
    let b = iter.next().unwrap();
}

#[clippy::msrv = "1.52"]
fn _msrv_1_52() {
    let _ = "key=value".split_once('=').unwrap().1;
    //~^ manual_split_once

    let (a, b) = "a.b.c".split_once('.').unwrap();
    //~^ manual_split_once
    
    
}