[SILOptimizer] FlowIsolation: Teach analysis to recognize use of init accessor properties

Init accessor properties should be handled specifically because
they do not reference underlying storage directly via `ref_element_addr`
instructions when 'self' is fully initialized.

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.

test/Concurrency/flow_isolation.swift

@@ -757,5 +757,63 @@ func testActorWithInitAccessorInit() {
     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)
+    }
   }
 }