Merge pull request #73781 from ktoso/da-as-a-conformance-fix-cross-module

Author: ktoso

include/swift/AST/DistributedDecl.h

@@ -102,6 +102,29 @@ Type getDistributedActorSystemResultHandlerType(NominalTypeDecl *system);
 /// Get the 'ActorID' type of a specific distributed actor system.
 Type getDistributedActorSystemActorIDType(NominalTypeDecl *system);
 
+/// Retrieve a protocol conformance to the `Actor` protocol for a
+/// distributed actor type that is described via a substitution map for
+/// the generic signature `<T: DistributedActor>`.
+///
+/// The protocol conformance is a special one that is currently
+/// only used by the `distributedActorAsAnyActor` builtin.
+NormalProtocolConformance *
+getDistributedActorAsActorConformance(ASTContext &C);
+
+ProtocolConformanceRef
+getDistributedActorAsActorConformanceRef(ASTContext &C);
+
+/// Find the extension that defines the methods necessary for creating the
+/// the DistributedActor-as-Actor conformance.
+ExtensionDecl *
+findDistributedActorAsActorExtension(
+    ProtocolDecl *distributedActorProto, ModuleDecl *module);
+
+bool isDistributedActorAsLocalActorComputedProperty(VarDecl *var);
+
+/// Get the ``DistributedActor/asLocalActor`` computed property.
+VarDecl *getDistributedActorAsLocalActorComputedProperty(ModuleDecl *module);
+
 /// Check if the `allRequirements` represent *exactly* the
 /// `Encodable & Decodable` (also known as `Codable`) requirement.
 ///

include/swift/AST/TypeCheckRequests.h

@@ -1138,6 +1138,25 @@ class CanSynthesizeDistributedActorCodableConformanceRequest :
     bool isCached() const { return true; }
 };
 
+/// Get a special conformance of the DistributedActor protocol to the Actor protocol.
+class GetDistributedActorAsActorConformanceRequest
+    : public SimpleRequest<GetDistributedActorAsActorConformanceRequest,
+                           NormalProtocolConformance *(ProtocolDecl *),
+                           RequestFlags::Cached> {
+  public:
+    using SimpleRequest::SimpleRequest;
+
+private:
+    friend SimpleRequest;
+
+    NormalProtocolConformance *
+    evaluate(Evaluator &evaluator, ProtocolDecl *distributedActorProto) const;
+
+  public:
+    // Caching
+    bool isCached() const { return true; }
+};
+
 /// Retrieve the implicit conformance for the given distributed actor type to
 /// the Codable protocol protocol.
 ///

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -118,11 +118,14 @@ SWIFT_REQUEST(TypeChecker, CheckDistributedFunctionRequest,
 SWIFT_REQUEST(TypeChecker, IsDistributedActorRequest, bool(NominalTypeDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetDistributedActorImplicitCodableRequest,
-               NormalProtocolConformance *(NominalTypeDecl *, KnownProtocolKind),
-               Cached, NoLocationInfo)
+              NormalProtocolConformance *(NominalTypeDecl *, KnownProtocolKind),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, CanSynthesizeDistributedActorCodableConformanceRequest,
-               bool (NominalTypeDecl *),
-               Cached, NoLocationInfo)
+              bool (NominalTypeDecl *),
+              Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, GetDistributedActorAsActorConformanceRequest,
+              NormalProtocolConformance *(ProtocolDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetDistributedActorSystemRemoteCallFunctionRequest,
               AbstractFunctionDecl *(NominalTypeDecl *, bool),
               Cached, NoLocationInfo)

lib/AST/DistributedDecl.cpp

@@ -61,7 +61,7 @@
 using namespace swift;
 
 /******************************************************************************/
-/************* Implicit Distributed Actor Codable Conformance *****************/
+/******************* Distributed Actor Conformances ***************************/
 /******************************************************************************/
 
 bool swift::canSynthesizeDistributedActorCodableConformance(NominalTypeDecl *actor) {
@@ -76,6 +76,68 @@ bool swift::canSynthesizeDistributedActorCodableConformance(NominalTypeDecl *act
       false);
 }
 
+ExtensionDecl *
+swift::findDistributedActorAsActorExtension(
+    ProtocolDecl *distributedActorProto, ModuleDecl *module) {
+  ASTContext &C = distributedActorProto->getASTContext();
+  auto name = C.getIdentifier("__actorUnownedExecutor");
+  auto results = distributedActorProto->lookupDirect(
+      name, SourceLoc(),
+      NominalTypeDecl::LookupDirectFlags::IncludeAttrImplements);
+  for (auto result : results) {
+    if (auto var = dyn_cast<VarDecl>(result)) {
+      return dyn_cast<ExtensionDecl>(var->getDeclContext());
+    }
+  }
+
+  return nullptr;
+}
+
+bool swift::isDistributedActorAsLocalActorComputedProperty(VarDecl *var) {
+  auto &C = var->getASTContext();
+  return var->getName() == C.Id_asLocalActor &&
+         var->getDeclContext()->getSelfProtocolDecl() &&
+         var->getDeclContext()->getSelfProtocolDecl()->isSpecificProtocol(
+             KnownProtocolKind::DistributedActor);
+}
+
+VarDecl *
+swift::getDistributedActorAsLocalActorComputedProperty(ModuleDecl *module) {
+  auto &C = module->getASTContext();
+  auto DA = C.getDistributedActorDecl();
+  auto extension = findDistributedActorAsActorExtension(DA, module);
+
+  if (!extension)
+    return nullptr;
+
+  for (auto decl : extension->getMembers()) {
+    if (auto var = dyn_cast<VarDecl>(decl)) {
+      if (isDistributedActorAsLocalActorComputedProperty(var)) {
+        return var;
+      }
+    }
+  }
+
+  return nullptr;
+}
+
+ProtocolConformanceRef
+swift::getDistributedActorAsActorConformanceRef(ASTContext &C) {
+  auto distributedActorAsActorConformance =
+      getDistributedActorAsActorConformance(C);
+
+  auto actorProto = C.getProtocol(KnownProtocolKind::Actor);
+  return ProtocolConformanceRef(actorProto, distributedActorAsActorConformance);
+}
+NormalProtocolConformance *
+swift::getDistributedActorAsActorConformance(ASTContext &C) {
+  auto distributedActorProtocol = C.getProtocol(KnownProtocolKind::DistributedActor);
+
+  return evaluateOrDefault(
+      C.evaluator,
+      GetDistributedActorAsActorConformanceRequest{distributedActorProtocol},
+      nullptr);
+}
 
 /******************************************************************************/
 /************** Distributed Actor System Associated Types *********************/

lib/AST/ProtocolConformance.cpp

@@ -1142,9 +1142,40 @@ void NominalTypeDecl::prepareConformanceTable() const {
   }
 }
 
+/// Handle special cased protocol-to-protocol conformances, such as e.g.
+/// DistributedActor-to-Actor.
+///
+/// \returns true when the conformance lookup was handled successfully
+static bool lookupSpecialProtocolToProtocolConformance(
+    const ProtocolDecl *thisProtocol, ProtocolDecl *toProtocol,
+    SmallVectorImpl<ProtocolConformance *> &conformances) {
+  auto &C = toProtocol->getASTContext();
+
+  // DistributedActor-to-Actor
+  if (thisProtocol->isSpecificProtocol(KnownProtocolKind::DistributedActor) &&
+      toProtocol->isSpecificProtocol(KnownProtocolKind::Actor)) {
+    if (auto conformance = getDistributedActorAsActorConformance(C)) {
+      conformances.push_back(conformance);
+      return true;
+    }
+  }
+
+  return false;
+}
+
 bool NominalTypeDecl::lookupConformance(
        ProtocolDecl *protocol,
        SmallVectorImpl<ProtocolConformance *> &conformances) const {
+
+  // In general, protocols cannot conform to other protocols, however there are
+  // exceptions, special handle those.
+  if (auto thisProtocol = dyn_cast<ProtocolDecl>(this)) {
+    if (lookupSpecialProtocolToProtocolConformance(thisProtocol, protocol,
+                                                   conformances)) {
+      return true;
+    }
+  }
+
   assert(!isa<ProtocolDecl>(this) &&
          "Self-conformances are only found by the higher-level "
          "ModuleDecl::lookupConformance() entry point");
@@ -1187,7 +1218,7 @@ void NominalTypeDecl::getImplicitProtocols(
 }
 
 void NominalTypeDecl::registerProtocolConformance(
-       NormalProtocolConformance *conformance, bool synthesized) {
+    NormalProtocolConformance *conformance, bool synthesized) {
   prepareConformanceTable();
   auto *dc = conformance->getDeclContext();
   ConformanceTable->registerProtocolConformance(dc, conformance, synthesized);

lib/SILGen/SILGen.h

@@ -83,10 +83,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   /// Set of delayed conformances that have already been forced.
   llvm::DenseSet<NormalProtocolConformance *> forcedConformances;
 
-  /// The conformance for any DistributedActor to the Actor protocol,
-  /// used only by the `distributedActorAsAnyActor` builtin.
-  NormalProtocolConformance *distributedActorAsActorConformance = nullptr;
-
   size_t anonymousSymbolCounter = 0;
 
   std::optional<SILDeclRef> StringToNSStringFn;
@@ -601,15 +597,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   /// mentioned by the given type.
   void useConformancesFromObjectiveCType(CanType type);
 
-  /// Retrieve a protocol conformance to the `Actor` protocol for a
-  /// distributed actor type that is described via a substitution map for
-  /// the generic signature `<T: DistributedActor>`.
-  ///
-  /// The protocol conformance is a special one that is currently
-  /// only used by the `distributedActorAsAnyActor` builtin.
-  ProtocolConformanceRef
-  getDistributedActorAsActorConformance(SubstitutionMap subs);
-
   /// Make a note of a member reference expression, which allows us
   /// to ensure that the conformance above is emitted wherever it
   /// needs to be.

lib/SILGen/SILGenBuiltin.cpp

@@ -23,6 +23,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Builtins.h"
 #include "swift/AST/DiagnosticsSIL.h"
+#include "swift/AST/DistributedDecl.h"
 #include "swift/AST/FileUnit.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Module.h"
@@ -1994,16 +1995,9 @@ void SILGenModule::noteMemberRefExpr(MemberRefExpr *e) {
   // distributed actors, make sure we have the conformance needed
   // for a builtin.
   ASTContext &ctx = var->getASTContext();
-  if (var->getName() == ctx.Id_asLocalActor &&
-      var->getDeclContext()->getSelfProtocolDecl() &&
-      var->getDeclContext()->getSelfProtocolDecl()
-          ->isSpecificProtocol(KnownProtocolKind::DistributedActor)) {
-    auto conformance =
-        getDistributedActorAsActorConformance(
-          e->getMember().getSubstitutions());
-    useConformance(conformance);
+  if (isDistributedActorAsLocalActorComputedProperty(var)) {
+    useConformance(getDistributedActorAsActorConformanceRef(ctx));
   }
-
 }
 
 static ManagedValue emitBuiltinDistributedActorAsAnyActor(

lib/SILGen/SILGenConcurrency.cpp

@@ -16,6 +16,7 @@
 #include "Scope.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Availability.h"
+#include "swift/AST/DistributedDecl.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/Basic/Range.h"
 
@@ -661,75 +662,29 @@ SILValue SILGenFunction::emitGetCurrentExecutor(SILLocation loc) {
   return ExpectedExecutor;
 }
 
-/// Find the extension on DistributedActor that defines __actorUnownedExecutor.
-static ExtensionDecl *findDistributedActorAsActorExtension(
-    ProtocolDecl *distributedActorProto, ModuleDecl *module) {
-  ASTContext &ctx = distributedActorProto->getASTContext();
-  auto name = ctx.getIdentifier("__actorUnownedExecutor");
-  auto results = distributedActorProto->lookupDirect(
-      name, SourceLoc(),
-      NominalTypeDecl::LookupDirectFlags::IncludeAttrImplements);
-  for (auto result : results) {
-    if (auto var = dyn_cast<VarDecl>(result)) {
-      return dyn_cast<ExtensionDecl>(var->getDeclContext());
-    }
-  }
-
-  return nullptr;
-}
-
-ProtocolConformanceRef
-SILGenModule::getDistributedActorAsActorConformance(SubstitutionMap subs) {
-  ASTContext &ctx = M.getASTContext();
-  auto actorProto = ctx.getProtocol(KnownProtocolKind::Actor);
-  Type distributedActorType = subs.getReplacementTypes()[0];
-
-  if (!distributedActorAsActorConformance) {
-    auto distributedActorProto = ctx.getProtocol(KnownProtocolKind::DistributedActor);
-    if (!distributedActorProto)
-      return ProtocolConformanceRef();
-
-    auto ext = findDistributedActorAsActorExtension(
-        distributedActorProto, M.getSwiftModule());
-    if (!ext)
-      return ProtocolConformanceRef();
-
-    // Conformance of DistributedActor to Actor.
-    auto genericParam = subs.getGenericSignature().getGenericParams()[0];
-    distributedActorAsActorConformance = ctx.getNormalConformance(
-        Type(genericParam), actorProto, SourceLoc(), ext,
-        ProtocolConformanceState::Incomplete, /*isUnchecked=*/false,
-        /*isPreconcurrency=*/false);
-  }
-
-  return ProtocolConformanceRef(
-      actorProto,
-      ctx.getSpecializedConformance(distributedActorType,
-                                    distributedActorAsActorConformance,
-                                    subs));
-}
-
 ManagedValue
 SILGenFunction::emitDistributedActorAsAnyActor(SILLocation loc,
                                            SubstitutionMap distributedActorSubs,
                                                ManagedValue actorValue) {
-  ProtocolConformanceRef conformances[1] = {
-    SGM.getDistributedActorAsActorConformance(distributedActorSubs)
-  };
+  auto &ctx = SGM.getASTContext();
+
+  auto distributedActorAsActorConformance =
+      getDistributedActorAsActorConformance(ctx);
+  auto actorProto = ctx.getProtocol(KnownProtocolKind::Actor);
+  auto distributedActorType = distributedActorSubs.getReplacementTypes()[0];
+  auto ref = ProtocolConformanceRef(
+      actorProto, ctx.getSpecializedConformance(
+                      distributedActorType, distributedActorAsActorConformance,
+                      distributedActorSubs));
+  ProtocolConformanceRef conformances[1] = {ref};
 
   // Erase the distributed actor instance into an `any Actor` existential with
   // the special conformance.
-  auto &ctx = SGM.getASTContext();
-  CanType distributedActorType =
-    distributedActorSubs.getReplacementTypes()[0]->getCanonicalType();
-  auto &distributedActorTL = getTypeLowering(distributedActorType);
-  auto actorProto = ctx.getProtocol(KnownProtocolKind::Actor);
+  CanType distributedActorCanType = distributedActorType->getCanonicalType();
+  auto &distributedActorTL = getTypeLowering(distributedActorCanType);
   auto &anyActorTL = getTypeLowering(actorProto->getDeclaredExistentialType());
-  return emitExistentialErasure(loc, distributedActorType,
-                                distributedActorTL, anyActorTL,
-                                ctx.AllocateCopy(conformances),
-                                SGFContext(),
-                                [actorValue](SGFContext) {
-    return actorValue;
-  });
+  return emitExistentialErasure(
+      loc, distributedActorCanType, distributedActorTL, anyActorTL,
+      ctx.AllocateCopy(conformances), SGFContext(),
+      [actorValue](SGFContext) { return actorValue; });
 }

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -14,7 +14,6 @@
 
 #include "CodeSynthesis.h"
 #include "DerivedConformances.h"
-#include "TypeCheckType.h"
 #include "TypeChecker.h"
 #include "swift/AST/ASTMangler.h"
 #include "swift/AST/ASTPrinter.h"
@@ -1066,3 +1065,30 @@ bool CanSynthesizeDistributedActorCodableConformanceRequest::evaluate(
          TypeChecker::conformsToKnownProtocol(
              idTy, KnownProtocolKind::Encodable, actor->getParentModule());
 }
+
+NormalProtocolConformance *
+GetDistributedActorAsActorConformanceRequest::evaluate(
+    Evaluator &evaluator, ProtocolDecl *distributedActorProto) const {
+  auto &ctx = distributedActorProto->getASTContext();
+  auto swiftModule = ctx.getStdlibModule();
+
+  auto actorProto = ctx.getProtocol(KnownProtocolKind::Actor);
+
+  auto ext = findDistributedActorAsActorExtension(
+      distributedActorProto, swiftModule);
+  if (!ext)
+    return nullptr;
+
+  auto genericParam = GenericTypeParamType::get(/*isParameterPack=*/false,
+                                                /*depth=*/0, /*index=*/0, ctx);
+
+  auto distributedActorAsActorConformance = ctx.getNormalConformance(
+      Type(genericParam), actorProto, SourceLoc(), ext,
+      ProtocolConformanceState::Incomplete, /*isUnchecked=*/false,
+      /*isPreconcurrency=*/false);
+  // NOTE: Normally we "register" a conformance, but here we don't
+  // because we cannot (currently) register them in a protocol,
+  // since they do not have conformance tables.
+
+  return distributedActorAsActorConformance;
+}