[Concurrency] Remove actorIndependent(unsafe) isolation.

Don't treat `actorIndependent(unsafe)` as its own kind of isolation.
It was only really used as a bring-up hack to break the isolation model,
but shouldn't be in the user model of the language and causes
complications to the implementation.

Author: DougGregor

include/swift/AST/ActorIsolation.h

@@ -51,11 +51,6 @@ class ActorIsolation {
     /// meaning that it can be used from any actor but is also unable to
     /// refer to the isolated state of any given actor.
     Independent,
-    /// The declaration is explicitly specified to be independent of any actor,
-    /// but the programmer promises to protect the declaration from concurrent
-    /// accesses manually. Thus, it is okay if this declaration is a mutable 
-    /// variable that creates storage.
-    IndependentUnsafe,
     /// The declaration is isolated to a global actor. It can refer to other
     /// entities with the same global actor.
     GlobalActor,
@@ -84,18 +79,8 @@ class ActorIsolation {
     return ActorIsolation(Unspecified, nullptr);
   }
 
-  static ActorIsolation forIndependent(ActorIndependentKind indepKind) {
-    ActorIsolation::Kind isoKind;
-    switch (indepKind) {
-      case ActorIndependentKind::Safe:
-        isoKind = Independent;
-        break;
-        
-      case ActorIndependentKind::Unsafe:
-        isoKind = IndependentUnsafe;
-        break;
-    }
-    return ActorIsolation(isoKind, nullptr);
+  static ActorIsolation forIndependent() {
+    return ActorIsolation(Independent, nullptr);
   }
 
   static ActorIsolation forActorInstance(NominalTypeDecl *actor) {
@@ -141,7 +126,6 @@ class ActorIsolation {
 
     switch (lhs.kind) {
     case Independent:
-    case IndependentUnsafe:
     case Unspecified:
       return true;
 

include/swift/AST/Attr.def

@@ -580,7 +580,7 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(actor, Actor,
 DECL_ATTR(actorIndependent, ActorIndependent,
   OnClass | OnStruct | OnEnum | OnExtension | OnFunc | OnConstructor |
   OnVar | OnSubscript | ConcurrencyOnly |
-  ABIStableToAdd | ABIStableToRemove |
+  ABIBreakingToAdd | ABIBreakingToRemove |
   APIBreakingToAdd | APIBreakingToRemove,
   103)
 

lib/AST/Decl.cpp

@@ -8034,7 +8034,7 @@ ActorIsolation swift::getActorIsolationOfContext(DeclContext *dc) {
   if (auto *closure = dyn_cast<AbstractClosureExpr>(dc)) {
     switch (auto isolation = closure->getActorIsolation()) {
     case ClosureActorIsolation::Independent:
-      return ActorIsolation::forIndependent(ActorIndependentKind::Safe);
+      return ActorIsolation::forIndependent();
 
     case ClosureActorIsolation::GlobalActor: {
       return ActorIsolation::forGlobalActor(

lib/AST/DiagnosticEngine.cpp

@@ -706,12 +706,8 @@ static void formatDiagnosticArgument(StringRef Modifier,
       Out << "actor-independent";
       break;
 
-    case ActorIsolation::IndependentUnsafe:
-      Out << "actor-independent-unsafe";
-      break;
-
     case ActorIsolation::Unspecified:
-      Out << "non-actor-isolated";
+      Out << "unspecified";
       break;
     }
   }

lib/AST/TypeCheckRequests.cpp

@@ -1526,7 +1526,6 @@ bool ActorIsolation::requiresSubstitution() const {
   switch (kind) {
   case ActorInstance:
   case Independent:
-  case IndependentUnsafe:
   case Unspecified:
     return false;
 
@@ -1541,7 +1540,6 @@ ActorIsolation ActorIsolation::subst(SubstitutionMap subs) const {
   switch (kind) {
   case ActorInstance:
   case Independent:
-  case IndependentUnsafe:
   case Unspecified:
     return *this;
 
@@ -1564,10 +1562,6 @@ void swift::simple_display(
       out << "actor-independent";
       break;
 
-    case ActorIsolation::IndependentUnsafe:
-      out << "actor-independent (unsafe)";
-      break;
-
     case ActorIsolation::Unspecified:
       out << "unspecified actor isolation";
       break;

lib/IDE/CodeCompletion.cpp

@@ -2535,7 +2535,6 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       break;
     case ActorIsolation::Unspecified:
     case ActorIsolation::Independent:
-    case ActorIsolation::IndependentUnsafe:
       return;
     }
 

lib/SILGen/SILGenProlog.cpp

@@ -473,7 +473,6 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
     switch (actorIsolation.getKind()) {
       case ActorIsolation::Unspecified:
       case ActorIsolation::Independent:
-      case ActorIsolation::IndependentUnsafe:
       case ActorIsolation::GlobalActorUnsafe:
         break;
 
@@ -566,7 +565,6 @@ ExecutorBreadcrumb SILGenFunction::emitHopToTargetActor(SILLocation loc,
   switch (actorIso.getKind()) {
   case ActorIsolation::Unspecified:
   case ActorIsolation::Independent:
-  case ActorIsolation::IndependentUnsafe:
     break;
 
   case ActorIsolation::ActorInstance: {

lib/Sema/TypeCheckConcurrency.cpp

@@ -668,7 +668,6 @@ ActorIsolationRestriction ActorIsolationRestriction::forDeclaration(
     }
 
     case ActorIsolation::Independent:
-    case ActorIsolation::IndependentUnsafe:
       // Actor-independent have no restrictions on their access.
       return forUnrestricted();
 
@@ -1549,7 +1548,6 @@ namespace {
       switch (auto isolation = getActorIsolationOfContext(dc)) {
       case ActorIsolation::ActorInstance:
       case ActorIsolation::Independent:
-      case ActorIsolation::IndependentUnsafe:
       case ActorIsolation::Unspecified:
         return isolation;
 
@@ -1725,10 +1723,6 @@ namespace {
         return true;
       }
 
-      case ActorIsolation::IndependentUnsafe:
-        // Allow unrestricted use of something in a global actor.
-        return false;
-
       case ActorIsolation::Independent: {
         auto result = tryMarkImplicitlyAsync(loc, valueRef, context);
         if (result == AsyncMarkingResult::FoundAsync)
@@ -2099,7 +2093,6 @@ namespace {
 
             return false;
 
-          case ActorIsolation::IndependentUnsafe:
           case ActorIsolation::Unspecified:
             return false;
 
@@ -2212,7 +2205,6 @@ namespace {
       // We must have parent isolation determined to get here.
       switch (parentIsolation) {
       case ActorIsolation::Independent:
-      case ActorIsolation::IndependentUnsafe:
       case ActorIsolation::Unspecified:
         return ClosureActorIsolation::forIndependent();
 
@@ -2364,13 +2356,13 @@ static Optional<ActorIsolation> getIsolationFromAttributes(
   // If the declaration is explicitly marked 'nonisolated', report it as
   // independent.
   if (nonisolatedAttr) {
-    return ActorIsolation::forIndependent(ActorIndependentKind::Safe);
+    return ActorIsolation::forIndependent();
   }
 
   // If the declaration is explicitly marked @actorIndependent, report it as
   // independent.
   if (independentAttr) {
-    return ActorIsolation::forIndependent(independentAttr->getKind());
+    return ActorIsolation::forIndependent();
   }
 
   // If the declaration is marked with a global actor, report it as being
@@ -2438,7 +2430,6 @@ static Optional<ActorIsolation> getIsolationFromWitnessedRequirements(
       case ActorIsolation::GlobalActor:
       case ActorIsolation::GlobalActorUnsafe:
       case ActorIsolation::Independent:
-      case ActorIsolation::IndependentUnsafe:
         break;
       }
 
@@ -2463,7 +2454,6 @@ static Optional<ActorIsolation> getIsolationFromWitnessedRequirements(
         llvm_unreachable("protocol requirements cannot be actor instances");
 
       case ActorIsolation::Independent:
-      case ActorIsolation::IndependentUnsafe:
         // We only need one @actorIndependent.
         if (sawActorIndependent)
           return true;
@@ -2525,8 +2515,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
   // A @Sendable function is assumed to be actor-independent.
   if (auto func = dyn_cast<AbstractFunctionDecl>(value)) {
     if (func->isSendable()) {
-      defaultIsolation = ActorIsolation::forIndependent(
-          ActorIndependentKind::Safe);
+      defaultIsolation = ActorIsolation::forIndependent();
     }
   }
 
@@ -2545,8 +2534,6 @@ ActorIsolation ActorIsolationRequest::evaluate(
     // inferred, so that (e.g.) it will be printed and serialized.
     ASTContext &ctx = value->getASTContext();
     switch (inferred) {
-    // FIXME: if the context is 'unsafe', is it fine to infer the 'safe' one?
-    case ActorIsolation::IndependentUnsafe:
     case ActorIsolation::Independent:
       value->getAttrs().add(new (ctx) ActorIndependentAttr(
                               ActorIndependentKind::Safe, /*IsImplicit=*/true));
@@ -2719,12 +2706,6 @@ void swift::checkOverrideActorIsolation(ValueDecl *value) {
   if (isolation == overriddenIsolation)
     return;
 
-  // If the overridden declaration is @actorIndependent(unsafe) and the
-  // overriding declaration has been placed in a global actor, allow it.
-  if (overriddenIsolation.getKind() == ActorIsolation::IndependentUnsafe &&
-      isolation.isGlobalActor())
-    return;
-
   // If the overridden declaration is from Objective-C with no actor annotation,
   // and the overriding declaration has been placed in a global actor, allow it.
   if (overridden->hasClangNode() && !overriddenIsolation &&
@@ -2736,7 +2717,6 @@ void swift::checkOverrideActorIsolation(ValueDecl *value) {
   if (overriddenIsolation == ActorIsolation::GlobalActorUnsafe) {
     switch (isolation) {
     case ActorIsolation::Independent:
-    case ActorIsolation::IndependentUnsafe:
     case ActorIsolation::Unspecified:
       return;
 
@@ -2765,7 +2745,6 @@ void swift::checkOverrideActorIsolation(ValueDecl *value) {
 
     case ActorIsolation::ActorInstance:
     case ActorIsolation::Independent:
-    case ActorIsolation::IndependentUnsafe:
       // Diagnose below.
       break;
 

lib/Sema/TypeCheckPropertyWrapper.cpp

@@ -93,7 +93,6 @@ static VarDecl *findValueProperty(ASTContext &ctx, NominalTypeDecl *nominal,
   case ActorIsolation::GlobalActor:
   case ActorIsolation::GlobalActorUnsafe:
   case ActorIsolation::Independent:
-  case ActorIsolation::IndependentUnsafe:
   case ActorIsolation::Unspecified:
     break;
   }

lib/Sema/TypeCheckProtocol.cpp

@@ -2807,10 +2807,6 @@ bool ConformanceChecker::checkActorIsolation(
     break;
   }
 
-  case ActorIsolation::IndependentUnsafe:
-    // The requirement is explicitly unsafe; allow it.
-    return false;
-
   case ActorIsolation::Independent:
   case ActorIsolation::Unspecified:
     break;