[mlir] Allow RegionRange to accept ArrayRef<Region *>

[Mogball]

Summary

Adds another pointer to the union in RegionRange to allow RegionRange to work on ArrayRef<Region *> (i.e. vectors of Region *).

[Mogball]

rebase (fix bazel build maybe)

mlir/include/mlir/IR/Region.h

 
 /// This class provides an abstraction over the different types of ranges over
 /// Regions. In many cases, this prevents the need to explicitly materialize a
 /// SmallVector/std::vector. This class should be used in places that are not
 /// suitable for a more derived type (e.g. ArrayRef) or a template range
 /// parameter.
 class RegionRange
     : public llvm::detail::indexed_accessor_range_base<
-          RegionRange, PointerUnion<Region *, const std::unique_ptr<Region> *>,
+          RegionRange,
+          PointerUnion<Region *, const std::unique_ptr<Region> *, Region **>,
           Region *, Region *, Region *> {
-  /// The type representing the owner of this range. This is either a list of
-  /// values, operands, or results.
-  using OwnerT = PointerUnion<Region *, const std::unique_ptr<Region> *>;
+  /// The type representing the owner of this range. This is either an owning
+  /// list of regions, a list of region unique pointers, or a list of region
+  /// pointers.
+  using OwnerT =
+      PointerUnion<Region *, const std::unique_ptr<Region> *, Region **>;
 
 public:
   using RangeBaseT::RangeBaseT;
 
   RegionRange(MutableArrayRef<Region> regions = llvm::None);
 
   template <typename Arg,
             typename = typename std::enable_if_t<std::is_constructible<
                 ArrayRef<std::unique_ptr<Region>>, Arg>::value>>
   RegionRange(Arg &&arg)
       : RegionRange(ArrayRef<std::unique_ptr<Region>>(std::forward<Arg>(arg))) {
   }
   RegionRange(ArrayRef<std::unique_ptr<Region>> regions);
+  RegionRange(ArrayRef<Region *> regions);
 
 private:
   /// See `llvm::detail::indexed_accessor_range_base` for details.
   static OwnerT offset_base(const OwnerT &owner, ptrdiff_t index);
   /// See `llvm::detail::indexed_accessor_range_base` for details.
   static Region *dereference_iterator(const OwnerT &owner, ptrdiff_t index);
 
   /// Allow access to `offset_base` and `dereference_iterator`.
   friend RangeBaseT;
 };
 
 } // namespace mlir
 
 #endif // MLIR_IR_REGION_H

mlir/lib/IR/Region.cpp

 //===----------------------------------------------------------------------===//
 // RegionRange
 //===----------------------------------------------------------------------===//
 
 RegionRange::RegionRange(MutableArrayRef<Region> regions)
     : RegionRange(regions.data(), regions.size()) {}
 RegionRange::RegionRange(ArrayRef<std::unique_ptr<Region>> regions)
     : RegionRange(regions.data(), regions.size()) {}
+RegionRange::RegionRange(ArrayRef<Region *> regions)
+    : RegionRange(const_cast<Region **>(regions.data()), regions.size()) {}
 
 /// See `llvm::detail::indexed_accessor_range_base` for details.
 RegionRange::OwnerT RegionRange::offset_base(const OwnerT &owner,
                                              ptrdiff_t index) {
-  if (auto *operand = owner.dyn_cast<const std::unique_ptr<Region> *>())
-    return operand + index;
+  if (auto *region = owner.dyn_cast<const std::unique_ptr<Region> *>())
+    return region + index;
+  if (auto **region = owner.dyn_cast<Region **>())
+    return region + index;
   return &owner.get<Region *>()[index];
 }
 /// See `llvm::detail::indexed_accessor_range_base` for details.
 Region *RegionRange::dereference_iterator(const OwnerT &owner,
                                           ptrdiff_t index) {
-  if (auto *operand = owner.dyn_cast<const std::unique_ptr<Region> *>())
-    return operand[index].get();
+  if (auto *region = owner.dyn_cast<const std::unique_ptr<Region> *>())
+    return region[index].get();
+  if (auto **region = owner.dyn_cast<Region **>())
+    return region[index];
   return &owner.get<Region *>()[index];
 }