[Distributed] Sema: Add a new distributed-thunk attribute

The attribute comes handy during solution application to
determine whether the call is using a distributed thunk.

Author: xedin

include/swift/AST/Attr.def

@@ -735,6 +735,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

@@ -6433,6 +6433,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
+  /// or computed property 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

@@ -4607,6 +4607,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))

lib/AST/ASTDumper.cpp

@@ -878,6 +878,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=";
@@ -1351,6 +1354,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/DistributedDecl.cpp

@@ -1290,6 +1290,10 @@ bool AbstractFunctionDecl::isDistributed() const {
   return getAttrs().hasAttribute<DistributedActorAttr>();
 }
 
+bool AbstractFunctionDecl::isDistributedThunk() const {
+  return getAttrs().hasAttribute<DistributedThunkAttr>();
+}
+
 ConstructorDecl *
 NominalTypeDecl::getDistributedRemoteCallTargetInitFunction() const {
   auto mutableThis = const_cast<NominalTypeDecl *>(this);

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -736,6 +736,7 @@ static FuncDecl *createDistributedThunkFunction(FuncDecl *func) {
   if (isa<ClassDecl>(DC))
     thunk->getAttrs().add(new (C) FinalAttr(/*isImplicit=*/true));
 
+  thunk->getAttrs().add(new (C) DistributedThunkAttr(/*isImplicit=*/true));
   thunk->setGenericSignature(baseSignature);
   thunk->copyFormalAccessFrom(func, /*sourceIsParentContext=*/false);
   thunk->setBodySynthesizer(deriveBodyDistributed_thunk, func);

lib/Sema/TypeCheckAttr.cpp

@@ -322,6 +322,8 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   void visitKnownToBeLocalAttr(KnownToBeLocalAttr *attr);
 
   void visitSendableAttr(SendableAttr *attr);
+
+  void visitDistributedThunkAttr(DistributedThunkAttr *attr);
 };
 
 } // end anonymous namespace
@@ -5934,6 +5936,11 @@ void AttributeChecker::visitSendableAttr(SendableAttr *attr) {
   }
 }
 
+void AttributeChecker::visitDistributedThunkAttr(DistributedThunkAttr *attr) {
+  if (!D->isImplicit())
+    diagnoseAndRemoveAttr(attr, diag::distributed_thunk_cannot_be_used);
+}
+
 void AttributeChecker::visitNonisolatedAttr(NonisolatedAttr *attr) {
   // 'nonisolated' can be applied to global and static/class variables
   // that do not have storage.

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1613,6 +1613,7 @@ namespace  {
     UNINTERESTING_ATTR(UnsafeInheritExecutor)
     UNINTERESTING_ATTR(CompilerInitialized)
 
+    UNINTERESTING_ATTR(DistributedThunk)
 #undef UNINTERESTING_ATTR
 
     void visitAvailableAttr(AvailableAttr *attr) {

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 695; // existential Any and AnyObject
+const uint16_t SWIFTMODULE_VERSION_MINOR = 696; // @_distributed_thunk attribute
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///