[Diagnostics] Special case requirement failures related to return statement/expression

Make sure that "affected" declaration is recognized as the one
to which result type is attached to if the requirement failure
is originated in contextual type of `return` statement/expression.

Resolves: SR-13992
Resolves: rdar://72819046
Resolves: rdar://57789606

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -249,8 +249,28 @@ ValueDecl *RequirementFailure::getDeclRef() const {
     return getAffectedDeclFromType(func->getResultInterfaceType());
   }
 
-  if (isFromContextualType())
-    return getAffectedDeclFromType(getContextualType(getRawAnchor()));
+  if (isFromContextualType()) {
+    auto anchor = getRawAnchor();
+    auto contextualPurpose = getContextualTypePurpose(anchor);
+    auto contextualTy = getContextualType(anchor);
+
+    // If the issue is a mismatch between `return` statement/expression
+    // and its contextual requirements, it means that affected declaration
+    // is a declarer of a contextual "result" type e.g. member of a
+    // type, local function etc.
+    if (contextualPurpose == CTP_ReturnStmt ||
+        contextualPurpose == CTP_ReturnSingleExpr) {
+      // In case of opaque result type, let's point to the declaration
+      // associated with the type itself (since it has one) instead of
+      // declarer.
+      if (auto *opaque = contextualTy->getAs<OpaqueTypeArchetypeType>())
+        return opaque->getDecl();
+
+      return cast<ValueDecl>(getDC()->getAsDecl());
+    }
+
+    return getAffectedDeclFromType(contextualTy);
+  }
 
   if (auto overload = getCalleeOverloadChoiceIfAvailable(getLocator())) {
     // If there is a declaration associated with this

test/Constraints/sr13992.swift

@@ -0,0 +1,29 @@
+// RUN: %target-typecheck-verify-swift
+
+// SR-13992
+
+protocol V {}
+
+protocol P1 {}
+protocol P2 {
+  func bar() -> V
+}
+protocol P3 {}
+
+struct S<T> {
+  var foo: T
+}
+
+extension S : P1 {}
+extension S : P2 where T: P3 { // expected-note {{requirement from conditional conformance of 'S<V>' to 'P2'}}
+  func bar() -> V { fatalError() }
+}
+
+struct Q {
+  var foo: V
+
+  func test() -> P1 & P2 {
+    S(foo: foo) // expected-error {{protocol 'V' as a type cannot conform to 'P3'}}
+    // expected-note@-1 {{only concrete types such as structs, enums and classes can conform to protocols}}
+  }
+}