Revert "[concurrency] Convert ActorIsolation::isConcurrentUnsafe -> isUnsafe."

This reverts commit 95623c6.

Author: gottesmm

include/swift/AST/ActorIsolation.h

@@ -203,10 +203,14 @@ class ActorIsolation {
     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;
   }

lib/SILOptimizer/Utils/SILIsolationInfo.cpp

@@ -96,7 +96,7 @@ class DeclRefExprAnalysis {
       if (auto *mri = dyn_cast<MemberRefExpr>(expr)) {
         if (mri->hasDecl()) {
           auto isolation = swift::getActorIsolation(mri->getDecl().getDecl());
-          if (isolation.isUnsafe())
+          if (isolation.isConcurrentUnsafe())
             return true;
         }
       }
@@ -485,16 +485,16 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
     if (nomDecl->isAnyActor())
       return SILIsolationInfo::getActorInstanceIsolated(rei, rei->getOperand(),
                                                         nomDecl)
-          .withUnsafeNonIsolated(varIsolation.isUnsafe());
+          .withUnsafeNonIsolated(varIsolation.isConcurrentUnsafe());
 
     if (auto isolation = swift::getActorIsolation(nomDecl)) {
       assert(isolation.isGlobalActor());
       return SILIsolationInfo::getGlobalActorIsolated(
                  rei, isolation.getGlobalActor())
-          .withUnsafeNonIsolated(varIsolation.isUnsafe());
+          .withUnsafeNonIsolated(varIsolation.isConcurrentUnsafe());
     }
 
-    return SILIsolationInfo::getDisconnected(varIsolation.isUnsafe());
+    return SILIsolationInfo::getDisconnected(varIsolation.isConcurrentUnsafe());
   }
 
   // Check if we have a global_addr inst.
@@ -507,7 +507,7 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
               ga, isolation.getGlobalActor());
         }
 
-        if (isolation.isUnsafe()) {
+        if (isolation.isConcurrentUnsafe()) {
           return SILIsolationInfo::getDisconnected(
               true /*is nonisolated(unsafe)*/);
         }
@@ -544,7 +544,7 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
       }
 
       // Then check if we have something that is nonisolated unsafe.
-      if (isolation.isUnsafe()) {
+      if (isolation.isConcurrentUnsafe()) {
         // First check if our function_ref is a method of a global actor
         // isolated type. In such a case, we create a global actor isolated
         // nonisolated(unsafe) so that if we assign the value to another
@@ -623,7 +623,7 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
             // Check if we have a global actor and handle it appropriately.
             if (isolation.getKind() == ActorIsolation::GlobalActor) {
               bool localNonIsolatedUnsafe =
-                  isNonIsolatedUnsafe | isolation.isUnsafe();
+                  isNonIsolatedUnsafe | isolation.isConcurrentUnsafe();
               return SILIsolationInfo::getGlobalActorIsolated(
                          cmi, isolation.getGlobalActor())
                   .withUnsafeNonIsolated(localNonIsolatedUnsafe);
@@ -633,7 +633,7 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
             if (isolation.getKind() != ActorIsolation::ActorInstance &&
                 isolation.isActorInstanceForSelfParameter()) {
               bool localNonIsolatedUnsafe =
-                  isNonIsolatedUnsafe | isolation.isUnsafe();
+                  isNonIsolatedUnsafe | isolation.isConcurrentUnsafe();
               return SILIsolationInfo::getActorInstanceIsolated(
                          cmi, cmi->getOperand(),
                          cmi->getOperand()
@@ -650,7 +650,7 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
               // Check if we have a global actor and handle it appropriately.
               if (isolation.getKind() == ActorIsolation::GlobalActor) {
                 bool localNonIsolatedUnsafe =
-                    isNonIsolatedUnsafe | isolation.isUnsafe();
+                    isNonIsolatedUnsafe | isolation.isConcurrentUnsafe();
                 return SILIsolationInfo::getGlobalActorIsolated(
                            cmi, isolation.getGlobalActor())
                     .withUnsafeNonIsolated(localNonIsolatedUnsafe);
@@ -660,7 +660,7 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
               if (isolation.getKind() != ActorIsolation::ActorInstance &&
                   isolation.isActorInstanceForSelfParameter()) {
                 bool localNonIsolatedUnsafe =
-                    isNonIsolatedUnsafe | isolation.isUnsafe();
+                    isNonIsolatedUnsafe | isolation.isConcurrentUnsafe();
                 return SILIsolationInfo::getActorInstanceIsolated(
                            cmi, cmi->getOperand(),
                            cmi->getOperand()
@@ -683,16 +683,16 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
     auto varIsolation = swift::getActorIsolation(sei->getField());
     if (auto isolation =
             SILIsolationInfo::getGlobalActorIsolated(sei, sei->getStructDecl()))
-      return isolation.withUnsafeNonIsolated(varIsolation.isUnsafe());
-    return SILIsolationInfo::getDisconnected(varIsolation.isUnsafe());
+      return isolation.withUnsafeNonIsolated(varIsolation.isConcurrentUnsafe());
+    return SILIsolationInfo::getDisconnected(varIsolation.isConcurrentUnsafe());
   }
 
   if (auto *seai = dyn_cast<StructElementAddrInst>(inst)) {
     auto varIsolation = swift::getActorIsolation(seai->getField());
     if (auto isolation = SILIsolationInfo::getGlobalActorIsolated(
             seai, seai->getStructDecl()))
-      return isolation.withUnsafeNonIsolated(varIsolation.isUnsafe());
-    return SILIsolationInfo::getDisconnected(varIsolation.isUnsafe());
+      return isolation.withUnsafeNonIsolated(varIsolation.isConcurrentUnsafe());
+    return SILIsolationInfo::getDisconnected(varIsolation.isConcurrentUnsafe());
   }
 
   // See if we have an unchecked_enum_data from a global actor isolated type.