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

class A {
  init(int i: Int) { }
  init(double d: Double) { }
  convenience init(float f: Float) {
    self.init(double: Double(f))
  }
}

// Implicit overriding of subobject initializers
class B : A {
  var x = "Hello"
  var (y, z) = (1, 2)
}

func testB() {
  _ = B(int: 5)
  _ = B(double: 2.71828)
  _ = B(float: 3.14159)
}

// Okay to have nothing
class C : B {
}

func testC() {
  _ = C(int: 5)
  _ = C(double: 2.71828)
  _ = C(float: 3.14159)
}

// Okay to add convenience initializers.
class D : C {
  convenience init(string s: String) {
    self.init(int: Int(s)!)
  }
}

func testD() {
  _ = D(int: 5)
  _ = D(double: 2.71828)
  _ = D(float: 3.14159)
  _ = D(string: "3.14159")
}

// Adding a subobject initializer prevents inheritance of subobject
// initializers.
class NotInherited1 : D {
  override init(int i: Int) {
    super.init(int: i)
  }

  convenience init(float f: Float) {
    self.init(int: Int(f))
  }
}

func testNotInherited1() {
  var n1 = NotInherited1(int: 5)
  var n2 = NotInherited1(double: 2.71828) // expected-error{{argument labels '(double:)' do not match any available overloads}}
  // expected-note @-1 {{overloads for 'NotInherited1' exist with these partially matching parameter lists: (int: Int), (float: Float)}}
}

class NotInherited1Sub : NotInherited1 {
  override init(int i: Int) {
    super.init(int: i)
  }
}

func testNotInherited1Sub() {
  var n1 = NotInherited1Sub(int: 5)
  var n2 = NotInherited1Sub(float: 3.14159)
  var n3 = NotInherited1Sub(double: 2.71828) // expected-error{{argument labels '(double:)' do not match any available overloads}}
  // expected-note @-1 {{overloads for 'NotInherited1Sub' exist with these partially matching parameter lists: (int: Int), (float: Float)}}
}

// Having a stored property without an initial value prevents
// inheritance of initializers.
class NotInherited2 : D { // expected-error{{class 'NotInherited2' has no initializers}}
  var a: Int // expected-note{{stored property 'a' without initial value prevents synthesized initializers}}{{13-13= = 0}}
  var b: Int // expected-note{{stored property 'b' without initial value prevents synthesized initializers}}{{13-13= = 0}}
    , c: Int  // expected-note{{stored property 'c' without initial value prevents synthesized initializers}}{{13-13= = 0}}
  
  var (d, e): (Int, String) // expected-note{{stored properties 'd' and 'e' without initial values prevent synthesized initializers}}{{28-28= = (0, "")}}
  var (f, (g, h)): (Int?, (Float, String)) // expected-note{{stored properties 'f', 'g', and 'h' without initial values prevent synthesized initializers}}{{43-43= = (nil, (0.0, ""))}}
  var (w, i, (j, k)): (Int?, Float, (String, D)) // expected-note{{stored properties 'w', 'i', 'j', and others without initial values prevent synthesized initializers}}
}

func testNotInherited2() {
  var n1 = NotInherited2(int: 5) // expected-error{{'NotInherited2' cannot be constructed because it has no accessible initializers}}
  var n2 = NotInherited2(double: 2.72828) // expected-error{{'NotInherited2' cannot be constructed because it has no accessible initializers}}
}

// Inheritance of unnamed parameters.
class SuperUnnamed {
  init(int _: Int) { }
  init(_ : Double) { }

  init(string _: String) { }
  init(_ : Float) { }
}

class SubUnnamed : SuperUnnamed { }

func testSubUnnamed(_ i: Int, d: Double, s: String, f: Float) {
  _ = SubUnnamed(int: i)
  _ = SubUnnamed(d)
  _ = SubUnnamed(string: s)
  _ = SubUnnamed(f)
}

// rdar://problem/17960407 - Inheritance of generic initializers
class ConcreteBase {
  required init(i: Int) {}
}

class GenericDerived<T> : ConcreteBase {}

class GenericBase<T> {
  required init(t: T) {}
}

class GenericDerived2<U> : GenericBase<(U, U)> {}

class ConcreteDerived : GenericBase<Int> {}

func testGenericInheritance() {
  _ = GenericDerived<Int>(i: 10)
  _ = GenericDerived2<Int>(t: (10, 100))
  _ = ConcreteDerived(t: 1000)
}

// FIXME: <rdar://problem/16331406> Implement inheritance of variadic designated initializers
class SuperVariadic {
  init(ints: Int...) { } // expected-note{{variadic superclass initializer defined here}}
  init(_ : Double...) { } // expected-note{{variadic superclass initializer defined here}}

  init(s: String, ints: Int...) { } // expected-note{{variadic superclass initializer defined here}}
  init(s: String, _ : Double...) { } // expected-note{{variadic superclass initializer defined here}}
}

class SubVariadic : SuperVariadic { } // expected-warning 4{{synthesizing a variadic inherited initializer for subclass 'SubVariadic' is unsupported}}

// Don't crash with invalid nesting of class in generic function

func testClassInGenericFunc<T>(t: T) {
  class A { init(t: T) {} } // expected-error {{type 'A' cannot be nested in generic function 'testClassInGenericFunc'}}
  class B : A {} // expected-error {{type 'B' cannot be nested in generic function 'testClassInGenericFunc'}}

  _ = B(t: t)
}
