[ADT] Add is_splat overload accepting initializer_list

[kuhar]

Summary

Allow for is_splat to be used inline, similar to is_contained, e.g.,

if (is_splat({type1, type2, type3, type4}))
  ...

which is much more concise and less typo-prone than an equivalent chain of equality comparisons.

My immediate motivation is to clean up some code in the SPIR-V dialect that currently needs to either construct a temporary container or use makeArrayRef before calling is_splat.

[dblaikie]

llvm/include/llvm/ADT/STLExtras.h

1801

hmm, Values is already a valid range, so it's a bit awkward/unfortunate to make a new range from it.

could we make this add the template parameter explicitly?

return is_splat<std::initializer_list<T>>(std::move(Values));

(the move doesn't do much (since std::initializer_list is immutable, yeah?), but I think it's that or you have to make the parameter a reference type, to work with the universal reference stuff?)

[kuhar]

llvm/include/llvm/ADT/STLExtras.h

1801

This looked like an infinite recursion to me initially, but you are right, move does fix it. Thanks for the suggestion!

[dblaikie]

Looks good, thanks!

llvm/include/llvm/ADT/STLExtras.h

 /// in a container are same.
 template <typename R>
 bool is_splat(R &&Range) {
   size_t range_size = size(Range);
   return range_size != 0 && (range_size == 1 ||
          std::equal(adl_begin(Range) + 1, adl_end(Range), adl_begin(Range)));
 }
 
+/// Returns true iff all Values in the initializer lists are same.
+template <typename T> bool is_splat(std::initializer_list<T> Values) {
+  return is_splat<std::initializer_list<T>>(std::move(Values));
+}
+
 /// Provide a container algorithm similar to C++ Library Fundamentals v2's
 /// `erase_if` which is equivalent to:
 ///
 ///   C.erase(remove_if(C, pred), C.end());
 ///
 /// This version works for any container with an erase method call accepting
 /// two iterators.
 template <typename Container, typename UnaryPredicate>

llvm/unittests/ADT/STLExtrasTest.cpp

#endif
   // Erasing the front including the current doesn't break incrementing.
   L.erase(L.begin(), std::prev(L.end()));
   ++I;
   EXPECT_EQ(&*L.begin(), *I);
   ++I;
   EXPECT_EQ(EIR.end(), I);
 }
 
-TEST(STLExtrasTest, splat) {
+TEST(STLExtrasTest, IsSplat) {
   std::vector<int> V;
   EXPECT_FALSE(is_splat(V));
 
   V.push_back(1);
   EXPECT_TRUE(is_splat(V));
 
   V.push_back(1);
   V.push_back(1);
   EXPECT_TRUE(is_splat(V));
 
   V.push_back(2);
   EXPECT_FALSE(is_splat(V));
 }
 
+TEST(STLExtrasTest, IsSplatInitializerList) {
+  EXPECT_TRUE(is_splat({1}));
+  EXPECT_TRUE(is_splat({1, 1}));
+  EXPECT_FALSE(is_splat({1, 2}));
+  EXPECT_TRUE(is_splat({1, 1, 1}));
+}
+
 TEST(STLExtrasTest, to_address) {
   int *V1 = new int;
   EXPECT_EQ(V1, to_address(V1));
 
   // Check fancy pointer overload for unique_ptr
   std::unique_ptr<int> V2 = std::make_unique<int>(0);
   EXPECT_EQ(V2.get(), llvm::to_address(V2));