Eliminate circular references while checking property wrapper isolation

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -2398,47 +2398,47 @@ ActorIsolation ActorIsolationRequest::evaluate(
     return getActorIsolation(accessor->getStorage());
   }
 
-  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 (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 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 (shouldInferAttributeInContext(value->getDeclContext())) {
     // If the declaration witnesses a protocol requirement that is isolated,
     // use that.
     if (auto witnessedIsolation = getIsolationFromWitnessedRequirements(value)) {
@@ -2615,6 +2615,13 @@ static bool shouldDiagnoseExistingDataRaces(const DeclContext *dc) {
         // features.
         if (func->getAttrs().hasAttribute<AsyncHandlerAttr>())
           return true;
+
+        // If we're in an accessor declaration, also check the storage
+        // declaration.
+        if (auto accessor = dyn_cast<AccessorDecl>(decl)) {
+          if (getIsolationFromAttributes(accessor->getStorage()))
+            return true;
+        }
       }
     }
 

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1766,6 +1766,29 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     });
   }
 
+  /// If the given pattern binding has a property wrapper, check the
+  /// isolation and effects of the backing storage initializer.
+  void checkPropertyWrapperBackingInitializer(PatternBindingDecl *PBD) {
+    auto singleVar = PBD->getSingleVar();
+    if (!singleVar)
+      return;
+
+    if (!singleVar->hasAttachedPropertyWrapper())
+      return;
+
+    auto backingInfo = singleVar->getPropertyWrapperBackingPropertyInfo();
+    if (!backingInfo)
+      return;
+
+    auto backingPBD = backingInfo.backingVar->getParentPatternBinding();
+    if (!backingPBD)
+      return;
+
+    if (auto initializer = backingInfo.getInitFromWrappedValue()) {
+      checkPropertyWrapperActorIsolation(backingPBD, initializer);
+      TypeChecker::checkPropertyWrapperEffects(backingPBD, initializer);
+    }
+  }
 
   void visitPatternBindingDecl(PatternBindingDecl *PBD) {
     DeclContext *DC = PBD->getDeclContext();
@@ -1913,6 +1936,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         }
       }
     }
+
+    checkPropertyWrapperBackingInitializer(PBD);
   }
 
   void visitSubscriptDecl(SubscriptDecl *SD) {

lib/Sema/TypeCheckStorage.cpp

@@ -2528,8 +2528,6 @@ static void typeCheckSynthesizedWrapperInitializer(
           dyn_cast_or_null<Initializer>(pbd->getInitContext(i))) {
     TypeChecker::contextualizeInitializer(initializerContext, initializer);
   }
-  checkPropertyWrapperActorIsolation(pbd, initializer);
-  TypeChecker::checkPropertyWrapperEffects(pbd, initializer);
 }
 
 static PropertyWrapperMutability::Value
@@ -2875,6 +2873,8 @@ PropertyWrapperBackingPropertyInfoRequest::evaluate(Evaluator &evaluator,
       // Check initializer effects.
       auto *initContext = new (ctx) PropertyWrapperInitializer(
           dc, param, PropertyWrapperInitializer::Kind::WrappedValue);
+      TypeChecker::contextualizeInitializer(initContext, wrappedValueInit);
+      checkInitializerActorIsolation(initContext, wrappedValueInit);
       TypeChecker::checkInitializerEffects(initContext, wrappedValueInit);
     } else {
       typeCheckSynthesizedWrapperInitializer(

test/Concurrency/global_actor_inference.swift

@@ -243,7 +243,7 @@ func barSync() {
 struct WrapperOnActor<Wrapped> {
   @actorIndependent(unsafe) private var stored: Wrapped
 
-  init(wrappedValue: Wrapped) {
+  @actorIndependent init(wrappedValue: Wrapped) {
     stored = wrappedValue
   }
 
@@ -336,6 +336,16 @@ actor WrapperActorBad2<Wrapped> {
   }
 }
 
+actor ActorWithWrapper {
+  @WrapperOnActor var synced: Int = 0
+  // expected-note@-1 3{{mutable state is only available within the actor instance}}
+  func f() {
+    _ = synced // expected-error{{'synced' isolated to global actor}}
+    _ = $synced // expected-error{{'$synced' isolated to global actor}}
+    _ = _synced // expected-error{{'_synced' isolated to global actor}}
+  }
+}
+
 // ----------------------------------------------------------------------
 // Unsafe global actors
 // ----------------------------------------------------------------------