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

// The first function argument does not have a label; the others do.
func f1(_ a: Int, b: Int) { }
func f1(_ a: Int, d: Int) { } // okay: names differ

func f2(_ a: Int, b: Int) { } // expected-note{{'f2(_:b:)' previously declared here}}
func f2(_ z: Int, b: Int) { } // expected-error{{invalid redeclaration of 'f2(_:b:)'}}

class X {
  // Initializer arguments are API by default.
  init(x: Int) { }
  init(y: Int) { } // okay

  // Method arguments after the first are API by default
  func f1(_ a: Int, b: Int) { }
  func f1(_ a: Int, c: Int) { } // okay

  func f2(_ a: Int, b: Int) { } // expected-note{{'f2(_:b:)' previously declared here}}
  func f2(_ A: Int, b: Int) { } // expected-error{{invalid redeclaration of 'f2(_:b:)'}}
}

protocol P {
  func g1(_ value: Int)
  func g2(_ value: Int, other: Int)
  func g3(_ value: Int, other: Int, third: Int) // expected-note{{requirement 'g3(_:other:third:)' declared here}}
  static func g4(_ value: Int)
}

class PX : P {
  func g1(_ x: Int) { } // okay
  func g2(_ x: Int, other: Int) { } // okay
  func g3(_ x: Int, y: Int, third: Int) { } // expected-error{{method 'g3(_:y:third:)' has different argument names from those required by protocol 'P' ('g3(_:other:third:)')}} {{21-21=other }}

  class func g4(_ x: Int) { }
}

// Default arguments have no effect on argument labels.
func f3(_ a: Int, b: Int = 5, c: Int = 6) { }
// expected-note@-1{{'f3(_:b:c:)' previously declared here}}
func f3(_ a: Int, b: Int, c: Int) { }
// expected-error@-1{{invalid redeclaration of 'f3(_:b:c:)'}}

class DefArg {
  func f(_ a: Int = 17) { } // okay: no label implied
  func f(a a: Int) { } // expected-warning{{extraneous duplicate parameter name; 'a' already has an argument label}} {{10-12=}}
}

struct Subscripts1 {
  subscript (i i: Int) -> Int {
    get { return i }
  }

  subscript (j j: Int) -> Int {
    get { return j }
  }
}

struct Subscripts2 {
  subscript (i: Int) -> Int { // expected-note{{'subscript' previously declared here}}
    get { return i }
  }

  subscript (j: Int) -> Int { // expected-error{{invalid redeclaration of 'subscript'}}
    get { return j }
  }
}


func f4(_ a: Int) -> (Int) -> () { return { b in () } }
func f5(_ a: Int) -> (_ b: Int) -> () { return { b in () } }

func testFunctions(_ i: Int, x: X) {
  f4(i)(i)
  f4(i)(b: i) // expected-error{{extraneous argument label 'b:' in call}} {{9-12=}}
  f5(i)(i)
  f5(i)(b: i) // expected-error{{extraneous argument label 'b:' in call}}{{9-12=}}
}

struct Y {
  func m0(_ a: Int) -> (Int) -> () { return { b in () } }
  func m1(_ a: Int) -> (_ b: Int) -> () { return { b in () } }

  func m2(_ a: Int) -> (Int, Int) -> () { return { b, c in () } }
  func m3(_ a: Int) -> (_ b: Int, _ c2: Int) -> () { return { b, c in () } }

  subscript (x: Int) -> Int {
    get { return x }
  }

  subscript (y y: String) -> String {
    get { return y }
  }
}

func testMethods(_ i: Int, x: Y) {
  x.m0(i)(i)
  x.m0(i)(b: i) // expected-error{{extraneous argument label 'b:' in call}} {{11-14=}}
  x.m1(i)(i)
  x.m1(i)(i) 
  x.m2(i)(i, c: i) // expected-error{{extraneous argument label 'c:' in call}} {{14-17=}}
  x.m2(i)(i, i)
  x.m3(i)(b: i, i) // expected-error{{extraneous argument label 'b:' in call}}{{11-14=}}
  x.m3(i)(b: i, c2: i) // expected-error{{extraneous argument labels 'b:c2:' in call}}{{11-14=}}{{17-21=}}
}

func testSubscripts(_ i: Int, s: String, x: Y) {
  var i2 = x[i]
  var i3 = x[x: i] // expected-error{{cannot subscript a value of type 'Y' with an index of type '(x: Int)'}}
  // expected-note @-1 {{overloads for 'subscript' exist with these partially matching parameter lists: (Int), (y: String)}}
  var s2 = x[y: s]
  var s3 = x[s]  // expected-error{{cannot convert value of type 'String' to expected argument type 'Int'}}
}

// Operators
func +(_ a: String,
       b b: Double) { } // expected-error{{operator cannot have keyword arguments}} {{8-10=}}

func +(a: Double, b: String) -> (Int) -> (_ d: Int) -> () {
  return { c in { e in () } }
}