A @_distributedActorIndependent declaration is nonisolated.

The `@__distributedActorIndependent` attribute is effectively the same
as nonisolated, so start treating it that way by making actor-isolation
checking look for it specifically and conclude "nonisolated". Remove
various special cases for this attribute that don't need to exist.

Author: DougGregor

include/swift/AST/Decl.h

@@ -2391,8 +2391,6 @@ class ValueDecl : public Decl {
   /// Is this declaration marked with 'dynamic'?
   bool isDynamic() const;
 
-  bool isDistributedActorIndependent() const;
-
 private:
   bool isObjCDynamic() const {
     return isObjC() && isDynamic();
@@ -4790,8 +4788,6 @@ class AbstractStorageDecl : public ValueDecl {
 
   bool hasAnyNativeDynamicAccessors() const;
 
-  bool isDistributedActorIndependent() const;
-
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_AbstractStorageDecl &&

lib/AST/Decl.cpp

@@ -2934,10 +2934,6 @@ bool ValueDecl::isDynamic() const {
     getAttrs().hasAttribute<DynamicAttr>());
 }
 
-bool ValueDecl::isDistributedActorIndependent() const {
-  return getAttrs().hasAttribute<DistributedActorIndependentAttr>();
-}
-
 bool ValueDecl::isObjCDynamicInGenericClass() const {
   if (!isObjCDynamic())
     return false;
@@ -5371,10 +5367,6 @@ bool AbstractStorageDecl::hasAnyNativeDynamicAccessors() const {
   return false;
 }
 
-bool AbstractStorageDecl::isDistributedActorIndependent() const {
-  return getAttrs().hasAttribute<DistributedActorIndependentAttr>();
-}
-
 void AbstractStorageDecl::setAccessors(SourceLoc lbraceLoc,
                                        ArrayRef<AccessorDecl *> accessors,
                                        SourceLoc rbraceLoc) {

lib/Sema/TypeCheckConcurrency.cpp

@@ -396,8 +396,6 @@ ActorIsolationRestriction ActorIsolationRestriction::forDeclaration(
                 func->getName());
           }
         } // TODO: need to handle protocol case here too?
-        return forDistributedActorSelf(isolation.getActor(),
-                                       /*isCrossActor*/ isAccessibleAcrossActors);
       }
     }
 
@@ -1586,13 +1584,6 @@ namespace {
       ValueDecl *decl = concDeclRef.getDecl();
       AsyncMarkingResult result = AsyncMarkingResult::NotFound;
 
-      // if it is explicitly marked distributed actor independent,
-      // it is synchronously accessible, no implicit async needed.
-      if (decl->getAttrs().hasAttribute<DistributedActorIndependentAttr>() ||
-          decl->getAttrs().hasAttribute<NonisolatedAttr>()) {
-        return result;
-      }
-
       // is it an access to a property?
       if (isPropOrSubscript(decl)) {
         if (auto declRef = dyn_cast_or_null<DeclRefExpr>(context)) {
@@ -2247,9 +2238,7 @@ namespace {
             !(isolatedActor.isActorSelf() &&
               member->isInstanceMember() &&
               isActorInitOrDeInitContext(getDeclContext())
-            ) &&
-            !member->getAttrs().hasAttribute<NonisolatedAttr>() &&
-            !member->getAttrs().hasAttribute<DistributedActorIndependentAttr>();
+            );
 
         if (performDistributedChecks) {
           if (auto func = dyn_cast<FuncDecl>(member)) {
@@ -2272,13 +2261,6 @@ namespace {
           } // end FuncDecl
 
           if (isPropOrSubscript(member)) {
-            DeclAttributes &attrs = member->getAttrs();
-            if (attrs.hasAttribute<DistributedActorIndependentAttr>())
-              return false;
-
-            if (attrs.hasAttribute<NonisolatedAttr>())
-              return false;
-
               ctx.Diags.diagnose(
                   memberLoc, diag::distributed_actor_isolated_non_self_reference,
                   member->getDescriptiveKind(),
@@ -2329,12 +2311,7 @@ namespace {
             } else {
               // it is some other member and since we only allow distributed
               // funcs this definitely is distributed-actor-isolated
-              auto distributedAccessAllowed =
-                  func->isDistributed() ||
-                  member->getAttrs()
-                      .hasAttribute<DistributedActorIndependentAttr>() ||
-                  member->getAttrs().hasAttribute<NonisolatedAttr>();
-              if (!distributedAccessAllowed) {
+              if (!func->isDistributed()) {
                 ctx.Diags.diagnose(
                     memberLoc,
                     diag::distributed_actor_isolated_non_self_reference,
@@ -2596,17 +2573,23 @@ static Optional<ActorIsolation> getIsolationFromAttributes(
   // If any of them are present, use that attribute.
   auto nonisolatedAttr = decl->getAttrs().getAttribute<NonisolatedAttr>();
   auto globalActorAttr = decl->getGlobalActorAttr();
+  auto distributedActorIndependentAttr =
+      decl->getAttrs().getAttribute<DistributedActorIndependentAttr>();
 
   // Remove implicit attributes if we only care about explicit ones.
   if (onlyExplicit) {
     if (nonisolatedAttr && nonisolatedAttr->isImplicit())
       nonisolatedAttr = nullptr;
     if (globalActorAttr && globalActorAttr->first->isImplicit())
       globalActorAttr = None;
+    if (distributedActorIndependentAttr &&
+        distributedActorIndependentAttr->isImplicit())
+      distributedActorIndependentAttr = nullptr;
   }
 
   unsigned numIsolationAttrs =
-    (nonisolatedAttr ? 1 : 0) + (globalActorAttr ? 1 : 0);
+    (nonisolatedAttr ? 1 : 0) + (globalActorAttr ? 1 : 0) +
+    (distributedActorIndependentAttr ? 1 : 0);
   if (numIsolationAttrs == 0)
     return None;
 
@@ -2623,19 +2606,32 @@ static Optional<ActorIsolation> getIsolationFromAttributes(
 
     if (globalActorAttr) {
       if (shouldDiagnose) {
-        decl->diagnose(
-            diag::actor_isolation_multiple_attr, decl->getDescriptiveKind(),
-            name, nonisolatedAttr->getAttrName(),
-            globalActorAttr->second->getName().str())
-          .highlight(nonisolatedAttr->getRangeWithAt())
-          .highlight(globalActorAttr->first->getRangeWithAt());
+        if (globalActorAttr) {
+          const DeclAttribute *otherAttr =
+              nonisolatedAttr
+                ? static_cast<const DeclAttribute *>(nonisolatedAttr)
+                : distributedActorIndependentAttr;
+          decl->diagnose(
+              diag::actor_isolation_multiple_attr, decl->getDescriptiveKind(),
+              name, otherAttr->getAttrName(),
+              globalActorAttr->second->getName().str())
+            .highlight(otherAttr->getRangeWithAt())
+            .highlight(globalActorAttr->first->getRangeWithAt());
+        } else {
+          decl->diagnose(
+              diag::actor_isolation_multiple_attr, decl->getDescriptiveKind(),
+              name, nonisolatedAttr->getAttrName(),
+              distributedActorIndependentAttr->getAttrName())
+            .highlight(nonisolatedAttr->getRangeWithAt())
+            .highlight(distributedActorIndependentAttr->getRangeWithAt());
+        }
       }
     }
   }
 
-  // If the declaration is explicitly marked 'nonisolated', report it as
-  // independent.
-  if (nonisolatedAttr) {
+  // If the declaration is explicitly marked 'nonisolated' or distributed
+  // actor-independent, report it as nonisolated.
+  if (nonisolatedAttr || distributedActorIndependentAttr) {
     return ActorIsolation::forIndependent();
   }
 
@@ -3089,17 +3085,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
       break;
     }
 
-    case ActorIsolation::DistributedActorInstance: {
-      /// 'distributed actor independent' implies 'nonisolated'
-      if (value->isDistributedActorIndependent()) {
-        // TODO: rename 'distributed actor independent' to 'distributed(nonisolated)'
-        value->getAttrs().add(
-            new (ctx) DistributedActorIndependentAttr(/*IsImplicit=*/true));
-        value->getAttrs().add(
-            new (ctx) NonisolatedAttr(/*IsImplicit=*/true));
-      }
-      break;
-    }
+    case ActorIsolation::DistributedActorInstance:
     case ActorIsolation::ActorInstance:
     case ActorIsolation::Unspecified:
       if (onlyGlobal)

lib/Sema/TypeCheckProtocol.cpp

@@ -2839,13 +2839,6 @@ bool ConformanceChecker::checkActorIsolation(
     /// nonisolated or distributed members.
     auto witnessClass = dyn_cast<ClassDecl>(witness->getDeclContext());
     if (witnessClass && witnessClass->isDistributedActor()) {
-        // we only have two 'distributed-actor-nonisolated' properties,
-        // the address and transport; if we see any such marked property,
-        // we're free to automatically assume those are fine and accessible always.
-      if (witness->isSynthesized() && witness->isDistributedActorIndependent()) {
-        return false;
-      }
-
       // Maybe we're dealing with a 'distributed func' which is witness to
       // a distributed function requirement, this is ok.
       if (requirementFunc && requirementFunc->isDistributed() &&

test/Distributed/distributed_actor_isolation.swift

@@ -67,24 +67,24 @@ distributed actor DistributedActor_1 {
     fatalError()
   }
 
-  distributed func distReturnGeneric<T: Codable>(item: T) async throws -> T { // ok
+  distributed func distReturnGeneric<T: Codable & Sendable>(item: T) async throws -> T { // ok
     item
   }
-  distributed func distReturnGenericWhere<T>(item: Int) async throws -> T where T: Codable { // ok
+  distributed func distReturnGenericWhere<T: Sendable>(item: Int) async throws -> T where T: Codable { // ok
     fatalError()
   }
-  distributed func distBadReturnGeneric<T>(int: Int) async throws -> T {
+  distributed func distBadReturnGeneric<T: Sendable>(int: Int) async throws -> T {
     // expected-error@-1 {{distributed function result type 'T' does not conform to 'Codable'}}
     fatalError()
   }
 
-  distributed func distGenericParam<T: Codable>(value: T) async throws { // ok
+  distributed func distGenericParam<T: Codable & Sendable>(value: T) async throws { // ok
     fatalError()
   }
-  distributed func distGenericParamWhere<T>(value: T) async throws -> T where T: Codable { // ok
+  distributed func distGenericParamWhere<T: Sendable>(value: T) async throws -> T where T: Codable { // ok
     value
   }
-  distributed func distBadGenericParam<T>(int: T) async throws {
+  distributed func distBadGenericParam<T: Sendable>(int: T) async throws {
     // expected-error@-1 {{distributed function parameter 'int' of type 'T' does not conform to 'Codable'}}
     fatalError()
   }