summaryrefslogtreecommitdiffstats
path: root/tests/ui/methods/method-normalize-bounds-issue-20604.rs
blob: 9c0b952849eab1c8fa182ec38e5eac3aa8b8f90d (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
// run-pass
#![allow(dead_code)]
#![allow(unused_variables)]
#![allow(stable_features)]

// Test that we handle projection types which wind up important for
// resolving methods. This test was reduced from a larger example; the
// call to `foo()` at the end was failing to resolve because the
// winnowing stage of method resolution failed to handle an associated
// type projection.

// pretty-expanded FIXME #23616

#![feature(associated_types)]

trait Hasher {
    type Output;
    fn finish(&self) -> Self::Output;
}

trait Hash<H: Hasher> {
    fn hash(&self, h: &mut H);
}

trait HashState {
    type Wut: Hasher;
    fn hasher(&self) -> Self::Wut;
}

struct SipHasher;
impl Hasher for SipHasher {
    type Output = u64;
    fn finish(&self) -> u64 { 4 }
}

impl Hash<SipHasher> for isize {
    fn hash(&self, h: &mut SipHasher) {}
}

struct SipState;
impl HashState for SipState {
    type Wut = SipHasher;
    fn hasher(&self) -> SipHasher { SipHasher }
}

struct Map<S> {
    s: S,
}

impl<S> Map<S>
    where S: HashState,
          <S as HashState>::Wut: Hasher<Output=u64>,
{
    fn foo<K>(&self, k: K) where K: Hash< <S as HashState>::Wut> {}
}

fn foo<K: Hash<SipHasher>>(map: &Map<SipState>) {
    map.foo(22);
}

fn main() {}