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
|
//@ 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.
#![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() {}
|
