summaryrefslogtreecommitdiffstats
path: root/tests/ui/higher-rank-trait-bounds/issue-62203-hrtb-ice.rs
blob: e70f6fc3430f67726e0192f0119ffd3657d5cff2 (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
trait T0<'a, A> {
    type O;
}

struct L<T> {
    f: T,
}

// explicitly named variants of what one would normally denote by the
// unit type `()`. Why do this? So that we can differentiate them in
// the diagnostic output.
struct Unit1;
struct Unit2;
struct Unit3;
struct Unit4;

impl<'a, A, T> T0<'a, A> for L<T>
where
    T: FnMut(A) -> Unit3,
{
    type O = T::Output;
}

trait T1: for<'r> Ty<'r> {
    fn m<'a, B: Ty<'a>, F>(&self, f: F) -> Unit1
    where
        F: for<'r> T0<'r, (<Self as Ty<'r>>::V,), O = <B as Ty<'r>>::V>,
    {
        unimplemented!();
    }
}

trait Ty<'a> {
    type V;
}

fn main() {
    let v = Unit2.m(
        L {
            //~^ ERROR to be a closure that returns `Unit3`, but it returns `Unit4`
            //~| ERROR type mismatch
            f: |x| {
                drop(x);
                Unit4
            },
        },
    );
}

impl<'a> Ty<'a> for Unit2 {
    type V = &'a u8;
}

impl T1 for Unit2 {}