[Concurrency] Remove remaining special cases of ActorIsolation::GlobalActorUnsafe.

Author: hborla

lib/AST/Decl.cpp

@@ -2512,15 +2512,21 @@ 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::GlobalActorUnsafe:
+          case ActorIsolation::GlobalActor:
+            if (isolation.preconcurrency())
+              break;
+
+            return true;
+
           case ActorIsolation::ActorInstance:
           case ActorIsolation::Nonisolated:
-          case ActorIsolation::GlobalActor:
             return true;
         }
       }

lib/AST/TypeCheckRequests.cpp

@@ -1687,6 +1687,9 @@ ActorIsolation ActorIsolation::subst(SubstitutionMap subs) const {
 
 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 ";
@@ -1721,9 +1724,6 @@ void swift::simple_display(
       } else {
         out << state.getGlobalActor().getString();
       }
-
-      if (state == ActorIsolation::GlobalActorUnsafe)
-        out << "(unsafe)";
       break;
   }
 }

lib/IDE/CompletionLookup.cpp

@@ -768,14 +768,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/Sema/TypeCheckConcurrency.cpp

@@ -4863,8 +4863,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
             TypeExpr::createImplicit(inferred.getGlobalActor(), ctx);
         auto attr =
             CustomAttr::create(ctx, SourceLoc(), typeExpr, /*implicit=*/true);
-        if (inferred == ActorIsolation::GlobalActorUnsafe)
-          attr->setArgIsUnsafe(true);
         value->getAttrs().add(attr);
 
         if (inferred.preconcurrency()) {

lib/Serialization/Deserialization.cpp

@@ -3863,8 +3863,9 @@ class DeclDeserializer {
 
       case ActorIsolation::GlobalActor:
       case ActorIsolation::GlobalActorUnsafe:
-        isolation = ActorIsolation::forGlobalActor(globalActor)
-            .withPreconcurrency(isoKind == ActorIsolation::GlobalActorUnsafe);
+        // 'unsafe' or 'preconcurrency' doesn't mean anything for isolated
+        // default arguments.
+        isolation = ActorIsolation::forGlobalActor(globalActor);
         break;
 
       case ActorIsolation::ActorInstance: