[ConstraintSystem] Record conformances synthesized for ad-hoc distributed requirements

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -1627,6 +1627,11 @@ class Solution {
   llvm::DenseMap<ConstraintLocator *, UnresolvedDotExpr *>
       ImplicitCallAsFunctionRoots;
 
+  /// The set of conformances synthesized during solving (i.e. for
+  /// ad-hoc distributed `SerializationRequirement` conformances).
+  llvm::MapVector<ConstraintLocator *, ProtocolConformanceRef>
+      SynthesizedConformances;
+
   /// Record a new argument matching choice for given locator that maps a
   /// single argument to a single parameter.
   void recordSingleArgMatchingChoice(ConstraintLocator *locator);
@@ -2415,6 +2420,11 @@ class ConstraintSystem {
   llvm::SmallMapVector<ConstraintLocator *, UnresolvedDotExpr *, 2>
       ImplicitCallAsFunctionRoots;
 
+  /// The set of conformances synthesized during solving (i.e. for
+  /// ad-hoc distributed `SerializationRequirement` conformances).
+  llvm::MapVector<ConstraintLocator *, ProtocolConformanceRef>
+      SynthesizedConformances;
+
 private:
   /// Describe the candidate expression for partial solving.
   /// This class used by shrink & solve methods which apply
@@ -2938,6 +2948,9 @@ class ConstraintSystem {
     /// The length of \c ImplicitCallAsFunctionRoots.
     unsigned numImplicitCallAsFunctionRoots;
 
+    /// The length of \c SynthesizedConformances.
+    unsigned numSynthesizedConformances;
+
     /// The previous score.
     Score PreviousScore;
 

lib/Sema/CSApply.cpp

@@ -105,7 +105,6 @@ Solution::computeSubstitutions(NullablePtr<ValueDecl> decl,
     subs[opened.first] = type;
   }
 
-  auto *DC = constraintSystem->DC;
   auto lookupConformanceFn =
       [&](CanType original, Type replacement,
           ProtocolDecl *protoType) -> ProtocolConformanceRef {
@@ -121,17 +120,9 @@ Solution::computeSubstitutions(NullablePtr<ValueDecl> decl,
             replacement, protoType, /*allowMissing=*/true);
 
     if (conformance.isInvalid()) {
-      if (auto *funcDecl = dyn_cast<FuncDecl>(decl.getPtrOrNull())) {
-        if (funcDecl->isDistributedActorSystemRemoteCall(
-                /*isVoidResult=*/false)) {
-          // `Res` conformances would be looked by at runtime but are
-          // guaranteed to be there by Sema because all distributed
-          // methods and accessors are checked to conform to
-          // `SerializationRequirement` of `DistributedActorSystem`.
-          if (original->isEqual(funcDecl->getResultInterfaceType()))
-            return ProtocolConformanceRef(protoType);
-        }
-      }
+      auto synthesized = SynthesizedConformances.find(locator);
+      if (synthesized != SynthesizedConformances.end())
+        return synthesized->second;
     }
 
     return conformance;

lib/Sema/CSSimplify.cpp

@@ -8583,9 +8583,17 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
       // 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)) {
+        auto synthesizeConformance = [&]() {
+          ProtocolConformanceRef synthesized(protocol);
+          auto witnessLoc = getConstraintLocator(
+              /*anchor=*/{}, LocatorPathElt::Witness(witness));
+          SynthesizedConformances.insert({witnessLoc, synthesized});
+          return recordConformance(synthesized);
+        };
+
         if (witness->isDistributedActorSystemRemoteCall(/*isVoidReturn=*/false)) {
           if (GP->isEqual(cast<FuncDecl>(witness)->getResultInterfaceType()))
-            return recordConformance(ProtocolConformanceRef(protocol));
+            return synthesizeConformance();
         }
       }
     }

lib/Sema/CSSolver.cpp

@@ -254,6 +254,10 @@ Solution ConstraintSystem::finalize() {
   for (const auto &packEltGenericEnv : PackElementGenericEnvironments)
     solution.PackElementGenericEnvironments.push_back(packEltGenericEnv);
 
+  for (const auto &synthesized : SynthesizedConformances) {
+    solution.SynthesizedConformances.insert(synthesized);
+  }
+
   return solution;
 }
 
@@ -406,6 +410,10 @@ void ConstraintSystem::applySolution(const Solution &solution) {
     ImplicitCallAsFunctionRoots.insert(implicitRoot);
   }
 
+  for (auto &synthesized : solution.SynthesizedConformances) {
+    SynthesizedConformances.insert(synthesized);
+  }
+
   // Register any fixes produced along this path.
   Fixes.insert(solution.Fixes.begin(), solution.Fixes.end());
 }
@@ -686,6 +694,7 @@ ConstraintSystem::SolverScope::SolverScope(ConstraintSystem &cs)
   numImplicitValueConversions = cs.ImplicitValueConversions.size();
   numArgumentLists = cs.ArgumentLists.size();
   numImplicitCallAsFunctionRoots = cs.ImplicitCallAsFunctionRoots.size();
+  numSynthesizedConformances = cs.SynthesizedConformances.size();
 
   PreviousScore = cs.CurrentScore;
 
@@ -832,6 +841,9 @@ ConstraintSystem::SolverScope::~SolverScope() {
   // which are no longer in scope.
   truncate(cs.ImplicitCallAsFunctionRoots, numImplicitCallAsFunctionRoots);
 
+  // Remove any implicitly synthesized conformances.
+  truncate(cs.SynthesizedConformances, numSynthesizedConformances);
+
   // Reset the previous score.
   cs.CurrentScore = PreviousScore;
 

lib/Sema/ConstraintSystem.cpp

@@ -4431,7 +4431,8 @@ size_t Solution::getTotalMemory() const {
          size_in_bytes(resultBuilderTransformed) +
          size_in_bytes(appliedPropertyWrappers) +
          size_in_bytes(argumentLists) +
-         ImplicitCallAsFunctionRoots.getMemorySize();
+         ImplicitCallAsFunctionRoots.getMemorySize() +
+         size_in_bytes(SynthesizedConformances);
 }
 
 DeclContext *Solution::getDC() const { return constraintSystem->DC; }