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
|
// RUN: %empty-directory(%t)
// RUN: %target-swift-frontend -emit-sil -o - -emit-module-path %t/Lib.swiftmodule -module-name Lib -I %S/Inputs/custom-modules -disable-objc-attr-requires-foundation-module %s > /dev/null
// RUN: %target-swift-ide-test -source-filename=x -print-module -module-to-print Lib -I %t -I %S/Inputs/custom-modules | %FileCheck %s
// RUN: %target-swift-ide-test -source-filename=x -print-module -module-to-print Lib -I %t -I %S/Inputs/custom-modules -Xcc -DBAD | %FileCheck -check-prefix CHECK-RECOVERY %s
// RUN: %target-swift-frontend -typecheck -I %t -I %S/Inputs/custom-modules -Xcc -DBAD -DTEST %s -verify
#if TEST
import Typedefs
import Lib
func use(_: OkayEnum) {}
// FIXME: Better to import the enum and make it unavailable.
func use(_: BadEnum) {} // expected-error {{cannot find type 'BadEnum' in scope}}
func test() {
_ = producesOkayEnum()
_ = producesBadEnum() // expected-error {{cannot find 'producesBadEnum' in scope}}
// Force a lookup of the ==
_ = Optional(OkayEnum.noPayload).map { $0 == .noPayload }
}
#else // TEST
import Typedefs
public enum BadEnum {
case noPayload
case perfectlyOkayPayload(Int)
case problematic(Any, WrappedInt)
case alsoOkay(Any, Any, Any)
public static func ==(a: BadEnum, b: BadEnum) -> Bool {
return false
}
}
// CHECK-LABEL: enum BadEnum {
// CHECK-RECOVERY-NOT: enum BadEnum
public enum GenericBadEnum<T: HasAssoc> where T.Assoc == WrappedInt {
case noPayload
case perfectlyOkayPayload(Int)
public static func ==(a: GenericBadEnum<T>, b: GenericBadEnum<T>) -> Bool {
return false
}
}
// CHECK-LABEL: enum GenericBadEnum<T> where T : HasAssoc, T.Assoc == WrappedInt {
// CHECK-RECOVERY-NOT: enum GenericBadEnum
public enum OkayEnum {
case noPayload
case plainOldAlias(Any, UnwrappedInt)
case other(Int)
public static func ==(a: OkayEnum, b: OkayEnum) -> Bool {
return false
}
}
// CHECK-LABEL: enum OkayEnum {
// CHECK-NEXT: case noPayload
// CHECK-NEXT: case plainOldAlias(Any, UnwrappedInt)
// CHECK-NEXT: case other(Int)
// CHECK-NEXT: static func == (a: OkayEnum, b: OkayEnum) -> Bool
// CHECK-NEXT: }
// CHECK-RECOVERY-LABEL: enum OkayEnum {
// CHECK-RECOVERY-NEXT: case noPayload
// CHECK-RECOVERY-NEXT: case plainOldAlias(Any, Int32)
// CHECK-RECOVERY-NEXT: case other(Int)
// CHECK-RECOVERY-NEXT: static func == (a: OkayEnum, b: OkayEnum) -> Bool
// CHECK-RECOVERY-NEXT: }
public enum OkayEnumWithSelfRefs {
public struct Nested {}
indirect case selfRef(OkayEnumWithSelfRefs)
case nested(Nested)
}
// CHECK-LABEL: enum OkayEnumWithSelfRefs {
// CHECK-NEXT: struct Nested {
// CHECK-NEXT: init()
// CHECK-NEXT: }
// CHECK-NEXT: indirect case selfRef(OkayEnumWithSelfRefs)
// CHECK-NEXT: case nested(OkayEnumWithSelfRefs.Nested)
// CHECK-NEXT: }
// CHECK-RECOVERY-LABEL: enum OkayEnumWithSelfRefs {
// CHECK-RECOVERY-NEXT: struct Nested {
// CHECK-RECOVERY-NEXT: init()
// CHECK-RECOVERY-NEXT: }
// CHECK-RECOVERY-NEXT: indirect case selfRef(OkayEnumWithSelfRefs)
// CHECK-RECOVERY-NEXT: case nested(OkayEnumWithSelfRefs.Nested)
// CHECK-RECOVERY-NEXT: }
public protocol HasAssoc {
associatedtype Assoc
}
public func producesBadEnum() -> BadEnum { return .noPayload }
// CHECK-LABEL: func producesBadEnum() -> BadEnum
// CHECK-RECOVERY-NOT: func producesBadEnum() -> BadEnum
public func producesGenericBadEnum<T>() -> GenericBadEnum<T> { return .noPayload }
// CHECK-LABEL: func producesGenericBadEnum<T>() -> GenericBadEnum<T>
// CHECK-RECOVERY-NOT: func producesGenericBadEnum
public func producesOkayEnum() -> OkayEnum { return .noPayload }
// CHECK-LABEL: func producesOkayEnum() -> OkayEnum
// CHECK-RECOVERY-LABEL: func producesOkayEnum() -> OkayEnum
extension Int /* or any imported type, really */ {
public enum OkayEnumWithSelfRefs {
public struct Nested {}
indirect case selfRef(OkayEnumWithSelfRefs)
case nested(Nested)
}
}
// CHECK-LABEL: extension Int {
// CHECK-NEXT: enum OkayEnumWithSelfRefs {
// CHECK-NEXT: struct Nested {
// CHECK-NEXT: init()
// CHECK-NEXT: }
// CHECK-NEXT: indirect case selfRef(Int.OkayEnumWithSelfRefs)
// CHECK-NEXT: case nested(Int.OkayEnumWithSelfRefs.Nested)
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-RECOVERY-LABEL: extension Int {
// CHECK-RECOVERY-NEXT: enum OkayEnumWithSelfRefs {
// CHECK-RECOVERY-NEXT: struct Nested {
// CHECK-RECOVERY-NEXT: init()
// CHECK-RECOVERY-NEXT: }
// CHECK-RECOVERY-NEXT: indirect case selfRef(Int.OkayEnumWithSelfRefs)
// CHECK-RECOVERY-NEXT: case nested(Int.OkayEnumWithSelfRefs.Nested)
// CHECK-RECOVERY-NEXT: }
// CHECK-RECOVERY-NEXT: }
#endif // TEST
|
