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
|
// RUN: %target-typecheck-verify-swift
// Array types.
class Base1 {
func f0(_ x: [Int]) { }
func f0a(_ x: [Int]?) { }
func f1(_ x: [[Int]]) { }
func f1a(_ x: [[Int]]?) { }
func f2(_ x: [([Int]) -> [Int]]) { }
func f2a(_ x: [([Int]?) -> [Int]?]?) { }
}
class Derived1 : Base1 {
override func f0(_ x: Array<Int>) { }
override func f0a(_ x: Optional<Array<Int>>) { }
override func f1(_ x: Array<Array<Int>>) { }
override func f1a(_ x: Optional<Array<Array<Int>>>) { }
override func f2(_ x: Array<(Array<Int>) -> Array<Int>>) { }
override func f2a(_ x: Optional<Array<(Optional<Array<Int>>) -> Optional<Array<Int>>>>) { }
}
// Array types in generic specializations.
struct X<T> { }
func testGenericSpec() {
_ = X<[Int]>()
}
// Array types for construction.
func constructArray(_ n: Int) {
var ones = [Int](repeating: 1, count: n)
ones[5] = 0
var matrix = [[Float]]()
matrix[1][2] = 3.14159
var _: [Int?] = [Int?]()
}
// Fix-Its from the old syntax to the new.
typealias FixIt0 = Int[] // expected-error{{array types are now written with the brackets around the element type}}{{20-20=[}}{{23-24=}}
// Make sure preCheckTarget() properly folds member types.
class Outer {
class Middle {
class Inner {}
class GenericInner<V> {}
typealias Alias = Inner
}
class GenericMiddle<U> {
class Inner {}
}
typealias Alias = Middle
}
class GenericOuter<T> {
class Middle {
class Inner {}
}
}
func takesMiddle(_: [Outer.Middle]) {}
takesMiddle([Outer.Middle]())
func takesInner(_: [Outer.Middle.Inner]) {}
takesInner([Outer.Middle.Inner]())
takesInner([Outer.Alias.Inner]())
takesInner([Outer.Middle.Alias]())
takesInner([Outer.Alias.Alias]())
takesInner([array.Outer.Middle.Inner]())
takesInner([array.Outer.Alias.Inner]())
takesInner([array.Outer.Middle.Alias]())
takesInner([array.Outer.Alias.Alias]())
func takesMiddle(_: [GenericOuter<Int>.Middle]) {}
takesMiddle([GenericOuter<Int>.Middle]())
func takesInner(_: [GenericOuter<Int>.Middle.Inner]) {}
takesInner([GenericOuter<Int>.Middle.Inner]())
takesInner([array.GenericOuter<Int>.Middle.Inner]())
func takesMiddle(_: [Outer.GenericMiddle<Int>]) {}
takesMiddle([Outer.GenericMiddle<Int>]())
func takesInner(_: [Outer.GenericMiddle<Int>.Inner]) {}
takesInner([Outer.GenericMiddle<Int>.Inner]())
takesInner([array.Outer.GenericMiddle<Int>.Inner]())
func takesInner(_: [Outer.Middle.GenericInner<Int>]) {}
takesInner([Outer.Middle.GenericInner<Int>]())
takesInner([array.Outer.Middle.GenericInner<Int>]())
protocol HasAssocType {
associatedtype A
}
func takesAssocType<T : HasAssocType>(_: T, _: [T.A], _: [T.A?]) {}
func passAssocType<T : HasAssocType>(_ t: T) {
takesAssocType(t, [T.A](), [T.A?]())
}
// https://github.com/apple/swift/issues/53530
do {
let _ = [[1, 2, 3][0]] // ok
let _ = [[1, 2, 3] [1]] // expected-warning {{unexpected subscript in array literal; did you mean to write two separate elements instead?}}
// expected-note@-1 {{add a separator between the elements}}{{21-21=,}}
// expected-note@-2 {{remove the space between the elements to silence this warning}}{{21-22=}}
let _ = [
[1, 2, 3] [1] // expected-warning {{unexpected subscript in array literal; did you mean to write two separate elements instead?}}
// expected-note@-1 {{add a separator between the elements}}{{14-14=,}}
// expected-note@-2 {{remove the space between the elements to silence this warning}}{{14-15=}}
]
}
struct TupleWith<T> {
typealias And<U> = (T, U)
}
_ = [TupleWith<String>.And<Int>](repeating: ("", 0), count: 0)
_ = [TupleWith.And<Int>](repeating: ("", 0), count: 0)
_ = [TupleWith<String>.And](repeating: ("", 0), count: 0)
_ = [TupleWith.And](repeating: ("", 0), count: 0)
|
