nonisolated(unsafe) to opt out of strict concurrency static checking for global variables

Author: sophiapoirier

include/swift/AST/ActorIsolation.h

@@ -60,6 +60,9 @@ 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.
     Nonisolated,
+    /// The declaration is explicitly specified to be not isolated and with the
+    /// "unsafe" annotation, which means that we do not enforce isolation.
+    NonisolatedUnsafe,
     /// The declaration is isolated to a global actor. It can refer to other
     /// entities with the same global actor.
     GlobalActor,
@@ -97,8 +100,8 @@ class ActorIsolation {
     return ActorIsolation(Unspecified, nullptr);
   }
 
-  static ActorIsolation forNonisolated() {
-    return ActorIsolation(Nonisolated, nullptr);
+  static ActorIsolation forNonisolated(bool unsafe) {
+    return ActorIsolation(unsafe ? NonisolatedUnsafe : Nonisolated, nullptr);
   }
 
   static ActorIsolation forActorInstanceSelf(NominalTypeDecl *actor) {
@@ -124,8 +127,10 @@ class ActorIsolation {
   operator Kind() const { return getKind(); }
 
   bool isUnspecified() const { return kind == Unspecified; }
-  
-  bool isNonisolated() const { return kind == Nonisolated; }
+
+  bool isNonisolated() const {
+    return (kind == Nonisolated) || (kind == NonisolatedUnsafe);
+  }
 
   /// Retrieve the parameter to which actor-instance isolation applies.
   ///
@@ -144,6 +149,7 @@ class ActorIsolation {
 
     case Unspecified:
     case Nonisolated:
+    case NonisolatedUnsafe:
       return false;
     }
   }
@@ -192,6 +198,7 @@ class ActorIsolation {
 
     switch (lhs.getKind()) {
     case Nonisolated:
+    case NonisolatedUnsafe:
     case Unspecified:
       return true;
 

include/swift/AST/Attr.def

@@ -498,7 +498,7 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(async, Async,
 SIMPLE_DECL_ATTR(reasync, Reasync,
   OnFunc | OnConstructor | RejectByParser | ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   109)
-CONTEXTUAL_SIMPLE_DECL_ATTR(nonisolated, Nonisolated,
+CONTEXTUAL_DECL_ATTR(nonisolated, Nonisolated,
   DeclModifier | OnFunc | OnConstructor | OnVar | OnSubscript | ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
   112)
 CONTEXTUAL_SIMPLE_DECL_ATTR(distributed, DistributedActor,

include/swift/AST/Attr.h

@@ -183,6 +183,10 @@ class DeclAttribute : public AttributeBase {
     SWIFT_INLINE_BITFIELD(ObjCImplementationAttr, DeclAttribute, 1,
       isCategoryNameInvalid : 1
     );
+
+    SWIFT_INLINE_BITFIELD(NonisolatedAttr, DeclAttribute, 1,
+      isUnsafe : 1
+    );
   } Bits;
   // clang-format on
 
@@ -2404,6 +2408,26 @@ class ObjCImplementationAttr final : public DeclAttribute {
   }
 };
 
+/// Represents nonisolated modifier.
+class NonisolatedAttr final : public DeclAttribute {
+public:
+  NonisolatedAttr(SourceLoc atLoc, SourceRange range, bool unsafe,
+                  bool implicit)
+      : DeclAttribute(DAK_Nonisolated, atLoc, range, implicit) {
+    Bits.NonisolatedAttr.isUnsafe = unsafe;
+    assert((isUnsafe() == unsafe) && "not enough bits for unsafe state");
+  }
+
+  NonisolatedAttr(bool unsafe, bool implicit)
+      : NonisolatedAttr({}, {}, unsafe, implicit) {}
+
+  bool isUnsafe() const { return Bits.NonisolatedAttr.isUnsafe; }
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_Nonisolated;
+  }
+};
+
 /// A macro role attribute, spelled with either @attached or @freestanding,
 /// which declares one of the roles that a given macro can inhabit.
 class MacroRoleAttr final

include/swift/AST/Decl.h

@@ -6109,7 +6109,10 @@ class VarDecl : public AbstractStorageDecl {
   /// True if this is a top-level global variable from the main source file.
   bool isTopLevelGlobal() const { return Bits.VarDecl.IsTopLevelGlobal; }
   void setTopLevelGlobal(bool b) { Bits.VarDecl.IsTopLevelGlobal = b; }
-  
+
+  /// True if this is any storage of static duration (global scope or static).
+  bool isGlobalStorage() const;
+
   /// Retrieve the custom attributes that attach property wrappers to this
   /// property. The returned list contains all of the attached property wrapper
   /// attributes in source order, which means the outermost wrapper attribute

lib/AST/ASTDumper.cpp

@@ -1429,8 +1429,10 @@ namespace {
         });
       }
 
-      printFlag(D->getAttrs().hasAttribute<NonisolatedAttr>(), "nonisolated",
-                ExprModifierColor);
+      if (auto *attr = D->getAttrs().getAttribute<NonisolatedAttr>()) {
+        printFlag(attr->isUnsafe() ? "nonisolated(unsafe)" : "nonisolated",
+                  ExprModifierColor);
+      }
       printFlag(D->isDistributed(), "distributed", ExprModifierColor);
       printFlag(D->isDistributedThunk(), "distributed_thunk",ExprModifierColor);
     }
@@ -2702,6 +2704,7 @@ class PrintExpr : public ExprVisitor<PrintExpr, void, StringRef>,
     switch (auto isolation = E->getActorIsolation()) {
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
+    case ActorIsolation::NonisolatedUnsafe:
       break;
 
     case ActorIsolation::ActorInstance:

lib/AST/Attr.cpp

@@ -1387,6 +1387,14 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     break;
   }
 
+  case DAK_Nonisolated: {
+    Printer.printAttrName("nonisolated");
+    if (cast<NonisolatedAttr>(this)->isUnsafe()) {
+      Printer << "(unsafe)";
+    }
+    break;
+  }
+
   case DAK_MacroRole: {
     auto Attr = cast<MacroRoleAttr>(this);
 
@@ -1707,6 +1715,12 @@ StringRef DeclAttribute::getAttrName() const {
     return "_section";
   case DAK_Documentation:
     return "_documentation";
+  case DAK_Nonisolated:
+    if (cast<NonisolatedAttr>(this)->isUnsafe()) {
+        return "nonisolated(unsafe)";
+    } else {
+        return "nonisolated";
+    }
   case DAK_MacroRole:
     switch (cast<MacroRoleAttr>(this)->getMacroSyntax()) {
     case MacroSyntax::Freestanding:

lib/AST/Decl.cpp

@@ -2402,6 +2402,7 @@ static bool deferMatchesEnclosingAccess(const FuncDecl *defer) {
 
         switch (getActorIsolation(type)) {
           case ActorIsolation::Unspecified:
+          case ActorIsolation::NonisolatedUnsafe:
           case ActorIsolation::GlobalActorUnsafe:
             break;
 
@@ -7832,6 +7833,14 @@ VarDecl *VarDecl::getLazyStorageProperty() const {
       {});
 }
 
+bool VarDecl::isGlobalStorage() const {
+  if (!hasStorage()) {
+    return false;
+  }
+  return isStatic() || getDeclContext()->isModuleScopeContext() ||
+         (getDeclContext()->isTypeContext() && !isInstanceMember());
+}
+
 bool VarDecl::isPropertyMemberwiseInitializedWithWrappedType() const {
   auto customAttrs = getAttachedPropertyWrappers();
   if (customAttrs.empty())
@@ -10439,6 +10448,7 @@ bool VarDecl::isSelfParamCaptureIsolated() const {
       switch (auto isolation = closure->getActorIsolation()) {
       case ActorIsolation::Unspecified:
       case ActorIsolation::Nonisolated:
+      case ActorIsolation::NonisolatedUnsafe:
       case ActorIsolation::GlobalActor:
       case ActorIsolation::GlobalActorUnsafe:
         return false;
@@ -10492,7 +10502,7 @@ ActorIsolation swift::getActorIsolationOfContext(
     if (ctx.LangOpts.hasFeature(Feature::IsolatedDefaultValues) &&
         var->isInstanceMember() &&
         !var->getAttrs().hasAttribute<LazyAttr>()) {
-      return ActorIsolation::forNonisolated();
+      return ActorIsolation::forNonisolated(/*unsafe*/ false);
     }
 
     return getActorIsolation(var);

lib/AST/DiagnosticEngine.cpp

@@ -921,8 +921,12 @@ static void formatDiagnosticArgument(StringRef Modifier,
     }
 
     case ActorIsolation::Nonisolated:
+    case ActorIsolation::NonisolatedUnsafe:
     case ActorIsolation::Unspecified:
       Out << "nonisolated";
+      if (isolation == ActorIsolation::NonisolatedUnsafe) {
+        Out << "(unsafe)";
+      }
       break;
     }
     break;

lib/AST/TypeCheckRequests.cpp

@@ -1739,7 +1739,11 @@ void swift::simple_display(
       break;
 
     case ActorIsolation::Nonisolated:
+    case ActorIsolation::NonisolatedUnsafe:
       out << "nonisolated";
+      if (state == ActorIsolation::NonisolatedUnsafe) {
+        out << "(unsafe)";
+      }
       break;
 
     case ActorIsolation::Unspecified:

lib/ClangImporter/ImportDecl.cpp

@@ -7838,7 +7838,8 @@ ClangImporter::Implementation::importSwiftAttrAttributes(Decl *MappedDecl) {
       // Hard-code @actorIndependent, until Objective-C clients start
       // using nonisolated.
       if (swiftAttr->getAttribute() == "@actorIndependent") {
-        auto attr = new (SwiftContext) NonisolatedAttr(/*isImplicit=*/true);
+        auto attr = new (SwiftContext)
+            NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true);
         MappedDecl->getAttrs().add(attr);
         continue;
       }