summaryrefslogtreecommitdiffstats
path: root/tests/ui/did_you_mean/issue-48492-tuple-destructure-missing-parens.rs
blob: 43b5f6d5431d68c1de714bd1ccf95debdad796a4 (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
#![allow(unused)]

#[derive(Copy, Clone)]
enum Nucleotide {
    Adenine,
    Thymine,
    Cytosine,
    Guanine
}

#[derive(Clone)]
struct Autosome;

#[derive(Clone)]
enum Allosome {
    X(Vec<Nucleotide>),
    Y(Vec<Nucleotide>)
}

impl Allosome {
    fn is_x(&self) -> bool {
        match *self {
            Allosome::X(_) => true,
            Allosome::Y(_) => false,
        }
    }
}

#[derive(Clone)]
struct Genome {
    autosomes: [Autosome; 22],
    allosomes: (Allosome, Allosome)
}

fn find_start_codon(strand: &[Nucleotide]) -> Option<usize> {
    let mut reading_frame = strand.windows(3);
    // (missing parentheses in `while let` tuple pattern)
    while let b1, b2, b3 = reading_frame.next().expect("there should be a start codon") {
        //~^ ERROR unexpected `,` in pattern
        // ...
    }
    None
}

fn find_thr(strand: &[Nucleotide]) -> Option<usize> {
    let mut reading_frame = strand.windows(3);
    let mut i = 0;
    // (missing parentheses in `if let` tuple pattern)
    if let b1, b2, b3 = reading_frame.next().unwrap() {
        //~^ ERROR unexpected `,` in pattern
        // ...
    }
    None
}

fn is_thr(codon: (Nucleotide, Nucleotide, Nucleotide)) -> bool {
    match codon {
        // (missing parentheses in match arm tuple pattern)
        Nucleotide::Adenine, Nucleotide::Cytosine, _ => true
        //~^ ERROR unexpected `,` in pattern
        _ => false
    }
}

fn analyze_female_sex_chromosomes(women: &[Genome]) {
    // (missing parentheses in `for` tuple pattern)
    for x, _barr_body in women.iter().map(|woman| woman.allosomes.clone()) {
        //~^ ERROR unexpected `,` in pattern
        // ...
    }
}

fn analyze_male_sex_chromosomes(men: &[Genome]) {
    // (missing parentheses in pattern with `@` binding)
    for x, y @ Allosome::Y(_) in men.iter().map(|man| man.allosomes.clone()) {
        //~^ ERROR unexpected `,` in pattern
        // ...
    }
}

fn main() {
    let genomes = Vec::new();
    // (missing parentheses in `let` pattern)
    let women, men: (Vec<Genome>, Vec<Genome>) = genomes.iter().cloned()
    //~^ ERROR unexpected `,` in pattern
        .partition(|g: &Genome| g.allosomes.0.is_x() && g.allosomes.1.is_x());
}