[TypeChecker] NFC: Update test-cases improved by new missing arguments diagnostic

Author: xedin

test/APINotes/versioned-objc.swift

@@ -166,7 +166,7 @@ extension PrintingInterference {
   func testDroppingRenamedPrints() {
     // CHECK-DIAGS-4: [[@LINE+1]]:{{[0-9]+}}: warning: use of 'print' treated as a reference to instance method
     print(self)
-    // CHECK-DIAGS-5: [[@LINE-1]]:{{[0-9]+}}: error: use of 'print' nearly matches global function 'print(_:separator:terminator:)' in module 'Swift' rather than instance method 'print(_:extra:)'
+    // CHECK-DIAGS-5: [[@LINE-1]]:{{[0-9]+}}: error: missing argument for parameter 'extra' in call
 
     // CHECK-DIAGS-4-NOT: [[@LINE+1]]:{{[0-9]+}}:
     print(self, extra: self)

test/ClangImporter/foreign_errors.swift

@@ -77,10 +77,7 @@ func testBlockFinal() throws {
 #if !EMIT_SIL
 func testNonBlockFinal() throws {
   ErrorProne.runWithError(count: 0) // expected-error {{missing argument for parameter #1 in call}}
-  // TODO(diagnostics): For situations where both label and type where incorrect, we should produce a single error
-  // which would say something like `cannot invoke 'bar' with argument list (count: Int)`.
-  ErrorProne.run(count: 0) // expected-error {{incorrect argument label in call (have 'count:', expected 'callback:')}}
-  // expected-error@-1 {{cannot convert value of type 'Int' to expected argument type '(() -> Void)?'}}
+  ErrorProne.run(count: 0) // expected-error {{missing argument for parameter 'withAnError' in call}} {{18-18=withAnError: <#AutoreleasingUnsafeMutablePointer<NSError?>?#>, }}
 }
 #endif
 

test/Constraints/casts.swift

@@ -215,9 +215,8 @@ func rdar29894174(v: B?) {
 // we would fail to produce a diagnostic.
 func process(p: Any?) {
   compare(p is String)
-  // expected-error@-1 {{cannot invoke 'compare' with an argument list of type '(Bool)'}}
-  // expected-note@-2 {{overloads for 'compare' exist with these partially matching parameter lists: (T, T), (T?, T?)}}
+  // expected-error@-1 {{missing argument for parameter #2 in call}} {{22-22=, <#Bool#>}}
 }
 
-func compare<T>(_: T, _: T) {}
+func compare<T>(_: T, _: T) {} // expected-note {{'compare' declared here}}
 func compare<T>(_: T?, _: T?) {}

test/Constraints/diag_missing_arg.swift

@@ -19,11 +19,11 @@ func attributedInOutFunc(x: inout @convention(c) () -> Int32) {} // expected-not
 attributedInOutFunc() // expected-error {{missing argument for parameter 'x' in call}} {{21-21=x: &<#@convention(c) () -> Int32#>}}
 
 func genericFunc1<T>(x: T) {} // expected-note * {{here}}
-genericFunc1() // expected-error {{missing argument for parameter 'x' in call}} {{14-14=x: <#T#>}}
+genericFunc1() // expected-error {{missing argument for parameter 'x' in call}} {{14-14=x: <#Any#>}}
 
 protocol P {}
 func genericFunc2<T : P>(x: T) {} // expected-note * {{here}}
-genericFunc2() // expected-error {{missing argument for parameter 'x' in call}} {{14-14=x: <#T#>}}
+genericFunc2() // expected-error {{missing argument for parameter 'x' in call}} {{14-14=x: <#Any#>}}
 
 typealias MyInt = Int
 func aliasedFunc(x: MyInt) {} // expected-note * {{here}}
@@ -61,11 +61,10 @@ param2FuncNonNamed2("foo") // expected-error {{missing argument for parameter 'x
 
 func param2FuncNonNamed3(_ x: Int, _ y: String) {} // expected-note * {{here}}
 param2FuncNonNamed3(1) // expected-error {{missing argument for parameter #2 in call}} {{22-22=, <#String#>}}
-param2FuncNonNamed3("foo") // expected-error {{missing argument for parameter #2 in call}} {{26-26=, <#String#>}}
-                           // FIXME: Bad diagnostic. Could this be #1?
+param2FuncNonNamed3("foo") // expected-error {{missing argument for parameter #1 in call}} {{21-21=<#Int#>, }}
 
 func unlabeledParamFollowingVariadic(_: Any..., _: Any, _: Any) {} // expected-error {{a parameter following a variadic parameter requires a label}}; // expected-note {{here}}
-unlabeledParamFollowingVariadic(1, 1, 1) // expected-error {{missing argument for parameter #2 in call}} {{40-40=, <#Any#>}}
+unlabeledParamFollowingVariadic(1, 1, 1) // expected-error {{missing arguments for parameters #2, #3 in call}}
 
 func labeledParamFollowingVariadic(_: Any..., label: Any, _: Any) {}
 labeledParamFollowingVariadic(1, label: 1, 1)
@@ -97,55 +96,61 @@ _ = s1[x: 1, y: {1}]  // Ok.
 _ = s1[x: 1] { 1 } // Ok.
 _ = s1[x: 1] // expected-error {{missing argument for parameter 'y' in call}} {{12-12=, y: <#() -> Int#>}}
 _ = s1[y: { 1 }] // expected-error {{missing argument for parameter 'x' in call}} {{8-8=x: <#Int#>, }}
-_ = s1[] { 1 } // expected-error {{cannot convert value of type '() -> Int' to expected argument type '(x: Int, y: () -> Int)'}} {{none}}
+_ = s1[] { 1 } // expected-error {{missing argument for parameter 'x' in call}} {{8-8=x: <#Int#>}}
 _ = s1 { 1 } // expected-error {{cannot call value of non-function type 'S1'}} {{none}}
-_ = s1[] // expected-error {{missing argument for parameter 'x' in call}} {{8-8=x: <#Int#>}}
+_ = s1[] // expected-error {{missing arguments for parameters 'x', 'y' in call}} {{8-8=x: <#Int#>, y: <#() -> Int#>}}
 s1[x: 1, y: {1}] = 1 // Ok.
 s1[x: 1] { 1 } = 1 // Ok.
 s1[x: 1] = 1 // expected-error {{missing argument for parameter 'y' in call}} {{8-8=, y: <#() -> Int#>}}
 s1[y: { 1 }] = 1 // expected-error {{missing argument for parameter 'x' in call}} {{4-4=x: <#Int#>, }}
-s1[] { 1 } = 1 // expected-error {{cannot convert value of type '() -> Int' to expected argument type '(x: Int, y: () -> Int)'}} {{none}}
+s1[] { 1 } = 1 // expected-error {{missing argument for parameter 'x' in call}} {{4-4=x: <#Int#>}}
 
 struct S2 {
   subscript(x: Int, y: () -> Int) -> Int { get { return 1 } set { } } // expected-note * {{here}}
 }
 var s2 = S2()
 _ = s2[1, {1}]  // Ok.
 _ = s2[1] { 1 } // Ok.
-_ = s2[1] // expected-error {{cannot convert value of type 'Int' to expected argument type '(Int, () -> Int)'}} {{none}}
-_ = s2[{ 1 }] // expected-error {{cannot convert value of type '() -> Int' to expected argument type '(Int, () -> Int)'}} {{none}}
-_ = s2[] { 1 } // expected-error {{cannot convert value of type '() -> Int' to expected argument type '(Int, () -> Int)'}} {{none}}
+_ = s2[1] // expected-error {{missing argument for parameter #2 in call}} {{9-9=, <#() -> Int#>}}
+_ = s2[{ 1 }] // expected-error {{missing argument for parameter #1 in call}} {{8-8=<#Int#>, }}
+_ = s2[] { 1 } // expected-error {{missing argument for parameter #1 in call}} {{8-8=<#Int#>}}
 _ = s2 { 1 } // expected-error {{cannot call value of non-function type 'S2'}} {{none}}
-_ = s2[] // expected-error {{missing argument for parameter #1 in call}} {{8-8=<#Int#>}}
+_ = s2[] // expected-error {{missing arguments for parameters #1, #2 in call}} {{8-8=<#Int#>, <#() -> Int#>}}
 s2[1, {1}] = 1 // Ok.
 s2[1] { 1 } = 1 // Ok.
-s2[1] = 1 // expected-error {{cannot convert value of type 'Int' to expected argument type '(Int, () -> Int)'}} {{none}}
-s2[{ 1 }] = 1 // expected-error {{cannot convert value of type '() -> Int' to expected argument type '(Int, () -> Int)'}} {{none}}
-s2[] { 1 } = 1 // expected-error {{cannot convert value of type '() -> Int' to expected argument type '(Int, () -> Int)'}} {{none}}
+s2[1] = 1 // expected-error {{missing argument for parameter #2 in call}} {{5-5=, <#() -> Int#>}}
+s2[{ 1 }] = 1 // expected-error {{missing argument for parameter #1 in call}} {{4-4=<#Int#>, }}
+s2[] { 1 } = 1 // expected-error {{missing argument for parameter #1 in call}} {{4-4=<#Int#>}}
 
 struct S3 {
       subscript(x x: Int, y y: Int, z z: (Int) -> Int) -> Int { get { return 1 } set { } } // expected-note * {{here}}
 }
 var s3 = S3()
 _ = s3[y: 1] { 1 } // expected-error {{missing argument for parameter 'x' in call}} {{8-8=x: <#Int#>, }}
+// expected-error@-1 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{15-15= _ in}}
 _ = s3[x: 1] { 1 } // expected-error {{missing argument for parameter 'y' in call}} {{12-12=, y: <#Int#>}}
+// expected-error@-1 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{15-15= _ in}}
 _ = s3[x: 1, y: 1] // expected-error {{missing argument for parameter 'z' in call}} {{18-18=, z: <#(Int) -> Int#>}}
 s3[y: 1] { 1 } = 1 // expected-error {{missing argument for parameter 'x' in call}} {{4-4=x: <#Int#>, }}
+// expected-error@-1 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{11-11= _ in}}
 s3[x: 1] { 1 } = 1 // expected-error {{missing argument for parameter 'y' in call}} {{8-8=, y: <#Int#>}}
+// expected-error@-1 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{11-11= _ in}}
 s3[x: 1, y: 1] = 1 // expected-error {{missing argument for parameter 'z' in call}} {{14-14=, z: <#(Int) -> Int#>}}
 
 struct S4 {
       subscript(x: Int, y: Int, z: (Int) -> Int) -> Int { get { return 1 } set { } } // expected-note * {{here}}
 }
 var s4 = S4()
 _ = s4[1] { 1 } // expected-error {{missing argument for parameter #2 in call}} {{9-9=, <#Int#>}}
+// expected-error@-1 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{12-12= _ in}}
 _ = s4[1, 1] // expected-error {{missing argument for parameter #3 in call}} {{12-12=, <#(Int) -> Int#>}}
 s4[1] { 1 } = 1 // expected-error {{missing argument for parameter #2 in call}} {{5-5=, <#Int#>}}
+// expected-error@-1 {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{8-8= _ in}}
 s4[1, 1] = 1 // expected-error {{missing argument for parameter #3 in call}} {{8-8=, <#(Int) -> Int#>}}
 
 func multiLine(x: Int, y: Int, z: Int) {} // expected-note * {{here}}
-multiLine(
-) // expected-error {{missing argument for parameter 'x' in call}} {{1-1=x: <#Int#>}}
+multiLine( // expected-error {{missing arguments for parameters 'x', 'y', 'z' in call}} {{11-11=x: <#Int#>, y: <#Int#>, z: <#Int#>}}
+)
 multiLine(
   y: 1, // expected-error {{missing argument for parameter 'x' in call}} {{3-3=x: <#Int#>, }}
   z: 1

test/Constraints/diagnostics.swift

@@ -409,7 +409,7 @@ f8(b: 1.0)         // expected-error {{extraneous argument label 'b:' in call}}
 class CurriedClass {
   func method1() {}
   func method2(_ a: Int) -> (_ b : Int) -> () { return { b in () } }
-  func method3(_ a: Int, b : Int) {}  // expected-note 5 {{'method3(_:b:)' declared here}}
+  func method3(_ a: Int, b : Int) {}  // expected-note 3 {{'method3(_:b:)' declared here}}
 }
 
 let c = CurriedClass()
@@ -449,15 +449,17 @@ _ = CurriedClass.method3(1, 2)           // expected-error {{instance member 'me
 // expected-error@-1 {{missing argument label 'b:' in call}}
 CurriedClass.method3(c)(1.0, b: 1)       // expected-error {{cannot convert value of type 'Double' to expected argument type 'Int'}}
 CurriedClass.method3(c)(1)               // expected-error {{missing argument for parameter 'b' in call}}
-CurriedClass.method3(c)(c: 1.0)          // expected-error {{missing argument for parameter #1 in call}}
+CurriedClass.method3(c)(c: 1.0)          // expected-error {{missing argument for parameter #1 in call}} expected-error {{cannot convert value of type 'Double' to expected argument type 'Int'}}
 
 
 extension CurriedClass {
   func f() {
     method3(1, b: 2)
-    method3()            // expected-error {{missing argument for parameter #1 in call}}
+    method3()            // expected-error {{missing arguments for parameters #1, 'b' in call}} {{13-13=<#Int#>, b: <#Int#>}}
     method3(42)          // expected-error {{missing argument for parameter 'b' in call}}
-    method3(self)        // expected-error {{missing argument for parameter 'b' in call}}
+    method3(self)
+    // expected-error@-1:13 {{cannot convert value of type 'CurriedClass' to expected argument type 'Int'}}
+    // expected-error@-2:17 {{missing argument for parameter 'b' in call}} {{17-17=, b: <#Int#>}}
   }
 }
 

test/Constraints/diagnostics_swift4.swift

@@ -34,7 +34,7 @@ enum R31898542<T> {
 }
 
 func foo() -> R31898542<()> {
-  return .success() // expected-error {{missing argument for parameter #1 in call}} {{19-19=<#T#>}}
+  return .success() // expected-error {{missing argument for parameter #1 in call}} {{19-19=<#()#>}}
 }
 
 // rdar://problem/31973368 - Cannot convert value of type '(K, V) -> ()' to expected argument type '((key: _, value: _)) -> Void'

test/Constraints/enum_cases.swift

@@ -54,7 +54,7 @@ bar_1(E.tuple) // Ok - it's going to be ((x: Int, y: Int))
 
 bar_2(G_E<String>.foo) // Ok
 bar_2(G_E<Int>.bar) // Ok
-bar_2(G_E<Int>.two) // expected-error {{cannot convert value of type '(Int, Int) -> G_E<Int>' to expected argument type '(_) -> G_E<_>'}}
+bar_2(G_E<Int>.two) // expected-error {{cannot convert value of type '(Int, Int) -> G_E<Int>' to expected argument type '(Int) -> G_E<Int>'}}
 bar_2(G_E<Int>.tuple) // expected-error {{cannot convert value of type '((x: Int, y: Int)) -> G_E<Int>' to expected argument type '(_) -> G_E<_>'}}
 bar_3(G_E<Int>.tuple) // Ok
 

test/Constraints/members.swift

@@ -620,13 +620,14 @@ func rdar_50467583_and_50909555() {
 
   // rdar://problem/50909555
   struct S {
-    static subscript(x: Int, y: Int) -> Int {
+    static subscript(x: Int, y: Int) -> Int { // expected-note {{'subscript(_:_:)' declared here}}
       return 1
     }
   }
 
   func test(_ s: S) {
     s[1] // expected-error {{static member 'subscript' cannot be used on instance of type 'S'}} {{5-6=S}}
+    // expected-error@-1 {{missing argument for parameter #2 in call}} {{8-8=, <#Int#>}}
   }
 }
 

test/Constraints/rdar45242032.swift

@@ -14,9 +14,9 @@ struct S {
 }
 
 do {
-  let _ = M.foo(bar & // expected-error {{missing argument for parameter 'bar' in call}}
+  let _ = M.foo(bar & // expected-error {{missing arguments for parameters 'bar', 'baz' in call}}
 } // expected-error {{expected expression after operator}}
 
 do {
-  let _ = S.bar(fiz & // expected-error {{missing argument for parameter 'fiz' in call}}
+  let _ = S.bar(fiz & // expected-error {{missing arguments for parameters 'fiz', 'baz' in call}}
 } // expected-error {{expected expression after operator}}

test/Constraints/tuple_arguments.swift

@@ -1716,7 +1716,7 @@ func rdar48443263() {
 
   func bar(_ s1: S1, _ s2: S2, _ fn: () -> Void) {
     foo(s1, fn) // Ok because s.V is Void
-    foo(s2, fn) // expected-error {{cannot convert value of type '() -> Void' to expected argument type '(_) -> Void'}}
+    foo(s2, fn) // expected-error {{cannot convert value of type '() -> Void' to expected argument type '(S2.V) -> Void' (aka '(Int) -> ()')}}
   }
 }
 

test/Sema/diag_ambiguous_overloads.swift

@@ -114,7 +114,7 @@ struct Count { // expected-note {{'init(title:)' declared here}}
 func getCounts(_ scheduler: sr5154_Scheduler, _ handler: @escaping ([Count]) -> Void) {
   scheduler.inBackground(run: {
     return [Count()] // expected-error {{missing argument for parameter 'title' in call}}
-  }, completedBy: {
+  }, completedBy: { // expected-error {{contextual type for closure argument list expects 1 argument, which cannot be implicitly ignored}} {{20-20= _ in}}
   })
 }
 

test/decl/func/constructor.swift

@@ -79,7 +79,7 @@ extension D {
   init() { i = 17 }
 }
 
-F() // expected-error{{missing argument for parameter 'd'}}
+F() // expected-error{{missing arguments for parameters 'd', 'b', 'c' in call}}
 D() // okay // expected-warning{{unused}}
 B() // okay // expected-warning{{unused}}
 C() // expected-error{{missing argument for parameter 'd'}}

test/decl/func/default-values.swift

@@ -162,7 +162,7 @@ let fooThing4 = Foo(a: 0, b: true, d: 1, e: 2, f: false, g: 10, h: nil) // ok
 
 // Ensure that tuple init is not allowed
 // Here b = false and g = nil, but we're checking that e and f don't get a default value
-let fooThing5 = Foo(a: 0, d: 1, h: nil) // expected-error {{missing argument for parameter 'e' in call}}
+let fooThing5 = Foo(a: 0, d: 1, h: nil) // expected-error {{missing arguments for parameters 'e', 'f' in call}}
                                         // expected-note@-25 {{'init(a:b:d:e:f:g:h:)' declared here}}
 
 // Here b = false and g = nil, but we're checking that f doesn't get a default value

test/decl/func/dynamic_self.swift

@@ -62,7 +62,7 @@ extension P1 {
 // ----------------------------------------------------------------------------
 // The 'self' type of a Self method is based on Self
 class C1 {
-  required init(int i: Int) {}
+  required init(int i: Int) {} // expected-note {{'init(int:)' declared here}}
 
   // Instance methods have a self of type Self.
   func f(_ b: Bool) -> Self {
@@ -89,7 +89,7 @@ class C1 {
 
     if b { return self.init(int: 5) }
 
-    return Self() // expected-error{{non-nominal type 'Self' does not support explicit initialization}}
+    return Self() // expected-error{{missing argument for parameter 'int' in call}} {{17-17=int: <#Int#>}}
   }
 
   // This used to crash because metatype construction went down a

test/expr/closure/closures.swift

@@ -43,6 +43,7 @@ func funcdecl5(_ a: Int, _ y: Int) {
 
   var testfunc : ((), Int) -> Int  // expected-note {{'testfunc' declared here}}
   testfunc({$0+1})  // expected-error {{missing argument for parameter #2 in call}}
+  // expected-error@-1 {{cannot convert value of type '(Int) -> Int' to expected argument type '()'}}
 
   funcdecl5(1, 2) // recursion.
 

test/expr/expressions.swift

@@ -858,10 +858,10 @@ _ = _.foo // expected-error {{type of expression is ambiguous without more conte
 
 // <rdar://problem/22211854> wrong arg list crashing sourcekit
 func r22211854() {
-    func f(_ x: Int, _ y: Int, _ z: String = "") {} // expected-note 2 {{'f' declared here}}
+    func f(_ x: Bool, _ y: Int, _ z: String = "") {} // expected-note 2 {{'f' declared here}}
     func g<T>(_ x: T, _ y: T, _ z: String = "") {} // expected-note 2 {{'g' declared here}}
 
-    f(1) // expected-error{{missing argument for parameter #2 in call}}
+    f(false) // expected-error{{missing argument for parameter #2 in call}}
     g(1) // expected-error{{missing argument for parameter #2 in call}}
     func h() -> Int { return 1 }
     f(h() == 1) // expected-error{{missing argument for parameter #2 in call}}

test/expr/postfix/dot/init_ref_delegation.swift

@@ -159,7 +159,7 @@ class RDar16666631 {
    var i: Int
    var d: Double
    var s: String
-   init(i: Int, d: Double, s: String) {
+   init(i: Int, d: Double, s: String) { // expected-note {{'init(i:d:s:)' declared here}}
       self.i = i
       self.d = d
       self.s = s
@@ -168,9 +168,7 @@ class RDar16666631 {
       self.init(i: i, d: 0.1, s: s)
    }
 }
-let rdar16666631 = RDar16666631(i: 5, d: 6) // expected-error {{incorrect argument label in call (have 'i:d:', expected 'i:s:')}}
-// expected-error@-1 {{cannot convert value of type 'Int' to expected argument type 'String'}}
-
+let rdar16666631 = RDar16666631(i: 5, d: 6) // expected-error {{missing argument for parameter 's' in call}} {{43-43=, s: <#String#>}}
 
 struct S {
   init() {

validation-test/Sema/type_checker_crashers_fixed/rdar48994658.swift

@@ -1,6 +1,6 @@
 // RUN: %target-typecheck-verify-swift
 
-struct Ref<Value> {
+struct Ref<Value> { // expected-note {{'Value' declared as parameter to type 'Ref'}}
   static func foo(_ value: Int) {} // expected-note {{declared here}}
 }
 
@@ -25,4 +25,6 @@ extension Ref : RefConvertible {
 
 func rdar_48994658() {
   Ref.foo() // expected-error {{missing argument for parameter #1 in call}}
+  // expected-error@-1 {{generic parameter 'Value' could not be inferred}}
+  // expected-note@-2 {{explicitly specify the generic arguments to fix this issue}} {{6-6=<Any>}}
 }

validation-test/compiler_crashers_2_fixed/0117-rdar33433087.swift

@@ -1,9 +1,11 @@
 // RUN: %target-typecheck-verify-swift
 
 class C {
-  private init() {} // expected-note {{declared here}}
-  init(n: Int) {}
+  private init() {}
+  init(n: Int) {} // expected-note {{'init(n:)' declared here}}
 }
 
+// TODO(diagnostics): Once "inaccessible members" are ported to the new framework it would be possible
+// to bring back `'C' initializer is inaccessible due to 'private' protection level` diagnostic here.
 _ = C()
-// expected-error@-1 {{'C' initializer is inaccessible due to 'private' protection level}}
+// expected-error@-1 {{missing argument for parameter 'n' in call}} {{7-7=n: <#Int#>}}