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
|
// RUN: %target-swiftc_driver %s -g %import-libdispatch -o %t
// RUN: %target-codesign %t
// RUN: %target-run %t
// REQUIRES: libdispatch
// REQUIRES: executable_test
// UNSUPPORTED: threading_none
import Dispatch
protocol P {
associatedtype Unused
}
struct A<T> : P {
// We never actually read this associated type, but its presence in the
// wtable should force it to be instantiated rather than shared for
// all specializations of A.
typealias Unused = A<A<T>>
}
protocol Q {
associatedtype Assoc: P
func foo()
}
struct B<T: P> : Q {
// Both the metadata and the wtable for this associated type require
// runtime instantiation and must be fetched lazily.
typealias Assoc = A<T>
func foo() {}
}
// It's possible that the optimizer might someday be able to recognize
// that this is a no-op.
func rundown<T: Q>(value: T, count: Int) {
guard count > 0 else { return }
value.foo()
// Assuming that T is B<U> for some U, this constructs B<A<U>>,
// which will be T in the recursive call; i.e. we should have a
// different metadata/wtable pair each time. In order to construct
// that, we have to read the associated metadata and wtable for T.Assoc.
rundown(value: B<T.Assoc>(), count: count - 1)
}
DispatchQueue.concurrentPerform(iterations: 5) { n in
rundown(value: B<A<()>>(), count: 1000)
}
|
