test/type/array.swift

// 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 preCheckExpression() 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?]())
}