[concurrency] Add Concurrent/ConcurrentUnsafe and use it instead of ActorIsolation::Nonisolated.

This is just the first part of a larger transition.

Author: gottesmm

include/swift/AST/ActorIsolation.h

@@ -57,8 +57,19 @@ class ActorIsolation {
     /// the actor is isolated to the instance of that actor.
     ActorInstance,
     /// 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.
+    /// meaning it cannot itself access actor isolated state but /does/ allow
+    /// for indirect access to actor isolated state if the declaration can
+    /// guarantee that all code generated to work with the declaration will run
+    /// on said actor.
+    ///
+    /// E.x.: a nonisolated function can accept actor-isolated values as
+    /// arguments since the caller knows that it will not escape the values to
+    /// another isolation domain and that the function will remain on the
+    /// caller's actor.
+    ///
+    /// NOTE: This used to have the meaning of Concurrent which is a stricter
+    /// definition of nonisolated that prevents the code generated to work with
+    /// the declaration to never touch actor isolated state.
     Nonisolated,
     /// The declaration is explicitly specified to be not isolated and with the
     /// "unsafe" annotation, which means that we do not enforce isolation.
@@ -74,6 +85,20 @@ class ActorIsolation {
     /// 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.
+    ///
+    /// NOTE: This used to be nonisolated, but we changed nonisolated to have a
+    /// weaker definition of nonisolated that allows for actor isolated state to
+    /// be manipulated by code generated to work with the actor as long as all
+    /// such code generation is guaranteed to always run on whatever actor
+    /// isolation it is invoked in consistently and not escape the value to any
+    /// other isolation domain.
+    Concurrent,
+    /// The declaration is explicitly specified to be concurrent and with the
+    /// "unsafe" annotation, which means that we do not enforce isolation.
+    ConcurrentUnsafe,
   };
 
 private:
@@ -82,13 +107,13 @@ class ActorIsolation {
     Type globalActor;
     void *pointer;
   };
-  unsigned kind : 3;
+  unsigned kind : 4;
   unsigned isolatedByPreconcurrency : 1;
 
   /// Set to true if this was parsed from SIL.
   unsigned silParsed : 1;
 
-  unsigned parameterIndex : 27;
+  unsigned parameterIndex : 26;
 
   ActorIsolation(Kind kind, NominalTypeDecl *actor, unsigned parameterIndex);
 
@@ -112,6 +137,10 @@ class ActorIsolation {
     return ActorIsolation(unsafe ? NonisolatedUnsafe : Nonisolated);
   }
 
+  static ActorIsolation forConcurrent(bool unsafe) {
+    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.
@@ -168,6 +197,10 @@ class ActorIsolation {
             .Case("caller_isolation_inheriting",
                   std::optional<ActorIsolation>(
                       ActorIsolation::CallerIsolationInheriting))
+            .Case("concurrent",
+                  std::optional<ActorIsolation>(ActorIsolation::Concurrent))
+            .Case("concurrent_unsafe", std::optional<ActorIsolation>(
+                                           ActorIsolation::ConcurrentUnsafe))
             .Default(std::nullopt);
     if (kind == std::nullopt)
       return std::nullopt;
@@ -180,12 +213,22 @@ class ActorIsolation {
 
   bool isUnspecified() const { return kind == Unspecified; }
 
+  bool isConcurrent() const {
+    return (kind == Concurrent) || (kind == ConcurrentUnsafe);
+  }
+
+  bool isConcurrentUnsafe() const { return kind == ConcurrentUnsafe; }
+
   bool isNonisolated() const {
     return (kind == Nonisolated) || (kind == NonisolatedUnsafe);
   }
 
   bool isNonisolatedUnsafe() const { return kind == NonisolatedUnsafe; }
 
+  bool isUnsafe() const {
+    return kind == NonisolatedUnsafe || kind == ConcurrentUnsafe;
+  }
+
   /// Retrieve the parameter to which actor-instance isolation applies.
   ///
   /// Parameter 0 is `self`.
@@ -213,6 +256,8 @@ class ActorIsolation {
     case Nonisolated:
     case NonisolatedUnsafe:
     case CallerIsolationInheriting:
+    case Concurrent:
+    case ConcurrentUnsafe:
       return false;
     }
   }

lib/AST/ASTDumper.cpp

@@ -3844,12 +3844,17 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, Label>,
     switch (auto isolation = E->getActorIsolation()) {
     case ActorIsolation::Unspecified:
     case ActorIsolation::NonisolatedUnsafe:
+    case ActorIsolation::ConcurrentUnsafe:
       break;
 
     case ActorIsolation::Nonisolated:
       printFlag(true, "nonisolated", CapturesColor);
       break;
 
+    case ActorIsolation::Concurrent:
+      printFlag(true, "concurrent", CapturesColor);
+      break;
+
     case ActorIsolation::Erased:
       printFlag(true, "dynamically_isolated", CapturesColor);
       break;

lib/AST/ActorIsolation.cpp

@@ -39,7 +39,10 @@ ActorIsolation::ActorIsolation(Kind kind, Expr *actor, unsigned parameterIndex)
 
 ActorIsolation::ActorIsolation(Kind kind, Type globalActor)
     : globalActor(globalActor), kind(kind), isolatedByPreconcurrency(false),
-      silParsed(false), parameterIndex(0) {}
+      silParsed(false), parameterIndex(0) {
+  assert((silParsed || globalActor) &&
+         "If we are not sil parsed, global actor must be a real type");
+}
 
 ActorIsolation
 ActorIsolation::forActorInstanceParameter(Expr *actor,
@@ -49,7 +52,7 @@ ActorIsolation::forActorInstanceParameter(Expr *actor,
   // An isolated value of `nil` is statically nonisolated.
   // FIXME: Also allow 'Optional.none'
   if (isa<NilLiteralExpr>(actor))
-    return ActorIsolation::forNonisolated(/*unsafe*/ false);
+    return ActorIsolation::forConcurrent(/*unsafe*/ false);
 
   // An isolated value of `<global actor type>.shared` is statically
   // global actor isolated.
@@ -164,6 +167,8 @@ bool ActorIsolation::isEqual(const ActorIsolation &lhs,
   switch (lhs.getKind()) {
   case Nonisolated:
   case NonisolatedUnsafe:
+  case Concurrent:
+  case ConcurrentUnsafe:
   case Unspecified:
     return true;
 

lib/AST/Decl.cpp

@@ -2757,6 +2757,7 @@ static bool deferMatchesEnclosingAccess(const FuncDecl *defer) {
         switch (isolation) {
           case ActorIsolation::Unspecified:
           case ActorIsolation::NonisolatedUnsafe:
+          case ActorIsolation::ConcurrentUnsafe:
             break;
 
           case ActorIsolation::GlobalActor:
@@ -2768,6 +2769,7 @@ static bool deferMatchesEnclosingAccess(const FuncDecl *defer) {
           case ActorIsolation::CallerIsolationInheriting:
           case ActorIsolation::ActorInstance:
           case ActorIsolation::Nonisolated:
+          case ActorIsolation::Concurrent:
           case ActorIsolation::Erased: // really can't happen
             return true;
         }
@@ -11458,6 +11460,8 @@ bool VarDecl::isSelfParamCaptureIsolated() const {
       case ActorIsolation::Unspecified:
       case ActorIsolation::Nonisolated:
       case ActorIsolation::NonisolatedUnsafe:
+      case ActorIsolation::Concurrent:
+      case ActorIsolation::ConcurrentUnsafe:
       case ActorIsolation::GlobalActor:
       case ActorIsolation::Erased:
       case ActorIsolation::CallerIsolationInheriting:

lib/AST/TypeCheckRequests.cpp

@@ -1860,6 +1860,8 @@ bool ActorIsolation::requiresSubstitution() const {
   case ActorInstance:
   case Nonisolated:
   case NonisolatedUnsafe:
+  case Concurrent:
+  case ConcurrentUnsafe:
   case Unspecified:
     return false;
 
@@ -1875,6 +1877,8 @@ ActorIsolation ActorIsolation::subst(SubstitutionMap subs) const {
   case CallerIsolationInheriting:
   case Nonisolated:
   case NonisolatedUnsafe:
+  case Concurrent:
+  case ConcurrentUnsafe:
   case Unspecified:
     return *this;
 
@@ -1912,11 +1916,13 @@ void ActorIsolation::printForDiagnostics(llvm::raw_ostream &os,
     os << "@isolated(any)";
     break;
 
+  case ActorIsolation::Concurrent:
+  case ActorIsolation::ConcurrentUnsafe:
   case ActorIsolation::Nonisolated:
   case ActorIsolation::NonisolatedUnsafe:
   case ActorIsolation::Unspecified:
     os << "nonisolated";
-    if (*this == ActorIsolation::NonisolatedUnsafe) {
+    if (isUnsafe()) {
       os << "(unsafe)";
     }
     break;
@@ -1943,6 +1949,12 @@ void ActorIsolation::print(llvm::raw_ostream &os) const {
   case NonisolatedUnsafe:
     os << "nonisolated_unsafe";
     return;
+  case Concurrent:
+    os << "concurrent";
+    return;
+  case ConcurrentUnsafe:
+    os << "concurrent_unsafe";
+    return;
   case GlobalActor:
     os << "global_actor. type: " << getGlobalActor();
     return;
@@ -1970,6 +1982,12 @@ void ActorIsolation::printForSIL(llvm::raw_ostream &os) const {
   case NonisolatedUnsafe:
     os << "nonisolated_unsafe";
     return;
+  case Concurrent:
+    os << "concurrent";
+    return;
+  case ConcurrentUnsafe:
+    os << "concurrent_unsafe";
+    return;
   case GlobalActor:
     os << "global_actor";
     return;
@@ -2015,8 +2033,10 @@ void swift::simple_display(
 
     case ActorIsolation::Nonisolated:
     case ActorIsolation::NonisolatedUnsafe:
+    case ActorIsolation::Concurrent:
+    case ActorIsolation::ConcurrentUnsafe:
       out << "nonisolated";
-      if (state == ActorIsolation::NonisolatedUnsafe) {
+      if (state.isUnsafe()) {
         out << "(unsafe)";
       }
       break;

lib/IDE/CompletionLookup.cpp

@@ -827,8 +827,10 @@ void CompletionLookup::analyzeActorIsolation(
     break;
   case ActorIsolation::Unspecified:
   case ActorIsolation::Nonisolated:
-  case ActorIsolation::CallerIsolationInheriting:
   case ActorIsolation::NonisolatedUnsafe:
+  case ActorIsolation::Concurrent:
+  case ActorIsolation::ConcurrentUnsafe:
+  case ActorIsolation::CallerIsolationInheriting:
     return;
   }
 }

lib/SIL/IR/SILFunctionType.cpp

@@ -2530,12 +2530,12 @@ static CanSILFunctionType getSILFunctionType(
     std::optional<ActorIsolation> actorIsolation;
     if (constant) {
       if (constant->kind == SILDeclRef::Kind::Deallocator) {
-        actorIsolation = ActorIsolation::forNonisolated(false);
+        actorIsolation = ActorIsolation::forConcurrent(false);
       } else if (auto *decl = constant->getAbstractFunctionDecl();
                  decl && decl->getExecutionBehavior().has_value()) {
         switch (*decl->getExecutionBehavior()) {
         case ExecutionKind::Concurrent:
-          actorIsolation = ActorIsolation::forNonisolated(false /*unsafe*/);
+          actorIsolation = ActorIsolation::forConcurrent(false /*unsafe*/);
           break;
         case ExecutionKind::Caller:
           actorIsolation = ActorIsolation::forCallerIsolationInheriting();

lib/SILGen/SILGen.cpp

@@ -735,7 +735,7 @@ static ActorIsolation getActorIsolationForFunction(SILFunction &fn) {
     if (constant.kind == SILDeclRef::Kind::Deallocator) {
       // Deallocating destructor is always nonisolated. Isolation of the deinit
       // applies only to isolated deallocator and destroyer.
-      return ActorIsolation::forNonisolated(false);
+      return ActorIsolation::forConcurrent(false);
     }
 
     // If we have actor isolation for our constant, put the isolation onto the

lib/SILGen/SILGenApply.cpp

@@ -3104,8 +3104,10 @@ static void emitDelayedArguments(SILGenFunction &SGF,
 
       case ActorIsolation::Unspecified:
       case ActorIsolation::Nonisolated:
-      case ActorIsolation::CallerIsolationInheriting:
       case ActorIsolation::NonisolatedUnsafe:
+      case ActorIsolation::Concurrent:
+      case ActorIsolation::ConcurrentUnsafe:
+      case ActorIsolation::CallerIsolationInheriting:
         llvm_unreachable("Not isolated");
       }
 
@@ -5832,8 +5834,10 @@ RValue SILGenFunction::emitApply(
 
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
-    case ActorIsolation::CallerIsolationInheriting:
     case ActorIsolation::NonisolatedUnsafe:
+    case ActorIsolation::Concurrent:
+    case ActorIsolation::ConcurrentUnsafe:
+    case ActorIsolation::CallerIsolationInheriting:
       llvm_unreachable("Not isolated");
       break;
     }

lib/SILGen/SILGenConcurrency.cpp

@@ -106,6 +106,8 @@ void SILGenFunction::emitExpectedExecutorProlog() {
           // the instance properties of the class.
           return false;
 
+        case ActorIsolation::Concurrent:
+        case ActorIsolation::ConcurrentUnsafe:
         case ActorIsolation::Nonisolated:
         case ActorIsolation::NonisolatedUnsafe:
         case ActorIsolation::Unspecified:
@@ -165,6 +167,8 @@ void SILGenFunction::emitExpectedExecutorProlog() {
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
     case ActorIsolation::NonisolatedUnsafe:
+    case ActorIsolation::Concurrent:
+    case ActorIsolation::ConcurrentUnsafe:
       break;
 
     case ActorIsolation::Erased:
@@ -205,8 +209,10 @@ void SILGenFunction::emitExpectedExecutorProlog() {
     switch (actorIsolation.getKind()) {
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
-    case ActorIsolation::CallerIsolationInheriting:
     case ActorIsolation::NonisolatedUnsafe:
+    case ActorIsolation::Concurrent:
+    case ActorIsolation::ConcurrentUnsafe:
+    case ActorIsolation::CallerIsolationInheriting:
       break;
 
     case ActorIsolation::Erased:
@@ -633,8 +639,10 @@ SILGenFunction::emitClosureIsolation(SILLocation loc, SILDeclRef constant,
   switch (isolation) {
   case ActorIsolation::Unspecified:
   case ActorIsolation::Nonisolated:
-  case ActorIsolation::CallerIsolationInheriting:
   case ActorIsolation::NonisolatedUnsafe:
+  case ActorIsolation::Concurrent:
+  case ActorIsolation::ConcurrentUnsafe:
+  case ActorIsolation::CallerIsolationInheriting:
     return emitNonIsolatedIsolation(loc);
 
   case ActorIsolation::Erased:
@@ -685,8 +693,10 @@ SILGenFunction::emitExecutor(SILLocation loc, ActorIsolation isolation,
   switch (isolation.getKind()) {
   case ActorIsolation::Unspecified:
   case ActorIsolation::Nonisolated:
-  case ActorIsolation::CallerIsolationInheriting:
   case ActorIsolation::NonisolatedUnsafe:
+  case ActorIsolation::Concurrent:
+  case ActorIsolation::ConcurrentUnsafe:
+  case ActorIsolation::CallerIsolationInheriting:
     return std::nullopt;
 
   case ActorIsolation::Erased:
@@ -716,6 +726,8 @@ void SILGenFunction::emitHopToActorValue(SILLocation loc, ManagedValue actor) {
       });
   if (isolation != ActorIsolation::Nonisolated &&
       isolation != ActorIsolation::NonisolatedUnsafe &&
+      isolation != ActorIsolation::Concurrent &&
+      isolation != ActorIsolation::ConcurrentUnsafe &&
       isolation != ActorIsolation::Unspecified) {
     // TODO: Explicit hop with no hop-back should only be allowed in nonisolated
     // async functions. But it needs work for any closure passed to