[Diagnostics] Allow requirement failure to diagnose operators

In absence of general argument conversion failures requirement
errors associated with operators couldn't be diagnosed properly,
now this restriction could be lifted.

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -455,9 +455,6 @@ bool RequirementFailure::isStaticOrInstanceMember(const ValueDecl *decl) {
 }
 
 bool RequirementFailure::diagnoseAsError() {
-  if (!canDiagnoseFailure())
-    return false;
-
   auto *anchor = getRawAnchor();
   const auto *reqDC = getRequirementDC();
   auto *genericCtx = getGenericContext();
@@ -532,9 +529,6 @@ void RequirementFailure::emitRequirementNote(const Decl *anchor, Type lhs,
 }
 
 bool MissingConformanceFailure::diagnoseAsError() {
-  if (!canDiagnoseFailure())
-    return false;
-
   auto *anchor = getAnchor();
   auto ownerType = getOwnerType();
   auto nonConformingType = getLHS();

lib/Sema/CSDiagnostics.h

@@ -285,24 +285,6 @@ class RequirementFailure : public FailureDiagnostic {
   virtual DiagInReference getDiagnosticInRereference() const = 0;
   virtual DiagAsNote getDiagnosticAsNote() const = 0;
 
-  /// Determine whether it would be possible to diagnose
-  /// current requirement failure.
-  bool canDiagnoseFailure() const {
-    // If this is a conditional requirement failure,
-    // we have a lot more information compared to
-    // type requirement case, because we know that
-    // underlying conformance requirement matched.
-    if (isConditional())
-      return true;
-
-    // For static/initializer calls there is going to be
-    // a separate fix, attached to the argument, which is
-    // much easier to diagnose.
-    // For operator calls we can't currently produce a good
-    // diagnostic, so instead let's refer to expression diagnostics.
-    return !(Apply && isOperator(Apply));
-  }
-
   static bool isOperator(const ApplyExpr *apply) {
     return isa<PrefixUnaryExpr>(apply) || isa<PostfixUnaryExpr>(apply) ||
            isa<BinaryExpr>(apply);

lib/Sema/CSSimplify.cpp

@@ -1775,8 +1775,24 @@ ConstraintSystem::matchExistentialTypes(Type type1, Type type2,
   if (auto layoutConstraint = layout.getLayoutConstraint()) {
     if (layoutConstraint->isClass()) {
       if (kind == ConstraintKind::ConformsTo) {
-        if (!type1->satisfiesClassConstraint())
+        if (!type1->satisfiesClassConstraint()) {
+          if (shouldAttemptFixes()) {
+            if (auto last = locator.last()) {
+              // If solver is in diagnostic mode and this is a
+              // superclass requirement, let's consider conformance
+              // to `AnyObject` as solved since actual superclass
+              // requirement is going to fail too (because type can't
+              // satisfy it), and it's more interesting from diagnostics
+              // perspective.
+              auto req = last->getAs<LocatorPathElt::AnyRequirement>();
+              if (req &&
+                  req->getRequirementKind() == RequirementKind::Superclass)
+                return getTypeMatchSuccess();
+            }
+          }
+
           return getTypeMatchFailure(locator);
+        }
       } else {
         // Subtype relation to AnyObject also allows class-bound
         // existentials that are not @objc and therefore carry