Merge pull request #71050 from hborla/global-actor-unsafe

[Concurrency] Deprecate `@GlobalActor(unsafe)` in favor of `@preconcurrency @GlobalActor`

Author: hborla

include/swift/AST/ActorIsolation.h

@@ -66,10 +66,6 @@ class ActorIsolation {
     /// The declaration is isolated to a global actor. It can refer to other
     /// entities with the same global actor.
     GlobalActor,
-    /// The declaration is isolated to a global actor but with the "unsafe"
-    /// annotation, which means that we only enforce the isolation if we're
-    /// coming from something with specific isolation.
-    GlobalActorUnsafe,
   };
 
 private:
@@ -121,9 +117,8 @@ class ActorIsolation {
     return ActorIsolation(ActorInstance, capturedActor);
   }
 
-  static ActorIsolation forGlobalActor(Type globalActor, bool unsafe) {
-    return ActorIsolation(
-        unsafe ? GlobalActorUnsafe : GlobalActor, globalActor);
+  static ActorIsolation forGlobalActor(Type globalActor) {
+    return ActorIsolation(GlobalActor, globalActor);
   }
 
   static std::optional<ActorIsolation> forSILString(StringRef string) {
@@ -140,7 +135,7 @@ class ActorIsolation {
             .Case("global_actor",
                   std::optional<ActorIsolation>(ActorIsolation::GlobalActor))
             .Case("global_actor_unsafe", std::optional<ActorIsolation>(
-                                             ActorIsolation::GlobalActorUnsafe))
+                                             ActorIsolation::GlobalActor))
             .Default(std::nullopt);
     if (kind == std::nullopt)
       return std::nullopt;
@@ -171,7 +166,6 @@ class ActorIsolation {
     switch (getKind()) {
     case ActorInstance:
     case GlobalActor:
-    case GlobalActorUnsafe:
       return true;
 
     case Unspecified:
@@ -186,7 +180,7 @@ class ActorIsolation {
   VarDecl *getActorInstance() const;
 
   bool isGlobalActor() const {
-    return getKind() == GlobalActor || getKind() == GlobalActorUnsafe;
+    return getKind() == GlobalActor;
   }
 
   bool isMainActor() const;
@@ -238,7 +232,6 @@ class ActorIsolation {
               lhs.parameterIndex == rhs.parameterIndex);
 
     case GlobalActor:
-    case GlobalActorUnsafe:
       llvm_unreachable("Global actors handled above");
     }
   }
@@ -271,9 +264,6 @@ class ActorIsolation {
     case GlobalActor:
       os << "global_actor";
       return;
-    case GlobalActorUnsafe:
-      os << "global_actor_unsafe";
-      return;
     }
     llvm_unreachable("Covered switch isn't covered?!");
   }

include/swift/AST/DiagnosticsSema.def

@@ -5743,8 +5743,13 @@ ERROR(global_actor_on_local_variable,none,
 ERROR(global_actor_on_storage_of_value_type,none,
       "stored property %0 within struct cannot have a global actor",
       (DeclName))
-ERROR(global_actor_non_unsafe_init,none,
-      "global actor attribute %0 argument can only be '(unsafe)'", (Type))
+ERROR(unsafe_global_actor,none,
+      "'(unsafe)' global actors are deprecated; "
+      "use '@preconcurrency' instead",
+      ())
+ERROR(global_actor_arg,none,
+      "global actor attribute %0 cannot have arguments",
+      (Type))
 ERROR(global_actor_non_final_class,none,
       "non-final class %0 cannot be a global actor", (DeclName))
 ERROR(global_actor_top_level_var,none,

lib/AST/ASTDumper.cpp

@@ -2790,7 +2790,6 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, StringRef>,
       break;
 
     case ActorIsolation::GlobalActor:
-    case ActorIsolation::GlobalActorUnsafe:
       printFieldQuoted(isolation.getGlobalActor().getString(),
                        "global_actor_isolated", CapturesColor);
       break;

lib/AST/Attr.cpp

@@ -1329,8 +1329,6 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
       type.print(Printer, Options);
     else
       attr->getTypeRepr()->print(Printer, Options);
-    if (attr->isArgUnsafe() && Options.IsForSwiftInterface)
-      Printer << "(unsafe)";
     Printer.printNamePost(PrintNameContext::Attribute);
     break;
   }

lib/AST/Decl.cpp

@@ -2512,15 +2512,20 @@ static bool deferMatchesEnclosingAccess(const FuncDecl *defer) {
         if (type->isAnyActor())
           return true;
 
-        switch (getActorIsolation(type)) {
+        auto isolation = getActorIsolation(type);
+        switch (isolation) {
           case ActorIsolation::Unspecified:
           case ActorIsolation::NonisolatedUnsafe:
-          case ActorIsolation::GlobalActorUnsafe:
             break;
 
+          case ActorIsolation::GlobalActor:
+            if (isolation.preconcurrency())
+              break;
+
+            return true;
+
           case ActorIsolation::ActorInstance:
           case ActorIsolation::Nonisolated:
-          case ActorIsolation::GlobalActor:
             return true;
         }
       }
@@ -10897,7 +10902,6 @@ bool VarDecl::isSelfParamCaptureIsolated() const {
       case ActorIsolation::Nonisolated:
       case ActorIsolation::NonisolatedUnsafe:
       case ActorIsolation::GlobalActor:
-      case ActorIsolation::GlobalActorUnsafe:
         return false;
 
       case ActorIsolation::ActorInstance:
@@ -10965,9 +10969,9 @@ ActorIsolation swift::getActorIsolationOfContext(
         dcToUse->getASTContext().LangOpts.StrictConcurrencyLevel >=
             StrictConcurrency::Complete) {
       if (Type mainActor = dcToUse->getASTContext().getMainActorType())
-        return ActorIsolation::forGlobalActor(
-            mainActor,
-            /*unsafe=*/!dcToUse->getASTContext().isSwiftVersionAtLeast(6));
+        return ActorIsolation::forGlobalActor(mainActor)
+            .withPreconcurrency(
+                !dcToUse->getASTContext().isSwiftVersionAtLeast(6));
     }
   }
 

lib/AST/DiagnosticEngine.cpp

@@ -910,8 +910,7 @@ static void formatDiagnosticArgument(StringRef Modifier,
       Out << "actor-isolated";
       break;
 
-    case ActorIsolation::GlobalActor:
-    case ActorIsolation::GlobalActorUnsafe: {
+    case ActorIsolation::GlobalActor: {
       if (isolation.isMainActor()) {
         Out << "main actor-isolated";
       } else {

lib/AST/TypeCheckRequests.cpp

@@ -1663,7 +1663,6 @@ bool ActorIsolation::requiresSubstitution() const {
     return false;
 
   case GlobalActor:
-  case GlobalActorUnsafe:
     return getGlobalActor()->hasTypeParameter();
   }
   llvm_unreachable("unhandled actor isolation kind!");
@@ -1678,16 +1677,17 @@ ActorIsolation ActorIsolation::subst(SubstitutionMap subs) const {
     return *this;
 
   case GlobalActor:
-  case GlobalActorUnsafe:
-    return forGlobalActor(
-        getGlobalActor().subst(subs), kind == GlobalActorUnsafe)
-              .withPreconcurrency(preconcurrency());
+    return forGlobalActor(getGlobalActor().subst(subs))
+        .withPreconcurrency(preconcurrency());
   }
   llvm_unreachable("unhandled actor isolation kind!");
 }
 
 void swift::simple_display(
     llvm::raw_ostream &out, const ActorIsolation &state) {
+  if (state.preconcurrency())
+    out << "preconcurrency ";
+
   switch (state) {
     case ActorIsolation::ActorInstance:
       out << "actor-isolated to instance of ";
@@ -1715,16 +1715,12 @@ void swift::simple_display(
       break;
 
     case ActorIsolation::GlobalActor:
-    case ActorIsolation::GlobalActorUnsafe:
       out << "actor-isolated to global actor ";
       if (state.isSILParsed()) {
         out << "SILPARSED";
       } else {
         out << state.getGlobalActor().getString();
       }
-
-      if (state == ActorIsolation::GlobalActorUnsafe)
-        out << "(unsafe)";
       break;
   }
 }

lib/IDE/CompletionLookup.cpp

@@ -767,15 +767,15 @@ void CompletionLookup::analyzeActorIsolation(
     }
     break;
   }
-  case ActorIsolation::GlobalActorUnsafe:
-    // For "unsafe" global actor isolation, automatic 'async' only happens
+  case ActorIsolation::GlobalActor: {
+    // For "preconcurrency" global actor isolation, automatic 'async' only happens
     // if the context has adopted concurrency.
-    if (!CanCurrDeclContextHandleAsync &&
+    if (isolation.preconcurrency() &&
+        !CanCurrDeclContextHandleAsync &&
         !completionContextUsesConcurrencyFeatures(CurrDeclContext)) {
       return;
     }
-    LLVM_FALLTHROUGH;
-  case ActorIsolation::GlobalActor: {
+
     auto getClosureActorIsolation = [this](AbstractClosureExpr *CE) {
       // Prefer solution-specific actor-isolations and fall back to the one
       // recorded in the AST.

lib/SILGen/SILGenApply.cpp

@@ -3051,7 +3051,6 @@ static void emitDelayedArguments(SILGenFunction &SGF,
     SILValue executor;
     switch (*defaultArgIsolation) {
     case ActorIsolation::GlobalActor:
-    case ActorIsolation::GlobalActorUnsafe:
       executor = SGF.emitLoadGlobalActorExecutor(
           defaultArgIsolation->getGlobalActor());
       break;
@@ -5630,7 +5629,6 @@ RValue SILGenFunction::emitApply(
       break;
 
     case ActorIsolation::GlobalActor:
-    case ActorIsolation::GlobalActorUnsafe:
       executor = emitLoadGlobalActorExecutor(
           implicitActorHopTarget->getGlobalActor());
       break;

lib/SILGen/SILGenConstructor.cpp

@@ -611,7 +611,6 @@ static bool ctorHopsInjectedByDefiniteInit(ConstructorDecl *ctor,
     case ActorIsolation::Nonisolated:
     case ActorIsolation::NonisolatedUnsafe:
     case ActorIsolation::GlobalActor:
-    case ActorIsolation::GlobalActorUnsafe:
       return false;
   }
 }
@@ -1582,7 +1581,6 @@ void SILGenFunction::emitMemberInitializer(DeclContext *dc, VarDecl *selfDecl,
       break;
 
     case ActorIsolation::GlobalActor:
-    case ActorIsolation::GlobalActorUnsafe:
     case ActorIsolation::ActorInstance: {
       if (requiredIsolation != contextIsolation) {
         // Implicit initializers diagnose actor isolation violations