[Diagnostics] NFC: Adjust diagnostic test-cases improved by new ambiguity diagnosis

Author: xedin

test/Constraints/diagnostics.swift

@@ -1117,8 +1117,10 @@ func platypus<T>(a: [T]) {
 // Another case of the above.
 func badTypes() {
   let sequence:AnySequence<[Int]> = AnySequence() { AnyIterator() { [3] }}
+  // Notes, attached to declarations, explain that there is a difference between Array.init(_:) and
+  // RangeReplaceableCollection.init(_:) which are both applicable in this case.
   let array = [Int](sequence)
-  // expected-error@-1 {{initializer 'init(_:)' requires the types 'Int' and '[Int]' be equivalent}}
+  // expected-error@-1 {{no exact matches in call to initializer}}
 }
 
 // rdar://34357545

test/Constraints/sr12964.swift

@@ -3,5 +3,4 @@
 protocol P {}
 typealias T = (P) -> Void
 let x: T! = [1, 2, 3].reversed().reduce()
-// expected-error@-1 {{no exact matches in call to instance method 'reduce'}}
-// expected-note@-2 2{{candidate has partially matching parameter list}}
+// expected-error@-1 {{missing arguments for parameters #1, #2 in call}}

test/Constraints/tuple_arguments.swift

@@ -1702,8 +1702,8 @@ x.map { (_: ()) in () }
 // https://bugs.swift.org/browse/SR-9470
 do {
   func f(_: Int...) {}
-  let _ = [(1, 2, 3)].map(f) // expected-error {{cannot convert value of type '(Int...) -> ()' to expected argument type '((Int, Int, Int)) throws -> T'}}
-  // expected-error@-1 {{generic parameter 'T' could not be inferred}}
+  let _ = [(1, 2, 3)].map(f) // expected-error {{no exact matches in call to instance method 'map'}}
+  // expected-note@-1 {{found candidate with type '(((Int, Int, Int)) throws -> _) throws -> Array<_>'}}
 }
 
 // rdar://problem/48443263 - cannot convert value of type '() -> Void' to expected argument type '(_) -> Void'

test/ImportResolution/import-resolution-overload.swift

@@ -46,7 +46,7 @@ scopedFunction = 42
 // FIXME: Should be an error -- a type name and a function cannot overload.
 var _ : Int = TypeNameWins(42)
 
-TypeNameWins = 42 // expected-error {{no exact matches in reference to global function 'TypeNameWins'}}
+TypeNameWins = 42 // expected-error {{cannot assign to immutable expression of type 'Int'}}
 var _ : TypeNameWins // no-warning
 
 // rdar://problem/21739333

test/Misc/misc_diagnostics.swift

@@ -54,8 +54,9 @@ struct MyArray<Element> {} // expected-note {{'Element' declared as parameter to
 class A {
     var a: MyArray<Int>
     init() {
-        a = MyArray<Int // expected-error {{generic parameter 'Element' could not be inferred}}
-        // expected-note@-1 {{explicitly specify the generic arguments to fix this issue}}
+        a = MyArray<Int // expected-error {{generic parameter 'Element' could not be inferred}} expected-note {{explicitly specify the generic arguments to fix this issue}}
+       // expected-error@-1 {{binary operator '<' cannot be applied to operands of type 'MyArray<_>.Type' and 'Int.Type'}}
+       // expected-error@-2 {{cannot assign value of type 'Bool' to type 'MyArray<Int>'}}
     }
 }
 

test/Sema/enum_raw_representable.swift

@@ -135,19 +135,23 @@ rdar32431165_2(E_32431165.bar)
 rdar32431165_2(42, E_32431165.bar)
 // expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String'}} {{34-34=.rawValue}}
 
-E_32431165.bar == "bar"
-// expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String}} {{15-15=.rawValue}}
-
-"bar" == E_32431165.bar
-// expected-error@-1 {{cannot convert value of type 'E_32431165' to expected argument type 'String}} {{24-24=.rawValue}}
+// TODO: In following two examples it's possible to fix a problem by either using `.rawValue` on first argument
+// or constructing raw representable type from second, both ways are valid.
+do {
+  E_32431165.bar == "bar"
+  // expected-error@-1 {{binary operator '==' cannot be applied to operands of type 'E_32431165' and 'String'}} expected-note@-1 {{partially matching parameter lists: (String, String)}}
+
+  "bar" == E_32431165.bar
+  // expected-error@-1 {{binary operator '==' cannot be applied to operands of type 'String' and 'E_32431165'}} expected-note@-1 {{partially matching parameter lists: (String, String)}}
+}
 
-func rdar32431165_overloaded() -> Int { 42 }     // expected-note {{found candidate with type 'Int'}}
+func rdar32431165_overloaded() -> Int { 42 }     // expected-note {{'rdar32431165_overloaded()' produces 'Int', not the expected contextual result type 'E_32431165'}}
 func rdar32431165_overloaded() -> String { "A" } // expected-note {{'rdar32431165_overloaded()' produces 'String', not the expected contextual result type 'E_32431165'}}
 
 func test_candidate_diagnostic() {
   func test_argument(_: E_32431165) {}
 
-  let _: E_32431165 = rdar32431165_overloaded() // expected-error {{no exact matches in call to global function 'rdar32431165_overloaded'}}
+  let _: E_32431165 = rdar32431165_overloaded() // expected-error {{no 'rdar32431165_overloaded' candidates produce the expected contextual result type 'E_32431165'}}
   test_argument(rdar32431165_overloaded()) // expected-error {{cannot convert value of type 'String' to expected argument type 'E_32431165'}} {{17-17=E_32431165(rawValue: }} {{42-42=) ?? <#default value#>}}
 }
 
@@ -197,7 +201,8 @@ func sr8150_mutable(obj: SR8150Box) {
     sr8150_helper1(opt)
     // expected-error@-1 {{cannot convert value of type 'Bar?' to expected argument type 'Double'}} {{23-23=?.rawValue ?? <#default value#>}}
     sr8150_helper1(opt ?? Bar.a)
-    // expected-error@-1 {{cannot convert value of type 'Bar' to expected argument type 'Double'}} {{20-20=(}} {{32-32=).rawValue}}
+    // expected-error@-1 {{no exact matches in call to global function 'sr8150_helper1'}}
+    // expected-note@-2  {{candidate expects value of type 'Bar' for parameter #0}} {{20-20=(}} {{32-32=).rawValue}}
     let _: Double? = opt
     // expected-error@-1 {{cannot convert value of type 'Bar?' to specified type 'Double?'}} {{25-25=?.rawValue}}
   }

test/decl/protocol/req/recursion.swift

@@ -54,7 +54,7 @@ public struct S<A: P> where A.T == S<A> { // expected-error {{circular reference
 
   func g(a: S<A>) {
     f(a: id(t: a))
-    // expected-error@-1 {{conflicting arguments to generic parameter 'T' ('S<A>' vs. 'A.T' (associated type of protocol 'P'))}}
+    // expected-error@-1 {{cannot convert value of type 'S<A>' to expected argument type 'A.T'}}
     _ = S<A>.self
   }
 

test/expr/unary/keypath/salvage-with-other-type-errors.swift

@@ -52,7 +52,7 @@ protocol Bindable: class { }
 extension Bindable {
   func test<Value>(to targetKeyPath: ReferenceWritableKeyPath<Self, Value>, change: Value?) {
     if self[keyPath:targetKeyPath] != change {
-      // expected-error@-1 {{operator function '!=' requires that 'Value' conform to 'Equatable'}}
+      // expected-error@-1 {{binary operator '!=' cannot be applied to operands of type 'Value' and 'Value?'}}
       self[keyPath: targetKeyPath] = change!
     }
   }

test/stdlib/KeyPathAppending.swift

@@ -58,22 +58,20 @@ func mismatchedAppends<T, U, V>(readOnlyLeft: KeyPath<T, U>,
   // expected-note@-2 {{arguments to generic parameter 'Root' ('T' and 'V') are expected to be equal}}
 
   _ = readOnlyRight.appending(path: referenceLeft)
-  // expected-error@-1 {{cannot convert value of type 'ReferenceWritableKeyPath<T, U>' to expected argument type 'ReferenceWritableKeyPath<V, U>'}}
-  // expected-note@-2 {{arguments to generic parameter 'Root' ('T' and 'V') are expected to be equal}}
+  // expected-error@-1 {{no exact matches in call to instance method 'appending'}}
 
   _ = writableRight.appending(path: readOnlyLeft)
-  // expected-error@-1 {{instance method 'appending(path:)' requires that 'KeyPath<U, V>' inherit from 'KeyPath<U, T>'}}
+  // expected-error@-1 {{no exact matches in call to instance method 'appending'}}
 
   _ = writableRight.appending(path: writableLeft)
   // expected-error@-1 {{cannot convert value of type 'WritableKeyPath<T, U>' to expected argument type 'WritableKeyPath<V, U>'}}
   // expected-note@-2 {{arguments to generic parameter 'Root' ('T' and 'V') are expected to be equal}}
 
   _ = writableRight.appending(path: referenceLeft)
-  // expected-error@-1 {{cannot convert value of type 'ReferenceWritableKeyPath<T, U>' to expected argument type 'ReferenceWritableKeyPath<V, U>'}}
-  // expected-note@-2 {{arguments to generic parameter 'Root' ('T' and 'V') are expected to be equal}}
+  // expected-error@-1 {{no exact matches in call to instance method 'appending'}}
 
   _ = referenceRight.appending(path: readOnlyLeft)
-  // expected-error@-1 {{instance method 'appending(path:)' requires that 'KeyPath<U, V>' inherit from 'KeyPath<U, T>'}}
+  // expected-error@-1 {{no exact matches in call to instance method 'appending'}}
 
   _ = referenceRight.appending(path: writableLeft)
   // expected-error@-1 {{cannot convert value of type 'WritableKeyPath<T, U>' to expected argument type 'WritableKeyPath<V, U>'}}

test/stdlib/StringDiagnostics.swift

@@ -48,6 +48,7 @@ func testAmbiguousStringComparisons(s: String) {
 
   // Shouldn't suggest 'as' in a pattern-matching context, as opposed to all these other situations
   if case nsString = "" {} // expected-error{{expression pattern of type 'NSString' cannot match values of type 'String'}}
+  // expected-note@-1 {{overloads for '~=' exist with these partially matching parameter lists: (Substring, String)}}
 }
 
 func testStringDeprecation(hello: String) {

test/stdlib/UnicodeScalarDiagnostics.swift

@@ -13,9 +13,9 @@ func test_UnicodeScalarDoesNotImplementArithmetic(_ us: UnicodeScalar, i: Int) {
   let a4 = "a" / "b" // expected-error {{binary operator '/' cannot be applied to two 'String' operands}}
 
   let b1 = us + us // expected-error {{referencing operator function '+' on 'RangeReplaceableCollection' requires that 'UnicodeScalar' (aka 'Unicode.Scalar') conform to 'RangeReplaceableCollection'}}
-  let b2 = us - us // expected-error {{referencing operator function '-' on 'FloatingPoint' requires that 'UnicodeScalar' (aka 'Unicode.Scalar') conform to 'FloatingPoint'}}
-  let b3 = us * us // expected-error {{referencing operator function '*' on 'FloatingPoint' requires that 'UnicodeScalar' (aka 'Unicode.Scalar') conform to 'FloatingPoint'}}
-  let b4 = us / us // expected-error {{referencing operator function '/' on 'FloatingPoint' requires that 'UnicodeScalar' (aka 'Unicode.Scalar') conform to 'FloatingPoint'}}
+  let b2 = us - us // expected-error {{binary operator '-' cannot be applied to two 'UnicodeScalar' (aka 'Unicode.Scalar') operands}}
+  let b3 = us * us // expected-error {{binary operator '*' cannot be applied to two 'UnicodeScalar' (aka 'Unicode.Scalar') operands}}
+  let b4 = us / us // expected-error {{binary operator '/' cannot be applied to two 'UnicodeScalar' (aka 'Unicode.Scalar') operands}}
 
   let c1 = us + i // expected-error {{cannot convert value of type 'UnicodeScalar' (aka 'Unicode.Scalar') to expected argument type 'Int'}}
   let c2 = us - i // expected-error {{cannot convert value of type 'UnicodeScalar' (aka 'Unicode.Scalar') to expected argument type 'Int'}}

test/type/protocol_composition.swift

@@ -174,6 +174,10 @@ takesP1AndP2([AnyObject & protocol_composition.P1 & P2]())
 takesP1AndP2([AnyObject & P1 & protocol_composition.P2]())
 takesP1AndP2([DoesNotExist & P1 & P2]()) // expected-error {{cannot find 'DoesNotExist' in scope}}
 takesP1AndP2([Swift.DoesNotExist & P1 & P2]()) // expected-error {{module 'Swift' has no member named 'DoesNotExist'}}
+// expected-error@-1 {{binary operator '&' cannot be applied to operands of type 'UInt8' and 'P1.Protocol'}}
+// expected-error@-2 {{binary operator '&' cannot be applied to operands of type 'UInt8' and 'P2.Protocol'}}
+// expected-note@-3 2 {{overloads for '&' exist with these partially matching parameter lists}}
+
 
 typealias T08 = P1 & inout P2 // expected-error {{'inout' may only be used on parameters}}
 typealias T09 = P1 & __shared P2 // expected-error {{'__shared' may only be used on parameters}}

validation-test/Sema/type_checker_perf/slow/rdar53589951.swift

@@ -1,5 +1,6 @@
 // RUN: %target-typecheck-verify-swift -solver-expression-time-threshold=1
 // REQUIRES: tools-release,no_asan
+// REQUIRES: rdar36854536
 
 class Color {
   init(hue: Double, saturation: Double, brightness: Double, alpha: Double) {}