[region-isolation] Fix isolation inference for init accessors.

rdar://127844737

Author: gottesmm

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -95,6 +95,65 @@ struct DenseMapInfo<swift::PartitionPrimitives::Region> {
 
 namespace swift {
 
+class ActorInstance {
+public:
+  enum class Kind : uint8_t {
+    Value,
+    ActorAccessorInit = 0x1,
+  };
+
+  llvm::PointerIntPair<SILValue, 1> value;
+
+  ActorInstance(SILValue value, Kind kind)
+      : value(value, std::underlying_type<Kind>::type(kind)) {}
+
+public:
+  ActorInstance() : ActorInstance(SILValue(), Kind::Value) {}
+
+  static ActorInstance getForValue(SILValue value) {
+    return ActorInstance(value, Kind::Value);
+  }
+
+  static ActorInstance getForActorAccessorInit() {
+    return ActorInstance(SILValue(), Kind::ActorAccessorInit);
+  }
+
+  explicit operator bool() const { return bool(value.getOpaqueValue()); }
+
+  Kind getKind() const { return Kind(value.getInt()); }
+
+  SILValue getValue() const {
+    assert(getKind() == Kind::Value);
+    return value.getPointer();
+  }
+
+  bool isValue() const { return getKind() == Kind::Value; }
+
+  bool isAccessorInit() const { return getKind() == Kind::ActorAccessorInit; }
+
+  bool operator==(const ActorInstance &other) const {
+    // If both are null, return true.
+    if (!bool(*this) && !bool(other))
+      return true;
+
+    // Otherwise, check if the kinds match.
+    if (getKind() != other.getKind())
+      return false;
+
+    // Now that we know that the kinds match, perform the kind specific check.
+    switch (getKind()) {
+    case Kind::Value:
+      return getValue() == other.getValue();
+    case Kind::ActorAccessorInit:
+      return true;
+    }
+  }
+
+  bool operator!=(const ActorInstance &other) const {
+    return !(*this == other);
+  }
+};
+
 class SILIsolationInfo {
 public:
   /// The lattice is:
@@ -122,18 +181,29 @@ class SILIsolationInfo {
 
   /// If set this is the SILValue that represents the actor instance that we
   /// derived isolatedValue from.
-  SILValue actorInstance;
+  ///
+  /// If set to (SILValue(), 1), then we are in an
+  ActorInstance actorInstance;
 
   SILIsolationInfo(SILValue isolatedValue, SILValue actorInstance,
                    ActorIsolation actorIsolation)
       : kind(Actor), actorIsolation(actorIsolation),
-        isolatedValue(isolatedValue), actorInstance(actorInstance) {
+        isolatedValue(isolatedValue),
+        actorInstance(ActorInstance::getForValue(actorInstance)) {
     assert((!actorInstance ||
             (actorIsolation.getKind() == ActorIsolation::ActorInstance &&
              actorInstance->getType().isAnyActor())) &&
            "actorInstance must be an actor if it is non-empty");
   }
 
+  SILIsolationInfo(SILValue isolatedValue, ActorInstance actorInstance,
+                   ActorIsolation actorIsolation)
+      : kind(Actor), actorIsolation(actorIsolation),
+        isolatedValue(isolatedValue), actorInstance(actorInstance) {
+    assert(actorInstance);
+    assert(actorIsolation.getKind() == ActorIsolation::ActorInstance);
+  }
+
   SILIsolationInfo(Kind kind, SILValue isolatedValue)
       : kind(kind), actorIsolation(), isolatedValue(isolatedValue) {}
 
@@ -180,7 +250,7 @@ class SILIsolationInfo {
 
   /// Return the specific SILValue for the actor that our isolated value is
   /// isolated to if one exists.
-  SILValue getActorInstance() const {
+  ActorInstance getActorInstance() const {
     assert(kind == Actor);
     return actorInstance;
   }
@@ -237,6 +307,19 @@ class SILIsolationInfo {
             ActorIsolation::forActorInstanceSelf(typeDecl)};
   }
 
+  static SILIsolationInfo getActorInstanceIsolated(SILValue isolatedValue,
+                                                   ActorInstance actorInstance,
+                                                   NominalTypeDecl *typeDecl) {
+    assert(actorInstance);
+    if (!typeDecl->isAnyActor()) {
+      assert(!swift::getActorIsolation(typeDecl).isGlobalActor() &&
+             "Should have called getGlobalActorIsolated");
+      return {};
+    }
+    return {isolatedValue, actorInstance,
+            ActorIsolation::forActorInstanceSelf(typeDecl)};
+  }
+
   /// A special actor instance isolated for partial apply cases where we do not
   /// close over the isolated parameter and thus do not know the actual actor
   /// instance that we are going to use.

lib/SILOptimizer/Utils/PartitionUtils.cpp

@@ -439,6 +439,20 @@ SILIsolationInfo SILIsolationInfo::get(SILArgument *arg) {
         return SILIsolationInfo::getDisconnected();
       }
     }
+
+    if (auto functionIsolation = fArg->getFunction()->getActorIsolation()) {
+      if (declRef.getDecl()) {
+        if (auto *accessor =
+                dyn_cast_or_null<AccessorDecl>(declRef.getFuncDecl())) {
+          if (accessor->isInitAccessor()) {
+            assert(functionIsolation.isActorInstanceIsolated());
+            return SILIsolationInfo::getActorInstanceIsolated(
+                fArg, ActorInstance::getForActorAccessorInit(),
+                functionIsolation.getActor());
+          }
+        }
+      }
+    }
   }
 
   // Otherwise, if we do not have an isolated argument and are not in an
@@ -463,10 +477,20 @@ void SILIsolationInfo::print(llvm::raw_ostream &os) const {
     os << "disconnected";
     return;
   case Actor:
-    if (SILValue instance = getActorInstance()) {
-      if (auto name = VariableNameInferrer::inferName(instance)) {
-        os << "'" << *name << "'-isolated\n";
-        os << "instance: " << *instance;
+    if (ActorInstance instance = getActorInstance()) {
+      switch (instance.getKind()) {
+      case ActorInstance::Kind::Value: {
+        SILValue value = instance.getValue();
+        if (auto name = VariableNameInferrer::inferName(value)) {
+          os << "'" << *name << "'-isolated\n";
+          os << "instance: " << *value;
+          return;
+        }
+        break;
+      }
+      case ActorInstance::Kind::ActorAccessorInit:
+        os << "'self'-isolated\n";
+        os << "instance: actor accessor init\n";
         return;
       }
     }
@@ -519,9 +543,9 @@ bool SILIsolationInfo::hasSameIsolation(const SILIsolationInfo &other) const {
     return true;
   case Task:
     return getIsolatedValue() == other.getIsolatedValue();
-  case Actor:
-    auto actor1 = getActorInstance();
-    auto actor2 = other.getActorInstance();
+  case Actor: {
+    ActorInstance actor1 = getActorInstance();
+    ActorInstance actor2 = other.getActorInstance();
 
     // If either are non-null, and the actor instance doesn't match, return
     // false.
@@ -532,6 +556,7 @@ bool SILIsolationInfo::hasSameIsolation(const SILIsolationInfo &other) const {
     auto rhsIsolation = other.getActorIsolation();
     return lhsIsolation == rhsIsolation;
   }
+  }
 }
 
 bool SILIsolationInfo::isEqual(const SILIsolationInfo &other) const {
@@ -579,9 +604,18 @@ void SILIsolationInfo::printForDiagnostics(llvm::raw_ostream &os) const {
     os << "disconnected";
     return;
   case Actor:
-    if (SILValue instance = getActorInstance()) {
-      if (auto name = VariableNameInferrer::inferName(instance)) {
-        os << "'" << *name << "'-isolated";
+    if (auto instance = getActorInstance()) {
+      switch (instance.getKind()) {
+      case ActorInstance::Kind::Value: {
+        SILValue value = instance.getValue();
+        if (auto name = VariableNameInferrer::inferName(value)) {
+          os << "'" << *name << "'-isolated";
+          return;
+        }
+        break;
+      }
+      case ActorInstance::Kind::ActorAccessorInit:
+        os << "'self'-isolated";
         return;
       }
     }

test/Concurrency/flow_isolation.swift

@@ -812,26 +812,6 @@ func testActorWithInitAccessorInit() {
       print(a) // Ok (nonisolated)
     }
   }
-
-  class NonSendableKlass {
-    init(_ x: NonSendableKlass? = nil) {
-
-    }
-  }
-  
-  @available(SwiftStdlib 5.1, *)
-  actor NonSendableInit {
-    var first: NonSendableKlass
-    var second: NonSendableKlass? = nil {
-      @storageRestrictions(initializes: first)
-      init(initialValue)  {
-        first = initialValue!
-      }
-
-      get { fatalError() }
-      set { fatalError() }
-    }
-  }
 }
 
 @available(SwiftStdlib 5.1, *)