Revert "[concurrency] Make ActorIsolation::Nonisolated -> CallerIsolationInheriting and delete CallerIsolationInheriting."

This reverts commit 543b1e6.

Author: gottesmm

include/swift/AST/ActorIsolation.h

@@ -80,6 +80,11 @@ class ActorIsolation {
     /// The actor isolation iss statically erased, as for a call to
     /// an isolated(any) function.  This is not possible for declarations.
     Erased,
+    /// Inherits isolation from the caller of the given function.
+    ///
+    /// DISCUSSION: This is used for nonisolated asynchronous functions that we
+    /// want to inherit from their context the context's actor isolation.
+    CallerIsolationInheriting,
     /// The declaration is explicitly specified to be not isolated to 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.
@@ -102,7 +107,7 @@ class ActorIsolation {
     Type globalActor;
     void *pointer;
   };
-  unsigned kind : 3;
+  unsigned kind : 4;
   unsigned isolatedByPreconcurrency : 1;
 
   /// Set to true if this was parsed from SIL.
@@ -136,6 +141,12 @@ class ActorIsolation {
     return ActorIsolation(unsafe ? ConcurrentUnsafe : Concurrent);
   }
 
+  static ActorIsolation forCallerIsolationInheriting() {
+    // NOTE: We do not use parameter indices since the parameter is implicit
+    // from the perspective of the AST.
+    return ActorIsolation(CallerIsolationInheriting);
+  }
+
   static ActorIsolation forActorInstanceSelf(ValueDecl *decl);
 
   /// Create an ActorIsolation appropriate for a type that is self.
@@ -183,6 +194,9 @@ class ActorIsolation {
                   std::optional<ActorIsolation>(ActorIsolation::GlobalActor))
             .Case("global_actor_unsafe",
                   std::optional<ActorIsolation>(ActorIsolation::GlobalActor))
+            .Case("caller_isolation_inheriting",
+                  std::optional<ActorIsolation>(
+                      ActorIsolation::CallerIsolationInheriting))
             .Case("concurrent",
                   std::optional<ActorIsolation>(ActorIsolation::Concurrent))
             .Case("concurrent_unsafe", std::optional<ActorIsolation>(
@@ -241,6 +255,7 @@ class ActorIsolation {
     case Unspecified:
     case Nonisolated:
     case NonisolatedUnsafe:
+    case CallerIsolationInheriting:
     case Concurrent:
     case ConcurrentUnsafe:
       return false;

lib/AST/ASTDumper.cpp

@@ -3920,6 +3920,10 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, Label>,
       printFlag(true, "dynamically_isolated", CapturesColor);
       break;
 
+    case ActorIsolation::CallerIsolationInheriting:
+      printFlag(true, "isolated_to_caller_isolation", CapturesColor);
+      break;
+
     case ActorIsolation::ActorInstance:
       printReferencedDeclWithContextField(isolation.getActorInstance(),
                                           Label::always("actor_isolated"),

lib/AST/ActorIsolation.cpp

@@ -165,6 +165,8 @@ bool ActorIsolation::isEqual(const ActorIsolation &lhs,
     return false;
 
   switch (lhs.getKind()) {
+  case Nonisolated:
+  case NonisolatedUnsafe:
   case Concurrent:
   case ConcurrentUnsafe:
   case Unspecified:
@@ -177,8 +179,7 @@ bool ActorIsolation::isEqual(const ActorIsolation &lhs,
     // to answer.
     return false;
 
-  case Nonisolated:
-  case NonisolatedUnsafe:
+  case CallerIsolationInheriting:
     // This returns false for the same reason as erased. The caller has to check
     // against the actual caller isolation.
     return false;

lib/AST/Decl.cpp

@@ -2766,6 +2766,7 @@ static bool deferMatchesEnclosingAccess(const FuncDecl *defer) {
 
             return true;
 
+          case ActorIsolation::CallerIsolationInheriting:
           case ActorIsolation::ActorInstance:
           case ActorIsolation::Nonisolated:
           case ActorIsolation::Concurrent:
@@ -11466,6 +11467,7 @@ bool VarDecl::isSelfParamCaptureIsolated() const {
       case ActorIsolation::ConcurrentUnsafe:
       case ActorIsolation::GlobalActor:
       case ActorIsolation::Erased:
+      case ActorIsolation::CallerIsolationInheriting:
         return false;
 
       case ActorIsolation::ActorInstance:

lib/AST/TypeCheckRequests.cpp

@@ -1856,6 +1856,7 @@ SourceLoc MacroDefinitionRequest::getNearestLoc() const {
 
 bool ActorIsolation::requiresSubstitution() const {
   switch (kind) {
+  case CallerIsolationInheriting:
   case ActorInstance:
   case Nonisolated:
   case NonisolatedUnsafe:
@@ -1873,6 +1874,7 @@ bool ActorIsolation::requiresSubstitution() const {
 ActorIsolation ActorIsolation::subst(SubstitutionMap subs) const {
   switch (kind) {
   case ActorInstance:
+  case CallerIsolationInheriting:
   case Nonisolated:
   case NonisolatedUnsafe:
   case Concurrent:
@@ -1895,6 +1897,11 @@ void ActorIsolation::printForDiagnostics(llvm::raw_ostream &os,
     os << "actor" << (asNoun ? " isolation" : "-isolated");
     break;
 
+  case ActorIsolation::CallerIsolationInheriting:
+    os << "caller isolation inheriting"
+       << (asNoun ? " isolation" : "-isolated");
+    break;
+
   case ActorIsolation::GlobalActor: {
     if (isMainActor()) {
       os << "main actor" << (asNoun ? " isolation" : "-isolated");
@@ -1933,6 +1940,9 @@ void ActorIsolation::print(llvm::raw_ostream &os) const {
       os << ". name: '" << vd->getBaseIdentifier() << "'";
     }
     return;
+  case CallerIsolationInheriting:
+    os << "caller_isolation_inheriting";
+    return;
   case Nonisolated:
     os << "nonisolated";
     return;
@@ -1963,6 +1973,9 @@ void ActorIsolation::printForSIL(llvm::raw_ostream &os) const {
   case ActorInstance:
     os << "actor_instance";
     return;
+  case CallerIsolationInheriting:
+    os << "caller_isolation_inheriting";
+    return;
   case Nonisolated:
     os << "nonisolated";
     return;
@@ -2014,6 +2027,10 @@ void swift::simple_display(
       }
       break;
 
+    case ActorIsolation::CallerIsolationInheriting:
+      out << "isolated to isolation of caller";
+      break;
+
     case ActorIsolation::Nonisolated:
     case ActorIsolation::NonisolatedUnsafe:
     case ActorIsolation::Concurrent:

lib/IDE/CompletionLookup.cpp

@@ -830,6 +830,7 @@ void CompletionLookup::analyzeActorIsolation(
   case ActorIsolation::NonisolatedUnsafe:
   case ActorIsolation::Concurrent:
   case ActorIsolation::ConcurrentUnsafe:
+  case ActorIsolation::CallerIsolationInheriting:
     return;
   }
 }

lib/SIL/IR/SILFunctionType.cpp

@@ -1651,7 +1651,8 @@ class DestructureInputs {
     // enabled.
     if (TC.Context.LangOpts.hasFeature(
             Feature::NonIsolatedAsyncInheritsIsolationFromContext) &&
-        IsolationInfo && IsolationInfo->isNonisolated() &&
+        IsolationInfo &&
+        IsolationInfo->getKind() == ActorIsolation::CallerIsolationInheriting &&
         extInfoBuilder.isAsync()) {
       auto actorProtocol = TC.Context.getProtocol(KnownProtocolKind::Actor);
       auto actorType =
@@ -2537,7 +2538,7 @@ static CanSILFunctionType getSILFunctionType(
           actorIsolation = ActorIsolation::forConcurrent(false /*unsafe*/);
           break;
         case ExecutionKind::Caller:
-          actorIsolation = ActorIsolation::forNonisolated(false /*unsafe*/);
+          actorIsolation = ActorIsolation::forCallerIsolationInheriting();
           break;
         }
       } else {

lib/SILGen/SILGenApply.cpp

@@ -3107,6 +3107,7 @@ static void emitDelayedArguments(SILGenFunction &SGF,
       case ActorIsolation::NonisolatedUnsafe:
       case ActorIsolation::Concurrent:
       case ActorIsolation::ConcurrentUnsafe:
+      case ActorIsolation::CallerIsolationInheriting:
         llvm_unreachable("Not isolated");
       }
 
@@ -5836,6 +5837,7 @@ RValue SILGenFunction::emitApply(
     case ActorIsolation::NonisolatedUnsafe:
     case ActorIsolation::Concurrent:
     case ActorIsolation::ConcurrentUnsafe:
+    case ActorIsolation::CallerIsolationInheriting:
       llvm_unreachable("Not isolated");
       break;
     }

lib/SILGen/SILGenConcurrency.cpp

@@ -73,7 +73,7 @@ setExpectedExecutorForParameterIsolation(SILGenFunction &SGF,
 
   // If we have caller isolation inheriting... just grab from our isolated
   // argument.
-  if (actorIsolation.isNonisolated()) {
+  if (actorIsolation.getKind() == ActorIsolation::CallerIsolationInheriting) {
     if (auto *isolatedArg = SGF.F.maybeGetIsolatedArgument()) {
       ManagedValue isolatedMV;
       if (isolatedArg->getOwnershipKind() == OwnershipKind::Guaranteed) {
@@ -111,6 +111,7 @@ void SILGenFunction::emitExpectedExecutorProlog() {
         case ActorIsolation::Nonisolated:
         case ActorIsolation::NonisolatedUnsafe:
         case ActorIsolation::Unspecified:
+        case ActorIsolation::CallerIsolationInheriting:
           return false;
 
         case ActorIsolation::Erased:
@@ -164,6 +165,8 @@ void SILGenFunction::emitExpectedExecutorProlog() {
     auto actorIsolation = getActorIsolation(funcDecl);
     switch (actorIsolation.getKind()) {
     case ActorIsolation::Unspecified:
+    case ActorIsolation::Nonisolated:
+    case ActorIsolation::NonisolatedUnsafe:
     case ActorIsolation::Concurrent:
     case ActorIsolation::ConcurrentUnsafe:
       break;
@@ -188,8 +191,7 @@ void SILGenFunction::emitExpectedExecutorProlog() {
       break;
     }
 
-    case ActorIsolation::Nonisolated:
-    case ActorIsolation::NonisolatedUnsafe:
+    case ActorIsolation::CallerIsolationInheriting:
       assert(F.isAsync());
       setExpectedExecutorForParameterIsolation(*this, actorIsolation);
       break;
@@ -210,6 +212,7 @@ void SILGenFunction::emitExpectedExecutorProlog() {
     case ActorIsolation::NonisolatedUnsafe:
     case ActorIsolation::Concurrent:
     case ActorIsolation::ConcurrentUnsafe:
+    case ActorIsolation::CallerIsolationInheriting:
       break;
 
     case ActorIsolation::Erased:
@@ -639,6 +642,7 @@ SILGenFunction::emitClosureIsolation(SILLocation loc, SILDeclRef constant,
   case ActorIsolation::NonisolatedUnsafe:
   case ActorIsolation::Concurrent:
   case ActorIsolation::ConcurrentUnsafe:
+  case ActorIsolation::CallerIsolationInheriting:
     return emitNonIsolatedIsolation(loc);
 
   case ActorIsolation::Erased:
@@ -692,6 +696,7 @@ SILGenFunction::emitExecutor(SILLocation loc, ActorIsolation isolation,
   case ActorIsolation::NonisolatedUnsafe:
   case ActorIsolation::Concurrent:
   case ActorIsolation::ConcurrentUnsafe:
+  case ActorIsolation::CallerIsolationInheriting:
     return std::nullopt;
 
   case ActorIsolation::Erased:

lib/SILGen/SILGenConstructor.cpp

@@ -606,6 +606,7 @@ static bool ctorHopsInjectedByDefiniteInit(ConstructorDecl *ctor,
   case ActorIsolation::Concurrent:
   case ActorIsolation::ConcurrentUnsafe:
   case ActorIsolation::GlobalActor:
+  case ActorIsolation::CallerIsolationInheriting:
     return false;
   }
 }
@@ -1561,6 +1562,7 @@ void SILGenFunction::emitMemberInitializer(DeclContext *dc, VarDecl *selfDecl,
     case ActorIsolation::NonisolatedUnsafe:
     case ActorIsolation::Concurrent:
     case ActorIsolation::ConcurrentUnsafe:
+    case ActorIsolation::CallerIsolationInheriting:
       break;
 
     case ActorIsolation::Erased: