[DistributedActor] ok progress on getting the system via witness

Author: ktoso

include/swift/AST/ASTContext.h

@@ -658,12 +658,11 @@ class ASTContext final {
 
   /// Retrieve the declaration of DistributedActorSystem.make().
   ///
-  /// \param actorOrSystem distributed actor or actor system to get the
-  /// remoteCall function for. Since the method we're looking for is an ad-hoc
-  /// requirement, a specific type MUST be passed here as it is not possible
-  /// to obtain the decl from just the `DistributedActorSystem` protocol type.
+  /// \param thunk the function from which we'll be invoking things on the obtained
+  /// actor system; This way we'll always get the right type, taking care of any
+  /// where clauses etc.
   FuncDecl *getMakeInvocationEncoderOnDistributedActorSystem(
-      NominalTypeDecl *actorOrSystem) const;
+      AbstractFunctionDecl *thunk) const;
 
   // Retrieve the declaration of
   // DistributedInvocationEncoder.recordGenericSubstitution(_:).

include/swift/AST/DistributedDecl.h

@@ -31,6 +31,11 @@ class DeclContext;
 class FuncDecl;
 class NominalTypeDecl;
 
+/// Determine the concrete type of 'ActorSystem' as seen from the member.
+/// E.g. when in a protocol, and trying to determine what the actor system was
+/// constrained to.
+Type getConcreteReplacementForProtocolActorSystemType(ValueDecl *member);
+
 /// Determine the `ActorSystem` type for the given actor.
 Type getDistributedActorSystemType(NominalTypeDecl *actor);
 

include/swift/SIL/SILDeclRef.h

@@ -105,6 +105,7 @@ struct SILDeclRef {
     /// entry point of a class ConstructorDecl or the constructor of a value
     /// ConstructorDecl.
     Allocator,
+
     /// Initializer - this constant references the initializing constructor
     /// entry point of the class ConstructorDecl in loc.
     Initializer,

lib/AST/ASTContext.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/DiagnosticsSema.h"
+#include "swift/AST/DistributedDecl.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/FileUnit.h"
 #include "swift/AST/ForeignAsyncConvention.h"
@@ -1277,15 +1278,32 @@ AbstractFunctionDecl *ASTContext::getRemoteCallOnDistributedActorSystem(
 }
 
 FuncDecl *ASTContext::getMakeInvocationEncoderOnDistributedActorSystem(
-    NominalTypeDecl *actorOrSystem) const {
-  NominalTypeDecl *system = actorOrSystem;
-  assert(actorOrSystem && "distributed actor (or system) decl must be provided");
-  if (actorOrSystem->isDistributedActor()) {
-    auto var = actorOrSystem->getDistributedActorSystemProperty();
-    system = var->getInterfaceType()->getAnyNominal();
-  }
+    AbstractFunctionDecl *thunk) const {
+//  NominalTypeDecl *system = actorOrSystem;
+//  assert(actorOrSystem && "distributed actor (or system) decl must be provided");
+//  if (actorOrSystem->isDistributedActor()) {
+//    auto ty = getDistributedActorSystemType(actorOrSystem);
+//    fprintf(stderr, "[%s:%d] (%s) getDistributedActorSystemType(actorOrSystem)\n", __FILE__, __LINE__, __FUNCTION__);
+//    ty.dump();
+//
+//    auto actor = actorOrSystem;
+//    auto var = actor->getDistributedActorSystemProperty();
+//    assert(var && "Could not locate 'actorSystem' property!");
+//    system = var->getInterfaceType()->getAnyNominal();
+//  }
+
+  auto systemTy = getConcreteReplacementForProtocolActorSystemType(thunk);
+  assert(systemTy && "No specific ActorSystem type found!");
+  fprintf(stderr, "[%s:%d] (%s) FOUND SYSTEM TYPE: %s\n", __FILE__, __LINE__, __FUNCTION__, systemTy->getAnyNominal()->getName().str().str().c_str());
+
+  auto systemNominal = systemTy->getNominalOrBoundGenericNominal();
+  assert(systemNominal && "No system nominal type found!");
+
+//  // NO, since we need the specific one
+//  auto &C = thunk->getASTContext();
+//  auto systemNominal = C.getProtocol(KnownProtocolKind::DistributedActorSystem);
 
-  for (auto result : system->lookupDirect(Id_makeInvocationEncoder)) {
+  for (auto result : systemNominal->lookupDirect(Id_makeInvocationEncoder)) {
     auto *fd = dyn_cast<FuncDecl>(result);
     if (!fd)
       continue;

lib/AST/DistributedDecl.cpp

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -65,19 +65,50 @@ using namespace swift;
 /************** Distributed Actor System Associated Types *********************/
 /******************************************************************************/
 
-Type swift::getDistributedActorSystemType(NominalTypeDecl *actor) {
-  assert(actor->isDistributedActor());
-  auto &ctx = actor->getASTContext();
+Type swift::getConcreteReplacementForProtocolActorSystemType(ValueDecl *member) {
+  auto &C = member->getASTContext();
+  auto *DC = member->getDeclContext();
+  auto DA = C.getDistributedActorDecl();
 
-  auto protocol = ctx.getProtocol(KnownProtocolKind::DistributedActor);
-  if (!protocol)
-    return ErrorType::get(ctx);
+  if (auto *protocol = DC->getSelfProtocolDecl()) {
+    GenericSignature signature;
+    if (auto *genericContext = member->getAsGenericContext()) {
+      signature = genericContext->getGenericSignature();
+    } else {
+      signature = DC->getGenericSignatureOfContext();
+    }
+
+    auto ActorSystemAssocType =
+        DA->getAssociatedType(C.Id_ActorSystem)->getDeclaredInterfaceType();
+
+    auto systemTy = signature->getConcreteType(ActorSystemAssocType);
+    assert(systemTy && "couldn't find concrete type for actor system");
+    return systemTy;
+  } else if (auto classDecl = dyn_cast<ClassDecl>(DC)) {
+      if (!classDecl)
+        return Type();
+
+      return getDistributedActorSystemType(classDecl);
+  }
+
+  llvm_unreachable("Unable to fetch ActorSystem type!");
+}
+
+Type swift::getDistributedActorSystemType(NominalTypeDecl *nominal) {
+  assert(!isa<ProtocolDecl>(nominal) && "FIXME: we should deal with it here too or collapse the two impls");
+  assert(nominal->isDistributedActor());
+  auto &C = nominal->getASTContext();
+  auto *DC = nominal->getDeclContext();
+
+  auto DAP = C.getDistributedActorDecl();
+  if (!DAP)
+    return ErrorType::get(C);
 
   // Dig out the actor system type.
-  auto module = actor->getParentModule();
-  Type selfType = actor->getSelfInterfaceType();
-  auto conformance = module->lookupConformance(selfType, protocol);
-  return conformance.getTypeWitnessByName(selfType, ctx.Id_ActorSystem);
+  auto module = nominal->getParentModule();
+  Type selfType = nominal->getSelfInterfaceType();
+  auto conformance = module->lookupConformance(selfType, DAP);
+  return conformance.getTypeWitnessByName(selfType, C.Id_ActorSystem);
 }
 
 Type swift::getDistributedActorIDType(NominalTypeDecl *actor) {