Merge pull request #59563 from apple/pick-distributed-computed-properties

🍒[5.7][Distributed] Implement distributed computed properties

Author: ktoso

include/swift/AST/ASTMangler.h

@@ -197,7 +197,7 @@ class ASTMangler : public Mangler {
                                              Type GlobalActorBound,
                                              ModuleDecl *Module);
 
-  std::string mangleDistributedThunk(const FuncDecl *thunk);
+  std::string mangleDistributedThunk(const AbstractFunctionDecl *thunk);
 
   /// Mangle a completion handler block implementation function, used for importing ObjC
   /// APIs as async.

include/swift/AST/Attr.def

@@ -661,7 +661,7 @@ SIMPLE_DECL_ATTR(_inheritActorContext, InheritActorContext,
 // 117 was 'spawn' and is now unused
 
 CONTEXTUAL_SIMPLE_DECL_ATTR(distributed, DistributedActor,
-  DeclModifier | OnClass | OnFunc | OnVar |
+  DeclModifier | OnClass | OnFunc | OnAccessor | OnVar |
   ABIBreakingToAdd | ABIBreakingToRemove |
   APIBreakingToAdd | APIBreakingToRemove,
   118)
@@ -732,6 +732,12 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(_local, KnownToBeLocal,
   APIBreakingToAdd | APIBreakingToRemove,
   130)
 
+SIMPLE_DECL_ATTR(_distributed_thunk, DistributedThunk,
+  OnFunc | UserInaccessible |
+  ABIBreakingToAdd | ABIBreakingToRemove |
+  APIBreakingToAdd | APIBreakingToRemove,
+  131)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 

include/swift/AST/Decl.h

@@ -5345,6 +5345,10 @@ class VarDecl : public AbstractStorageDecl {
   /// 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;
+
   /// Is this var known to be a "local" distributed actor,
   /// if so the implicit throwing ans some isolation checks can be skipped.
   bool isKnownToBeLocal() const;
@@ -6393,6 +6397,9 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// A function is concurrent if it has the @Sendable attribute.
   bool isSendable() const;
 
+  /// Determine if function has 'nonisolated' attribute
+  bool isNonisolated() const;
+
   /// Returns true if the function is a suitable 'async' context.
   ///
   /// Functions that are an 'async' context can make calls to 'async' functions.
@@ -6412,6 +6419,10 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Returns 'true' if the function is distributed.
   bool isDistributed() const;
 
+  /// Is this a thunk function used to access a distributed method outside
+  /// of its actor isolation context?
+  bool isDistributedThunk() const;
+
   /// For a 'distributed' target (func or computed property),
   /// get the 'thunk' responsible for performing the 'remoteCall'.
   ///

include/swift/AST/DiagnosticsSema.def

@@ -4633,6 +4633,9 @@ ERROR(distributed_actor_isolated_method,none,
 ERROR(distributed_local_cannot_be_used,none,
       "'local' cannot be used in user-defined code currently",
       ())
+ERROR(distributed_thunk_cannot_be_used,none,
+      "'distributed_thunk' cannot be used in user-defined code",
+      ())
 ERROR(distributed_actor_func_param_not_codable,none,
       "parameter '%0' of type %1 in %2 does not conform to serialization requirement '%3'",
       (StringRef, Type, DescriptiveDeclKind, StringRef))
@@ -4827,6 +4830,9 @@ ERROR(distributed_property_cannot_be_static,none,
 ERROR(distributed_property_can_only_be_computed,none,
       "%0 %1 cannot be 'distributed', only computed properties can",
       (DescriptiveDeclKind, DeclName))
+ERROR(distributed_property_accessor_only_get_can_be_distributed,none,
+      "only 'get' accessors may be 'distributed'",
+      ())
 NOTE(distributed_actor_isolated_property,none,
       "access to %0 %1 is only permitted within distributed actor %2",
       (DescriptiveDeclKind, DeclName, DeclName))

include/swift/AST/Expr.h

@@ -319,7 +319,7 @@ class alignas(8) Expr : public ASTAllocated<Expr> {
     ImplicitlyAsync : 1,
     ImplicitlyThrows : 1,
     NoAsync : 1,
-    ShouldApplyDistributedThunk : 1
+    UsesDistributedThunk : 1
   );
 
   SWIFT_INLINE_BITFIELD_EMPTY(CallExpr, ApplyExpr);
@@ -4445,7 +4445,7 @@ class ApplyExpr : public Expr {
     Bits.ApplyExpr.ImplicitlyAsync = false;
     Bits.ApplyExpr.ImplicitlyThrows = false;
     Bits.ApplyExpr.NoAsync = false;
-    Bits.ApplyExpr.ShouldApplyDistributedThunk = false;
+    Bits.ApplyExpr.UsesDistributedThunk = false;
   }
 
 public:
@@ -4532,11 +4532,11 @@ class ApplyExpr : public Expr {
 
   /// Informs IRGen to that this expression should be applied as its distributed
   /// thunk, rather than invoking the function directly.
-  bool shouldApplyDistributedThunk() const {
-    return Bits.ApplyExpr.ShouldApplyDistributedThunk;
+  bool usesDistributedThunk() const {
+    return Bits.ApplyExpr.UsesDistributedThunk;
   }
-  void setShouldApplyDistributedThunk(bool flag) {
-    Bits.ApplyExpr.ShouldApplyDistributedThunk = flag;
+  void setUsesDistributedThunk(bool flag) {
+    Bits.ApplyExpr.UsesDistributedThunk = flag;
   }
 
   ValueDecl *getCalledValue() const;

include/swift/AST/TypeCheckRequests.h

@@ -1279,17 +1279,20 @@ class GetDistributedRemoteCallArgumentInitFunctionRequest :
 ///
 /// The thunk is responsible for invoking 'remoteCall' when invoked on a remote
 /// 'distributed actor'.
-class GetDistributedThunkRequest :
-    public SimpleRequest<GetDistributedThunkRequest,
-                         FuncDecl *(AbstractFunctionDecl *),
-                         RequestFlags::Cached> {
+class GetDistributedThunkRequest
+    : public SimpleRequest<
+          GetDistributedThunkRequest,
+          FuncDecl *(llvm::PointerUnion<VarDecl *, AbstractFunctionDecl *>),
+          RequestFlags::Cached> {
+  using Originator = llvm::PointerUnion<VarDecl *, AbstractFunctionDecl *>;
+
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  FuncDecl *evaluate(Evaluator &evaluator, AbstractFunctionDecl *distributedFunc) const;
+  FuncDecl *evaluate(Evaluator &evaluator, Originator originator) const;
 
 public:
   // Caching

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -137,7 +137,7 @@ SWIFT_REQUEST(TypeChecker, GetDistributedTargetInvocationResultHandlerOnReturnFu
               AbstractFunctionDecl *(NominalTypeDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetDistributedThunkRequest,
-              FuncDecl *(AbstractFunctionDecl *),
+              FuncDecl *(llvm::PointerUnion<VarDecl *, AbstractFunctionDecl *>),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, GetDistributedActorIDPropertyRequest,
               VarDecl *(NominalTypeDecl *),

lib/AST/ASTDumper.cpp

@@ -742,6 +742,8 @@ namespace {
 
     void visitVarDecl(VarDecl *VD) {
       printCommon(VD, "var_decl");
+      if (VD->isDistributed())
+        PrintWithColorRAII(OS, DeclModifierColor) << " distributed";
       if (VD->isLet())
         PrintWithColorRAII(OS, DeclModifierColor) << " let";
       if (VD->getAttrs().hasAttribute<LazyAttr>())
@@ -872,6 +874,9 @@ namespace {
       if (D->isDistributed()) {
         PrintWithColorRAII(OS, ExprModifierColor) << " distributed";
       }
+      if (D->isDistributedThunk()) {
+        PrintWithColorRAII(OS, ExprModifierColor) << " distributed-thunk";
+      }
 
       if (auto fac = D->getForeignAsyncConvention()) {
         OS << " foreign_async=";
@@ -1335,6 +1340,10 @@ void ValueDecl::dumpRef(raw_ostream &os) const {
     os << " known-to-be-local";
   }
 
+  if (getAttrs().hasAttribute<DistributedThunkAttr>()) {
+    os << " distributed-thunk";
+  }
+
   // Print location.
   auto &srcMgr = getASTContext().SourceMgr;
   if (getLoc().isValid()) {

lib/AST/ASTMangler.cpp

@@ -3484,7 +3484,7 @@ ASTMangler::mangleOpaqueTypeDescriptorRecord(const OpaqueTypeDecl *decl) {
   return finalize();
 }
 
-std::string ASTMangler::mangleDistributedThunk(const FuncDecl *thunk) {
+std::string ASTMangler::mangleDistributedThunk(const AbstractFunctionDecl *thunk) {
   // Marker protocols cannot be checked at runtime, so there is no point
   // in recording them for distributed thunks.
   llvm::SaveAndRestore<bool> savedAllowMarkerProtocols(AllowMarkerProtocols,

lib/AST/Decl.cpp

@@ -7742,6 +7742,10 @@ bool AbstractFunctionDecl::isSendable() const {
   return getAttrs().hasAttribute<SendableAttr>();
 }
 
+bool AbstractFunctionDecl::isNonisolated() const {
+  return getAttrs().hasAttribute<NonisolatedAttr>();
+}
+
 bool AbstractFunctionDecl::isBackDeployed() const {
   if (getAttrs().hasAttribute<BackDeployAttr>())
     return true;