Merge pull request #73556 from gottesmm/rdar127295657_127844737

[region-isolation] When inferring isolation for an argument, handle non-self isolated parameters as well as self parameters that are actor isolated.

Author: gottesmm

docs/SIL.rst

@@ -692,6 +692,18 @@ autorelease in the callee.
   type behaves like a non-generic type, as if the substitutions were
   actually applied to the underlying function type.
 
+- SIL functions may optionally mark a function parameter as
+  ``@sil_isolated``. An ``@sil_isolated`` parameter must be one of:
+
+  - An actor or any actor type.
+  - A generic type that conforms to Actor or AnyActor.
+
+  and must be the actor instance that a function is isolated to. Importantly
+  this means that global actor isolated nominal types are never
+  ``@sil_isolated``. Only one parameter can ever be marked as ``@sil_isolated``
+  since a function cannot be isolated to multiple actors at the same time.
+
+
 Async Functions
 ```````````````
 

include/swift/AST/ActorIsolation.h

@@ -205,6 +205,8 @@ class ActorIsolation {
     return getKind() == GlobalActor;
   }
 
+  bool isActorInstanceIsolated() const { return getKind() == ActorInstance; }
+
   bool isMainActor() const;
 
   bool isDistributedActor() const;
@@ -262,37 +264,14 @@ class ActorIsolation {
                               state.parameterIndex);
   }
 
-  void print(llvm::raw_ostream &os) const {
-    switch (getKind()) {
-    case Unspecified:
-      os << "unspecified";
-      return;
-    case ActorInstance:
-      os << "actor_instance";
-      return;
-    case Nonisolated:
-      os << "nonisolated";
-      return;
-    case NonisolatedUnsafe:
-      os << "nonisolated_unsafe";
-      return;
-    case GlobalActor:
-      os << "global_actor";
-      return;
-    case Erased:
-      os << "erased";
-      return;
-    }
-    llvm_unreachable("Covered switch isn't covered?!");
-  }
+  void print(llvm::raw_ostream &os) const;
+
+  void printForSIL(llvm::raw_ostream &os) const;
 
   void printForDiagnostics(llvm::raw_ostream &os,
                            StringRef openingQuotationMark = "'") const;
 
-  SWIFT_DEBUG_DUMP {
-    print(llvm::dbgs());
-    llvm::dbgs() << '\n';
-  }
+  SWIFT_DEBUG_DUMPER(dump());
 
   // Defined out of line to prevent linker errors since libswiftBasic would
   // include this header exascerbating a layering violation where libswiftBasic

include/swift/SIL/SILFunction.h

@@ -1551,6 +1551,17 @@ class SILFunction
     return getArguments().back();
   }
 
+  /// If we have an isolated argument, return that. Returns nullptr otherwise.
+  const SILArgument *maybeGetIsolatedArgument() const {
+    for (auto *arg : getArgumentsWithoutIndirectResults()) {
+      if (cast<SILFunctionArgument>(arg)->getKnownParameterInfo().hasOption(
+              SILParameterInfo::Isolated))
+        return arg;
+    }
+
+    return nullptr;
+  }
+
   const SILArgument *getDynamicSelfMetadata() const {
     assert(hasDynamicSelfMetadata() && "This method can only be called if the "
            "SILFunction has a self-metadata parameter");

include/swift/SILOptimizer/Analysis/RegionAnalysis.h

@@ -31,27 +31,6 @@ using TransferringOperandSetFactory = Partition::TransferringOperandSetFactory;
 using Element = PartitionPrimitives::Element;
 using Region = PartitionPrimitives::Region;
 
-/// Check if the passed in type is NonSendable.
-///
-/// NOTE: We special case RawPointer and NativeObject to ensure they are
-/// treated as non-Sendable and strict checking is applied to it.
-inline bool isNonSendableType(SILType type, SILFunction *fn) {
-  // Treat Builtin.NativeObject and Builtin.RawPointer as non-Sendable.
-  if (type.getASTType()->is<BuiltinNativeObjectType>() ||
-      type.getASTType()->is<BuiltinRawPointerType>()) {
-    return true;
-  }
-
-  // Treat Builtin.SILToken as Sendable. It cannot escape from the current
-  // function. We should change isSendable to hardwire this.
-  if (type.getASTType()->is<SILTokenType>()) {
-    return false;
-  }
-
-  // Otherwise, delegate to seeing if type conforms to the Sendable protocol.
-  return !type.isSendable(fn);
-}
-
 /// Return the ApplyIsolationCrossing for a specific \p inst if it
 /// exists. Returns std::nullopt otherwise.
 std::optional<ApplyIsolationCrossing>
@@ -305,7 +284,10 @@ class regionanalysisimpl::TrackableValue {
     os << "\n    Rep Value: " << getRepresentative();
   }
 
-  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
+  SWIFT_DEBUG_DUMP {
+    print(llvm::dbgs());
+    llvm::dbgs() << '\n';
+  }
 };
 
 class RegionAnalysis;

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(ActorIsolation actorIsolation, SILValue isolatedValue,
-                   SILValue 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;
   }
@@ -193,37 +263,91 @@ class SILIsolationInfo {
 
   [[nodiscard]] SILIsolationInfo merge(SILIsolationInfo other) const;
 
-  SILIsolationInfo withActorIsolated(SILValue isolatedValue,
-                                     SILValue actorInstance,
-                                     ActorIsolation isolation) {
-    return SILIsolationInfo::getActorIsolated(isolatedValue, actorInstance,
-                                              isolation);
-  }
-
   static SILIsolationInfo getDisconnected() { return {Kind::Disconnected}; }
 
-  static SILIsolationInfo getActorIsolated(SILValue isolatedValue,
-                                           SILValue actorInstance,
-                                           ActorIsolation actorIsolation) {
-    return {actorIsolation, isolatedValue, actorInstance};
-  }
-
-  static SILIsolationInfo getActorIsolated(SILValue isolatedValue,
-                                           SILValue actorInstance,
-                                           NominalTypeDecl *typeDecl) {
-    if (typeDecl->isAnyActor())
-      return {ActorIsolation::forActorInstanceSelf(typeDecl), isolatedValue,
-              actorInstance};
-    auto isolation = swift::getActorIsolation(typeDecl);
-    if (isolation.isGlobalActor())
-      return {isolation, isolatedValue, actorInstance};
+  /// Create an actor isolation for a value that we know is actor isolated to a
+  /// specific actor, but we do not know the specific instance yet.
+  ///
+  /// This can occur when closing over a closure with an isolated parameter or
+  /// if we are determining isolation of a function_ref that takes an isolated
+  /// parameter. In both cases, we cannot know what the actual isolation is
+  /// until we invoke the closure or function.
+  ///
+  /// TODO: This is just a stub currently until I implement the flow sensitive
+  /// part. We just treat all instances the same. There are tests that validate
+  /// this behavior.
+  static SILIsolationInfo
+  getFlowSensitiveActorIsolated(SILValue isolatedValue,
+                                ActorIsolation actorIsolation) {
+    return {isolatedValue, SILValue(), actorIsolation};
+  }
+
+  /// Only use this as a fallback if we cannot find better information.
+  static SILIsolationInfo
+  getWithIsolationCrossing(ApplyIsolationCrossing crossing) {
+    if (crossing.getCalleeIsolation().isActorIsolated()) {
+      // SIL level, just let it through
+      return SILIsolationInfo(SILValue(), SILValue(),
+                              crossing.getCalleeIsolation());
+    }
+
     return {};
   }
 
+  static SILIsolationInfo getActorInstanceIsolated(SILValue isolatedValue,
+                                                   SILValue actorInstance,
+                                                   NominalTypeDecl *typeDecl) {
+    assert(actorInstance);
+    if (!typeDecl->isAnyActor()) {
+      assert(!swift::getActorIsolation(typeDecl).isGlobalActor() &&
+             "Should have called getGlobalActorIsolated");
+      return {};
+    }
+    return {isolatedValue, actorInstance,
+            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.
+  static SILIsolationInfo
+  getPartialApplyActorInstanceIsolated(SILValue isolatedValue,
+                                       NominalTypeDecl *typeDecl) {
+    if (!typeDecl->isAnyActor()) {
+      assert(!swift::getActorIsolation(typeDecl).isGlobalActor() &&
+             "Should have called getGlobalActorIsolated");
+      return {};
+    }
+    return {isolatedValue, SILValue(),
+            ActorIsolation::forActorInstanceSelf(typeDecl)};
+  }
+
   static SILIsolationInfo getGlobalActorIsolated(SILValue value,
                                                  Type globalActorType) {
-    return getActorIsolated(value, SILValue() /*no actor instance*/,
-                            ActorIsolation::forGlobalActor(globalActorType));
+    return {value, SILValue() /*no actor instance*/,
+            ActorIsolation::forGlobalActor(globalActorType)};
+  }
+
+  static SILIsolationInfo getGlobalActorIsolated(SILValue value,
+                                                 ValueDecl *decl) {
+    auto isolation = swift::getActorIsolation(decl);
+    if (!isolation.isGlobalActor())
+      return {};
+    return SILIsolationInfo::getGlobalActorIsolated(value,
+                                                    isolation.getGlobalActor());
   }
 
   static SILIsolationInfo getTaskIsolated(SILValue value) {
@@ -244,6 +368,18 @@ class SILIsolationInfo {
     return {};
   }
 
+  /// A helper that is used to ensure that we treat certain builtin values as
+  /// non-Sendable that the AST level otherwise thinks are non-Sendable.
+  ///
+  /// E.x.: Builtin.RawPointer and Builtin.NativeObject
+  ///
+  /// TODO: Fix the type checker.
+  static bool isNonSendableType(SILType type, SILFunction *fn);
+
+  static bool isNonSendableType(SILValue value) {
+    return isNonSendableType(value->getType(), value->getFunction());
+  }
+
   bool hasSameIsolation(ActorIsolation actorIsolation) const;
 
   /// Returns true if \p this and \p other have the same isolation. It allows