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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
// RUN: %target-run-simple-swift(-Xfrontend -sil-verify-all -Xfrontend -disable-availability-checking) | %FileCheck %s
// RUN: %target-run-simple-swift(-O -Xfrontend -sil-verify-all -Xfrontend -disable-availability-checking) | %FileCheck %s
// REQUIRES: executable_test
// UNSUPPORTED: use_os_stdlib
// UNSUPPORTED: back_deployment_runtime
protocol P {
func speak()
}
extension P {
func speak() { print("hello") }
}
struct Noncopyable: ~Copyable {}
struct Ordinary {}
struct Dog<T: ~Copyable>: Copyable {}
extension Dog: P where T: Copyable {}
enum Cat<Left: ~Copyable, Right: ~Copyable>: Copyable {
case meows
init() { self = .meows }
}
extension Cat: P where Left: Copyable, Right: ~Copyable {}
struct ConditionallyCopyable<T: ~Copyable>: ~Copyable {
var value: Int = 17
}
extension ConditionallyCopyable: Copyable where T: Copyable { }
// FIXME: Not yet supported
// struct VariadicCopyable<each T: ~Copyable>: Copyable { }
// extension VariadicCopyable: P where repeat each T: Copyable { }
func attemptCall(_ a: Any) {
if let value = a as? P {
value.speak()
return
}
print("failed to cast (attemptCall)")
}
@_silgen_name("swift_getExtendedFunctionTypeMetadata")
func _getExtendedFunctionTypeMetadata(
flags: UInt, differentiabilityKind: UInt,
parameterTypes: UnsafePointer<Any.Type>?,
parameterFlags: UnsafePointer<UInt32>?,
resultType: Any.Type, globalActorType: Any.Type? = nil,
extendedFlags: UInt32, thrownErrorType: Any.Type? = nil) -> Any.Type
defer { main() }
func main() {
// CHECK: hello
attemptCall(Dog<Ordinary>())
// CHECK: failed to cast (attemptCall)
attemptCall(Dog<Noncopyable>())
// CHECK: failed to cast (attemptCall)
attemptCall(Dog<ConditionallyCopyable<Noncopyable>>())
// CHECK: hello
attemptCall(Cat<Ordinary, Noncopyable>())
// CHECK: failed to cast (attemptCall)
attemptCall(Cat<Noncopyable, Ordinary>())
// CHECK: failed to cast (attemptCall)
attemptCall(Cat<Noncopyable, ConditionallyCopyable<Ordinary>>())
// CHECK-FIXME: hello
// attemptCall(VariadicCopyable<Ordinary, ConditionallyCopyable<Ordinary>>())
// CHECK-FIXME: failed to cast (attemptCall)
// attemptCall(VariadicCopyable<Ordinary, ConditionallyCopyable<Noncopyable>>())
// CHECK: tuple types
print("tuple types")
// CHECK: hello
attemptCall(Dog<(Ordinary, Ordinary)>())
// CHECK-FIXME: failed to cast (attemptCall)
// FIXME: Requires the ability to create such tuple types
// attemptCall(Dog<(Ordinary, Noncopyable)>())
// CHECK: metatype types
print("metatype types")
// CHECK: hello
attemptCall(Dog<Ordinary.Type>())
// CHECK: hello
attemptCall(Dog<Noncopyable.Type>())
// CHECK: function types
print("function types")
attemptCall(Dog<(Ordinary) -> Noncopyable>())
// This is a nonmovable function type, which cannot currently be
// expressed in the language.
let noncopyableFnType = _getExtendedFunctionTypeMetadata(
flags: 0x04000000 | 0x80000000,
differentiabilityKind: 0,
parameterTypes: nil,
parameterFlags: nil,
resultType: Void.self,
extendedFlags: 0x1 << 16)
// CHECK: failed to cast (attemptCall)
func doFuncCall<F>(_: F.Type) {
attemptCall(Dog<F>())
}
_openExistential(noncopyableFnType, do: doFuncCall)
// CHECK: existential types
print("existential types")
// CHECK: hello
attemptCall(Dog<Any>())
// CHECK-FIXME: failed to cast (attemptCall)
// FIXME crashes: attemptCall(Dog<any ~Copyable>())
// CHECK: cast succeeded
test_radar124171788(.nothing)
}
// coverage for rdar://124171788
enum Maybe<Wrapped: ~Copyable>: ~Copyable {
case just(Wrapped)
case nothing
}
extension Maybe: Copyable where Wrapped: Copyable {}
extension Maybe: CustomDebugStringConvertible {
var debugDescription: String {
"cast succeeded"
}
}
func test_radar124171788(_ v: Maybe<Int>) {
if let foo = v as? CustomDebugStringConvertible {
print("\(foo.debugDescription)")
return
}
print("failed to cast (test_radar124171788)")
}
|
