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

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

@@ -499,7 +499,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

@@ -187,6 +187,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
 
@@ -2434,6 +2438,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

@@ -6128,7 +6128,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

@@ -1456,8 +1456,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);
     }
@@ -2735,6 +2737,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

@@ -1401,6 +1401,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);
 
@@ -1721,6 +1729,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

@@ -2460,6 +2460,7 @@ static bool deferMatchesEnclosingAccess(const FuncDecl *defer) {
 
         switch (getActorIsolation(type)) {
           case ActorIsolation::Unspecified:
+          case ActorIsolation::NonisolatedUnsafe:
           case ActorIsolation::GlobalActorUnsafe:
             break;
 
@@ -7893,6 +7894,15 @@ VarDecl *VarDecl::getLazyStorageProperty() const {
       {});
 }
 
+bool VarDecl::isGlobalStorage() const {
+  if (!hasStorage()) {
+    return false;
+  }
+  const auto *dc = getDeclContext();
+  return isStatic() || dc->isModuleScopeContext() ||
+         (dc->isTypeContext() && !isInstanceMember());
+}
+
 bool VarDecl::isPropertyMemberwiseInitializedWithWrappedType() const {
   auto customAttrs = getAttachedPropertyWrappers();
   if (customAttrs.empty())
@@ -10500,6 +10510,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;

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

@@ -1741,7 +1741,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

@@ -7844,7 +7844,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;
       }

lib/ClangImporter/SwiftDeclSynthesizer.cpp

@@ -422,7 +422,8 @@ ValueDecl *SwiftDeclSynthesizer::createConstant(
 
   // Mark the function transparent so that we inline it away completely.
   func->getAttrs().add(new (C) TransparentAttr(/*implicit*/ true));
-  auto nonisolatedAttr = new (C) NonisolatedAttr(/*IsImplicit=*/true);
+  auto nonisolatedAttr =
+      new (C) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true);
   var->getAttrs().add(nonisolatedAttr);
 
   // Set the function up as the getter.

lib/IDE/CompletionLookup.cpp

@@ -789,6 +789,7 @@ void CompletionLookup::analyzeActorIsolation(
   }
   case ActorIsolation::Unspecified:
   case ActorIsolation::Nonisolated:
+  case ActorIsolation::NonisolatedUnsafe:
     return;
   }
 

lib/Parse/ParseDecl.cpp

@@ -3839,6 +3839,20 @@ ParserStatus Parser::parseNewDeclAttribute(DeclAttributes &Attributes,
       return makeParserSuccess();
     break;
   }
+  case DAK_Nonisolated: {
+    auto isUnsafe =
+        parseSingleAttrOption<bool>(*this, Loc, AttrRange, AttrName, DK,
+                                    {{Context.Id_unsafe, true}}, false);
+    if (!isUnsafe) {
+      return makeParserSuccess();
+    }
+
+    if (!DiscardAttribute) {
+      Attributes.add(new (Context) NonisolatedAttr(AtLoc, AttrRange, *isUnsafe,
+                                                   /*implicit*/ false));
+    }
+    break;
+  }
   case DAK_MacroRole: {
     auto syntax = (AttrName == "freestanding" ? MacroSyntax::Freestanding
                                               : MacroSyntax::Attached);

lib/SILGen/SILGenApply.cpp

@@ -5521,6 +5521,7 @@ RValue SILGenFunction::emitApply(
 
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
+    case ActorIsolation::NonisolatedUnsafe:
       llvm_unreachable("Not isolated");
       break;
     }

lib/SILGen/SILGenConstructor.cpp

@@ -610,6 +610,7 @@ static bool ctorHopsInjectedByDefiniteInit(ConstructorDecl *ctor,
 
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
+    case ActorIsolation::NonisolatedUnsafe:
     case ActorIsolation::GlobalActor:
     case ActorIsolation::GlobalActorUnsafe:
       return false;
@@ -1554,6 +1555,7 @@ void SILGenFunction::emitMemberInitializer(DeclContext *dc, VarDecl *selfDecl,
     // 'nonisolated' expressions can be evaluated from anywhere
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
+    case ActorIsolation::NonisolatedUnsafe:
       break;
 
     case ActorIsolation::GlobalActor:

lib/SILGen/SILGenProlog.cpp

@@ -1281,6 +1281,7 @@ void SILGenFunction::emitProlog(
           return false;
 
         case ActorIsolation::Nonisolated:
+        case ActorIsolation::NonisolatedUnsafe:
         case ActorIsolation::Unspecified:
           return false;
         }
@@ -1332,6 +1333,7 @@ void SILGenFunction::emitProlog(
     switch (actorIsolation.getKind()) {
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
+    case ActorIsolation::NonisolatedUnsafe:
       break;
 
     case ActorIsolation::ActorInstance: {
@@ -1384,6 +1386,7 @@ void SILGenFunction::emitProlog(
     switch (actorIsolation.getKind()) {
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated:
+    case ActorIsolation::NonisolatedUnsafe:
       break;
 
     case ActorIsolation::ActorInstance: {
@@ -1572,6 +1575,7 @@ SILGenFunction::emitExecutor(SILLocation loc, ActorIsolation isolation,
   switch (isolation.getKind()) {
   case ActorIsolation::Unspecified:
   case ActorIsolation::Nonisolated:
+  case ActorIsolation::NonisolatedUnsafe:
     return llvm::None;
 
   case ActorIsolation::ActorInstance: {
@@ -1597,8 +1601,9 @@ void SILGenFunction::emitHopToActorValue(SILLocation loc, ManagedValue actor) {
       getActorIsolationOfContext(FunctionDC, [](AbstractClosureExpr *CE) {
         return CE->getActorIsolation();
       });
-  if (isolation != ActorIsolation::Nonisolated
-      && isolation != ActorIsolation::Unspecified) {
+  if (isolation != ActorIsolation::Nonisolated &&
+      isolation != ActorIsolation::NonisolatedUnsafe &&
+      isolation != ActorIsolation::Unspecified) {
     // TODO: Explicit hop with no hop-back should only be allowed in nonisolated
     // async functions. But it needs work for any closure passed to
     // Task.detached, which currently has unspecified isolation.

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -1046,6 +1046,7 @@ void LifetimeChecker::injectActorHops() {
 
   case ActorIsolation::Unspecified:
   case ActorIsolation::Nonisolated:
+  case ActorIsolation::NonisolatedUnsafe:
   case ActorIsolation::GlobalActorUnsafe:
   case ActorIsolation::GlobalActor:
     return;

lib/Sema/CodeSynthesis.cpp

@@ -1634,7 +1634,8 @@ bool swift::addNonIsolatedToSynthesized(NominalTypeDecl *nominal,
     return false;
 
   ASTContext &ctx = nominal->getASTContext();
-  value->getAttrs().add(new (ctx) NonisolatedAttr(/*isImplicit=*/true));
+  value->getAttrs().add(
+      new (ctx) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
   return true;
 }
 

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -108,7 +108,7 @@ static VarDecl *addImplicitDistributedActorIDProperty(
 
   // mark as nonisolated, allowing access to it from everywhere
   propDecl->getAttrs().add(
-      new (C) NonisolatedAttr(/*IsImplicit=*/true));
+      new (C) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
   // mark as @_compilerInitialized, since we synthesize the initializing
   // assignment during SILGen.
   propDecl->getAttrs().add(
@@ -158,7 +158,7 @@ static VarDecl *addImplicitDistributedActorActorSystemProperty(
 
   // mark as nonisolated, allowing access to it from everywhere
   propDecl->getAttrs().add(
-      new (C) NonisolatedAttr(/*IsImplicit=*/true));
+      new (C) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
 
   auto idProperty = nominal->getDistributedActorIDProperty();
   // If the id was not yet synthesized, we need to ensure that eventually
@@ -735,7 +735,8 @@ static FuncDecl *createDistributedThunkFunction(FuncDecl *func) {
 
   thunk->setSynthesized(true);
   thunk->setDistributedThunk(true);
-  thunk->getAttrs().add(new (C) NonisolatedAttr(/*isImplicit=*/true));
+  thunk->getAttrs().add(
+      new (C) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
 
   if (isa<ClassDecl>(DC))
     thunk->getAttrs().add(new (C) FinalAttr(/*isImplicit=*/true));

lib/Sema/DerivedConformanceActor.cpp

@@ -147,7 +147,8 @@ static ValueDecl *deriveActor_unownedExecutor(DerivedConformance &derived) {
   property->getAttrs().add(new (ctx) SemanticsAttr(SEMANTICS_DEFAULT_ACTOR,
                                                    SourceLoc(), SourceRange(),
                                                    /*implicit*/ true));
-  property->getAttrs().add(new (ctx) NonisolatedAttr(/*IsImplicit=*/true));
+  property->getAttrs().add(
+      new (ctx) NonisolatedAttr(/*unsafe=*/false, /*implicit=*/true));
 
   // Make the property implicitly final.
   property->getAttrs().add(new (ctx) FinalAttr(/*IsImplicit=*/true));