|
32 | 32 | case fizz(buzz: String)
|
33 | 33 | case fizzier(Int, buzzier: String)
|
34 | 34 |
|
35 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 35 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
36 | 36 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
37 | 37 | if root.is(\.bar) {
|
38 | 38 | return \.bar
|
|
82 | 82 | return (v0, v1)
|
83 | 83 | }
|
84 | 84 | }
|
85 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 85 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
86 | 86 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
87 | 87 | allCasePaths.append(\.bar)
|
88 | 88 | allCasePaths.append(\.baz)
|
|
109 | 109 | #"""
|
110 | 110 | enum EnumWithNoCases {
|
111 | 111 |
|
112 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 112 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
113 | 113 | public subscript(root: EnumWithNoCases) -> CasePaths.PartialCaseKeyPath<EnumWithNoCases> {
|
114 | 114 | \.never
|
115 | 115 | }
|
116 | 116 |
|
117 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<EnumWithNoCases>]> { |
| 117 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<EnumWithNoCases>]> { |
118 | 118 | let allCasePaths: [CasePaths.PartialCaseKeyPath<EnumWithNoCases>] = []
|
119 | 119 | return allCasePaths.makeIterator()
|
120 | 120 | }
|
|
140 | 140 | enum Foo {
|
141 | 141 | case bar(Never)
|
142 | 142 |
|
143 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 143 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
144 | 144 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
145 | 145 | if root.is(\.bar) {
|
146 | 146 | return \.bar
|
|
155 | 155 | return v0
|
156 | 156 | }
|
157 | 157 | }
|
158 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 158 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
159 | 159 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
160 | 160 | allCasePaths.append(\.bar)
|
161 | 161 | return allCasePaths.makeIterator()
|
|
182 | 182 | public enum Foo {
|
183 | 183 | case bar(Int), baz(String)
|
184 | 184 |
|
185 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 185 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
186 | 186 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
187 | 187 | if root.is(\.bar) {
|
188 | 188 | return \.bar
|
|
208 | 208 | return v0
|
209 | 209 | }
|
210 | 210 | }
|
211 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 211 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
212 | 212 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
213 | 213 | allCasePaths.append(\.bar)
|
214 | 214 | allCasePaths.append(\.baz)
|
|
236 | 236 | public enum Foo {
|
237 | 237 | case bar(Int)
|
238 | 238 |
|
239 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 239 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
240 | 240 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
241 | 241 | if root.is(\.bar) {
|
242 | 242 | return \.bar
|
|
251 | 251 | return v0
|
252 | 252 | }
|
253 | 253 | }
|
254 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 254 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
255 | 255 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
256 | 256 | allCasePaths.append(\.bar)
|
257 | 257 | return allCasePaths.makeIterator()
|
|
275 | 275 | package enum Foo {
|
276 | 276 | case bar(Int)
|
277 | 277 |
|
278 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 278 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
279 | 279 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
280 | 280 | if root.is(\.bar) {
|
281 | 281 | return \.bar
|
|
290 | 290 | return v0
|
291 | 291 | }
|
292 | 292 | }
|
293 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 293 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
294 | 294 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
295 | 295 | allCasePaths.append(\.bar)
|
296 | 296 | return allCasePaths.makeIterator()
|
|
314 | 314 | private enum Foo {
|
315 | 315 | case bar(Int)
|
316 | 316 |
|
317 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 317 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
318 | 318 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
319 | 319 | if root.is(\.bar) {
|
320 | 320 | return \.bar
|
|
329 | 329 | return v0
|
330 | 330 | }
|
331 | 331 | }
|
332 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 332 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
333 | 333 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
334 | 334 | allCasePaths.append(\.bar)
|
335 | 335 | return allCasePaths.makeIterator()
|
|
390 | 390 | #"""
|
391 | 391 | enum Foo: CasePathable {
|
392 | 392 |
|
393 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 393 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
394 | 394 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
395 | 395 | \.never
|
396 | 396 | }
|
397 | 397 |
|
398 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 398 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
399 | 399 | let allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
400 | 400 | return allCasePaths.makeIterator()
|
401 | 401 | }
|
|
416 | 416 | #"""
|
417 | 417 | enum Foo: CasePaths.CasePathable {
|
418 | 418 |
|
419 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 419 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
420 | 420 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
421 | 421 | \.never
|
422 | 422 | }
|
423 | 423 |
|
424 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 424 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
425 | 425 | let allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
426 | 426 | return allCasePaths.makeIterator()
|
427 | 427 | }
|
|
447 | 447 | enum Foo {
|
448 | 448 | case bar(_ int: Int, _ bool: Bool)
|
449 | 449 |
|
450 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 450 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
451 | 451 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
452 | 452 | if root.is(\.bar) {
|
453 | 453 | return \.bar
|
|
462 | 462 | return (v0, v1)
|
463 | 463 | }
|
464 | 464 | }
|
465 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 465 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
466 | 466 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
467 | 467 | allCasePaths.append(\.bar)
|
468 | 468 | return allCasePaths.makeIterator()
|
|
489 | 489 | enum Foo {
|
490 | 490 | case bar(Bar<Self>)
|
491 | 491 |
|
492 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 492 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
493 | 493 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
494 | 494 | if root.is(\.bar) {
|
495 | 495 | return \.bar
|
|
504 | 504 | return v0
|
505 | 505 | }
|
506 | 506 | }
|
507 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 507 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
508 | 508 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
509 | 509 | allCasePaths.append(\.bar)
|
510 | 510 | return allCasePaths.makeIterator()
|
|
531 | 531 | enum Foo {
|
532 | 532 | case bar(int: Int = 42, bool: Bool = true)
|
533 | 533 |
|
534 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 534 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
535 | 535 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
536 | 536 | if root.is(\.bar) {
|
537 | 537 | return \.bar
|
|
546 | 546 | return (v0, v1)
|
547 | 547 | }
|
548 | 548 | }
|
549 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 549 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
550 | 550 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
551 | 551 | allCasePaths.append(\.bar)
|
552 | 552 | return allCasePaths.makeIterator()
|
|
607 | 607 | #endif
|
608 | 608 | #endif
|
609 | 609 |
|
610 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 610 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
611 | 611 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
612 | 612 | if root.is(\.bar) {
|
613 | 613 | return \.bar
|
|
725 | 725 | }
|
726 | 726 | #endif
|
727 | 727 | #endif
|
728 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 728 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
729 | 729 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
730 | 730 | allCasePaths.append(\.bar)
|
731 | 731 | #if os(macOS)
|
|
770 | 770 | enum Foo {
|
771 | 771 | case bar
|
772 | 772 |
|
773 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 773 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
774 | 774 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
775 | 775 | if root.is(\.bar) {
|
776 | 776 | return \.bar
|
|
787 | 787 | return ()
|
788 | 788 | }
|
789 | 789 | }
|
790 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 790 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
791 | 791 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
792 | 792 | allCasePaths.append(\.bar)
|
793 | 793 | return allCasePaths.makeIterator()
|
|
843 | 843 | */
|
844 | 844 | case fizz, buzz
|
845 | 845 |
|
846 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 846 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
847 | 847 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
848 | 848 | if root.is(\.bar) {
|
849 | 849 | return \.bar
|
|
913 | 913 | return ()
|
914 | 914 | }
|
915 | 915 | }
|
916 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 916 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
917 | 917 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
918 | 918 | allCasePaths.append(\.bar)
|
919 | 919 | allCasePaths.append(\.baz)
|
|
948 | 948 | // case foo
|
949 | 949 | case bar
|
950 | 950 |
|
951 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 951 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
952 | 952 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
953 | 953 | if root.is(\.bar) {
|
954 | 954 | return \.bar
|
|
967 | 967 | return ()
|
968 | 968 | }
|
969 | 969 | }
|
970 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 970 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
971 | 971 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
972 | 972 | allCasePaths.append(\.bar)
|
973 | 973 | return allCasePaths.makeIterator()
|
|
1004 | 1004 | case fizzier/*Comment in case*/(Int, buzzier: String)
|
1005 | 1005 | case fizziest // Comment without associated value
|
1006 | 1006 |
|
1007 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 1007 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
1008 | 1008 | public subscript(root: Foo) -> CasePaths.PartialCaseKeyPath<Foo> {
|
1009 | 1009 | if root.is(\.bar) {
|
1010 | 1010 | return \.bar
|
|
1068 | 1068 | return ()
|
1069 | 1069 | }
|
1070 | 1070 | }
|
1071 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
| 1071 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Foo>]> { |
1072 | 1072 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Foo>] = []
|
1073 | 1073 | allCasePaths.append(\.bar)
|
1074 | 1074 | allCasePaths.append(\.baz)
|
|
1099 | 1099 | enum Action<Element> {
|
1100 | 1100 | case element(Element)
|
1101 | 1101 |
|
1102 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 1102 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
1103 | 1103 | public subscript(root: Action) -> CasePaths.PartialCaseKeyPath<Action> {
|
1104 | 1104 | if root.is(\.element) {
|
1105 | 1105 | return \.element
|
|
1114 | 1114 | return v0
|
1115 | 1115 | }
|
1116 | 1116 | }
|
1117 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Action>]> { |
| 1117 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Action>]> { |
1118 | 1118 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Action>] = []
|
1119 | 1119 | allCasePaths.append(\.element)
|
1120 | 1120 | return allCasePaths.makeIterator()
|
|
1146 | 1146 | enum Action {
|
1147 | 1147 | case element(Element)
|
1148 | 1148 |
|
1149 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 1149 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
1150 | 1150 | public subscript(root: Action) -> CasePaths.PartialCaseKeyPath<Action> {
|
1151 | 1151 | if root.is(\.element) {
|
1152 | 1152 | return \.element
|
|
1161 | 1161 | return v0
|
1162 | 1162 | }
|
1163 | 1163 | }
|
1164 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Action>]> { |
| 1164 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Action>]> { |
1165 | 1165 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Action>] = []
|
1166 | 1166 | allCasePaths.append(\.element)
|
1167 | 1167 | return allCasePaths.makeIterator()
|
|
1191 | 1191 | enum Action<Element> {
|
1192 | 1192 | case element(Array<Element>)
|
1193 | 1193 |
|
1194 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 1194 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
1195 | 1195 | public subscript(root: Action) -> CasePaths.PartialCaseKeyPath<Action> {
|
1196 | 1196 | if root.is(\.element) {
|
1197 | 1197 | return \.element
|
|
1206 | 1206 | return v0
|
1207 | 1207 | }
|
1208 | 1208 | }
|
1209 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Action>]> { |
| 1209 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Action>]> { |
1210 | 1210 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Action>] = []
|
1211 | 1211 | allCasePaths.append(\.element)
|
1212 | 1212 | return allCasePaths.makeIterator()
|
|
1239 | 1239 | case secondElement(Element)
|
1240 | 1240 | case thirdElement(Element, Element, Int)
|
1241 | 1241 |
|
1242 |
| - public struct AllCasePaths: CasePaths.CasePathReflectable, Sendable, Sequence { |
| 1242 | + public struct AllCasePaths: CasePaths.CasePathReflectable, Swift.Sendable, Swift.Sequence { |
1243 | 1243 | public subscript(root: Action) -> CasePaths.PartialCaseKeyPath<Action> {
|
1244 | 1244 | if root.is(\.element) {
|
1245 | 1245 | return \.element
|
|
1276 | 1276 | return (v0, v1, v2)
|
1277 | 1277 | }
|
1278 | 1278 | }
|
1279 |
| - public func makeIterator() -> IndexingIterator<[CasePaths.PartialCaseKeyPath<Action>]> { |
| 1279 | + public func makeIterator() -> Swift.IndexingIterator<[CasePaths.PartialCaseKeyPath<Action>]> { |
1280 | 1280 | var allCasePaths: [CasePaths.PartialCaseKeyPath<Action>] = []
|
1281 | 1281 | allCasePaths.append(\.element)
|
1282 | 1282 | allCasePaths.append(\.secondElement)
|
|
0 commit comments