[Diagnostics] Check whether all contextual mismatches has the same type before diagnosing ambiguity

xedin · xedin · commit b0070f57397f · 2020-06-12T11:47:04.000-07:00
Instead of requiring sub-classes of `ContextualMismatch` to implement
`diagnoseForAmbiguity` let's implement it directly on `ContextualMismatch`
itself and check whether all of the aggregated fixes have same types on
both sides and if so, diagnose as-if it was a single fix.
diff --git a/lib/Sema/CSFix.cpp b/lib/Sema/CSFix.cpp
@@ -252,6 +252,33 @@ bool ContextualMismatch::diagnose(const Solution &solution, bool asNote) const {
   return failure.diagnose(asNote);
 }
 
+bool ContextualMismatch::diagnoseForAmbiguity(
+    CommonFixesArray commonFixes) const {
+  auto getTypes =
+      [&](const std::pair<const Solution *, const ConstraintFix *> &entry)
+      -> std::pair<Type, Type> {
+    auto &solution = *entry.first;
+    auto *fix = static_cast<const ContextualMismatch *>(entry.second);
+
+    return {solution.simplifyType(fix->getFromType()),
+            solution.simplifyType(fix->getToType())};
+  };
+
+  auto etalonTypes = getTypes(commonFixes.front());
+  if (llvm::all_of(
+          commonFixes,
+          [&](const std::pair<const Solution *, const ConstraintFix *> &entry) {
+            auto types = getTypes(entry);
+            return etalonTypes.first->isEqual(types.first) &&
+                   etalonTypes.second->isEqual(types.second);
+          })) {
+    const auto &primary = commonFixes.front();
+    return primary.second->diagnose(*primary.first, /*aNote=*/false);
+  }
+
+  return false;
+}
+
 ContextualMismatch *ContextualMismatch::create(ConstraintSystem &cs, Type lhs,
                                                Type rhs,
                                                ConstraintLocator *locator) {
diff --git a/lib/Sema/CSFix.h b/lib/Sema/CSFix.h
@@ -526,6 +526,8 @@ class ContextualMismatch : public ConstraintFix {
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override;
+
   static ContextualMismatch *create(ConstraintSystem &cs, Type lhs, Type rhs,
                                     ConstraintLocator *locator);
 };
@@ -562,10 +564,6 @@ class ForceOptional final : public ContextualMismatch {
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 
-  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
-    return diagnose(*commonFixes.front().first);
-  }
-
   static ForceOptional *create(ConstraintSystem &cs, Type fromType, Type toType,
                                ConstraintLocator *locator);
 };
@@ -675,10 +673,6 @@ class GenericArgumentsMismatch final
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
 
-  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
-    return diagnose(*commonFixes.front().first);
-  }
-
   static GenericArgumentsMismatch *create(ConstraintSystem &cs, Type actual,
                                           Type required,
                                           llvm::ArrayRef<unsigned> mismatches,
diff --git a/test/ClangImporter/objc_factory_method.swift b/test/ClangImporter/objc_factory_method.swift
@@ -75,7 +75,7 @@ func testNSErrorFactoryMethod(_ path: String) throws {
 }
 
 func testNonInstanceTypeFactoryMethod(_ s: String) {
-  _ = NSObjectFactory(string: s) // expected-error{{no exact matches in call to initializer}}
+  _ = NSObjectFactory(string: s) // expected-error{{argument passed to call that takes no arguments}}
 }
 
 func testUseOfFactoryMethod(_ queen: Bee) {
diff --git a/test/ClangImporter/objc_implicit_with.swift b/test/ClangImporter/objc_implicit_with.swift
@@ -43,7 +43,7 @@ func testNSErrorFactoryMethod(_ path: String) throws {
 }
 
 func testNonInstanceTypeFactoryMethod(_ s: String) {
-  _ = NSObjectFactory(string: s) // expected-error{{no exact matches in call to initializer}}
+  _ = NSObjectFactory(string: s) // expected-error{{argument passed to call that takes no arguments}}
 }
 
 func testUseOfFactoryMethod(_ queen: Bee) {
diff --git a/test/Constraints/diagnostics.swift b/test/Constraints/diagnostics.swift
@@ -408,8 +408,7 @@ enum Color {
 }
 
 let _: (Int, Color) = [1,2].map({ ($0, .Unknown("")) })
-// expected-error@-1 {{no 'map' candidates produce the expected contextual result type '(Int, Color)'}}
-// expected-note@-2 {{found candidate with type '((Int) throws -> (Int, _)) throws -> Array<(Int, _)>'}}
+// expected-error@-1 {{cannot convert value of type 'Array<(Int, _)>' to specified type '(Int, Color)'}}
 
 let _: [(Int, Color)] = [1,2].map({ ($0, .Unknown("")) })// expected-error {{missing argument label 'description:' in call}}
 
diff --git a/test/Constraints/optional.swift b/test/Constraints/optional.swift
@@ -424,8 +424,7 @@ func test_force_unwrap_not_being_too_eager() {
 // rdar://problem/57097401
 func invalidOptionalChaining(a: Any) {
   a == "="? // expected-error {{cannot use optional chaining on non-optional value of type 'String'}}
-  // expected-error@-1 {{value of protocol type 'Any' cannot conform to 'Equatable'; only struct/enum/class types can conform to protocols}}
-  // expected-note@-2 {{requirement from conditional conformance of 'Any?' to 'Equatable'}}
+  // expected-error@-1 {{cannot convert value of type 'Any' to expected argument type 'Any.Type?'}}
 }
 
 // SR-12309 - Force unwrapping 'nil' compiles without warning
diff --git a/test/Constraints/patterns.swift b/test/Constraints/patterns.swift
@@ -274,9 +274,7 @@ struct StaticMembers: Equatable {
   static var optProp: Optional = StaticMembers()
 
   static func method(_: Int) -> StaticMembers { return prop }
-  // expected-note@-1 {{found candidate with type '(Int) -> StaticMembers'}}
   static func method(withLabel: Int) -> StaticMembers { return prop }
-  // expected-note@-1 {{found candidate with type '(Int) -> StaticMembers'}}
   static func optMethod(_: Int) -> StaticMembers? { return optProp }
 
   static func ==(x: StaticMembers, y: StaticMembers) -> Bool { return true }
@@ -301,7 +299,7 @@ switch staticMembers {
   // TODO: repeated error message
   case .optProp: break // expected-error* {{not unwrapped}}
 
-  case .method: break // expected-error{{no exact matches in reference to static method 'method'}}
+  case .method: break // expected-error{{member 'method' expects argument of type 'Int'}}
   case .method(0): break
   case .method(_): break // expected-error{{'_' can only appear in a pattern}}
   case .method(let x): break // expected-error{{cannot appear in an expression}}
diff --git a/test/Constraints/rdar42678836.swift b/test/Constraints/rdar42678836.swift
@@ -1,6 +1,5 @@
 // RUN: %target-typecheck-verify-swift
 
 func foo(chr: Character) -> String {
-  return String(repeating: String(chr)) // expected-error {{no exact matches in call to initializer}}
-  // expected-note@-1 {{candidate has partially matching parameter list (repeating: String, count: Int)}}
+  return String(repeating: String(chr)) // expected-error {{missing argument for parameter 'count' in call}} {{39-39=, count: <#Int#>}}
 }
diff --git a/test/Constraints/rdar44770297.swift b/test/Constraints/rdar44770297.swift
@@ -8,4 +8,6 @@ func foo<T: P>(_: () throws -> T) -> T.A? {
   fatalError()
 }
 
-let _ = foo() {fatalError()} & nil // expected-error {{binary operator '&' cannot be applied to operands of type 'Never.A?' and '_'}}
+let _ = foo() {fatalError()} & nil // expected-error {{value of optional type 'Never.A?' must be unwrapped to a value of type 'Never.A'}}
+// expected-note@-1 {{coalesce using '??' to provide a default when the optional value contains 'nil'}}
+// expected-note@-2 {{force-unwrap using '!' to abort execution if the optional value contains 'nil'}}
diff --git a/test/Sema/diag_ambiguous_overloads.swift b/test/Sema/diag_ambiguous_overloads.swift
@@ -51,10 +51,10 @@ func testDiagnoseForAmbiguityCrash(schools: [School]) {
 
 class DefaultValue {
   static func foo(_ a: Int) {}
-  static func foo(_ a: Int, _ b: Int = 1) {} // expected-note {{candidate expects value of type 'Int' for parameter #1}}
-  static func foo(_ a: Int, _ b: Int = 1, _ c: Int = 2) {} // expected-note {{candidate expects value of type 'Int' for parameter #1}}
+  static func foo(_ a: Int, _ b: Int = 1) {}
+  static func foo(_ a: Int, _ b: Int = 1, _ c: Int = 2) {}
 }
-DefaultValue.foo(1.0, 1) // expected-error {{no exact matches in call to static method 'foo'}}
+DefaultValue.foo(1.0, 1) // expected-error {{cannot convert value of type 'Double' to expected argument type 'Int'}}
 
 
 class Variadic {
diff --git a/test/attr/attr_dynamic_member_lookup.swift b/test/attr/attr_dynamic_member_lookup.swift
@@ -600,9 +600,7 @@ func keypath_with_subscripts(_ arr: SubscriptLens<[Int]>,
 
 func keypath_with_incorrect_return_type(_ arr: Lens<Array<Int>>) {
   for idx in 0..<arr.count {
-    // expected-error@-1 {{protocol 'Sequence' requires that 'Lens<Int>' conform to 'Strideable'}}
-    // expected-error@-2 {{cannot convert value of type 'Int' to expected argument type 'Lens<Int>'}}
-    // expected-error@-3 {{referencing operator function '..<' on 'Comparable' requires that 'Lens<Int>' conform to 'Comparable'}}
+    // expected-error@-1 {{cannot convert value of type 'Int' to expected argument type 'Lens<Int>'}}
     let _ = arr[idx]
   }
 }
diff --git a/test/decl/subscript/subscripting.swift b/test/decl/subscript/subscripting.swift
@@ -349,9 +349,9 @@ func testUnresolvedMemberSubscriptFixit(_ s0: GenSubscriptFixitTest) {
 
 struct SubscriptTest1 {
   subscript(keyword:String) -> Bool { return true }
-  // expected-note@-1 5 {{found this candidate}} expected-note@-1 {{found candidate with type 'Bool'}}
+  // expected-note@-1 5 {{found this candidate}} expected-note@-1 {{'subscript(_:)' produces 'Bool', not the expected contextual result type 'Int'}}
   subscript(keyword:String) -> String? {return nil }
-  // expected-note@-1 5 {{found this candidate}} expected-note@-1 {{found candidate with type 'String?'}}
+  // expected-note@-1 5 {{found this candidate}} expected-note@-1 {{'subscript(_:)' produces 'String?', not the expected contextual result type 'Int'}}
 
   subscript(arg: SubClass) -> Bool { return true } // expected-note {{declared here}}
   // expected-note@-1 2 {{found this candidate}}
@@ -397,14 +397,12 @@ func testSubscript1(_ s1 : SubscriptTest1) {
 
 struct SubscriptTest2 {
   subscript(a : String, b : Int) -> Int { return 0 } // expected-note {{candidate expects value of type 'Int' for parameter #2}}
-  // expected-note@-1 {{declared here}}
-  // expected-note@-2 {{candidate has partially matching parameter list (String, Int)}}
-    subscript(a : String, b : String) -> Int { return 0 } // expected-note {{candidate expects value of type 'String' for parameter #2}}
-  // expected-note@-1 {{candidate has partially matching parameter list (String, String)}}
+  // expected-note@-1 2 {{declared here}}
+  subscript(a : String, b : String) -> Int { return 0 } // expected-note {{candidate expects value of type 'String' for parameter #2}}
 }
 
 func testSubscript1(_ s2 : SubscriptTest2) {
-  _ = s2["foo"] // expected-error {{no exact matches in call to subscript}}
+  _ = s2["foo"] // expected-error {{missing argument for parameter #2 in call}}
 
   let a = s2["foo", 1.0] // expected-error {{no exact matches in call to subscript}}
 
diff --git a/test/expr/expressions.swift b/test/expr/expressions.swift
@@ -791,7 +791,6 @@ func testNilCoalescePrecedence(cond: Bool, a: Int?, r: ClosedRange<Int>?) {
   // ?? should have lower precedence than range and arithmetic operators.
   let r1 = r ?? (0...42) // ok
   let r2 = (r ?? 0)...42 // not ok: expected-error 2 {{cannot convert value of type 'Int' to expected argument type 'ClosedRange<Int>'}}
-  // expected-error@-1 {{referencing operator function '...' on 'Comparable' requires that 'ClosedRange<Int>' conform to 'Comparable'}}
   let r3 = r ?? 0...42 // parses as the first one, not the second.
   
   
diff --git a/test/expr/unary/keypath/keypath.swift b/test/expr/unary/keypath/keypath.swift
@@ -507,7 +507,7 @@ func testLabeledSubscript() {
   let k = \AA.[labeled: 0]
 
   // TODO: These ought to work without errors.
-  let _ = \AA.[keyPath: k] // expected-error {{extraneous argument label 'keyPath:' in call}}
+  let _ = \AA.[keyPath: k]
   // expected-error@-1 {{cannot convert value of type 'KeyPath<AA, Int>' to expected argument type 'Int'}}
 
   let _ = \AA.[keyPath: \AA.[labeled: 0]] // expected-error {{extraneous argument label 'keyPath:' in call}}
diff --git a/test/stmt/foreach.swift b/test/stmt/foreach.swift
@@ -68,8 +68,7 @@ func patterns(gir: GoodRange<Int>, gtr: GoodTupleIterator) {
   for (i, f) in gtr {
     sum = sum + i
     sumf = sumf + f
-    sum = sum + f  // expected-error {{binary operator '+' cannot be applied to operands of type 'Int' and 'Float'}}
-    // expected-note@-1 {{overloads for '+' exist with}}
+    sum = sum + f  // expected-error {{cannot convert value of type 'Float' to expected argument type 'Int'}} {{17-17=Int(}} {{18-18=)}}
   }
 
   for (i, _) : (Int, Float) in gtr { sum = sum + i }
diff --git a/test/type/types.swift b/test/type/types.swift
@@ -20,14 +20,7 @@ var d4 : () -> Int = { d2 }  // expected-error{{function produces expected type
 
 if #available(macOS 9999, iOS 9999, tvOS 9999, watchOS 9999, *) {
   var e0 : [Int]
-  e0[] // expected-error {{no exact matches in call to subscript}}
-  // expected-note@-1 {{candidate has partially matching parameter list (Int)}}
-  // expected-note@-2 {{candidate has partially matching parameter list (Range<Int>)}}
-  // expected-note@-3 {{candidate has partially matching parameter list ((UnboundedRange_) -> ())}}
-  // expected-note@-4 {{candidate has partially matching parameter list (RangeSet<Array<Int>.Index>)}}
-  // expected-note@-5 {{candidate has partially matching parameter list (Range<Array<Int>.Index>)}}
-  // expected-note@-6 {{candidate has partially matching parameter list ((UnboundedRange_) -> ())}}
-  // expected-note@-7 {{candidate has partially matching parameter list (RangeSet<Array<Int>.Index>)}}
+  e0[] // expected-error {{missing argument for parameter #1 in call}} {{6-6=<#Int#>}}
 }
 
 var f0 : [Float]

Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ func testNSErrorFactoryMethod(_ path: String) throws {`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`func testNonInstanceTypeFactoryMethod(_ s: String) {`
`78`		`- _ = NSObjectFactory(string: s) // expected-error{{no exact matches in call to initializer}}`
	`78`	`+ _ = NSObjectFactory(string: s) // expected-error{{argument passed to call that takes no arguments}}`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`func testUseOfFactoryMethod(_ queen: Bee) {`
Original file line number	Diff line number	Diff line change
`@@ -43,7 +43,7 @@ func testNSErrorFactoryMethod(_ path: String) throws {`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`func testNonInstanceTypeFactoryMethod(_ s: String) {`
`46`		`- _ = NSObjectFactory(string: s) // expected-error{{no exact matches in call to initializer}}`
	`46`	`+ _ = NSObjectFactory(string: s) // expected-error{{argument passed to call that takes no arguments}}`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`func testUseOfFactoryMethod(_ queen: Bee) {`
Original file line number	Diff line number	Diff line change
`@@ -408,8 +408,7 @@ enum Color {`
`408`	`408`	`}`
`409`	`409`
`410`	`410`	`let _: (Int, Color) = [1,2].map({ ($0, .Unknown("")) })`
`411`		`-// expected-error@-1 {{no 'map' candidates produce the expected contextual result type '(Int, Color)'}}`
`412`		`-// expected-note@-2 {{found candidate with type '((Int) throws -> (Int, _)) throws -> Array<(Int, _)>'}}`
	`411`	`+// expected-error@-1 {{cannot convert value of type 'Array<(Int, _)>' to specified type '(Int, Color)'}}`
`413`	`412`
`414`	`413`	`let _: [(Int, Color)] = [1,2].map({ ($0, .Unknown("")) })// expected-error {{missing argument label 'description:' in call}}`
`415`	`414`
Original file line number	Diff line number	Diff line change
`@@ -424,8 +424,7 @@ func test_force_unwrap_not_being_too_eager() {`
`424`	`424`	`// rdar://problem/57097401`
`425`	`425`	`func invalidOptionalChaining(a: Any) {`
`426`	`426`	`a == "="? // expected-error {{cannot use optional chaining on non-optional value of type 'String'}}`
`427`		`- // expected-error@-1 {{value of protocol type 'Any' cannot conform to 'Equatable'; only struct/enum/class types can conform to protocols}}`
`428`		`- // expected-note@-2 {{requirement from conditional conformance of 'Any?' to 'Equatable'}}`
	`427`	`+ // expected-error@-1 {{cannot convert value of type 'Any' to expected argument type 'Any.Type?'}}`
`429`	`428`	`}`
`430`	`429`
`431`	`430`	`// SR-12309 - Force unwrapping 'nil' compiles without warning`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`// RUN: %target-typecheck-verify-swift`
`2`	`2`
`3`	`3`	`func foo(chr: Character) -> String {`
`4`		`- return String(repeating: String(chr)) // expected-error {{no exact matches in call to initializer}}`
`5`		`- // expected-note@-1 {{candidate has partially matching parameter list (repeating: String, count: Int)}}`
	`4`	`+ return String(repeating: String(chr)) // expected-error {{missing argument for parameter 'count' in call}} {{39-39=, count: <#Int#>}}`
`6`	`5`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,4 +8,6 @@ func foo<T: P>(_: () throws -> T) -> T.A? {`
`8`	`8`	`fatalError()`
`9`	`9`	`}`
`10`	`10`
`11`		`-let _ = foo() {fatalError()} & nil // expected-error {{binary operator '&' cannot be applied to operands of type 'Never.A?' and '_'}}`
	`11`	`+let _ = foo() {fatalError()} & nil // expected-error {{value of optional type 'Never.A?' must be unwrapped to a value of type 'Never.A'}}`
	`12`	`+// expected-note@-1 {{coalesce using '??' to provide a default when the optional value contains 'nil'}}`
	`13`	`+// expected-note@-2 {{force-unwrap using '!' to abort execution if the optional value contains 'nil'}}`