[CSDiagnostics] Augment RequirementFailure to support conditional requirements

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -24,6 +24,8 @@
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Pattern.h"
+#include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Parse/Lexer.h"
@@ -88,19 +90,54 @@ Type RequirementFailure::getOwnerType() const {
 }
 
 const GenericContext *RequirementFailure::getGenericContext() const {
+  // For conditional requirements, this is easy because all
+  // required information is contained in the conformance
+  // reference.
+  if (isConditional()) {
+    auto *conformance = getConformanceRef().getConcrete();
+    auto *DC = conformance->getDeclContext();
+    return DC->getAsDecl()->getAsGenericContext();
+  }
+
   if (auto *genericCtx = AffectedDecl->getAsGenericContext())
     return genericCtx;
   return AffectedDecl->getDeclContext()->getAsDecl()->getAsGenericContext();
 }
 
 const Requirement &RequirementFailure::getRequirement() const {
+  // If this is a conditional requirement failure we need to
+  // fetch conformance from constraint system associated with
+  // type requirement this conditional conformance belongs to.
+  if (isConditional()) {
+    auto conformanceRef = getConformanceRef();
+    return conformanceRef.getConditionalRequirements()[getRequirementIndex()];
+  }
+
   return getGenericContext()->getGenericRequirements()[getRequirementIndex()];
 }
 
+ProtocolConformanceRef RequirementFailure::getConformanceRef() const {
+  assert(isConditional());
+
+  auto &cs = getConstraintSystem();
+  auto *locator = getLocator();
+
+  auto *typeReqLoc =
+      cs.getConstraintLocator(getRawAnchor(), locator->getPath().drop_back(),
+                              /*summaryFlags=*/0);
+
+  auto conformance = llvm::find_if(
+      cs.CheckedConformances,
+      [&](const std::pair<ConstraintLocator *, ProtocolConformanceRef>
+              &conformance) { return conformance.first == typeReqLoc; });
+  assert(conformance != cs.CheckedConformances.end());
+  return conformance->second;
+}
+
 ValueDecl *RequirementFailure::getDeclRef() const {
   auto &cs = getConstraintSystem();
 
-  auto *anchor = getAnchor();
+  auto *anchor = getRawAnchor();
   auto *locator = cs.getConstraintLocator(anchor);
   if (auto *AE = dyn_cast<CallExpr>(anchor)) {
     assert(isa<TypeExpr>(AE->getFn()));
@@ -142,6 +179,13 @@ ValueDecl *RequirementFailure::getDeclRef() const {
 }
 
 const DeclContext *RequirementFailure::getRequirementDC() const {
+  // In case of conditional requirement failure, we don't
+  // have to guess where the it comes from.
+  if (isConditional()) {
+    auto *conformance = getConformanceRef().getConcrete();
+    return conformance->getDeclContext();
+  }
+
   const auto &req = getRequirement();
   auto *DC = AffectedDecl->getDeclContext();
 
@@ -159,23 +203,26 @@ bool RequirementFailure::diagnoseAsError() {
   if (!canDiagnoseFailure())
     return false;
 
-  auto *anchor = getAnchor();
+  auto *anchor = getRawAnchor();
   const auto *reqDC = getRequirementDC();
   auto *genericCtx = getGenericContext();
 
+  auto lhs = resolveType(getLHS());
+  auto rhs = resolveType(getRHS());
+
   if (reqDC != genericCtx) {
     auto *NTD = reqDC->getSelfNominalTypeDecl();
     emitDiagnostic(anchor->getLoc(), getDiagnosticInRereference(),
                    AffectedDecl->getDescriptiveKind(),
-                   AffectedDecl->getFullName(), NTD->getDeclaredType(),
-                   getLHS(), getRHS());
+                   AffectedDecl->getFullName(), NTD->getDeclaredType(), lhs,
+                   rhs);
   } else {
     emitDiagnostic(anchor->getLoc(), getDiagnosticOnDecl(),
                    AffectedDecl->getDescriptiveKind(),
-                   AffectedDecl->getFullName(), getLHS(), getRHS());
+                   AffectedDecl->getFullName(), lhs, rhs);
   }
 
-  emitRequirementNote(reqDC->getAsDecl());
+  emitRequirementNote(reqDC->getAsDecl(), lhs, rhs);
   return true;
 }
 
@@ -188,23 +235,32 @@ bool RequirementFailure::diagnoseAsNote() {
   return true;
 }
 
-void RequirementFailure::emitRequirementNote(const Decl *anchor) const {
+void RequirementFailure::emitRequirementNote(const Decl *anchor, Type lhs,
+                                             Type rhs) const {
   auto &req = getRequirement();
 
-  if (getRHS()->isEqual(req.getSecondType())) {
+  if (isConditional()) {
+    auto *conformance = getConformanceRef().getConcrete();
+    emitDiagnostic(anchor, diag::requirement_implied_by_conditional_conformance,
+                   resolveType(conformance->getType()),
+                   conformance->getProtocol()->getDeclaredInterfaceType());
+    return;
+  }
+
+  if (rhs->isEqual(req.getSecondType())) {
     emitDiagnostic(anchor, diag::where_requirement_failure_one_subst,
-                   req.getFirstType(), getLHS());
+                   req.getFirstType(), lhs);
     return;
   }
 
-  if (getLHS()->isEqual(req.getFirstType())) {
+  if (lhs->isEqual(req.getFirstType())) {
     emitDiagnostic(anchor, diag::where_requirement_failure_one_subst,
-                   req.getSecondType(), getRHS());
+                   req.getSecondType(), rhs);
     return;
   }
 
   emitDiagnostic(anchor, diag::where_requirement_failure_both_subst,
-                 req.getFirstType(), getLHS(), req.getSecondType(), getRHS());
+                 req.getFirstType(), lhs, req.getSecondType(), rhs);
 }
 
 bool MissingConformanceFailure::diagnoseAsError() {

lib/Sema/CSDiagnostics.h

@@ -172,6 +172,9 @@ class RequirementFailure : public FailureDiagnostic {
   /// to diagnose failures related to arguments.
   const ApplyExpr *Apply = nullptr;
 
+  /// If this failure associated with one of the conditional requirements.
+  bool IsConditional = false;
+
 public:
   RequirementFailure(ConstraintSystem &cs, Expr *expr, RequirementKind kind,
                      ConstraintLocator *locator)
@@ -183,9 +186,12 @@ class RequirementFailure : public FailureDiagnostic {
     assert(!path.empty());
 
     auto &last = path.back();
-    assert(last.getKind() == ConstraintLocator::TypeParameterRequirement);
+    assert(last.getKind() == ConstraintLocator::TypeParameterRequirement ||
+           last.getKind() == ConstraintLocator::ConditionalRequirement);
     assert(static_cast<RequirementKind>(last.getValue2()) == kind);
 
+    IsConditional = last.getKind() == ConstraintLocator::ConditionalRequirement;
+
     // It's possible sometimes not to have no base expression.
     if (!expr)
       return;
@@ -199,7 +205,10 @@ class RequirementFailure : public FailureDiagnostic {
     assert(!path.empty());
 
     auto &requirementLoc = path.back();
-    assert(requirementLoc.getKind() == PathEltKind::TypeParameterRequirement);
+    assert(requirementLoc.getKind() ==
+               ConstraintLocator::TypeParameterRequirement ||
+           requirementLoc.getKind() ==
+               ConstraintLocator::ConditionalRequirement);
     return requirementLoc.getValue();
   }
 
@@ -219,6 +228,13 @@ class RequirementFailure : public FailureDiagnostic {
   bool diagnoseAsNote() override;
 
 protected:
+  /// Determine whether this is a conditional requirement failure.
+  bool isConditional() const { return IsConditional; }
+
+  /// If this is a failure in condition requirement, retrieve
+  /// conformance information.
+  ProtocolConformanceRef getConformanceRef() const;
+
   /// Retrieve declaration contextual where current
   /// requirement has been introduced.
   const DeclContext *getRequirementDC() const;
@@ -230,6 +246,13 @@ class RequirementFailure : public FailureDiagnostic {
   /// 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.
@@ -247,7 +270,7 @@ class RequirementFailure : public FailureDiagnostic {
   /// Retrieve declaration associated with failing generic requirement.
   ValueDecl *getDeclRef() const;
 
-  void emitRequirementNote(const Decl *anchor) const;
+  void emitRequirementNote(const Decl *anchor, Type lhs, Type rhs) const;
 };
 
 /// Diagnostics for failed conformance checks originating from