[Concurrency] Allow nonisolated to be used on protocols, extensions, classes, structs, and enums.

Author: simanerush

include/swift/AST/DeclAttr.def

@@ -441,7 +441,7 @@ SIMPLE_DECL_ATTR(reasync, Reasync,
   OnFunc | OnConstructor | RejectByParser | ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   109)
 CONTEXTUAL_DECL_ATTR(nonisolated, Nonisolated,
-  DeclModifier | OnFunc | OnConstructor | OnVar | OnSubscript | ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
+  DeclModifier | OnFunc | OnConstructor | OnVar | OnSubscript | OnProtocol | OnExtension | OnClass | OnStruct | OnEnum | ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
   112)
 CONTEXTUAL_SIMPLE_DECL_ATTR(distributed, DistributedActor,
   DeclModifier | OnClass | OnFunc | OnAccessor | OnVar | ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,

lib/Sema/TypeCheckConcurrency.cpp

@@ -5425,11 +5425,12 @@ static void checkDeclWithIsolatedParameter(ValueDecl *value) {
 InferredActorIsolation ActorIsolationRequest::evaluate(
     Evaluator &evaluator, ValueDecl *value) const {
   auto &ctx = value->getASTContext();
+  auto dc = value->getDeclContext();
 
   // If this declaration has actor-isolated "self", it's isolated to that
   // actor.
   if (evaluateOrDefault(evaluator, HasIsolatedSelfRequest{value}, false)) {
-    auto actor = value->getDeclContext()->getSelfNominalTypeDecl();
+    auto actor = dc->getSelfNominalTypeDecl();
     assert(actor && "could not find the actor that 'self' is isolated to");
     return {
       ActorIsolation::forActorInstanceSelf(value),
@@ -5466,6 +5467,14 @@ InferredActorIsolation ActorIsolationRequest::evaluate(
     value->getAttrs().add(preconcurrency);
   }
 
+  // If this declaration is non-isolated, we are done.
+  auto ctxIsolation = getActorIsolationOfContext(dc);
+  if (ctxIsolation.isNonisolated()) {
+    return {
+      ctxIsolation,
+      IsolationSource(dc->getAsDecl(), IsolationSource::LexicalContext)};
+  }
+
   if (FuncDecl *fd = dyn_cast<FuncDecl>(value)) {
     // Main.main() and Main.$main are implicitly MainActor-protected.
     // Any other isolation is an error.
@@ -5511,7 +5520,7 @@ InferredActorIsolation ActorIsolationRequest::evaluate(
   }
 
   // When no other isolation applies, an actor's non-async init is independent
-  if (auto nominal = value->getDeclContext()->getSelfNominalTypeDecl())
+  if (auto nominal = dc->getSelfNominalTypeDecl())
     if (nominal->isAnyActor())
       if (auto ctor = dyn_cast<ConstructorDecl>(value))
         if (!ctor->hasAsync())
@@ -5681,7 +5690,7 @@ InferredActorIsolation ActorIsolationRequest::evaluate(
     }
   }
 
-  if (shouldInferAttributeInContext(value->getDeclContext())) {
+  if (shouldInferAttributeInContext(dc)) {
     // If the declaration witnesses a protocol requirement that is isolated,
     // use that.
     if (auto witnessedIsolation = getIsolationFromWitnessedRequirements(value)) {
@@ -5767,7 +5776,7 @@ InferredActorIsolation ActorIsolationRequest::evaluate(
 
     // If the declaration is in an extension that has one of the isolation
     // attributes, use that.
-    if (auto ext = dyn_cast<ExtensionDecl>(value->getDeclContext())) {
+    if (auto ext = dyn_cast<ExtensionDecl>(dc)) {
       if (auto isolationFromAttr = getIsolationFromAttributes(ext)) {
         return {
           inferredIsolation(*isolationFromAttr, onlyGlobal),
@@ -5778,7 +5787,7 @@ InferredActorIsolation ActorIsolationRequest::evaluate(
 
     // If the declaration is in a nominal type (or extension thereof) that
     // has isolation, use that.
-    if (auto selfTypeDecl = value->getDeclContext()->getSelfNominalTypeDecl()) {
+    if (auto selfTypeDecl = dc->getSelfNominalTypeDecl()) {
       auto selfTypeIsolation = getInferredActorIsolation(selfTypeDecl);
       if (selfTypeIsolation.isolation) {
         return {

test/Concurrency/mutable_storage_nonisolated.swift

@@ -0,0 +1,107 @@
+// RUN: %target-swift-frontend -disable-availability-checking -swift-version 6 -parse-as-library %s -emit-sil -o /dev/null -verify
+// RUN: %target-swift-frontend -disable-availability-checking -swift-version 6 -parse-as-library %s -emit-sil -o /dev/null -verify -strict-concurrency=complete
+
+// REQUIRES: concurrency
+// REQUIRES: asserts
+
+@MainActor
+protocol GloballyIsolated {}
+
+// expected-note@+1 {{class 'NonSendable' does not conform to the 'Sendable' protocol}}
+class NonSendable {}
+
+// MARK: - Structs
+
+@MainActor
+struct ImplicitlySendable {
+  var x: Int
+  nonisolated var y: Int // okay
+}
+
+@MainActor
+struct ImplicitlyNonSendable {
+  let x: NonSendable
+  nonisolated var y: Int // okay
+}
+
+nonisolated struct NonisolatedStruct: GloballyIsolated {
+  var x: NonSendable
+  var y: Int = 1
+
+  init(x: NonSendable) {
+    self.x = x // okay
+  }
+
+  struct Nested: GloballyIsolated {
+    // expected-note@+1 {{mutation of this property is only permitted within the actor}}
+    var z: NonSendable
+    nonisolated init(z: NonSendable) {
+      // expected-error@+1 {{main actor-isolated property 'z' can not be mutated from a nonisolated context}}
+      self.z = z
+    }
+  }
+}
+
+@MainActor struct S {
+  var value: NonSendable // globally-isolated
+  struct Nested {} // 'Nested' is not @MainActor-isolated
+}
+
+// MARK: - Protocols
+
+nonisolated protocol Refined: GloballyIsolated {}
+
+struct A: Refined {
+  var x: NonSendable
+  init(x: NonSendable) {
+    self.x = x // okay
+  }
+}
+
+// MARK: - Extensions
+
+nonisolated extension GloballyIsolated {
+  var x: NonSendable { .init () }
+  func implicitlyNonisolated() {}
+}
+
+struct C: GloballyIsolated {
+  nonisolated func explicitlyNonisolated() {
+    let _ = x // okay
+    implicitlyNonisolated() // okay
+  }
+}
+
+// MARK: - Enums
+
+nonisolated enum E: GloballyIsolated {
+  func implicitlyNonisolated() {}
+  init() {}
+}
+
+struct TestEnum {
+  nonisolated func call() {
+    E().implicitlyNonisolated() // okay
+  }
+}
+
+// MARK: - Classes
+
+nonisolated class K: GloballyIsolated {
+  var x: NonSendable
+  init(x: NonSendable) {
+    self.x = x // okay
+  }
+}
+
+// MARK: - Storage of non-Sendable
+
+class KlassA {
+  nonisolated var test: NonSendable = NonSendable()
+}
+
+// MARK: - Restrictions
+
+@MainActor
+nonisolated struct Conflict {}
+// expected-error@-1 {{struct 'Conflict' has multiple actor-isolation attributes ('nonisolated' and 'MainActor')}}