[Sema] nonisolated(unsafe) for local variables

lib/AST/TypeCheckRequests.cpp

@@ -1699,6 +1699,7 @@ bool ActorIsolation::requiresSubstitution() const {
   switch (kind) {
   case ActorInstance:
   case Nonisolated:
+  case NonisolatedUnsafe:
   case Unspecified:
     return false;
 
@@ -1713,6 +1714,7 @@ ActorIsolation ActorIsolation::subst(SubstitutionMap subs) const {
   switch (kind) {
   case ActorInstance:
   case Nonisolated:
+  case NonisolatedUnsafe:
   case Unspecified:
     return *this;
 

lib/Sema/TypeCheckAttr.cpp

@@ -6816,12 +6816,14 @@ void AttributeChecker::visitNonisolatedAttr(NonisolatedAttr *attr) {
   auto dc = D->getDeclContext();
 
   if (auto var = dyn_cast<VarDecl>(D)) {
+    const bool isUnsafe =
+        attr->isUnsafe() && Ctx.LangOpts.hasFeature(Feature::GlobalConcurrency);
+
     // stored properties have limitations as to when they can be nonisolated.
     if (var->hasStorage()) {
-      const bool isUnsafeGlobal = attr->isUnsafe() && var->isGlobalStorage();
-
-      // 'nonisolated' can not be applied to mutable stored properties.
-      if (var->supportsMutation() && !isUnsafeGlobal) {
+      // 'nonisolated' can not be applied to mutable stored properties unless
+      // qualified as 'unsafe'.
+      if (var->supportsMutation() && !isUnsafe) {
         diagnoseAndRemoveAttr(attr, diag::nonisolated_mutable_storage);
         return;
       }
@@ -6863,8 +6865,9 @@ void AttributeChecker::visitNonisolatedAttr(NonisolatedAttr *attr) {
       return;
     }
 
-    // nonisolated can not be applied to local properties.
-    if (dc->isLocalContext()) {
+    // nonisolated can not be applied to local properties unless qualified as
+    // 'unsafe'.
+    if (dc->isLocalContext() && !isUnsafe) {
       diagnoseAndRemoveAttr(attr, diag::nonisolated_local_var);
       return;
     }

lib/Sema/TypeCheckConcurrency.cpp

@@ -2813,6 +2813,12 @@ namespace {
       if (getActorIsolation(value).isActorIsolated())
         return false;
 
+      if (auto attr = value->getAttrs().getAttribute<NonisolatedAttr>();
+          ctx.LangOpts.hasFeature(Feature::GlobalConcurrency) && attr &&
+          attr->isUnsafe()) {
+        return false;
+      }
+
       ctx.Diags.diagnose(loc, diag::shared_mutable_state_access, value);
       value->diagnose(diag::kind_declared_here, value->getDescriptiveKind());
       return true;
@@ -3279,6 +3285,12 @@ namespace {
           }
         }
 
+        if (auto attr = var->getAttrs().getAttribute<NonisolatedAttr>();
+            ctx.LangOpts.hasFeature(Feature::GlobalConcurrency) && attr &&
+            attr->isUnsafe()) {
+          return false;
+        }
+
         // Otherwise, we have concurrent access. Complain.
         bool preconcurrencyContext =
             getActorIsolationOfContext(

test/Concurrency/experimental_feature_strictconcurrency.swift

@@ -75,3 +75,12 @@ func f() {
   print(TestStatics.immutableInferredSendable)
   print(TestStatics.mutable) // expected-warning{{reference to static property 'mutable' is not concurrency-safe because it involves shared mutable state}}
 }
+
+func testLocalNonisolatedUnsafe() async {
+  nonisolated(unsafe) var value = 1
+  let task = Task {
+    value = 2
+    return value
+  }
+  print(await task.value)
+}