Add new indexed_accessor_range_base and indexed_accessor_range classes that simplify defining index-able ranges.

Many ranges want similar functionality from a range type(e.g. slice/drop_front/operator[]/etc.), so these classes provide a generic implementation that may be used by many different types of ranges. This removes some code duplication, and also empowers many of the existing range types in MLIR(e.g. result type ranges, operand ranges, ElementsAttr ranges, etc.). This change only updates RegionRange and ValueRange, more ranges will be updated in followup commits.

PiperOrigin-RevId: 284615679

Author: River707

mlir/include/mlir/IR/Attributes.h

@@ -641,12 +641,12 @@ class DenseElementIndexedIteratorImpl
   /// Return the current index for this iterator, adjusted for the case of a
   /// splat.
   ptrdiff_t getDataIndex() const {
-    bool isSplat = this->object.getInt();
+    bool isSplat = this->base.getInt();
     return isSplat ? 0 : this->index;
   }
 
-  /// Return the data object pointer.
-  const char *getData() const { return this->object.getPointer(); }
+  /// Return the data base pointer.
+  const char *getData() const { return this->base.getPointer(); }
 };
 } // namespace detail
 

mlir/include/mlir/IR/Block.h

@@ -460,9 +460,9 @@ class SuccessorIterator final
                                   Block *>(object, index) {}
 
   SuccessorIterator(const SuccessorIterator &other)
-      : SuccessorIterator(other.object, other.index) {}
+      : SuccessorIterator(other.base, other.index) {}
 
-  Block *operator*() const { return this->object->getSuccessor(this->index); }
+  Block *operator*() const { return this->base->getSuccessor(this->index); }
 
   /// Get the successor number in the terminator.
   unsigned getSuccessorIndex() const { return this->index; }

mlir/include/mlir/IR/Operation.h

@@ -668,7 +668,7 @@ class OperandIterator final
       : indexed_accessor_iterator<OperandIterator, Operation *, Value *,
                                   Value *, Value *>(object, index) {}
 
-  Value *operator*() const { return this->object->getOperand(this->index); }
+  Value *operator*() const { return this->base->getOperand(this->index); }
 };
 
 /// This class implements the operand type iterators for the Operation
@@ -721,11 +721,11 @@ class ResultIterator final
                                        Value *, Value *> {
 public:
   /// Initializes the result iterator to the specified index.
-  ResultIterator(Operation *object, unsigned index)
+  ResultIterator(Operation *base, unsigned index)
       : indexed_accessor_iterator<ResultIterator, Operation *, Value *, Value *,
-                                  Value *>(object, index) {}
+                                  Value *>(base, index) {}
 
-  Value *operator*() const { return this->object->getResult(this->index); }
+  Value *operator*() const { return this->base->getResult(this->index); }
 };
 
 /// This class implements the result type iterators for the Operation
@@ -799,15 +799,19 @@ inline auto Operation::getResultTypes() -> result_type_range {
 /// 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 ValueRange {
+class ValueRange
+    : public detail::indexed_accessor_range_base<
+          ValueRange,
+          llvm::PointerUnion<Value *const *, OpOperand *, OpResult *>, Value *,
+          Value *, Value *> {
   /// The type representing the owner of this range. This is either a list of
   /// values, operands, or results.
   using OwnerT = llvm::PointerUnion<Value *const *, OpOperand *, OpResult *>;
 
 public:
-  ValueRange(const ValueRange &) = default;
-  ValueRange(ValueRange &&) = default;
-  ValueRange &operator=(const ValueRange &) = default;
+  using detail::indexed_accessor_range_base<
+      ValueRange, OwnerT, Value *, Value *,
+      Value *>::indexed_accessor_range_base;
 
   template <typename Arg,
             typename = typename std::enable_if_t<
@@ -822,46 +826,15 @@ class ValueRange {
   ValueRange(iterator_range<OperandIterator> values);
   ValueRange(iterator_range<ResultIterator> values);
 
-  /// An iterator element of this range.
-  class Iterator : public indexed_accessor_iterator<Iterator, OwnerT, Value *,
-                                                    Value *, Value *> {
-  public:
-    Value *operator*() const;
-
-  private:
-    Iterator(OwnerT owner, unsigned curIndex);
-
-    /// Allow access to the constructor.
-    friend ValueRange;
-  };
-
-  Iterator begin() const { return Iterator(owner, 0); }
-  Iterator end() const { return Iterator(owner, count); }
-  Value *operator[](unsigned index) const {
-    assert(index < size() && "invalid index for value range");
-    return *std::next(begin(), index);
-  }
-
-  /// Return the size of this range.
-  size_t size() const { return count; }
-
-  /// Return if the range is empty.
-  bool empty() const { return size() == 0; }
-
-  /// Drop the first N elements, and keep M elements.
-  ValueRange slice(unsigned n, unsigned m) const;
-  /// Drop the first n elements.
-  ValueRange drop_front(unsigned n = 1) const;
-  /// Drop the last n elements.
-  ValueRange drop_back(unsigned n = 1) const;
-
 private:
-  ValueRange(OwnerT owner, unsigned count) : owner(owner), count(count) {}
-
-  /// The object that owns the provided range of values.
-  OwnerT owner;
-  /// The size from the owning range.
-  unsigned count;
+  /// See `detail::indexed_accessor_range_base` for details.
+  static OwnerT offset_base(const OwnerT &owner, ptrdiff_t index);
+  /// See `detail::indexed_accessor_range_base` for details.
+  static Value *dereference_iterator(const OwnerT &owner, ptrdiff_t index);
+
+  /// Allow access to `offset_base` and `dereference_iterator`.
+  friend detail::indexed_accessor_range_base<ValueRange, OwnerT, Value *,
+                                             Value *, Value *>;
 };
 
 } // end namespace mlir

mlir/include/mlir/IR/Region.h

@@ -165,14 +165,19 @@ class Region {
 /// 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 {
+class RegionRange
+    : public detail::indexed_accessor_range_base<
+          RegionRange,
+          llvm::PointerUnion<Region *, const std::unique_ptr<Region> *>,
+          Region *, Region *, Region *> {
   /// The type representing the owner of this range. This is either a list of
   /// values, operands, or results.
   using OwnerT = llvm::PointerUnion<Region *, const std::unique_ptr<Region> *>;
 
 public:
-  RegionRange(const RegionRange &) = default;
-  RegionRange(RegionRange &&) = default;
+  using detail::indexed_accessor_range_base<
+      RegionRange, OwnerT, Region *, Region *,
+      Region *>::indexed_accessor_range_base;
 
   RegionRange(MutableArrayRef<Region> regions = llvm::None);
 
@@ -184,33 +189,15 @@ class RegionRange {
   }
   RegionRange(ArrayRef<std::unique_ptr<Region>> regions);
 
-  /// An iterator element of this range.
-  class Iterator : public indexed_accessor_iterator<Iterator, OwnerT, Region *,
-                                                    Region *, Region *> {
-  public:
-    Region *operator*() const;
-
-  private:
-    Iterator(OwnerT owner, unsigned curIndex);
-    /// Allow access to the constructor.
-    friend RegionRange;
-  };
-  Iterator begin() const { return Iterator(owner, 0); }
-  Iterator end() const { return Iterator(owner, count); }
-  Region *operator[](unsigned index) const {
-    assert(index < size() && "invalid index for region range");
-    return *std::next(begin(), index);
-  }
-  /// Return the size of this range.
-  size_t size() const { return count; }
-  /// Return if the range is empty.
-  bool empty() const { return size() == 0; }
-
 private:
-  /// The object that owns the provided range of regions.
-  OwnerT owner;
-  /// The size from the owning range.
-  unsigned count;
+  /// See `detail::indexed_accessor_range_base` for details.
+  static OwnerT offset_base(const OwnerT &owner, ptrdiff_t index);
+  /// See `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 detail::indexed_accessor_range_base<RegionRange, OwnerT, Region *,
+                                             Region *, Region *>;
 };
 
 } // end namespace mlir

mlir/include/mlir/Support/STLExtras.h

@@ -147,24 +147,24 @@ using is_invocable = is_detected<detail::is_invocable, Callable, Args...>;
 //     Extra additions to <iterator>
 //===----------------------------------------------------------------------===//
 
-/// A utility class used to implement an iterator that contains some object and
-/// an index. The iterator moves the index but keeps the object constant.
-template <typename DerivedT, typename ObjectType, typename T,
+/// A utility class used to implement an iterator that contains some base object
+/// and an index. The iterator moves the index but keeps the base constant.
+template <typename DerivedT, typename BaseT, typename T,
           typename PointerT = T *, typename ReferenceT = T &>
 class indexed_accessor_iterator
     : public llvm::iterator_facade_base<DerivedT,
                                         std::random_access_iterator_tag, T,
                                         std::ptrdiff_t, PointerT, ReferenceT> {
 public:
   ptrdiff_t operator-(const indexed_accessor_iterator &rhs) const {
-    assert(object == rhs.object && "incompatible iterators");
+    assert(base == rhs.base && "incompatible iterators");
     return index - rhs.index;
   }
   bool operator==(const indexed_accessor_iterator &rhs) const {
-    return object == rhs.object && index == rhs.index;
+    return base == rhs.base && index == rhs.index;
   }
   bool operator<(const indexed_accessor_iterator &rhs) const {
-    assert(object == rhs.object && "incompatible iterators");
+    assert(base == rhs.base && "incompatible iterators");
     return index < rhs.index;
   }
 
@@ -180,16 +180,134 @@ class indexed_accessor_iterator
   /// Returns the current index of the iterator.
   ptrdiff_t getIndex() const { return index; }
 
-  /// Returns the current object of the iterator.
-  const ObjectType &getObject() const { return object; }
+  /// Returns the current base of the iterator.
+  const BaseT &getBase() const { return base; }
 
 protected:
-  indexed_accessor_iterator(ObjectType object, ptrdiff_t index)
-      : object(object), index(index) {}
-  ObjectType object;
+  indexed_accessor_iterator(BaseT base, ptrdiff_t index)
+      : base(base), index(index) {}
+  BaseT base;
   ptrdiff_t index;
 };
 
+namespace detail {
+/// The class represents the base of a range of indexed_accessor_iterators. It
+/// provides support for many different range functionalities, e.g.
+/// drop_front/slice/etc.. Derived range classes must implement the following
+/// static methods:
+///   * ReferenceT dereference_iterator(const BaseT &base, ptrdiff_t index)
+///     - Derefence an iterator pointing to the base object at the given index.
+///   * BaseT offset_base(const BaseT &base, ptrdiff_t index)
+///     - Return a new base that is offset from the provide base by 'index'
+///       elements.
+template <typename DerivedT, typename BaseT, typename T,
+          typename PointerT = T *, typename ReferenceT = T &>
+class indexed_accessor_range_base {
+public:
+  /// An iterator element of this range.
+  class iterator : public indexed_accessor_iterator<iterator, BaseT, T,
+                                                    PointerT, ReferenceT> {
+  public:
+    // Index into this iterator, invoking a static method on the derived type.
+    ReferenceT operator*() const {
+      return DerivedT::dereference_iterator(this->getBase(), this->getIndex());
+    }
+
+  private:
+    iterator(BaseT owner, ptrdiff_t curIndex)
+        : indexed_accessor_iterator<iterator, BaseT, T, PointerT, ReferenceT>(
+              owner, curIndex) {}
+
+    /// Allow access to the constructor.
+    friend indexed_accessor_range_base<DerivedT, BaseT, T, PointerT,
+                                       ReferenceT>;
+  };
+
+  iterator begin() const { return iterator(base, 0); }
+  iterator end() const { return iterator(base, count); }
+  ReferenceT operator[](unsigned index) const {
+    assert(index < size() && "invalid index for value range");
+    return *std::next(begin(), index);
+  }
+
+  /// Return the size of this range.
+  size_t size() const { return count; }
+
+  /// Return if the range is empty.
+  bool empty() const { return size() == 0; }
+
+  /// Drop the first N elements, and keep M elements.
+  DerivedT slice(unsigned n, unsigned m) const {
+    assert(n + m <= size() && "invalid size specifiers");
+    return DerivedT(DerivedT::offset_base(base, n), m);
+  }
+
+  /// Drop the first n elements.
+  DerivedT drop_front(unsigned n = 1) const {
+    assert(size() >= n && "Dropping more elements than exist");
+    return slice(n, size() - n);
+  }
+  /// Drop the last n elements.
+  DerivedT drop_back(unsigned n = 1) const {
+    assert(size() >= n && "Dropping more elements than exist");
+    return DerivedT(base, size() - n);
+  }
+
+protected:
+  indexed_accessor_range_base(BaseT base, ptrdiff_t count)
+      : base(base), count(count) {}
+  indexed_accessor_range_base(const indexed_accessor_range_base &) = default;
+  indexed_accessor_range_base(indexed_accessor_range_base &&) = default;
+  indexed_accessor_range_base &
+  operator=(const indexed_accessor_range_base &) = default;
+
+  /// The base that owns the provided range of values.
+  BaseT base;
+  /// The size from the owning range.
+  ptrdiff_t count;
+};
+} // end namespace detail
+
+/// This class provides an implementation of a range of
+/// indexed_accessor_iterators where the base is not indexable. Ranges with
+/// bases that are offsetable should derive from indexed_accessor_range_base
+/// instead. Derived range classes are expected to implement the following
+/// static method:
+///   * ReferenceT dereference_iterator(const BaseT &base, ptrdiff_t index)
+///     - Derefence an iterator pointing to a parent base at the given index.
+template <typename DerivedT, typename BaseT, typename T,
+          typename PointerT = T *, typename ReferenceT = T &>
+class indexed_accessor_range
+    : public detail::indexed_accessor_range_base<
+          indexed_accessor_range<DerivedT, BaseT, T, PointerT, ReferenceT>,
+          std::pair<BaseT, ptrdiff_t>, T, PointerT, ReferenceT> {
+protected:
+  indexed_accessor_range(BaseT base, ptrdiff_t startIndex, ptrdiff_t count)
+      : detail::indexed_accessor_range_base<
+            DerivedT, std::pair<BaseT, ptrdiff_t>, T, PointerT, ReferenceT>(
+            std::make_pair(base, startIndex), count) {}
+
+private:
+  /// See `detail::indexed_accessor_range_base` for details.
+  static std::pair<BaseT, ptrdiff_t>
+  offset_base(const std::pair<BaseT, ptrdiff_t> &base, ptrdiff_t index) {
+    // We encode the internal base as a pair of the derived base and a start
+    // index into the derived base.
+    return std::make_pair(base.first, base.second + index);
+  }
+  /// See `detail::indexed_accessor_range_base` for details.
+  static ReferenceT
+  dereference_iterator(const std::pair<BaseT, ptrdiff_t> &base,
+                       ptrdiff_t index) {
+    return DerivedT::dereference_iterator(base.first, base.second + index);
+  }
+
+  /// Allow access to `offset_base` and `dereference_iterator`.
+  friend detail::indexed_accessor_range_base<
+      indexed_accessor_range<DerivedT, BaseT, T, PointerT, ReferenceT>,
+      std::pair<BaseT, ptrdiff_t>, T, PointerT, ReferenceT>;
+};
+
 /// Given a container of pairs, return a range over the second elements.
 template <typename ContainerTy> auto make_second_range(ContainerTy &&c) {
   return llvm::map_range(

mlir/lib/IR/Attributes.cpp

@@ -527,7 +527,7 @@ DenseElementsAttr::AttributeElementIterator::AttributeElementIterator(
 
 /// Accesses the Attribute value at this iterator position.
 Attribute DenseElementsAttr::AttributeElementIterator::operator*() const {
-  auto owner = getFromOpaquePointer(object).cast<DenseElementsAttr>();
+  auto owner = getFromOpaquePointer(base).cast<DenseElementsAttr>();
   Type eltTy = owner.getType().getElementType();
   if (auto intEltTy = eltTy.dyn_cast<IntegerType>()) {
     if (intEltTy.getWidth() == 1)