Support actor isolation for property wrappers

Property wrappers can provide global actor isolation based on the
property wrapper type itself (which affects the backing property),
`wrappedValue` (which affects the wrapped property), and
`projectedValue` (which affects the $ property). This allows us to
express, e.g., property wrappers that require accesses to occur on a
particular global actor.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4406,6 +4406,11 @@ ERROR(actorindependent_local_var,none,
       "'@actorIndependent' can not be applied to local variables",
       ())
 
+ERROR(actor_instance_property_wrapper,none,
+      "%0 property in property wrapper type %1 cannot be isolated to "
+      "the actor instance; consider @actorIndependent",
+      (Identifier, Identifier))
+
 ERROR(concurrency_lib_missing,none,
       "missing '%0' declaration, probably because the '_Concurrency' "
       "module was not imported", (StringRef))

lib/Sema/TypeCheckConcurrency.cpp

@@ -2344,7 +2344,8 @@ ActorIsolation ActorIsolationRequest::evaluate(
   }
 
   // Function used when returning an inferred isolation.
-  auto inferredIsolation = [&](ActorIsolation inferred) {
+  auto inferredIsolation = [&](
+      ActorIsolation inferred, bool propagateUnsafe = false) {
     // Add an implicit attribute to capture the actor isolation that was
     // inferred, so that (e.g.) it will be printed and serialized.
     ASTContext &ctx = value->getASTContext();
@@ -2357,13 +2358,19 @@ ActorIsolation ActorIsolationRequest::evaluate(
       break;
 
     case ActorIsolation::GlobalActorUnsafe:
-      // Don't infer unsafe global actor isolation.
-      return ActorIsolation::forUnspecified();
+      if (!propagateUnsafe) {
+        // Don't infer unsafe global actor isolation.
+        return ActorIsolation::forUnspecified();
+      }
+
+      LLVM_FALLTHROUGH;
 
     case ActorIsolation::GlobalActor: {
       auto typeExpr = TypeExpr::createImplicit(inferred.getGlobalActor(), ctx);
       auto attr = CustomAttr::create(
           ctx, SourceLoc(), typeExpr, /*implicit=*/true);
+      if (inferred == ActorIsolation::GlobalActorUnsafe)
+        attr->setArgIsUnsafe(true);
       value->getAttrs().add(attr);
       break;
     }
@@ -2401,6 +2408,46 @@ ActorIsolation ActorIsolationRequest::evaluate(
   }
 
   if (shouldInferAttributeInContext(value->getDeclContext())) {
+    if (auto var = dyn_cast<VarDecl>(value)) {
+      // If this is a variable with a property wrapper, infer from the property
+      // wrapper's wrappedValue.
+      if (auto wrapperInfo = var->getAttachedPropertyWrapperTypeInfo(0)) {
+        if (auto wrappedValue = wrapperInfo.valueVar) {
+          if (auto isolation = getActorIsolation(wrappedValue))
+            return inferredIsolation(isolation, /*propagateUnsafe=*/true);
+        }
+      }
+
+      // If this is the backing storage for a property wrapper, infer from the
+      // type of the outermost property wrapper.
+      if (auto originalVar = var->getOriginalWrappedProperty(
+              PropertyWrapperSynthesizedPropertyKind::Backing)) {
+        if (auto backingType =
+                originalVar->getPropertyWrapperBackingPropertyType()) {
+          if (auto backingNominal = backingType->getAnyNominal()) {
+            if (!isa<ClassDecl>(backingNominal) ||
+                !cast<ClassDecl>(backingNominal)->isActor()) {
+              if (auto isolation = getActorIsolation(backingNominal))
+                return inferredIsolation(isolation, /*propagateUnsafe=*/true);
+            }
+          }
+        }
+      }
+
+      // If this is the projected property for a property wrapper, infer from
+      // the property wrapper's projectedValue.
+      if (auto originalVar = var->getOriginalWrappedProperty(
+              PropertyWrapperSynthesizedPropertyKind::Projection)) {
+        if (auto wrapperInfo =
+                originalVar->getAttachedPropertyWrapperTypeInfo(0)) {
+          if (auto projectedValue = wrapperInfo.projectedValueVar) {
+            if (auto isolation = getActorIsolation(projectedValue))
+              return inferredIsolation(isolation, /*propagateUnsafe=*/true);
+          }
+        }
+      }
+    }
+
     // If the declaration witnesses a protocol requirement that is isolated,
     // use that.
     if (auto witnessedIsolation = getIsolationFromWitnessedRequirements(value)) {

lib/Sema/TypeCheckPropertyWrapper.cpp

@@ -82,6 +82,22 @@ static VarDecl *findValueProperty(ASTContext &ctx, NominalTypeDecl *nominal,
     return nullptr;
   }
 
+  // The property must not be isolated to an actor instance.
+  switch (auto isolation = getActorIsolation(var)) {
+  case ActorIsolation::ActorInstance:
+    var->diagnose(
+        diag::actor_instance_property_wrapper, var->getName(),
+        nominal->getName());
+    return nullptr;
+
+  case ActorIsolation::GlobalActor:
+  case ActorIsolation::GlobalActorUnsafe:
+  case ActorIsolation::Independent:
+  case ActorIsolation::IndependentUnsafe:
+  case ActorIsolation::Unspecified:
+    break;
+  }
+
   return var;
 }
 

test/Concurrency/global_actor_inference.swift

@@ -234,6 +234,107 @@ func barSync() {
   foo() // expected-error {{global function 'foo()' isolated to global actor 'SomeGlobalActor' can not be referenced from this context}}
 }
 
+// ----------------------------------------------------------------------
+// Property wrappers
+// ----------------------------------------------------------------------
+
+@propertyWrapper
+@OtherGlobalActor
+struct WrapperOnActor<Wrapped> {
+  @actorIndependent(unsafe) private var stored: Wrapped
+
+  init(wrappedValue: Wrapped) {
+    stored = wrappedValue
+  }
+
+  @MainActor var wrappedValue: Wrapped {
+    get { stored }
+    set { stored = newValue }
+  }
+
+  @SomeGlobalActor var projectedValue: Wrapped {
+    get { stored }
+    set { stored = newValue }
+  }
+}
+
+@propertyWrapper
+actor WrapperActor<Wrapped> {
+  @actorIndependent(unsafe) var storage: Wrapped
+
+  init(wrappedValue: Wrapped) {
+    storage = wrappedValue
+  }
+
+  @actorIndependent var wrappedValue: Wrapped {
+    get { storage }
+    set { storage = newValue }
+  }
+
+  @actorIndependent var projectedValue: Wrapped {
+    get { storage }
+    set { storage = newValue }
+  }
+}
+
+struct HasWrapperOnActor {
+  @WrapperOnActor var synced: Int = 0
+  // expected-note@-1 3{{mutable state is only available within the actor instance}}
+
+  // expected-note@+1 3{{to make instance method 'testErrors()'}}
+  func testErrors() {
+    _ = synced // expected-error{{property 'synced' isolated to global actor 'MainActor' can not be referenced from this context}}
+    _ = $synced // expected-error{{property '$synced' isolated to global actor 'SomeGlobalActor' can not be referenced from this context}}
+    _ = _synced // expected-error{{property '_synced' isolated to global actor 'OtherGlobalActor' can not be referenced from this context}}
+  }
+
+  @MainActor mutating func testOnMain() {
+    _ = synced
+    synced = 17
+  }
+
+  @WrapperActor var actorSynced: Int = 0
+
+  func testActorSynced() {
+    _ = actorSynced
+    _ = $actorSynced
+    _ = _actorSynced
+  }
+}
+
+
+@propertyWrapper
+actor WrapperActorBad1<Wrapped> {
+  var storage: Wrapped
+
+  init(wrappedValue: Wrapped) {
+    storage = wrappedValue
+  }
+
+  var wrappedValue: Wrapped { // expected-error{{'wrappedValue' property in property wrapper type 'WrapperActorBad1' cannot be isolated to the actor instance; consider @actorIndependent}}}}
+    get { storage }
+    set { storage = newValue }
+  }
+}
+
+@propertyWrapper
+actor WrapperActorBad2<Wrapped> {
+  @actorIndependent(unsafe) var storage: Wrapped
+
+  init(wrappedValue: Wrapped) {
+    storage = wrappedValue
+  }
+
+  @actorIndependent var wrappedValue: Wrapped {
+    get { storage }
+    set { storage = newValue }
+  }
+
+  var projectedValue: Wrapped { // expected-error{{'projectedValue' property in property wrapper type 'WrapperActorBad2' cannot be isolated to the actor instance; consider @actorIndependent}}
+    get { storage }
+    set { storage = newValue }
+  }
+}
 
 // ----------------------------------------------------------------------
 // Unsafe global actors
@@ -266,3 +367,45 @@ class UGASubclass1: UGAClass {
 class UGASubclass2: UGAClass {
   override func method() { }
 }
+
+@propertyWrapper
+@OtherGlobalActor(unsafe)
+struct WrapperOnUnsafeActor<Wrapped> {
+  @actorIndependent(unsafe) private var stored: Wrapped
+
+  init(wrappedValue: Wrapped) {
+    stored = wrappedValue
+  }
+
+  @MainActor(unsafe) var wrappedValue: Wrapped {
+    get { stored }
+    set { stored = newValue }
+  }
+
+  @SomeGlobalActor(unsafe) var projectedValue: Wrapped {
+    get { stored }
+    set { stored = newValue }
+  }
+}
+
+struct HasWrapperOnUnsafeActor {
+  @WrapperOnUnsafeActor var synced: Int = 0
+  // expected-note@-1 3{{mutable state is only available within the actor instance}}
+
+  func testUnsafeOkay() {
+    _ = synced
+    _ = $synced
+    _ = _synced
+  }
+
+  @actorIndependent func testErrors() {
+    _ = synced // expected-error{{property 'synced' isolated to global actor 'MainActor' can not be referenced from}}
+    _ = $synced // expected-error{{property '$synced' isolated to global actor 'SomeGlobalActor' can not be referenced from}}
+    _ = _synced // expected-error{{property '_synced' isolated to global actor 'OtherGlobalActor' can not be referenced from}}
+  }
+
+  @MainActor mutating func testOnMain() {
+    _ = synced
+    synced = 17
+  }
+}