In a property-wrapper, global-actor isolation remains on wrappedValue

If a struct is a property-wrapper, then global-actor isolation
still applies to the `wrappedValue`, even if it's a stored property.
This is needed in order to support the propagation of global-actor
isolation through the wrapper, even when the programmer has opted
to use a stored property instead of a computed one for the
`wrappedValue`. Since this propagation is a useful pattern, I think
this exception is reasonable.

Author: kavon

lib/Sema/TypeCheckAttr.cpp

@@ -5630,8 +5630,10 @@ void AttributeChecker::visitNonisolatedAttr(NonisolatedAttr *attr) {
         }
 
         // 'nonisolated' is redundant for the stored properties of a struct.
-        if (isa<StructDecl>(nominal) && !var->isStatic() &&
-            var->isOrdinaryStoredProperty()) {
+        if (isa<StructDecl>(nominal) &&
+            !var->isStatic() &&
+            var->isOrdinaryStoredProperty() &&
+            !isWrappedValueOfPropWrapper(var)) {
           diagnoseAndRemoveAttr(attr, diag::nonisolated_storage_value_type,
                                 nominal->getDescriptiveKind())
             .warnUntilSwiftVersion(6);

lib/Sema/TypeCheckConcurrency.cpp

@@ -359,7 +359,7 @@ GlobalActorAttributeRequest::evaluate(
       // ... and not if it's the instance storage of a struct
       if (!var->isStatic() && var->isOrdinaryStoredProperty()) {
         if (auto *nominal = var->getDeclContext()->getSelfNominalTypeDecl()) {
-          if (isa<StructDecl>(nominal)) {
+          if (isa<StructDecl>(nominal) && !isWrappedValueOfPropWrapper(var)) {
 
             var->diagnose(diag::global_actor_on_storage_of_value_type,
                           var->getName(), nominal->getDescriptiveKind())
@@ -3631,7 +3631,7 @@ ActorIsolation ActorIsolationRequest::evaluate(
         if (!var->isStatic() && var->isOrdinaryStoredProperty())
           if (auto *varDC = var->getDeclContext())
             if (auto *nominal = varDC->getSelfNominalTypeDecl())
-              if (isa<StructDecl>(nominal))
+              if (isa<StructDecl>(nominal) && !isWrappedValueOfPropWrapper(var))
                 return ActorIsolation::forUnspecified();
 
       auto typeExpr = TypeExpr::createImplicit(inferred.getGlobalActor(), ctx);

lib/Sema/TypeCheckPropertyWrapper.cpp

@@ -799,3 +799,14 @@ Expr *swift::buildPropertyWrapperInitCall(
 
   return initializer;
 }
+
+bool swift::isWrappedValueOfPropWrapper(VarDecl *var) {
+  if (!var->isStatic())
+    if (auto *dc = var->getDeclContext())
+      if (auto *nominal = dc->getSelfNominalTypeDecl())
+        if (nominal->getAttrs().hasAttribute<PropertyWrapperAttr>())
+          if (var->getName() == var->getASTContext().Id_wrappedValue)
+            return true;
+
+  return false;
+}

lib/Sema/TypeChecker.h

@@ -1276,6 +1276,10 @@ Expr *buildPropertyWrapperInitCall(
     PropertyWrapperInitKind initKind,
     llvm::function_ref<void(ApplyExpr *)> callback = [](ApplyExpr *) {});
 
+/// Check if this var is the \c wrappedValue property belonging to
+/// a property wrapper type declaration.
+bool isWrappedValueOfPropWrapper(VarDecl *var);
+
 /// Whether an overriding declaration requires the 'override' keyword.
 enum class OverrideRequiresKeyword {
   /// The keyword is never required.

test/Concurrency/global_actor_inference.swift

@@ -299,7 +299,7 @@ struct WrapperOnActor<Wrapped: Sendable> {
     stored = wrappedValue
   }
 
-  @MainActor var wrappedValue: Wrapped {
+  @MainActor var wrappedValue: Wrapped { // expected-note {{property declared here}}
     get { }
     set { }
   }
@@ -314,7 +314,19 @@ struct WrapperOnActor<Wrapped: Sendable> {
 @propertyWrapper
 public struct WrapperOnMainActor<Wrapped> {
   // Make sure inference of @MainActor on wrappedValue doesn't crash.
-  public var wrappedValue: Wrapped
+  
+  public var wrappedValue: Wrapped // expected-note {{property declared here}}
+
+  public var accessCount: Int
+
+  nonisolated public init(wrappedValue: Wrapped) {
+    self.wrappedValue = wrappedValue
+  }
+}
+
+@propertyWrapper
+public struct WrapperOnMainActor2<Wrapped> {
+  @MainActor public var wrappedValue: Wrapped
 
   public init(wrappedValue: Wrapped) {
     self.wrappedValue = wrappedValue
@@ -340,15 +352,36 @@ actor WrapperActor<Wrapped: Sendable> {
   }
 }
 
+struct HasMainActorWrappedProp {
+  @WrapperOnMainActor var thing: Int = 1 // expected-note {{property declared here}}
+
+  var plainStorage: Int
+
+  var computedProp: Int { 0 } // expected-note {{property declared here}}
+
+  nonisolated func testErrors() {
+    _ = thing // expected-error {{property 'thing' isolated to global actor 'MainActor' can not be referenced from a non-isolated synchronous context}}
+    _ = _thing.wrappedValue // expected-error {{property 'wrappedValue' isolated to global actor 'MainActor' can not be referenced from a non-isolated synchronous context}}
+
+    _ = _thing
+    _ = _thing.accessCount
+
+    _ = plainStorage
+
+    _ = computedProp // expected-error {{property 'computedProp' isolated to global actor 'MainActor' can not be referenced from a non-isolated synchronous context}}
+  }
+}
+
 struct HasWrapperOnActor {
   @WrapperOnActor var synced: Int = 0
   // expected-note@-1 2{{property declared here}}
 
-  // expected-note@+1 2{{to make instance method 'testErrors()'}}
+  // 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 synchronous context}}
     _ = $synced // expected-error{{property '$synced' isolated to global actor 'SomeGlobalActor' can not be referenced from this synchronous context}}
     _ = _synced
+    _ = _synced.wrappedValue // expected-error{{property 'wrappedValue' isolated to global actor 'MainActor' can not be referenced from this synchronous context}}
   }
 
   @MainActor mutating func testOnMain() {

validation-test/Sema/SwiftUI/rdar76252310.swift

@@ -0,0 +1,53 @@
+// RUN: %target-typecheck-verify-swift -target %target-cpu-apple-macosx10.15 -swift-version 5
+
+// REQUIRES: objc_interop
+// REQUIRES: OS=macosx
+
+import SwiftUI
+
+class Visibility: ObservableObject { // expected-note {{class 'Visibility' does not conform to the 'Sendable' protocol}}
+    @Published var yes = false // some nonsense
+}
+
+struct CoffeeTrackerView: View { // expected-note{{consider making struct 'CoffeeTrackerView' conform to the 'Sendable' protocol}}
+    @ObservedObject var showDrinkList: Visibility = Visibility()
+
+    var storage: Visibility = Visibility()
+
+    var body: some View {
+        VStack {
+          Button(action: {}) {
+            Image(self.showDrinkList.yes ? "add-coffee" : "add-tea")
+                    .renderingMode(.template)
+            }
+        }
+    }
+}
+
+@MainActor
+func fromMainActor() async {
+  let view = CoffeeTrackerView()
+  _ = view.body
+  _ = view.showDrinkList
+  _ = view.storage
+}
+
+
+func fromConcurrencyAware() async {
+  // expected-note@+3 {{calls to initializer 'init()' from outside of its actor context are implicitly asynchronous}}
+  // expected-error@+2 {{expression is 'async' but is not marked with 'await'}}
+  // expected-warning@+1 {{non-sendable type 'CoffeeTrackerView' returned by call to main actor-isolated function cannot cross actor boundary}}
+  let view = CoffeeTrackerView()
+
+  // expected-note@+3 {{property access is 'async'}}
+  // expected-warning@+2 {{non-sendable type 'some View' in implicitly asynchronous access to main actor-isolated property 'body' cannot cross actor boundary}}
+  // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+  _ = view.body
+
+  // expected-note@+3 {{property access is 'async'}}
+  // expected-warning@+2 {{non-sendable type 'Visibility' in implicitly asynchronous access to main actor-isolated property 'showDrinkList' cannot cross actor boundary}}
+  // expected-error@+1 {{expression is 'async' but is not marked with 'await'}}
+  _ = view.showDrinkList
+
+  _ = view.storage
+}