[Concurrency] Eliminate "privileged" forms of ActorIsolation.

The "privileged" cases for actor instance and global actor isolation
covered the case where the entity itself is within the particular
actor but can be freely used from outside the actor, e.g., because it
is asynchronous or an asynchronous handler. This is the wrong modeling
for the problem, because it's only the first part of that---what the
isolation of the particular entity is---that is needed for most
clients. There will be a different abstraction for that.

Author: DougGregor

include/swift/AST/ActorIsolation.h

@@ -42,19 +42,13 @@ class ActorIsolation {
     /// For example, a mutable stored property or synchronous function within
     /// the actor is isolated to the instance of that actor.
     ActorInstance,
-    /// The declaration can refer to actor-isolated state, but can also be
-    /// referenced from outside the actor.
-    ActorPrivileged,
     /// The declaration is explicitly specified to be independent of any actor,
     /// meaning that it can be used from any actor but is also unable to
     /// refer to the isolated state of any given actor.
     Independent,
     /// The declaration is isolated to a global actor. It can refer to other
     /// entities with the same global actor.
     GlobalActor,
-    /// The declaration can refer to state isolated by the given global actor,
-    /// and can be used from anywhere.
-    GlobalActorPrivileged,
   };
 
 private:
@@ -78,18 +72,10 @@ class ActorIsolation {
     return ActorIsolation(Independent, nullptr);
   }
 
-  static ActorIsolation forActorPrivileged(ClassDecl *actor) {
-    return ActorIsolation(ActorPrivileged, actor);
-  }
-
   static ActorIsolation forActorInstance(ClassDecl *actor) {
     return ActorIsolation(ActorInstance, actor);
   }
 
-  static ActorIsolation forGlobalActorPrivileged(Type globalActor) {
-    return ActorIsolation(GlobalActorPrivileged, globalActor);
-  }
-
   static ActorIsolation forGlobalActor(Type globalActor) {
     return ActorIsolation(GlobalActor, globalActor);
   }
@@ -99,12 +85,12 @@ class ActorIsolation {
   operator Kind() const { return getKind(); }
 
   ClassDecl *getActor() const {
-    assert(getKind() == ActorInstance || getKind() == ActorPrivileged);
+    assert(getKind() == ActorInstance);
     return actor;
   }
 
   Type getGlobalActor() const {
-    assert(getKind() == GlobalActor || getKind() == GlobalActorPrivileged);
+    assert(getKind() == GlobalActor);
     return globalActor;
   }
 
@@ -119,11 +105,9 @@ class ActorIsolation {
       return true;
 
     case ActorInstance:
-    case ActorPrivileged:
       return lhs.actor == rhs.actor;
 
     case GlobalActor:
-    case GlobalActorPrivileged:
       return areTypesEqual(lhs.globalActor, rhs.globalActor);
     }
   }

lib/AST/TypeCheckRequests.cpp

@@ -1455,10 +1455,6 @@ void swift::simple_display(
       out << "actor-isolated to instance of " << state.getActor()->getName();
       break;
 
-    case ActorIsolation::ActorPrivileged:
-      out << "actor-privileged to instance of " << state.getActor()->getName();
-      break;
-
     case ActorIsolation::Independent:
       out << "actor-independent";
       break;
@@ -1471,11 +1467,6 @@ void swift::simple_display(
       out << "actor-isolated to global actor "
           << state.getGlobalActor().getString();
       break;
-
-    case ActorIsolation::GlobalActorPrivileged:
-      out << "actor-privileged to global actor "
-          << state.getGlobalActor().getString();
-      break;
   }
 }
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -550,6 +550,13 @@ class IsolationRestriction {
     case DeclKind::Accessor:
     case DeclKind::Func:
     case DeclKind::Subscript:
+      // A function that provides an asynchronous context has no restrictions
+      // on its access.
+      if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
+        if (func->isAsyncContext())
+          return forUnrestricted();
+      }
+
       // Local captures can only be referenced in their local context or a
       // context that is guaranteed not to run concurrently with it.
       if (cast<ValueDecl>(decl)->isLocalCapture())
@@ -565,10 +572,7 @@ class IsolationRestriction {
         return forGlobalActor(isolation.getGlobalActor());
 
       case ActorIsolation::Independent:
-      case ActorIsolation::ActorPrivileged:
-      case ActorIsolation::GlobalActorPrivileged:
-        // Actor-independent and actor-privileged declarations have no
-        // restrictions on their access.
+        // Actor-independent have no restrictions on their access.
         return forUnrestricted();
 
       case ActorIsolation::Unspecified:
@@ -869,7 +873,6 @@ void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
       switch (auto contextIsolation =
                   getInnermostIsolatedContext(getDeclContext())) {
       case ActorIsolation::ActorInstance:
-      case ActorIsolation::ActorPrivileged:
         ctx.Diags.diagnose(
             loc, diag::global_actor_from_instance_actor_context,
             value->getDescriptiveKind(), value->getName(), globalActor,
@@ -878,7 +881,6 @@ void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
         return true;
 
       case ActorIsolation::GlobalActor:
-      case ActorIsolation::GlobalActorPrivileged:
         // If the global actor types are the same, we're done.
         if (contextIsolation.getGlobalActor()->isEqual(globalActor))
           return false;
@@ -973,7 +975,6 @@ void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
         switch (auto contextIsolation = getActorIsolation(
                    cast<ValueDecl>(selfVar->getDeclContext()->getAsDecl()))) {
           case ActorIsolation::ActorInstance:
-          case ActorIsolation::ActorPrivileged:
             // An escaping partial application of something that is part of
             // the actor's isolated state is never permitted.
             if (isEscapingPartialApply) {
@@ -1001,7 +1002,6 @@ void swift::checkActorIsolation(const Expr *expr, const DeclContext *dc) {
             return true;
 
           case ActorIsolation::GlobalActor:
-          case ActorIsolation::GlobalActorPrivileged:
             // The 'self' is for a member that's part of a global actor, which
             // means we cannot refer to actor-isolated state.
             ctx.Diags.diagnose(
@@ -1081,12 +1081,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
       if (!globalActorType || globalActorType->hasError())
         return ActorIsolation::forUnspecified();
 
-      // A function that is an asynchronous context is actor-privileged.
-      if (auto func = dyn_cast<AbstractFunctionDecl>(value)) {
-        if (func->isAsyncContext())
-          return ActorIsolation::forGlobalActorPrivileged(globalActorType);
-      }
-
       return ActorIsolation::forGlobalActor(globalActorType);
     }
 
@@ -1104,13 +1098,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
   // actor-isolated state.
   auto classDecl = value->getDeclContext()->getSelfClassDecl();
   if (classDecl && classDecl->isActor() && value->isInstanceMember()) {
-    // A function that is an asynchronous context is actor-privileged.
-    if (auto func = dyn_cast<AbstractFunctionDecl>(value)) {
-      if (func->isAsyncContext())
-        return ActorIsolation::forActorPrivileged(classDecl);
-    }
-
-    // Everything else is part of the actor's isolated state.
+    // Part of the actor's isolated state.
     return ActorIsolation::forActorInstance(classDecl);
   }
 

lib/Sema/TypeCheckDeclObjC.cpp

@@ -375,6 +375,13 @@ static bool checkObjCActorIsolation(const ValueDecl *VD,
   // Check actor isolation.
   bool Diagnose = shouldDiagnoseObjCReason(Reason, VD->getASTContext());
 
+  // Asynchronous contexts can be @objc.
+  // FIXME: Feels duplicative of TypeCheckConcurrency.
+  if (auto func = dyn_cast<AbstractFunctionDecl>(VD)) {
+    if (func->isAsyncContext())
+      return false;
+  }
+
   switch (getActorIsolation(const_cast<ValueDecl *>(VD))) {
   case ActorIsolation::ActorInstance:
     // Actor-isolated functions cannot be @objc.
@@ -388,9 +395,9 @@ static bool checkObjCActorIsolation(const ValueDecl *VD,
     }
     return true;
 
-  case ActorIsolation::ActorPrivileged:
   case ActorIsolation::GlobalActor:
-  case ActorIsolation::GlobalActorPrivileged:
+    // FIXME: Consider whether to limit @objc on global-actor-qualified
+    // declarations.
   case ActorIsolation::Independent:
   case ActorIsolation::Unspecified:
     return false;

lib/Sema/TypeCheckProtocol.cpp

@@ -4340,6 +4340,14 @@ void ConformanceChecker::resolveValueWitnesses() {
       // Check for actor-isolation consistency.
       switch (getActorIsolation(witness)) {
       case ActorIsolation::ActorInstance: {
+        // Asynchronous contexts can be used to conform to protocol
+        // requirements.
+        // FIXME: Feels duplicative.
+        if (auto func = dyn_cast<AbstractFunctionDecl>(witness)) {
+          if (func->isAsyncContext())
+            break;
+        }
+
         // Actor-isolated witnesses cannot conform to protocol requirements.
         bool canBeAsyncHandler = false;
         if (auto witnessFunc = dyn_cast<FuncDecl>(witness)) {
@@ -4364,8 +4372,6 @@ void ConformanceChecker::resolveValueWitnesses() {
         break;
       }
 
-      case ActorIsolation::ActorPrivileged:
-      case ActorIsolation::GlobalActorPrivileged:
       case ActorIsolation::Independent:
       case ActorIsolation::Unspecified:
         break;