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

This reverts commit 0cb6463.

Author: gottesmm

include/swift/AST/ActorIsolation.h

@@ -57,19 +57,8 @@ 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 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.
+    /// meaning that it can be used from any actor but is also unable to
+    /// refer to the isolated state of any given actor.
     Nonisolated,
     /// The declaration is explicitly specified to be not isolated and with the
     /// "unsafe" annotation, which means that we do not enforce isolation.
@@ -85,20 +74,6 @@ 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:
@@ -107,13 +82,13 @@ class ActorIsolation {
     Type globalActor;
     void *pointer;
   };
-  unsigned kind : 4;
+  unsigned kind : 3;
   unsigned isolatedByPreconcurrency : 1;
 
   /// Set to true if this was parsed from SIL.
   unsigned silParsed : 1;
 
-  unsigned parameterIndex : 26;
+  unsigned parameterIndex : 27;
 
   ActorIsolation(Kind kind, NominalTypeDecl *actor, unsigned parameterIndex);
 
@@ -137,10 +112,6 @@ 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.
@@ -197,10 +168,6 @@ 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;
@@ -213,22 +180,12 @@ 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`.
@@ -256,8 +213,6 @@ class ActorIsolation {
     case Nonisolated:
     case NonisolatedUnsafe:
     case CallerIsolationInheriting:
-    case Concurrent:
-    case ConcurrentUnsafe:
       return false;
     }
   }

lib/AST/ASTDumper.cpp

@@ -3905,17 +3905,12 @@ 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,10 +39,7 @@ ActorIsolation::ActorIsolation(Kind kind, Expr *actor, unsigned parameterIndex)
 
 ActorIsolation::ActorIsolation(Kind kind, Type globalActor)
     : globalActor(globalActor), kind(kind), isolatedByPreconcurrency(false),
-      silParsed(false), parameterIndex(0) {
-  assert((silParsed || globalActor) &&
-         "If we are not sil parsed, global actor must be a real type");
-}
+      silParsed(false), parameterIndex(0) {}
 
 ActorIsolation
 ActorIsolation::forActorInstanceParameter(Expr *actor,
@@ -52,7 +49,7 @@ ActorIsolation::forActorInstanceParameter(Expr *actor,
   // An isolated value of `nil` is statically nonisolated.
   // FIXME: Also allow 'Optional.none'
   if (isa<NilLiteralExpr>(actor))
-    return ActorIsolation::forConcurrent(/*unsafe*/ false);
+    return ActorIsolation::forNonisolated(/*unsafe*/ false);
 
   // An isolated value of `<global actor type>.shared` is statically
   // global actor isolated.
@@ -167,8 +164,6 @@ 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,7 +2757,6 @@ static bool deferMatchesEnclosingAccess(const FuncDecl *defer) {
         switch (isolation) {
           case ActorIsolation::Unspecified:
           case ActorIsolation::NonisolatedUnsafe:
-          case ActorIsolation::ConcurrentUnsafe:
             break;
 
           case ActorIsolation::GlobalActor:
@@ -2769,7 +2768,6 @@ 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;
         }
@@ -11463,8 +11461,6 @@ 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,8 +1860,6 @@ bool ActorIsolation::requiresSubstitution() const {
   case ActorInstance:
   case Nonisolated:
   case NonisolatedUnsafe:
-  case Concurrent:
-  case ConcurrentUnsafe:
   case Unspecified:
     return false;
 
@@ -1877,8 +1875,6 @@ ActorIsolation ActorIsolation::subst(SubstitutionMap subs) const {
   case CallerIsolationInheriting:
   case Nonisolated:
   case NonisolatedUnsafe:
-  case Concurrent:
-  case ConcurrentUnsafe:
   case Unspecified:
     return *this;
 
@@ -1916,13 +1912,11 @@ 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 (isUnsafe()) {
+    if (*this == ActorIsolation::NonisolatedUnsafe) {
       os << "(unsafe)";
     }
     break;
@@ -1949,12 +1943,6 @@ 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;
@@ -1982,12 +1970,6 @@ 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;
@@ -2033,10 +2015,8 @@ void swift::simple_display(
 
     case ActorIsolation::Nonisolated:
     case ActorIsolation::NonisolatedUnsafe:
-    case ActorIsolation::Concurrent:
-    case ActorIsolation::ConcurrentUnsafe:
       out << "nonisolated";
-      if (state.isUnsafe()) {
+      if (state == ActorIsolation::NonisolatedUnsafe) {
         out << "(unsafe)";
       }
       break;

lib/IDE/CompletionLookup.cpp

@@ -827,10 +827,8 @@ void CompletionLookup::analyzeActorIsolation(
     break;
   case ActorIsolation::Unspecified:
   case ActorIsolation::Nonisolated:
-  case ActorIsolation::NonisolatedUnsafe:
-  case ActorIsolation::Concurrent:
-  case ActorIsolation::ConcurrentUnsafe:
   case ActorIsolation::CallerIsolationInheriting:
+  case ActorIsolation::NonisolatedUnsafe:
     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::forConcurrent(false);
+        actorIsolation = ActorIsolation::forNonisolated(false);
       } else if (auto *decl = constant->getAbstractFunctionDecl();
                  decl && decl->getExecutionBehavior().has_value()) {
         switch (*decl->getExecutionBehavior()) {
         case ExecutionKind::Concurrent:
-          actorIsolation = ActorIsolation::forConcurrent(false /*unsafe*/);
+          actorIsolation = ActorIsolation::forNonisolated(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::forConcurrent(false);
+      return ActorIsolation::forNonisolated(false);
     }
 
     // If we have actor isolation for our constant, put the isolation onto the

lib/SILGen/SILGenApply.cpp

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

lib/SILGen/SILGenConcurrency.cpp

@@ -106,8 +106,6 @@ 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:
@@ -167,8 +165,6 @@ void SILGenFunction::emitExpectedExecutorProlog() {
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
     case ActorIsolation::NonisolatedUnsafe:
-    case ActorIsolation::Concurrent:
-    case ActorIsolation::ConcurrentUnsafe:
       break;
 
     case ActorIsolation::Erased:
@@ -209,10 +205,8 @@ void SILGenFunction::emitExpectedExecutorProlog() {
     switch (actorIsolation.getKind()) {
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
-    case ActorIsolation::NonisolatedUnsafe:
-    case ActorIsolation::Concurrent:
-    case ActorIsolation::ConcurrentUnsafe:
     case ActorIsolation::CallerIsolationInheriting:
+    case ActorIsolation::NonisolatedUnsafe:
       break;
 
     case ActorIsolation::Erased:
@@ -639,10 +633,8 @@ SILGenFunction::emitClosureIsolation(SILLocation loc, SILDeclRef constant,
   switch (isolation) {
   case ActorIsolation::Unspecified:
   case ActorIsolation::Nonisolated:
-  case ActorIsolation::NonisolatedUnsafe:
-  case ActorIsolation::Concurrent:
-  case ActorIsolation::ConcurrentUnsafe:
   case ActorIsolation::CallerIsolationInheriting:
+  case ActorIsolation::NonisolatedUnsafe:
     return emitNonIsolatedIsolation(loc);
 
   case ActorIsolation::Erased:
@@ -693,10 +685,8 @@ SILGenFunction::emitExecutor(SILLocation loc, ActorIsolation isolation,
   switch (isolation.getKind()) {
   case ActorIsolation::Unspecified:
   case ActorIsolation::Nonisolated:
-  case ActorIsolation::NonisolatedUnsafe:
-  case ActorIsolation::Concurrent:
-  case ActorIsolation::ConcurrentUnsafe:
   case ActorIsolation::CallerIsolationInheriting:
+  case ActorIsolation::NonisolatedUnsafe:
     return std::nullopt;
 
   case ActorIsolation::Erased:
@@ -726,8 +716,6 @@ 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