[llvm] remove Sequence::asSmallVector()

[gchatelet]

Summary

There's no need for toSmallVector() as SmallVector.h already provides a to_vector free function that takes a range.

[• Quuxplusone]

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

385–387

The <16> here confuses me. I think to_vector should just figure out the appropriate small-buffer capacity, the same way SmallVector itself does. I think the way to do that would be to add this diff in SmallVector.h:

--- a/llvm/include/llvm/ADT/SmallVector.h
+++ b/llvm/include/llvm/ADT/SmallVector.h
@@ -1249,6 +1249,13 @@ to_vector(R &&Range) {
   return {std::begin(Range), std::end(Range)};
 }
 
+template <typename R>
+SmallVector<typename std::remove_const<typename std::remove_reference<
+                decltype(*std::begin(std::declval<R &>()))>::type>::type>
+to_vector(R &&Range) {
+  return {std::begin(Range), std::end(Range)};
+}
+
 } // end namespace llvm

It would be reasonable, but not strictly necessary, to then audit the codebase for places where llvm::to_vector<N>(r) is called with a template argument, and update them to call just llvm::to_vector(r). If you were to do that, presumably it'd be in a separate (and unfortunately massive) PR.

llvm/include/llvm/ADT/Sequence.h

 /// values. The names are intentionally kept very short as they tend to occur
 /// in common and widely used contexts.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_ADT_SEQUENCE_H
 #define LLVM_ADT_SEQUENCE_H
 
-#include "llvm/ADT/SmallVector.h"
-
 #include <cstddef>  //std::ptrdiff_t
 #include <iterator> //std::random_access_iterator_tag
 
 namespace llvm {
 
 namespace detail {
 
 template <typename T, bool IsReversed> struct iota_range_iterator {
template <typename ValueT> struct iota_range {
   bool empty() const { return Begin == End; }
 
   auto begin() const { return const_iterator(Begin); }
   auto end() const { return const_iterator(End); }
 
   auto rbegin() const { return const_reverse_iterator(End - 1); }
   auto rend() const { return const_reverse_iterator(Begin - 1); }
 
-  auto asSmallVector() const { return SmallVector<ValueT>(begin(), end()); }
-
 private:
   static_assert(std::is_same<ValueT, std::remove_cv_t<ValueT>>::value,
                 "ValueT must not be const nor volatile");
 };
 
 template <typename ValueT> auto seq(ValueT Begin, ValueT End) {
   return iota_range<ValueT>(Begin, End);
 }
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_SEQUENCE_H

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

 #include "../PassDetail.h"
 #include "PredicateTree.h"
 #include "mlir/Dialect/PDL/IR/PDL.h"
 #include "mlir/Dialect/PDL/IR/PDLTypes.h"
 #include "mlir/Dialect/PDLInterp/IR/PDLInterp.h"
 #include "mlir/Pass/Pass.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/ScopedHashTable.h"
+#include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 using namespace mlir;
 using namespace mlir::pdl_to_pdl_interp;
 
 //===----------------------------------------------------------------------===//
 // PatternLowering
 //===----------------------------------------------------------------------===//
void PatternLowering::generateSwitch(SwitchNode *switchNode,
                                      Block *currentBlock, Qualifier *question,
                                      Value val, Block *defaultDest) {
   // If the switch question is not an exact answer, i.e. for the `at_least`
   // cases, we generate a special block sequence.
   Predicates::Kind kind = question->getKind();
   if (kind == Predicates::OperandCountAtLeastQuestion ||
       kind == Predicates::ResultCountAtLeastQuestion) {
     // Order the children such that the cases are in reverse numerical order.
-    SmallVector<unsigned> sortedChildren =
-        llvm::seq<unsigned>(0, switchNode->getChildren().size())
-            .asSmallVector();
+    SmallVector<unsigned> sortedChildren = llvm::to_vector<16>(
+        llvm::seq<unsigned>(0, switchNode->getChildren().size()));
     llvm::sort(sortedChildren, [&](unsigned lhs, unsigned rhs) {
       return cast<UnsignedAnswer>(switchNode->getChild(lhs).first)->getValue() >
              cast<UnsignedAnswer>(switchNode->getChild(rhs).first)->getValue();
     });
 
     // Build the destination for each child using the next highest child as a
     // a failure destination. This essentially creates the following control
     // flow:
     //

mlir/lib/Dialect/Linalg/Transforms/Vectorization.cpp

 #include "mlir/Dialect/Vector/VectorOps.h"
 #include "mlir/IR/AffineExpr.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/Pass/Pass.h"
 #include "mlir/Support/LLVM.h"
 #include "mlir/Transforms/RegionUtils.h"
 #include "llvm/ADT/ScopeExit.h"
+#include "llvm/ADT/Sequence.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/TypeSwitch.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 #include <type_traits>
 
 using namespace mlir;
 using namespace mlir::linalg;
 
static VectorizationResult vectorizeLinalgIndex(OpBuilder &b, Operation *op,
   IndexOp indexOp = dyn_cast<linalg::IndexOp>(op);
   if (!indexOp)
     return VectorizationResult{VectorizationStatus::Failure, nullptr};
   auto loc = indexOp.getLoc();
   // Compute the static loop sizes of the index op.
   auto targetShape = linalgOp.computeStaticLoopSizes();
   // Compute a one-dimensional index vector for the index op dimension.
   SmallVector<int64_t> constantSeq =
-      llvm::seq<int64_t>(0, targetShape[indexOp.dim()]).asSmallVector();
+      llvm::to_vector<16>(llvm::seq<int64_t>(0, targetShape[indexOp.dim()]));
   ConstantOp constantOp =
       b.create<ConstantOp>(loc, b.getIndexVectorAttr(constantSeq));
   // Return the one-dimensional index vector if it lives in the trailing
   // dimension of the iteration space since the vectorization algorithm in this
   // case can handle the broadcast.
   if (indexOp.dim() == targetShape.size() - 1)
     return VectorizationResult{VectorizationStatus::NewOp, constantOp};
   // Otherwise permute the targetShape to move the index dimension last,
   // broadcast the one-dimensional index vector to the permuted shape, and
   // finally transpose the broadcasted index vector to undo the permutation.
   std::swap(targetShape[indexOp.dim()], targetShape.back());
   auto broadCastOp = b.create<vector::BroadcastOp>(
       loc, VectorType::get(targetShape, b.getIndexType()), constantOp);
   SmallVector<int64_t> transposition =
-      llvm::seq<int64_t>(0, linalgOp.getNumLoops()).asSmallVector();
+      llvm::to_vector<16>(llvm::seq<int64_t>(0, linalgOp.getNumLoops()));
   std::swap(transposition.back(), transposition[indexOp.dim()]);
   auto transposeOp =
       b.create<vector::TransposeOp>(loc, broadCastOp, transposition);
   return VectorizationResult{VectorizationStatus::NewOp, transposeOp};
 }
 
 /// Generic vectorization for a single operation `op`, given already vectorized
 /// operands carried by `bvm`. Vectorization occurs as follows: