[region-isolation] Move RepresentativeValue from RegionAnalysis.h -> PartitionUtils.h and add APIs for mapping an ElementID -> Representative.

This is just moving up the declaration in the chain of dependencies so that I
can write logic in PartitionUtils.h using it. I also added entrypoints to lookup
the ReprensetativeValue for our various emitters.

(cherry picked from commit ace94b0)

Author: gottesmm

include/swift/SILOptimizer/Analysis/RegionAnalysis.h

@@ -114,7 +114,6 @@ class BlockPartitionState {
 
 class TrackableValue;
 class TrackableValueState;
-class RepresentativeValue;
 
 enum class TrackableValueFlag {
   /// Base value that says a value is uniquely represented and is
@@ -208,53 +207,6 @@ class regionanalysisimpl::TrackableValueState {
   }
 };
 
-/// The representative value of the equivalence class that makes up a tracked
-/// value.
-///
-/// We use a wrapper struct here so that we can inject "fake" actor isolated
-/// values into the regions of values that become merged into an actor by
-/// calling a function without a non-sendable result.
-class regionanalysisimpl::RepresentativeValue {
-  friend llvm::DenseMapInfo<RepresentativeValue>;
-
-  using InnerType = PointerUnion<SILValue, SILInstruction *>;
-
-  /// If this is set to a SILValue then it is the actual represented value. If
-  /// it is set to a SILInstruction, then this is a "fake" representative value
-  /// used to inject actor isolatedness. The instruction stored is the
-  /// instruction that introduced the actor isolated-ness.
-  InnerType value;
-
-public:
-  RepresentativeValue() : value() {}
-  RepresentativeValue(SILValue value) : value(value) {}
-  RepresentativeValue(SILInstruction *actorRegionInst)
-      : value(actorRegionInst) {}
-
-  operator bool() const { return bool(value); }
-
-  void print(llvm::raw_ostream &os) const {
-    if (auto *inst = value.dyn_cast<SILInstruction *>()) {
-      os << "ActorRegionIntroducingInst: " << *inst;
-      return;
-    }
-
-    os << *value.get<SILValue>();
-  }
-
-  SILValue getValue() const { return value.get<SILValue>(); }
-  SILValue maybeGetValue() const { return value.dyn_cast<SILValue>(); }
-  bool hasRegionIntroducingInst() const { return value.is<SILInstruction *>(); }
-  SILInstruction *getActorRegionIntroducingInst() const {
-    return value.get<SILInstruction *>();
-  }
-
-  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
-
-private:
-  RepresentativeValue(InnerType value) : value(value) {}
-};
-
 /// A tuple consisting of a base value and its value state.
 ///
 /// DISCUSSION: We are computing regions among equivalence classes of values
@@ -336,7 +288,6 @@ class RegionAnalysisValueMap {
   using Region = PartitionPrimitives::Region;
   using TrackableValue = regionanalysisimpl::TrackableValue;
   using TrackableValueState = regionanalysisimpl::TrackableValueState;
-  using RepresentativeValue = regionanalysisimpl::RepresentativeValue;
 
 private:
   /// A map from the representative of an equivalence class of values to their
@@ -365,6 +316,10 @@ class RegionAnalysisValueMap {
   /// value" returns an empty SILValue.
   SILValue maybeGetRepresentative(Element trackableValueID) const;
 
+  /// Returns the value for this instruction if it isn't a fake "represenative
+  /// value" to inject actor isolatedness. Asserts in such a case.
+  RepresentativeValue getRepresentativeValue(Element trackableValueID) const;
+
   /// Returns the fake "representative value" for this element if it
   /// exists. Returns nullptr otherwise.
   SILInstruction *maybeGetActorIntroducingInst(Element trackableValueID) const;
@@ -576,37 +531,4 @@ class RegionAnalysis final
 
 } // namespace swift
 
-namespace llvm {
-
-inline llvm::raw_ostream &
-operator<<(llvm::raw_ostream &os,
-           const swift::regionanalysisimpl::RepresentativeValue &value) {
-  value.print(os);
-  return os;
-}
-
-template <>
-struct DenseMapInfo<swift::regionanalysisimpl::RepresentativeValue> {
-  using RepresentativeValue = swift::regionanalysisimpl::RepresentativeValue;
-  using InnerType = RepresentativeValue::InnerType;
-  using InnerDenseMapInfo = DenseMapInfo<InnerType>;
-
-  static RepresentativeValue getEmptyKey() {
-    return RepresentativeValue(InnerDenseMapInfo::getEmptyKey());
-  }
-  static RepresentativeValue getTombstoneKey() {
-    return RepresentativeValue(InnerDenseMapInfo::getTombstoneKey());
-  }
-
-  static unsigned getHashValue(RepresentativeValue value) {
-    return InnerDenseMapInfo::getHashValue(value.value);
-  }
-
-  static bool isEqual(RepresentativeValue LHS, RepresentativeValue RHS) {
-    return InnerDenseMapInfo::isEqual(LHS.value, RHS.value);
-  }
-};
-
-} // namespace llvm
-
 #endif

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -100,6 +100,53 @@ namespace swift {
 class Partition;
 class TransferringOperandToStateMap;
 
+/// The representative value of the equivalence class that makes up a tracked
+/// value.
+///
+/// We use a wrapper struct here so that we can inject "fake" actor isolated
+/// values into the regions of values that become merged into an actor by
+/// calling a function without a non-sendable result.
+class RepresentativeValue {
+  friend llvm::DenseMapInfo<RepresentativeValue>;
+
+  using InnerType = PointerUnion<SILValue, SILInstruction *>;
+
+  /// If this is set to a SILValue then it is the actual represented value. If
+  /// it is set to a SILInstruction, then this is a "fake" representative value
+  /// used to inject actor isolatedness. The instruction stored is the
+  /// instruction that introduced the actor isolated-ness.
+  InnerType value;
+
+public:
+  RepresentativeValue() : value() {}
+  RepresentativeValue(SILValue value) : value(value) {}
+  RepresentativeValue(SILInstruction *actorRegionInst)
+      : value(actorRegionInst) {}
+
+  operator bool() const { return bool(value); }
+
+  void print(llvm::raw_ostream &os) const {
+    if (auto *inst = value.dyn_cast<SILInstruction *>()) {
+      os << "ActorRegionIntroducingInst: " << *inst;
+      return;
+    }
+
+    os << *value.get<SILValue>();
+  }
+
+  SILValue getValue() const { return value.get<SILValue>(); }
+  SILValue maybeGetValue() const { return value.dyn_cast<SILValue>(); }
+  bool hasRegionIntroducingInst() const { return value.is<SILInstruction *>(); }
+  SILInstruction *getActorRegionIntroducingInst() const {
+    return value.get<SILInstruction *>();
+  }
+
+  SWIFT_DEBUG_DUMP { print(llvm::dbgs()); }
+
+private:
+  RepresentativeValue(InnerType value) : value(value) {}
+};
+
 /// A persistent data structure that is used to "rewind" partition history so
 /// that we can discover when values become part of the same region.
 ///
@@ -1029,6 +1076,10 @@ struct PartitionOpEvaluator {
     return asImpl().getRepresentative(value);
   }
 
+  RepresentativeValue getRepresentativeValue(Element element) const {
+    return asImpl().getRepresentativeValue(element);
+  }
+
   /// Apply \p op to the partition op.
   void apply(const PartitionOp &op) const {
     if (shouldEmitVerboseLogging()) {
@@ -1409,6 +1460,10 @@ struct PartitionOpEvaluatorBaseImpl : PartitionOpEvaluator<Subclass> {
   /// have one.
   SILValue getRepresentative(SILValue value) const { return SILValue(); }
 
+  RepresentativeValue getRepresentativeValue(Element element) const {
+    return RepresentativeValue();
+  }
+
   /// Check if the representative value of \p elt is closure captured at \p
   /// op.
   ///
@@ -1441,4 +1496,36 @@ struct PartitionOpEvaluatorBasic final
 
 } // namespace swift
 
+namespace llvm {
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                                     const swift::RepresentativeValue &value) {
+  value.print(os);
+  return os;
+}
+
+template <>
+struct DenseMapInfo<swift::RepresentativeValue> {
+  using RepresentativeValue = swift::RepresentativeValue;
+  using InnerType = RepresentativeValue::InnerType;
+  using InnerDenseMapInfo = DenseMapInfo<InnerType>;
+
+  static RepresentativeValue getEmptyKey() {
+    return RepresentativeValue(InnerDenseMapInfo::getEmptyKey());
+  }
+  static RepresentativeValue getTombstoneKey() {
+    return RepresentativeValue(InnerDenseMapInfo::getTombstoneKey());
+  }
+
+  static unsigned getHashValue(RepresentativeValue value) {
+    return InnerDenseMapInfo::getHashValue(value.value);
+  }
+
+  static bool isEqual(RepresentativeValue LHS, RepresentativeValue RHS) {
+    return InnerDenseMapInfo::isEqual(LHS.value, RHS.value);
+  }
+};
+
+} // namespace llvm
+
 #endif // SWIFT_PARTITIONUTILS_H

lib/SILOptimizer/Analysis/RegionAnalysis.cpp

@@ -3264,6 +3264,10 @@ bool BlockPartitionState::recomputeExitFromEntry(
           .maybeGetValue();
     }
 
+    RepresentativeValue getRepresentativeValue(Element element) const {
+      return translator.getValueMap().getRepresentativeValue(element);
+    }
+
     bool isClosureCaptured(Element elt, Operand *op) const {
       auto iter = translator.getValueForId(elt);
       if (!iter)
@@ -3502,6 +3506,11 @@ RegionAnalysisValueMap::maybeGetRepresentative(Element trackableValueID) const {
   return getValueForId(trackableValueID)->getRepresentative().maybeGetValue();
 }
 
+RepresentativeValue
+RegionAnalysisValueMap::getRepresentativeValue(Element trackableValueID) const {
+  return getValueForId(trackableValueID)->getRepresentative();
+}
+
 SILIsolationInfo
 RegionAnalysisValueMap::getIsolationRegion(Element trackableValueID) const {
   auto iter = getValueForId(trackableValueID);

lib/SILOptimizer/Mandatory/TransferNonSendable.cpp

@@ -2029,6 +2029,10 @@ struct DiagnosticEvaluator final
         .maybeGetValue();
   }
 
+  RepresentativeValue getRepresentativeValue(Element element) const {
+    return info->getValueMap().getRepresentativeValue(element);
+  }
+
   bool isClosureCaptured(Element element, Operand *op) const {
     auto value = info->getValueMap().maybeGetRepresentative(element);
     if (!value)