array.swift

// RUN: %target-typecheck-verify-swift

// Array types.
classBase1{
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]?]?){}
}

classDerived1:Base1{
overridefunc f0(_ x:Array<Int>){}
overridefunc f0a(_ x:Optional<Array<Int>>){}
overridefunc f1(_ x:Array<Array<Int>>){}
overridefunc f1a(_ x:Optional<Array<Array<Int>>>){}
overridefunc f2(_ x:Array<(Array<Int>)->Array<Int>>){}
overridefunc f2a(_ x:Optional<Array<(Optional<Array<Int>>)->Optional<Array<Int>>>>){}
}


// Array types in generic specializations.
structX<T>{}

func testGenericSpec(){
 _ =X<[Int]>()
}

// Array types for construction.
func constructArray(_ n:Int){
varones=[Int](repeating:1, count: n)
ones[5]=0

varmatrix=[[Float]]()
matrix[1][2]=3.14159

var _:[Int?]=[Int?]()
}

// Fix-Its from the old syntax to the new.

typealiasFixIt0=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.

classOuter{
classMiddle{
classInner{}
classGenericInner<V>{}

typealiasAlias=Inner
}

classGenericMiddle<U>{
classInner{}
}

typealiasAlias=Middle
}

classGenericOuter<T>{
classMiddle{
classInner{}
}
}

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>]())

protocolHasAssocType{
associatedtypeA
}

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=}}
]
}

structTupleWith<T>{
typealiasAnd<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)