Merge pull request swiftlang#72959 from gottesmm/tns-upstream-2

[region-isolation] Do not look through begin_borrow or move_value if they are marked as a var_decl.

Author: gottesmm

include/swift/SIL/SILType.h

@@ -917,8 +917,16 @@ class SILType {
 
   bool isMarkedAsImmortal() const;
 
+  /// Returns true if this type is an actor type. Returns false if this is any
+  /// other type. This includes distributed actors. To check for distributed
+  /// actors and actors, use isAnyActor().
   bool isActor() const { return getASTType()->isActorType(); }
 
+  bool isDistributedActor() const { return getASTType()->isDistributedActor(); }
+
+  /// Returns true if this type is an actor or a distributed actor.
+  bool isAnyActor() const { return getASTType()->isAnyActorType(); }
+
   /// Returns true if this function conforms to the Sendable protocol.
   bool isSendable(SILFunction *fn) const;
 

include/swift/SILOptimizer/Analysis/RegionAnalysis.h

@@ -28,7 +28,7 @@ class RegionAnalysisFunctionInfo;
 namespace regionanalysisimpl {
 
 using TransferringOperandSetFactory = Partition::TransferringOperandSetFactory;
-using TrackableValueID = PartitionPrimitives::Element;
+using Element = PartitionPrimitives::Element;
 using Region = PartitionPrimitives::Region;
 
 /// Check if the passed in type is NonSendable.
@@ -175,7 +175,7 @@ class regionanalysisimpl::TrackableValueState {
 
   SILIsolationInfo getIsolationRegionInfo() const { return regionInfo; }
 
-  TrackableValueID getID() const { return TrackableValueID(id); }
+  Element getID() const { return Element(id); }
 
   void addFlag(TrackableValueFlag flag) { flagSet |= flag; }
 
@@ -186,7 +186,7 @@ class regionanalysisimpl::TrackableValueState {
        << "][is_no_alias: " << (isNoAlias() ? "yes" : "no")
        << "][is_sendable: " << (isSendable() ? "yes" : "no")
        << "][region_value_kind: ";
-    getIsolationRegionInfo().print(os);
+    getIsolationRegionInfo().printForDiagnostics(os);
     os << "].";
   }
 
@@ -276,9 +276,7 @@ class regionanalysisimpl::TrackableValue {
     return valueState.getIsolationRegionInfo();
   }
 
-  TrackableValueID getID() const {
-    return TrackableValueID(valueState.getID());
-  }
+  Element getID() const { return Element(valueState.getID()); }
 
   /// Return the representative value of this equivalence class of values.
   RepresentativeValue getRepresentative() const { return representativeValue; }
@@ -289,6 +287,11 @@ class regionanalysisimpl::TrackableValue {
   /// parameter.
   bool isTransferringParameter() const;
 
+  void printIsolationInfo(SmallString<64> &outString) const {
+    llvm::raw_svector_ostream os(outString);
+    getIsolationRegionInfo().printForDiagnostics(os);
+  }
+
   void print(llvm::raw_ostream &os) const {
     os << "TrackableValue. State: ";
     valueState.print(os);
@@ -315,7 +318,6 @@ class RegionAnalysisValueMap {
   using Region = PartitionPrimitives::Region;
   using TrackableValue = regionanalysisimpl::TrackableValue;
   using TrackableValueState = regionanalysisimpl::TrackableValueState;
-  using TrackableValueID = Element;
   using RepresentativeValue = regionanalysisimpl::RepresentativeValue;
 
 private:
@@ -369,14 +371,14 @@ class RegionAnalysisValueMap {
       SILInstruction *introducingInst) const;
 
 private:
-  std::optional<TrackableValue> getValueForId(TrackableValueID id) const;
+  std::optional<TrackableValue> getValueForId(Element id) const;
   std::optional<TrackableValue> tryToTrackValue(SILValue value) const;
   TrackableValue
   getActorIntroducingRepresentative(SILInstruction *introducingInst,
                                     SILIsolationInfo isolation) const;
   bool mergeIsolationRegionInfo(SILValue value, SILIsolationInfo isolation);
   bool valueHasID(SILValue value, bool dumpIfHasNoID = false);
-  TrackableValueID lookupValueID(SILValue value);
+  Element lookupValueID(SILValue value);
 };
 
 class RegionAnalysisFunctionInfo {

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -118,14 +118,24 @@ class SILIsolationInfo {
 
   /// This is the value that we got isolation from if we were able to find
   /// one. Used for isolation history.
-  SILValue isolationSource;
+  SILValue isolatedValue;
 
-  SILIsolationInfo(ActorIsolation actorIsolation, SILValue isolationSource)
+  /// If set this is the SILValue that represents the actor instance that we
+  /// derived isolatedValue from.
+  SILValue actorInstance;
+
+  SILIsolationInfo(ActorIsolation actorIsolation, SILValue isolatedValue,
+                   SILValue actorInstance)
       : kind(Actor), actorIsolation(actorIsolation),
-        isolationSource(isolationSource) {}
+        isolatedValue(isolatedValue), actorInstance(actorInstance) {
+    assert((!actorInstance ||
+            (actorIsolation.getKind() == ActorIsolation::ActorInstance &&
+             actorInstance->getType().isAnyActor())) &&
+           "actorInstance must be an actor if it is non-empty");
+  }
 
-  SILIsolationInfo(Kind kind, SILValue isolationSource)
-      : kind(kind), actorIsolation(), isolationSource(isolationSource) {}
+  SILIsolationInfo(Kind kind, SILValue isolatedValue)
+      : kind(kind), actorIsolation(), isolatedValue(isolatedValue) {}
 
   SILIsolationInfo(Kind kind) : kind(kind), actorIsolation() {}
 
@@ -151,51 +161,68 @@ class SILIsolationInfo {
 
   void printForDiagnostics(llvm::raw_ostream &os) const;
 
+  SWIFT_DEBUG_DUMPER(dumpForDiagnostics()) {
+    printForDiagnostics(llvm::dbgs());
+    llvm::dbgs() << '\n';
+  }
+
   ActorIsolation getActorIsolation() const {
     assert(kind == Actor);
     return actorIsolation;
   }
 
-  // If we are actor or task isolated and could find a specific value that
-  // caused the isolation, put it here. Used for isolation history.
+  /// If we are actor or task isolated and could find a specific value that
+  /// caused the isolation, put it here. Used for isolation history.
   SILValue getIsolatedValue() const {
     assert(kind == Task || kind == Actor);
-    return isolationSource;
+    return isolatedValue;
+  }
+
+  /// Return the specific SILValue for the actor that our isolated value is
+  /// isolated to if one exists.
+  SILValue getActorInstance() const {
+    assert(kind == Actor);
+    return actorInstance;
   }
 
   bool hasActorIsolation() const { return kind == Actor; }
 
   bool hasIsolatedValue() const {
-    return (kind == Task || kind == Actor) && bool(isolationSource);
+    return (kind == Task || kind == Actor) && bool(isolatedValue);
   }
 
   [[nodiscard]] SILIsolationInfo merge(SILIsolationInfo other) const;
 
   SILIsolationInfo withActorIsolated(SILValue isolatedValue,
+                                     SILValue actorInstance,
                                      ActorIsolation isolation) {
-    return SILIsolationInfo::getActorIsolated(isolatedValue, 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};
+    return {actorIsolation, isolatedValue, actorInstance};
   }
 
   static SILIsolationInfo getActorIsolated(SILValue isolatedValue,
+                                           SILValue actorInstance,
                                            NominalTypeDecl *typeDecl) {
-    if (typeDecl->isActor())
-      return {ActorIsolation::forActorInstanceSelf(typeDecl), isolatedValue};
+    if (typeDecl->isAnyActor())
+      return {ActorIsolation::forActorInstanceSelf(typeDecl), isolatedValue,
+              actorInstance};
     auto isolation = swift::getActorIsolation(typeDecl);
     if (isolation.isGlobalActor())
-      return {isolation, isolatedValue};
+      return {isolation, isolatedValue, actorInstance};
     return {};
   }
 
   static SILIsolationInfo getGlobalActorIsolated(SILValue value,
                                                  Type globalActorType) {
-    return getActorIsolated(value,
+    return getActorIsolated(value, SILValue() /*no actor instance*/,
                             ActorIsolation::forGlobalActor(globalActorType));
   }
 
@@ -207,7 +234,15 @@ class SILIsolationInfo {
   static SILIsolationInfo get(SILInstruction *inst);
 
   /// Attempt to infer the isolation region info for \p arg.
-  static SILIsolationInfo get(SILFunctionArgument *arg);
+  static SILIsolationInfo get(SILArgument *arg);
+
+  static SILIsolationInfo get(SILValue value) {
+    if (auto *arg = dyn_cast<SILArgument>(value))
+      return get(arg);
+    if (auto *inst = dyn_cast<SingleValueInstruction>(value))
+      return get(inst);
+    return {};
+  }
 
   bool hasSameIsolation(ActorIsolation actorIsolation) const;
 
@@ -670,7 +705,7 @@ class Partition {
 
   /// Track a label that is guaranteed to be strictly larger than all in use,
   /// and therefore safe for use as a fresh label.
-  Region fresh_label = Region(0);
+  Region freshLabel = Region(0);
 
   /// An immutable data structure that we use to push/pop isolation history.
   IsolationHistory history;
@@ -841,7 +876,7 @@ class Partition {
     llvm::dbgs() << "Partition";
     if (canonical)
       llvm::dbgs() << "(canonical)";
-    llvm::dbgs() << "(fresh=" << fresh_label << "){";
+    llvm::dbgs() << "(fresh=" << freshLabel << "){";
     for (const auto &[i, label] : elementToRegionMap)
       llvm::dbgs() << "[" << i << ": " << label << "] ";
     llvm::dbgs() << "}\n";

include/swift/SILOptimizer/Utils/VariableNameUtils.h

@@ -192,6 +192,15 @@ class VariableNameInferrer {
 
   StringRef getName() const { return resultingString; }
 
+  /// Given a specific SILValue, construct a VariableNameInferrer and use it to
+  /// attempt to infer an identifier for the value.
+  static std::optional<Identifier> inferName(SILValue value);
+
+  /// Given a specific SILValue, construct a VariableNameInferrer and use it to
+  /// attempt to infer an identifier for the value and a named value.
+  static std::optional<std::pair<Identifier, SILValue>>
+  inferNameAndRoot(SILValue value);
+
 private:
   void drainVariableNamePath();
   void popSingleVariableName();