[CSSimplify] Synthesize conformances for ad-hoc distributed witness requirements

Instead of handing failures in `matchWitness` let's syntehsize
conformances during solving. Next step would be to record them
and use in `Solution::computeSubstitutions`.

Author: xedin

include/swift/Sema/ConstraintLocator.h

@@ -1293,6 +1293,37 @@ class ConstraintLocatorBuilder {
     return false;
   }
 
+  std::optional<std::pair</*witness=*/ValueDecl *, GenericTypeParamType *>>
+  isForWitnessGenericParameterRequirement() const {
+    SmallVector<LocatorPathElt, 2> path;
+    getLocatorParts(path);
+
+    // -> witness -> generic env -> requirement
+    if (path.size() < 3)
+      return std::nullopt;
+
+    GenericTypeParamType *GP = nullptr;
+    if (auto reqLoc =
+            path.back().getAs<LocatorPathElt::TypeParameterRequirement>()) {
+      path.pop_back();
+      if (auto openedGeneric =
+              path.back().getAs<LocatorPathElt::OpenedGeneric>()) {
+        auto signature = openedGeneric->getSignature();
+        auto requirement = signature.getRequirements()[reqLoc->getIndex()];
+        GP = requirement.getFirstType()->getAs<GenericTypeParamType>();
+      }
+    }
+
+    if (!GP)
+      return std::nullopt;
+
+    auto witness = path.front().getAs<LocatorPathElt::Witness>();
+    if (!witness)
+      return std::nullopt;
+
+    return std::make_pair(witness->getDecl(), GP);
+  }
+
   /// Checks whether this locator is describing an argument application for a
   /// non-ephemeral parameter.
   bool isNonEphemeralParameterApplication() const {

lib/Sema/CSSimplify.cpp

@@ -8572,6 +8572,23 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
     if (conformance) {
       return recordConformance(conformance);
     }
+
+    // Account for ad-hoc requirements on some distributed actor
+    // requirements.
+    if (auto witnessInfo = locator.isForWitnessGenericParameterRequirement()) {
+      auto *GP = witnessInfo->second;
+
+      // Conformance requirement between on `Res` and `SerializationRequirement`
+      // of `DistributedActorSystem.remoteCall` are not expressible at the moment
+      // but they are verified by Sema so it's okay to omit them here and lookup
+      // dynamically during IRGen.
+      if (auto *witness = dyn_cast<FuncDecl>(witnessInfo->first)) {
+        if (witness->isDistributedActorSystemRemoteCall(/*isVoidReturn=*/false)) {
+          if (GP->isEqual(cast<FuncDecl>(witness)->getResultInterfaceType()))
+            return recordConformance(ProtocolConformanceRef(protocol));
+        }
+      }
+    }
   } break;
 
   default:

lib/Sema/TypeCheckProtocol.cpp

@@ -1246,38 +1246,6 @@ swift::matchWitness(WitnessChecker::RequirementEnvironmentCache &reqEnvCache,
             }))
           return true;
 
-        auto *funcDecl = dyn_cast<AbstractFunctionDecl>(req);
-        // Conformance requirement between on `Res` and `SerializationRequirement`
-        // of `DistributedActorSystem.remoteCall` are not expressible at the moment
-        // but they are verified by Sema so it's okay to omit them here and lookup
-        // dynamically during IRGen.
-        if (funcDecl && funcDecl->isDistributedActorSystemRemoteCallRequirement(
-                            /*withResult=*/true)) {
-          if (llvm::all_of(solution.Fixes, [&witness](constraints::ConstraintFix
-                                                          *fix) {
-                auto conformance = dyn_cast<MissingConformance>(fix);
-                if (!conformance)
-                  return false;
-
-                auto *locator = fix->getLocator();
-                auto requirement = locator->getLastElementAs<
-                    LocatorPathElt::TypeParameterRequirement>();
-                if (!requirement)
-                  return false;
-
-                auto signature =
-                    locator->findLast<LocatorPathElt::OpenedGeneric>()
-                        ->getSignature();
-
-                auto subject =
-                    signature.getRequirements()[requirement->getIndex()]
-                        .getFirstType();
-                // `Res` is the result type so we can check against that.
-                return subject->isEqual(
-                    cast<FuncDecl>(witness)->getResultInterfaceType());
-              }))
-            return true;
-        }
         // In all other cases - disallow the match.
         return false;
       };