[CSDiagnostics] Use generic signature to retrieve failing requirement

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -99,30 +99,35 @@ 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()];
+  auto requirements = isConditional()
+                          ? Conformance->getConditionalRequirements()
+                          : Signature->getRequirements();
+  return requirements[getRequirementIndex()];
 }
 
-ProtocolConformanceRef RequirementFailure::getConformanceRef() const {
-  assert(isConditional());
-
+ProtocolConformance *RequirementFailure::getConformanceForConditionalReq(
+    ConstraintLocator *locator) {
   auto &cs = getConstraintSystem();
-  auto *locator = getLocator();
+  auto path = locator->getPath();
+  assert(!path.empty());
+
+  if (!path.back().isConditionalRequirement()) {
+    assert(path.back().isTypeParameterRequirement());
+    return nullptr;
+  }
 
-  auto *typeReqLoc =
-      cs.getConstraintLocator(getRawAnchor(), locator->getPath().drop_back(),
-                              /*summaryFlags=*/0);
+  auto *typeReqLoc = cs.getConstraintLocator(getRawAnchor(), path.drop_back(),
+                                             /*summaryFlags=*/0);
 
-  auto conformance = llvm::find_if(
+  auto result = llvm::find_if(
       cs.CheckedConformances,
       [&](const std::pair<ConstraintLocator *, ProtocolConformanceRef>
               &conformance) { return conformance.first == typeReqLoc; });
-  assert(conformance != cs.CheckedConformances.end());
-  return conformance->second;
+  assert(result != cs.CheckedConformances.end());
+
+  auto conformance = result->second;
+  assert(conformance.isConcrete());
+  return conformance.getConcrete();
 }
 
 ValueDecl *RequirementFailure::getDeclRef() const {
@@ -169,13 +174,25 @@ ValueDecl *RequirementFailure::getDeclRef() const {
   return ownerType->getAnyGeneric();
 }
 
+GenericSignature *RequirementFailure::getSignature(ConstraintLocator *locator) {
+  if (isConditional())
+    return Conformance->getGenericSignature();
+
+  auto path = locator->getPath();
+  for (auto iter = path.rbegin(); iter != path.rend(); ++iter) {
+    const auto &elt = *iter;
+    if (elt.getKind() == ConstraintLocator::OpenedGeneric)
+      return elt.getGenericSignature();
+  }
+
+  llvm_unreachable("Type requirement failure should always have signature");
+}
+
 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();
-  }
+  if (isConditional())
+    return Conformance->getDeclContext();
 
   const auto &req = getRequirement();
   auto *DC = AffectedDecl->getDeclContext();
@@ -242,10 +259,9 @@ void RequirementFailure::emitRequirementNote(const Decl *anchor, Type lhs,
   auto &req = getRequirement();
 
   if (isConditional()) {
-    auto *conformance = getConformanceRef().getConcrete();
     emitDiagnostic(anchor, diag::requirement_implied_by_conditional_conformance,
-                   resolveType(conformance->getType()),
-                   conformance->getProtocol()->getDeclaredInterfaceType());
+                   resolveType(Conformance->getType()),
+                   Conformance->getProtocol()->getDeclaredInterfaceType());
     return;
   }
 

lib/Sema/CSDiagnostics.h

@@ -166,20 +166,29 @@ class RequirementFailure : public FailureDiagnostic {
   using DiagInReference = Diag<DescriptiveDeclKind, DeclName, Type, Type, Type>;
   using DiagAsNote = Diag<Type, Type, Type, Type, StringRef>;
 
+  /// If this failure associated with one of the conditional requirements,
+  /// this field would represent conformance where requirement comes from.
+  const ProtocolConformance *Conformance = nullptr;
+
+  /// The source of the requirement, if available. One exception
+  /// is failure associated with conditional requirement where
+  /// underlying conformance is specialized.
+  const GenericSignature *Signature;
+
   const ValueDecl *AffectedDecl;
   /// If possible, find application expression associated
   /// with current generic requirement failure, that helps
   /// 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)
-      : FailureDiagnostic(expr, cs, locator), AffectedDecl(getDeclRef()) {
+      : FailureDiagnostic(expr, cs, locator),
+        Conformance(getConformanceForConditionalReq(locator)),
+        Signature(getSignature(locator)), AffectedDecl(getDeclRef()) {
     assert(locator);
+    assert(isConditional() || Signature);
     assert(AffectedDecl);
 
     auto path = locator->getPath();
@@ -190,8 +199,6 @@ class RequirementFailure : public FailureDiagnostic {
            last.isConditionalRequirement());
     assert(static_cast<RequirementKind>(last.getValue2()) == kind);
 
-    IsConditional = last.isConditionalRequirement();
-
     // It's possible sometimes not to have no base expression.
     if (!expr)
       return;
@@ -227,11 +234,7 @@ class RequirementFailure : public FailureDiagnostic {
 
 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;
+  bool isConditional() const { return bool(Conformance); }
 
   /// Retrieve declaration contextual where current
   /// requirement has been introduced.
@@ -268,11 +271,19 @@ class RequirementFailure : public FailureDiagnostic {
   /// Retrieve declaration associated with failing generic requirement.
   ValueDecl *getDeclRef() const;
 
+  /// Retrieve generic signature where this parameter originates from.
+  GenericSignature *getSignature(ConstraintLocator *locator);
+
   void emitRequirementNote(const Decl *anchor, Type lhs, Type rhs) const;
 
   /// Determine whether given declaration represents a static
   /// or instance property/method, excluding operators.
   static bool isStaticOrInstanceMember(const ValueDecl *decl);
+
+  /// If this is a failure in conditional requirement, retrieve
+  /// conformance information.
+  ProtocolConformance *
+  getConformanceForConditionalReq(ConstraintLocator *locator);
 };
 
 /// Diagnostics for failed conformance checks originating from

lib/Sema/CSSimplify.cpp

@@ -1612,20 +1612,27 @@ static ConstraintFix *fixRequirementFailure(ConstraintSystem &cs, Type type1,
   if (type1->hasDependentMember() || type2->hasDependentMember())
     return nullptr;
 
-  auto req = path.back();
+  auto reqPath = path.take_back(2);
+  auto req = reqPath.back();
 
   ConstraintLocator *reqLoc = nullptr;
   if (req.isConditionalRequirement()) {
-    // If underlaying conformance requirement has been fixed as
-    // we there is no reason to fix up conditional requirements.
-    if (cs.hasFixFor(cs.getConstraintLocator(anchor, req)))
+    // path is - ... -> open generic -> type req # -> cond req #,
+    // to identify type requirement we only need `open generic -> type req #`
+    // part, because that's how fixes for type requirements are recorded.
+    reqPath = path.drop_back().take_back(2);
+    // If underlying conformance requirement has been fixed,
+    // then there is no reason to fix up conditional requirements.
+    if (cs.hasFixFor(cs.getConstraintLocator(anchor, reqPath,
+                                             /*summaryFlags=*/0)))
       return nullptr;
 
     // For conditional requirements we need a full path.
     reqLoc = cs.getConstraintLocator(anchor, path, /*summaryFlags=*/0);
   } else {
     // Build simplified locator which only contains anchor and requirement info.
-    reqLoc = cs.getConstraintLocator(anchor, req);
+    reqLoc = cs.getConstraintLocator(anchor, reqPath,
+                                     /*summaryFlags=*/0);
   }
 
   auto reqKind = static_cast<RequirementKind>(req.getValue2());
@@ -2784,9 +2791,14 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
         path.back().isConditionalRequirement()) {
       ConstraintLocator *reqLoc = nullptr;
       if (path.back().isConditionalRequirement()) {
+        // Drop 'conditional requirement' element remainder
+        // of the path is going to point to type requirement
+        // this conditional comes from.
+        auto reqPath = ArrayRef<LocatorPathElt>(path).drop_back();
         // Underlying conformance requirement is itself fixed,
-        // this wouldn't lead to right solution.
-        if (hasFixFor(getConstraintLocator(anchor, path.back())))
+        // this wouldn't lead to a right solution.
+        if (hasFixFor(getConstraintLocator(anchor, reqPath.take_back(2),
+                                           /*summaryFlags=*/0)))
           return SolutionKind::Error;
 
         // For conditional requirements we need complete path, which includes
@@ -2795,8 +2807,11 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
       } else {
         // Let's strip all of the unnecessary information from locator,
         // diagnostics only care about anchor - to lookup type,
-        // and what was the requirement# which is not satisfied.
-        reqLoc = getConstraintLocator(anchor, path.back());
+        // generic signature where requirement comes from, and
+        // what was the requirement# which is not satisfied.
+        auto reqPath = ArrayRef<LocatorPathElt>(path).take_back(2);
+        reqLoc = getConstraintLocator(anchor, reqPath,
+                                      /*summaryFlags=*/0);
       }
 
       auto *fix = MissingConformance::create(*this, type, protocol, reqLoc);