Merge pull request #34614 from xedin/improvements-to-ambiguity-diags

[Diagnostic] Improve diagnostics for situations with ambiguity caused by conformance requirements

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -1672,20 +1672,6 @@ assessRequirementFailureImpact(ConstraintSystem &cs, Type requirementType,
   if (!anchor)
     return impact;
 
-  // If this is a conditional requirement failure associated with a
-  // call, let's increase impact of the fix to show that such failure
-  // makes member/function unreachable in current context or with
-  // given arguments.
-  if (auto last = locator.last()) {
-    if (last->isConditionalRequirement()) {
-      if (auto *expr = getAsExpr(anchor)) {
-        auto *parent = cs.getParentExpr(expr);
-        if (parent && isa<ApplyExpr>(parent))
-          return 5;
-      }
-    }
-  }
-
   // If this requirement is associated with a member reference and it
   // was possible to check it before overload choice is bound, that means
   // types came from the context (most likely Self, or associated type(s))

lib/Sema/ConstraintSystem.cpp

@@ -3399,6 +3399,30 @@ static bool diagnoseAmbiguity(
 
   auto &DE = cs.getASTContext().Diags;
 
+  llvm::SmallPtrSet<ValueDecl *, 4> localAmbiguity;
+  {
+    for (auto &entry : aggregateFix) {
+      const auto &solution = entry.first;
+      const auto &overload = solution->getOverloadChoice(ambiguity.locator);
+      auto *choice = overload.choice.getDeclOrNull();
+
+      // It's not possible to diagnose different kinds of overload choices.
+      if (!choice)
+        return false;
+
+      localAmbiguity.insert(choice);
+    }
+  }
+
+  if (localAmbiguity.empty())
+    return false;
+
+  // If all of the fixes are rooted in the same choice.
+  if (localAmbiguity.size() == 1) {
+    auto &primaryFix = aggregateFix.front();
+    return primaryFix.second->diagnose(*primaryFix.first);
+  }
+
   {
     auto fixKind = aggregateFix.front().second->getKind();
     if (llvm::all_of(
@@ -3413,10 +3437,7 @@ static bool diagnoseAmbiguity(
     }
   }
 
-  auto *decl = ambiguity.choices.front().getDeclOrNull();
-  if (!decl)
-    return false;
-
+  auto *decl = *localAmbiguity.begin();
   auto *commonCalleeLocator = ambiguity.locator;
 
   bool diagnosed = true;

test/Constraints/bridging.swift

@@ -180,7 +180,8 @@ func dictionaryToNSDictionary() {
 // In this case, we should not implicitly convert Dictionary to NSDictionary.
 struct NotEquatable {}
 func notEquatableError(_ d: Dictionary<Int, NotEquatable>) -> Bool {
-  return d == d // expected-error{{referencing operator function '==' on 'Dictionary' requires that 'NotEquatable' conform to 'Equatable'}}
+  // There is a note attached to a requirement `requirement from conditional conformance of 'Dictionary<Int, NotEquatable>' to 'Equatable'`
+  return d == d // expected-error{{operator function '==' requires that 'NotEquatable' conform to 'Equatable'}}
 }
 
 // NSString -> String

test/Constraints/operator.swift

@@ -216,14 +216,11 @@ func rdar46459603() {
   let e = E.foo(value: "String")
   var arr = ["key": e]
 
-  // FIXME(rdar://problem/64844584) - on iOS simulator this diagnostic is flaky,
-  // either `referencing operator function '==' on 'Equatable'` or `operator function '==' requires`
   _ = arr.values == [e]
-  // expected-error@-1 {{requires that 'Dictionary<String, E>.Values' conform to 'Equatable'}}
-  // expected-error@-2 {{cannot convert value of type '[E]' to expected argument type 'Dictionary<String, E>.Values'}}
+  // expected-error@-1 {{binary operator '==' cannot be applied to operands of type 'Dictionary<String, E>.Values' and '[E]'}}
   _ = [arr.values] == [[e]]
-  // expected-error@-1 {{requires that 'Dictionary<String, E>.Values' conform to 'Equatable'}}
-  // expected-error@-2 {{cannot convert value of type '[E]' to expected element type 'Dictionary<String, E>.Values'}}
+  // expected-error@-1 {{referencing operator function '==' on 'Array' requires that 'E' conform to 'Equatable'}} expected-note@-1 {{binary operator '==' cannot be synthesized for enums with associated values}}
+  // expected-error@-2 {{cannot convert value of type 'Dictionary<String, E>.Values' to expected element type '[E]'}}
 }
 
 // SR-10843

test/Generics/conditional_conformances.swift

@@ -413,9 +413,9 @@ extension Foo: P where Bar: P {
 extension BinaryInteger {
   var foo: Self {
     return self <= 1
-            ? 1 // expected-error {{cannot convert return expression of type 'Int' to return type 'Self'}}
+            ? 1
             : (2...self).reduce(1, *)
-            // expected-error@-1 {{cannot convert value of type 'Self' to expected argument type 'Int'}} {{20-20=Int(}} {{24-24=)}}
+            // expected-error@-1 {{referencing instance method 'reduce' on 'ClosedRange' requires that 'Self.Stride' conform to 'SignedInteger'}}
   }
 }
 

test/Parse/pointer_conversion.swift.gyb

@@ -307,7 +307,8 @@ struct NotEquatable {}
 func arrayComparison(_ x: [NotEquatable], y: [NotEquatable], p: UnsafeMutablePointer<NotEquatable>) {
   var x = x
   // Don't allow implicit array-to-pointer conversions in operators.
-  let a: Bool = x == y // expected-error{{referencing operator function '==' on 'Array' requires that 'NotEquatable' conform to 'Equatable'}}
+  // There is a note attached to declaration - requirement from conditional conformance of '[NotEquatable]' to 'Equatable'
+  let a: Bool = x == y // expected-error{{operator function '==' requires that 'NotEquatable' conform to 'Equatable'}}
   let _: Bool = p == &x  // Allowed!
 }
 

test/Sema/enum_raw_representable.swift

@@ -204,8 +204,7 @@ 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 {{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}}
+    // expected-error@-1 {{cannot convert value of type 'Bar' to expected argument type 'Double'}} {{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/expr/unary/keypath/salvage-with-other-type-errors.swift

@@ -53,8 +53,9 @@ protocol Bindable: class { }
 
 extension Bindable {
   func test<Value>(to targetKeyPath: ReferenceWritableKeyPath<Self, Value>, change: Value?) {
+    // There is also a note attached to declaration - requirement from conditional conformance of 'Optional<Value>' to 'Equatable'
     if self[keyPath:targetKeyPath] != change {
-      // expected-error@-1 {{binary operator '!=' cannot be applied to operands of type 'Value' and 'Value?'}}
+      // expected-error@-1 {{operator function '!=' requires that 'Value' conform to 'Equatable'}}
       self[keyPath: targetKeyPath] = change!
     }
   }

test/stdlib/ArrayDiagnostics.swift

@@ -4,5 +4,6 @@ class NotEquatable {}
 
 func test_ArrayOfNotEquatableIsNotEquatable() {
   var a = [ NotEquatable(), NotEquatable() ]
-  if a == a {} // expected-error {{referencing operator function '==' on 'Array' requires that 'NotEquatable' conform to 'Equatable'}}
+  // There is also a note attached to declaration - requirement from conditional conformance of '[NotEquatable]' to 'Equatable'
+  if a == a {} // expected-error {{operator function '==' requires that 'NotEquatable' conform to 'Equatable'}}
 }

test/stdlib/KeyPathAppending.swift

@@ -61,7 +61,7 @@ func mismatchedAppends<T, U, V>(readOnlyLeft: KeyPath<T, U>,
   // expected-error@-1 {{no exact matches in call to instance method 'appending'}}
 
   _ = writableRight.appending(path: readOnlyLeft)
-  // expected-error@-1 {{no exact matches in call to instance method 'appending'}}
+  // expected-error@-1 {{instance method 'appending(path:)' requires that 'KeyPath<U, V>' inherit from 'KeyPath<U, T>'}}
 
   _ = writableRight.appending(path: writableLeft)
   // expected-error@-1 {{cannot convert value of type 'WritableKeyPath<T, U>' to expected argument type 'WritableKeyPath<V, U>'}}
@@ -71,7 +71,7 @@ func mismatchedAppends<T, U, V>(readOnlyLeft: KeyPath<T, U>,
   // expected-error@-1 {{no exact matches in call to instance method 'appending'}}
 
   _ = referenceRight.appending(path: readOnlyLeft)
-  // expected-error@-1 {{no exact matches in call to instance method 'appending'}}
+  // expected-error@-1 {{instance method 'appending(path:)' requires that 'KeyPath<U, V>' inherit from 'KeyPath<U, T>'}}
 
   _ = referenceRight.appending(path: writableLeft)
   // expected-error@-1 {{cannot convert value of type 'WritableKeyPath<T, U>' to expected argument type 'WritableKeyPath<V, U>'}}