[region-isolation] Ensure that if a var is captured by reference in a closure that we do not allow for later accesses to sendableFields

include/swift/Basic/ImmutablePointerSet.h

@@ -58,19 +58,22 @@
 
 namespace swift {
 
-template <typename PtrTy> class ImmutablePointerSetFactory;
+template <typename T>
+class ImmutablePointerSetFactory;
 
 /// An immutable set of pointers. It is backed by a tail allocated sorted array
 /// ref.
-template <typename T> class ImmutablePointerSet : public llvm::FoldingSetNode {
-  using PtrTy = typename std::add_pointer<T>::type;
+template <typename T>
+class ImmutablePointerSet : public llvm::FoldingSetNode {
   friend class ImmutablePointerSetFactory<T>;
 
+  using PtrTraits = llvm::PointerLikeTypeTraits<T>;
+
   NullablePtr<ImmutablePointerSetFactory<T>> ParentFactory;
-  llvm::ArrayRef<PtrTy> Data;
+  llvm::ArrayRef<T> Data;
 
   ImmutablePointerSet(ImmutablePointerSetFactory<T> *ParentFactory,
-                      llvm::ArrayRef<PtrTy> NewData)
+                      llvm::ArrayRef<T> NewData)
       : ParentFactory(ParentFactory), Data(NewData) {}
 
 public:
@@ -100,7 +103,7 @@ template <typename T> class ImmutablePointerSet : public llvm::FoldingSetNode {
     return !(*this == P);
   }
 
-  unsigned count(PtrTy Ptr) const {
+  unsigned count(T Ptr) const {
     // This returns the first element >= Ptr. Since we know that our array is
     // sorted and uniqued, Ptr must be that element.
     auto LowerBound = std::lower_bound(begin(), end(), Ptr);
@@ -113,17 +116,19 @@ template <typename T> class ImmutablePointerSet : public llvm::FoldingSetNode {
     return *LowerBound == Ptr;
   }
 
-  using iterator = typename llvm::ArrayRef<PtrTy>::iterator;
+  using iterator = typename llvm::ArrayRef<T>::iterator;
   iterator begin() const { return Data.begin(); }
   iterator end() const { return Data.end(); }
+  llvm::iterator_range<iterator> range() const { return {begin(), end()}; }
+  llvm::ArrayRef<T> data() const { return Data; }
 
   unsigned size() const { return Data.size(); }
   bool empty() const { return Data.empty(); }
 
   void Profile(llvm::FoldingSetNodeID &ID) const {
     assert(!Data.empty() && "Should not profile empty ImmutablePointerSet");
-    for (PtrTy P : Data) {
-      ID.AddPointer(P);
+    for (T P : Data) {
+      ID.AddPointer(PtrTraits::getAsVoidPointer(P));
     }
   }
 
@@ -177,10 +182,11 @@ template <typename T> class ImmutablePointerSet : public llvm::FoldingSetNode {
   }
 };
 
-template <typename T> class ImmutablePointerSetFactory {
-  using PtrTy = typename std::add_pointer<T>::type;
-
+template <typename T>
+class ImmutablePointerSetFactory {
   using PtrSet = ImmutablePointerSet<T>;
+  using PtrTraits = typename PtrSet::PtrTraits;
+
   // This is computed out-of-line so that ImmutablePointerSetFactory is
   // treated as a complete type.
   static const unsigned AllocAlignment;
@@ -205,7 +211,7 @@ template <typename T> class ImmutablePointerSetFactory {
 
   /// Given a sorted and uniqued list \p Array, return the ImmutablePointerSet
   /// containing Array. Asserts if \p Array is not sorted and uniqued.
-  PtrSet *get(llvm::ArrayRef<PtrTy> Array) {
+  PtrSet *get(llvm::ArrayRef<T> Array) {
     if (Array.empty())
       return ImmutablePointerSetFactory::getEmptySet();
 
@@ -215,8 +221,8 @@ template <typename T> class ImmutablePointerSetFactory {
     assert(is_sorted_and_uniqued(Array));
 
     llvm::FoldingSetNodeID ID;
-    for (PtrTy Ptr : Array) {
-      ID.AddPointer(Ptr);
+    for (T Ptr : Array) {
+      ID.AddPointer(PtrTraits::getAsVoidPointer(Ptr));
     }
 
     void *InsertPt;
@@ -225,7 +231,7 @@ template <typename T> class ImmutablePointerSetFactory {
     }
 
     size_t NumElts = Array.size();
-    size_t MemSize = sizeof(PtrSet) + sizeof(PtrTy) * NumElts;
+    size_t MemSize = sizeof(PtrSet) + sizeof(T) * NumElts;
 
     // Allocate the memory.
     auto *Mem =
@@ -234,8 +240,8 @@ template <typename T> class ImmutablePointerSetFactory {
     // Copy in the pointers into the tail allocated memory. We do not need to do
     // any sorting/uniquing ourselves since we assume that our users perform
     // this task for us.
-    llvm::MutableArrayRef<PtrTy> DataMem(reinterpret_cast<PtrTy *>(&Mem[1]),
-                                         NumElts);
+    llvm::MutableArrayRef<T> DataMem(reinterpret_cast<T *>(&Mem[1]),
+                                     NumElts);
     std::copy(Array.begin(), Array.end(), DataMem.begin());
 
     // Allocate the new node and insert it into the Set.
@@ -244,7 +250,35 @@ template <typename T> class ImmutablePointerSetFactory {
     return NewNode;
   }
 
-  PtrSet *merge(PtrSet *S1, llvm::ArrayRef<PtrTy> S2) {
+  PtrSet *get(T value) {
+    llvm::FoldingSetNodeID ID;
+    ID.AddPointer(PtrTraits::getAsVoidPointer(value));
+
+    void *InsertPt;
+    if (auto *PSet = Set.FindNodeOrInsertPos(ID, InsertPt)) {
+      return PSet;
+    }
+
+    size_t NumElts = 1;
+    size_t MemSize = sizeof(PtrSet) + sizeof(T) * NumElts;
+
+    // Allocate the memory.
+    auto *Mem =
+        reinterpret_cast<PtrSet *>(Allocator.Allocate(MemSize, AllocAlignment));
+
+    // Copy in the pointers into the tail allocated memory. We do not need to do
+    // any sorting/uniquing ourselves since we assume that our users perform
+    // this task for us.
+    llvm::MutableArrayRef<T> DataMem(reinterpret_cast<T *>(&Mem[1]), NumElts);
+    DataMem[0] = value;
+
+    // Allocate the new node and insert it into the Set.
+    auto *NewNode = new (Mem) PtrSet(this, DataMem);
+    Set.InsertNode(NewNode, InsertPt);
+    return NewNode;
+  }
+
+  PtrSet *merge(PtrSet *S1, llvm::ArrayRef<T> S2) {
     if (S1->empty())
       return get(S2);
 
@@ -266,7 +300,7 @@ template <typename T> class ImmutablePointerSetFactory {
     // perform a sorted set merging algorithm to create the ID. We also count
     // the number of unique elements for allocation purposes.
     unsigned NumElts = 0;
-    set_union_for_each(*S1, S2, [&ID, &NumElts](const PtrTy Ptr) -> void {
+    set_union_for_each(*S1, S2, [&ID, &NumElts](const T Ptr) -> void {
       ID.AddPointer(Ptr);
       NumElts++;
     });
@@ -277,7 +311,7 @@ template <typename T> class ImmutablePointerSetFactory {
       return PSet;
     }
 
-    unsigned MemSize = sizeof(PtrSet) + sizeof(PtrTy) * NumElts;
+    unsigned MemSize = sizeof(PtrSet) + sizeof(T) * NumElts;
 
     // Allocate the memory.
     auto *Mem =
@@ -286,8 +320,7 @@ template <typename T> class ImmutablePointerSetFactory {
     // Copy in the union of the two pointer sets into the tail allocated
     // memory. Since we know that our sorted arrays are uniqued, we can use
     // set_union to get the uniqued sorted array that we want.
-    llvm::MutableArrayRef<PtrTy> DataMem(reinterpret_cast<PtrTy *>(&Mem[1]),
-                                         NumElts);
+    llvm::MutableArrayRef<T> DataMem(reinterpret_cast<T *>(&Mem[1]), NumElts);
     std::set_union(S1->begin(), S1->end(), S2.begin(), S2.end(),
                    DataMem.begin());
 
@@ -316,8 +349,8 @@ template <typename T> class ImmutablePointerSetFactory {
     // perform a sorted set merging algorithm to create the ID. We also count
     // the number of unique elements for allocation purposes.
     unsigned NumElts = 0;
-    set_union_for_each(*S1, *S2, [&ID, &NumElts](const PtrTy Ptr) -> void {
-      ID.AddPointer(Ptr);
+    set_union_for_each(*S1, *S2, [&ID, &NumElts](const T Ptr) -> void {
+      ID.AddPointer(PtrTraits::getAsVoidPointer(Ptr));
       NumElts++;
     });
 
@@ -327,7 +360,7 @@ template <typename T> class ImmutablePointerSetFactory {
       return PSet;
     }
 
-    unsigned MemSize = sizeof(PtrSet) + sizeof(PtrTy) * NumElts;
+    unsigned MemSize = sizeof(PtrSet) + sizeof(T) * NumElts;
 
     // Allocate the memory.
     auto *Mem =
@@ -336,8 +369,7 @@ template <typename T> class ImmutablePointerSetFactory {
     // Copy in the union of the two pointer sets into the tail allocated
     // memory. Since we know that our sorted arrays are uniqued, we can use
     // set_union to get the uniqued sorted array that we want.
-    llvm::MutableArrayRef<PtrTy> DataMem(reinterpret_cast<PtrTy *>(&Mem[1]),
-                                         NumElts);
+    llvm::MutableArrayRef<T> DataMem(reinterpret_cast<T *>(&Mem[1]), NumElts);
     std::set_union(S1->begin(), S1->end(), S2->begin(), S2->end(),
                    DataMem.begin());
 
@@ -356,8 +388,8 @@ template <typename T>
 #if !defined(_MSC_VER) || defined(__clang__)
 constexpr
 #endif
-const unsigned ImmutablePointerSetFactory<T>::AllocAlignment =
-    (alignof(PtrSet) > alignof(PtrTy)) ? alignof(PtrSet) : alignof(PtrTy);
+    const unsigned ImmutablePointerSetFactory<T>::AllocAlignment =
+        (alignof(PtrSet) > alignof(T)) ? alignof(PtrSet) : alignof(T);
 
 } // end swift namespace
 

include/swift/SIL/SILBasicBlock.h

@@ -231,6 +231,52 @@ public SwiftObjectHeader {
   const_reverse_iterator rbegin() const { return InstList.rbegin(); }
   const_reverse_iterator rend() const { return InstList.rend(); }
 
+  llvm::iterator_range<iterator> getRangeStartingAtInst(SILInstruction *inst) {
+    assert(inst->getParent() == this);
+    return {inst->getIterator(), end()};
+  }
+
+  llvm::iterator_range<iterator> getRangeEndingAtInst(SILInstruction *inst) {
+    assert(inst->getParent() == this);
+    return {begin(), inst->getIterator()};
+  }
+
+  llvm::iterator_range<reverse_iterator>
+  getReverseRangeStartingAtInst(SILInstruction *inst) {
+    assert(inst->getParent() == this);
+    return {inst->getReverseIterator(), rend()};
+  }
+
+  llvm::iterator_range<reverse_iterator>
+  getReverseRangeEndingAtInst(SILInstruction *inst) {
+    assert(inst->getParent() == this);
+    return {rbegin(), inst->getReverseIterator()};
+  }
+
+  llvm::iterator_range<const_iterator>
+  getRangeStartingAtInst(SILInstruction *inst) const {
+    assert(inst->getParent() == this);
+    return {inst->getIterator(), end()};
+  }
+
+  llvm::iterator_range<const_iterator>
+  getRangeEndingAtInst(SILInstruction *inst) const {
+    assert(inst->getParent() == this);
+    return {begin(), inst->getIterator()};
+  }
+
+  llvm::iterator_range<const_reverse_iterator>
+  getReverseRangeStartingAtInst(SILInstruction *inst) const {
+    assert(inst->getParent() == this);
+    return {inst->getReverseIterator(), rend()};
+  }
+
+  llvm::iterator_range<const_reverse_iterator>
+  getReverseRangeEndingAtInst(SILInstruction *inst) const {
+    assert(inst->getParent() == this);
+    return {rbegin(), inst->getReverseIterator()};
+  }
+
   /// Allows deleting instructions while iterating over all instructions of the
   /// block.
   ///