[Distributed] Target identifiers for protocol calls (#70928)

Author: ktoso

include/swift/ABI/Metadata.h

@@ -4970,7 +4970,7 @@ class DynamicReplacementScope
 /// and then called through a fully-abstracted entry point whose arguments
 /// can be constructed in code.
 template <typename Runtime>
-struct TargetAccessibleFunctionRecord final {
+struct TargetAccessibleFunctionRecord {
 public:
   /// The name of the function, which is a unique string assigned to the
   /// function so it can be looked up later.
@@ -4992,7 +4992,24 @@ struct TargetAccessibleFunctionRecord final {
   AccessibleFunctionFlags Flags;
 };
 
+/// More advanced than AccessibleFunctionRecord and contains Actor name
+template <typename Runtime>
+struct TargetAccessibleProtocolRequirementFunctionRecord
+    : public TargetAccessibleFunctionRecord<Runtime> {
+public:
+  /// The concrete Actor type for this accessor.
+  RelativeDirectPointer<const char, /*nullable*/ false> ConcreteActorName;
+
+  /// The concrete witness method mangled name.
+  /// The record name for such record is the mangled name of the protocol
+  /// method. This is the mangled name of the concrete witness method.
+  RelativeDirectPointer<const char, /*nullable*/ false>
+      ConcreteWitnessMethodName;
+};
+
 using AccessibleFunctionRecord = TargetAccessibleFunctionRecord<InProcess>;
+using AccessibleProtocolRequirementFunctionRecord =
+    TargetAccessibleProtocolRequirementFunctionRecord<InProcess>;
 
 enum class PackLifetime : uint8_t {
   OnStack = 0,

include/swift/ABI/MetadataValues.h

@@ -1574,6 +1574,8 @@ namespace SpecialPointerAuthDiscriminators {
 
   /// Functions accessible at runtime (i.e. distributed method accessors).
   const uint16_t AccessibleFunctionRecord = 0x438c; // = 17292
+  const uint16_t AccessibleProtocolRequirementFunctionRecord =
+      0xa98e; // = 43406
 
   /// C type GetExtraInhabitantTag function descriminator
   const uint16_t GetExtraInhabitantTagFunction = 0x392e; // = 14638

include/swift/AST/ASTMangler.h

@@ -159,6 +159,7 @@ class ASTMangler : public Mangler {
     DistributedThunk,
     DistributedAccessor,
     AccessibleFunctionRecord,
+    AccessibleProtocolRequirementFunctionRecord,
     BackDeploymentThunk,
     BackDeploymentFallback,
     HasSymbolQuery,

include/swift/AST/Attr.h

@@ -2603,6 +2603,28 @@ class RawLayoutAttr final : public DeclAttribute {
   }
 };
 
+/// The @_distributedThunkTarget(for:) attribute.
+class DistributedThunkTargetAttr final
+    : public DeclAttribute {
+
+  AbstractFunctionDecl *TargetFunction;
+
+public:
+  DistributedThunkTargetAttr(AbstractFunctionDecl *target)
+      : DeclAttribute(DeclAttrKind::DistributedThunkTarget, SourceLoc(),
+                      SourceRange(),
+                      /*Implicit=*/false),
+        TargetFunction(target) {}
+
+  AbstractFunctionDecl *getTargetFunction() const {
+    return TargetFunction;
+  }
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DeclAttrKind::DistributedThunkTarget;
+  }
+};
+
 /// Predicate used to filter MatchingAttributeRange.
 template <typename ATTR, bool AllowInvalid> struct ToAttributeKind {
   ToAttributeKind() {}

include/swift/AST/Decl.h

@@ -2773,6 +2773,12 @@ class ValueDecl : public Decl {
     Bits.ValueDecl.Synthesized = value;
   }
 
+  /// Does this have a 'distributed' modifier?
+  ///
+  /// Only member methods and computed properties of a `distributed actor`
+  /// can be distributed.
+  bool isDistributed() const;
+
   bool hasName() const { return bool(Name); }
   bool isOperator() const { return Name.isOperator(); }
 
@@ -5869,9 +5875,6 @@ class AbstractStorageDecl : public ValueDecl {
 
   bool hasAnyNativeDynamicAccessors() const;
 
-  /// Does this have a 'distributed' modifier?
-  bool isDistributed() const;
-
   /// Return a distributed thunk if this computed property is marked as
   /// 'distributed' and and nullptr otherwise.
   FuncDecl *getDistributedThunk() const;
@@ -7379,9 +7382,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Returns if the function is 'rethrows' or 'reasync'.
   bool hasPolymorphicEffect(EffectKind kind) const;
 
-  /// Returns 'true' if the function is distributed.
-  bool isDistributed() const;
-
   /// Is this a thunk function used to access a distributed method
   /// or computed property outside of its actor isolation context?
   bool isDistributedThunk() const {
@@ -7528,6 +7528,15 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
            getSILSynthesizeKind() == SILSynthesizeKind::DistributedActorFactory;
   }
 
+  /// Return a vector of distributed requirements that this distributed method
+  /// is implementing.
+  ///
+  /// If the method is witness to multiple requirements this is incorrect and
+  /// should be diagnosed during type-checking as it may make remoteCalls
+  /// ambiguous.
+  llvm::ArrayRef<ValueDecl *>
+  getDistributedMethodWitnessedProtocolRequirements() const;
+
   /// Determines whether this function is a 'remoteCall' function,
   /// which is used as ad-hoc protocol requirement by the
   /// 'DistributedActorSystem' protocol.

include/swift/AST/DeclAttr.def

@@ -485,7 +485,10 @@ SIMPLE_DECL_ATTR(_noExistentials, NoExistentials,
 SIMPLE_DECL_ATTR(_noObjCBridging, NoObjCBridging,
   OnAbstractFunction | OnSubscript | UserInaccessible | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   155)
-LAST_DECL_ATTR(NoObjCBridging)
+DECL_ATTR(_distributedThunkTarget, DistributedThunkTarget,
+  OnAbstractFunction | UserInaccessible | ABIStableToAdd | ABIBreakingToRemove | APIStableToAdd | APIStableToRemove,
+  156)
+LAST_DECL_ATTR(DistributedThunkTarget)
 
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/TypeCheckRequests.h

@@ -1372,6 +1372,27 @@ class GetDistributedActorArgumentDecodingMethodRequest :
   bool isCached() const { return true; }
 };
 
+/// Find out if a distributed method is implementing a distributed protocol
+/// requirement.
+class GetDistributedMethodWitnessedProtocolRequirements :
+    public SimpleRequest<GetDistributedMethodWitnessedProtocolRequirements,
+                         llvm::ArrayRef<ValueDecl *> (AbstractFunctionDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  llvm::ArrayRef<ValueDecl *> evaluate(
+      Evaluator &evaluator,
+      AbstractFunctionDecl *nominal) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 /// Retrieve the static "shared" property within a global actor that provides
 /// the actor instance representing the global actor.
 ///

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -150,6 +150,9 @@ SWIFT_REQUEST(TypeChecker, GetDistributedActorSystemPropertyRequest,
 SWIFT_REQUEST(TypeChecker, GetDistributedRemoteCallTargetInitFunctionRequest,
               ConstructorDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, GetDistributedMethodWitnessedProtocolRequirements,
+              ArrayRef<ValueDecl *> (AbstractFunctionDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetDistributedRemoteCallArgumentInitFunctionRequest,
               ConstructorDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)

include/swift/Demangling/DemangleNodes.def

@@ -358,6 +358,9 @@ NODE(AsyncSuspendResumePartialFunction)
 NODE(AccessibleFunctionRecord)
 NODE(CompileTimeConst)
 
+// Added in Swift 5.11
+NODE(AccessibleProtocolRequirementFunctionRecord)
+
 // Added in Swift 5.7
 NODE(BackDeploymentThunk)
 NODE(BackDeploymentFallback)

include/swift/IRGen/Linking.h

@@ -382,7 +382,8 @@ class LinkEntity {
     /// A SIL global variable. The pointer is a SILGlobalVariable*.
     SILGlobalVariable,
 
-    /// An outlined read-only global object. The pointer is a SILGlobalVariable*.
+    /// An outlined read-only global object. The pointer is a
+    /// SILGlobalVariable*.
     ReadOnlyGlobalObject,
 
     // These next few are protocol-conformance kinds.
@@ -513,13 +514,15 @@ class LinkEntity {
 
     /// The pointer is SILFunction*
     DistributedAccessor,
-    /// An async function pointer for a distributed accessor (method or property).
+    /// An async function pointer for a distributed accessor (method or
+    /// property).
     /// The pointer is a SILFunction*.
     DistributedAccessorAsyncPointer,
 
     /// Accessible function record, which describes a function that can be
     /// looked up by name by the runtime.
     AccessibleFunctionRecord,
+    AccessibleProtocolRequirementFunctionRecord,
 
     /// Extended existential type shape.
     /// Pointer is the (generalized) existential type.