Merge pull request #70555 from xedin/issue-70550

[Concurrency] `memberAccessHasSpecialPermissionInSwift5` should treat…

Author: xedin

include/swift/AST/DiagnosticsSIL.def

@@ -674,6 +674,10 @@ NOTE(nonisolated_blame, none, "after %1%2 %3, "
 ERROR(non_sendable_from_deinit,none,
         "cannot access %1 %2 with a non-sendable type %0 from non-isolated deinit",
         (Type, DescriptiveDeclKind, DeclName))
+ERROR(isolated_property_mutation_in_nonisolated_context,none,
+      "actor-isolated %kind0 can not be %select{referenced|mutated}1 "
+      "from a non-isolated context",
+      (const ValueDecl *, bool))
 
 // Yield usage errors
 ERROR(return_before_yield, none, "accessor must yield before returning",())

lib/SILOptimizer/Mandatory/FlowIsolation.cpp

@@ -457,11 +457,22 @@ void Info::diagnoseAll(AnalysisInfo &info, bool forDeinit,
     // If the illegal use is a call to a defer, then recursively diagnose
     // all of the defer's uses, if this is the first time encountering it.
     if (auto *callee = getCallee(use)) {
-      assert(info.haveDeferInfo(callee) && "non-defer call as a property use?");
-      auto &defer = info.getOrCreateDeferInfo(callee);
-      if (defer.setNonisolatedStart()) {
-        defer.diagnoseEntireFunction(blame);
+      if (info.haveDeferInfo(callee)) {
+        auto &defer = info.getOrCreateDeferInfo(callee);
+        if (defer.setNonisolatedStart()) {
+          defer.diagnoseEntireFunction(blame);
+        }
+        continue;
       }
+
+      // Init accessor `setter` use.
+      auto *accessor =
+          cast<AccessorDecl>(callee->getLocation().getAsDeclContext());
+      auto illegalLoc = use->getDebugLocation().getLocation();
+      diag.diagnose(illegalLoc.getSourceLoc(),
+                    diag::isolated_property_mutation_in_nonisolated_context,
+                    accessor->getStorage(), accessor->isSetter())
+          .warnUntilSwiftVersion(6);
       continue;
     }
 
@@ -631,6 +642,37 @@ void AnalysisInfo::analyze(const SILArgument *selfParam) {
             }
           }
         }
+
+        // Detect and handle use of init accessor properties.
+        if (callee->hasLocation()) {
+          auto loc = callee->getLocation();
+          if (auto *accessor =
+                  dyn_cast_or_null<AccessorDecl>(loc.getAsDeclContext())) {
+            auto *storage = accessor->getStorage();
+
+            // Note 'nonisolated' property use.
+            if (storage->getAttrs().hasAttribute<NonisolatedAttr>()) {
+              markNonIsolated(user);
+              continue;
+            }
+
+            // Init accessor is used exclusively for initialization
+            // of properties while 'self' is not fully initialized.
+            if (accessor->isInitAccessor()) {
+              markNonIsolated(user);
+              continue;
+            }
+
+            // Otherwise if this is an init accessor property, it's either
+            // a call to a getter or a setter and should be treated like
+            // an isolated computed property reference.
+
+            if (storage->hasInitAccessor()) {
+              markPropertyUse(user);
+              continue;
+            }
+          }
+        }
       }
 
       // For all other call-sites, uses of `self` are nonisolated.

lib/Sema/TypeCheckConcurrency.cpp

@@ -1772,10 +1772,20 @@ static bool memberAccessHasSpecialPermissionInSwift5(
 
     // If the context in which we consider the access matches between the
     // old (escaping-use restriction) and new (flow-isolation) contexts,
-    // and it is a stored property, then permit it here without any warning.
+    // and it is a stored or init accessor property, then permit it here
+    // without any warning.
     // Later, flow-isolation pass will check and emit a warning if needed.
-    if (refCxt == oldFn && isStoredProperty(member))
-      return true;
+    if (refCxt == oldFn) {
+      if (isStoredProperty(member))
+        return true;
+
+      if (auto *var = dyn_cast<VarDecl>(member)) {
+        // Init accessor properties are permitted to access only stored
+        // properties.
+        if (var->hasInitAccessor())
+          return true;
+      }
+    }
 
     // Otherwise, it's definitely going to be illegal, so warn and permit.
     auto &diags = refCxt->getASTContext().Diags;

test/Concurrency/flow_isolation.swift

@@ -734,3 +734,86 @@ actor CheckDeinitFromActor {
     ns = nil // expected-warning {{cannot access property 'ns' with a non-sendable type 'NonSendableType?' from non-isolated deinit; this is an error in Swift 6}}
   }
 }
+
+// https://github.com/apple/swift/issues/70550
+func testActorWithInitAccessorInit() {
+  @available(SwiftStdlib 5.1, *)
+  actor Angle {
+    var degrees: Double
+    var radians: Double = 0 {
+      @storageRestrictions(initializes: degrees)
+      init(initialValue)  {
+        degrees = initialValue * 180 / .pi
+      }
+
+      get { degrees * .pi / 180 }
+      set { degrees = newValue * 180 / .pi }
+    }
+
+    init(degrees: Double) {
+      self.degrees = degrees // Ok
+    }
+
+    init(radians: Double) {
+      self.radians = radians // Ok
+    }
+
+    init(value: Double) {
+      let escapingSelf: (Angle) -> Void = { _ in }
+
+      // degrees are initialized here via default value associated with radians
+
+      escapingSelf(self)
+
+      self.radians = 0
+      // expected-warning@-1 {{actor-isolated property 'radians' can not be mutated from a non-isolated context; this is an error in Swift 6}}
+    }
+  }
+
+  @available(SwiftStdlib 5.1, *)
+  actor EscapeBeforeFullInit {
+    var _a: Int // expected-note {{'self._a' not initialized}}
+
+    var a: Int {
+      @storageRestrictions(initializes: _a)
+      init {
+        _a = newValue
+      }
+
+      get { _a }
+      set { _a = newValue }
+    }
+
+    init(v: Int) {
+      let escapingSelf: (EscapeBeforeFullInit) -> Void = { _ in }
+
+      escapingSelf(self) // expected-error {{'self' used before all stored properties are initialized}}
+      // expected-note@-1 {{after this closure involving 'self', only non-isolated properties of 'self' can be accessed from this init}}
+
+      self.a = v
+      // expected-warning@-1 {{cannot access property '_a' here in non-isolated initializer; this is an error in Swift 6}}
+    }
+  }
+
+  @available(SwiftStdlib 5.1, *)
+  actor NonisolatedAccessors {
+    nonisolated var a: Int = 0 {
+      init {
+      }
+
+      get { 0 }
+      set {}
+    }
+
+    init(value: Int) {
+      let escapingSelf: (NonisolatedAccessors) -> Void = { _ in }
+
+      // a is initialized here via default value
+
+      escapingSelf(self)
+
+      self.a = value // Ok (nonisolated)
+      print(a) // Ok (nonisolated)
+    }
+  }
+}