[llvm][STLExtras] Move the algorithm `interleave*` methods from MLIR to LLVM

[rriddle]

Summary

These have proved incredibly useful for interleaving values between a range w.r.t to streams. After this revision, the mlir/Support/STLExtras.h is empty. A followup revision will remove it from the tree.

Depends On D78064

[lattner]

Awesome work!

flang/include/flang/Optimizer/Dialect/FIROps.td

251

How does this work?

[rriddle]

flang/include/flang/Optimizer/Dialect/FIROps.td

251

All of the value range types(ValueRange, OperandRange, ResultRange, etc.) have utility getTypes()/getType() methods that return a range of types for the held values. The OpAsmPrinter has operator<< overloads for value and type ranges, so there is generally no need to do this manually.

[lattner]

Huh ok!

[rriddle]

Rebase

[rriddle]

Rebase

flang/include/flang/Optimizer/Dialect/FIROps.td

if (parser.parseOptionalAttrDict(result.attributes) ||
       return mlir::failure();
     return mlir::success();
   }];
 
   let printer = [{
     p << getOperationName() << ' ' << getAttr(inType());
     if (hasLenParams()) {
       // print the LEN parameters to a derived type in parens
-      p << '(';
-      p.printOperands(getLenParams());
-      p << " : ";
-      mlir::interleaveComma(getLenParams(), p.getStream(),
-                            [&](const auto &opnd) {
-                                p.printType(opnd.getType());
-                            });
-      p << ')';
+      p << '(' << getLenParams() << " : " << getLenParams().getTypes() << ')';
     }
     // print the shape of the allocation (if any); all must be index type
     for (auto sh : getShapeOperands()) {
       p << ", ";
       p.printOperand(sh);
     }
     p.printOptionalAttrDict(getAttrs(), {inType(), lenpName()});
   }];

llvm/include/llvm/ADT/STLExtras.h

 // using SFINAE to test for the existence of member functions.
 template <typename T, T> struct SameType;
 
 namespace detail {
 
 template <typename RangeT>
 using IterOfRange = decltype(std::begin(std::declval<RangeT &>()));
 
+template <typename RangeT>
+using ValueOfRange = typename std::remove_reference<decltype(
+    *std::begin(std::declval<RangeT &>()))>::type;
+
 } // end namespace detail
 
 //===----------------------------------------------------------------------===//
 //     Extra additions to <type_traits>
 //===----------------------------------------------------------------------===//
 
 template <typename T>
 struct negation : std::integral_constant<bool, !bool(T::value)> {};

 /// the range R.
 template<typename Container, typename Range = std::initializer_list<
                                  typename Container::value_type>>
 void replace(Container &Cont, typename Container::iterator ContIt,
              typename Container::iterator ContEnd, Range R) {
   replace(Cont, ContIt, ContEnd, R.begin(), R.end());
 }
 
+/// An STL-style algorithm similar to std::for_each that applies a second
+/// functor between every pair of elements.
+///
+/// This provides the control flow logic to, for example, print a
+/// comma-separated list:
+/// \code
+///   interleave(names.begin(), names.end(),
+///              [&](StringRef name) { os << name; },
+///              [&] { os << ", "; });
+/// \endcode
+template <typename ForwardIterator, typename UnaryFunctor,
+          typename NullaryFunctor,
+          typename = typename std::enable_if<
+              !std::is_constructible<StringRef, UnaryFunctor>::value &&
+              !std::is_constructible<StringRef, NullaryFunctor>::value>::type>
+inline void interleave(ForwardIterator begin, ForwardIterator end,
+                       UnaryFunctor each_fn, NullaryFunctor between_fn) {
+  if (begin == end)
+    return;
+  each_fn(*begin);
+  ++begin;
+  for (; begin != end; ++begin) {
+    between_fn();
+    each_fn(*begin);
+  }
+}
+
+template <typename Container, typename UnaryFunctor, typename NullaryFunctor,
+          typename = typename std::enable_if<
+              !std::is_constructible<StringRef, UnaryFunctor>::value &&
+              !std::is_constructible<StringRef, NullaryFunctor>::value>::type>
+inline void interleave(const Container &c, UnaryFunctor each_fn,
+                       NullaryFunctor between_fn) {
+  interleave(c.begin(), c.end(), each_fn, between_fn);
+}
+
+/// Overload of interleave for the common case of string separator.
+template <typename Container, typename UnaryFunctor, typename StreamT,
+          typename T = detail::ValueOfRange<Container>>
+inline void interleave(const Container &c, StreamT &os, UnaryFunctor each_fn,
+                       const StringRef &separator) {
+  interleave(c.begin(), c.end(), each_fn, [&] { os << separator; });
+}
+template <typename Container, typename StreamT,
+          typename T = detail::ValueOfRange<Container>>
+inline void interleave(const Container &c, StreamT &os,
+                       const StringRef &separator) {
+  interleave(
+      c, os, [&](const T &a) { os << a; }, separator);
+}
+
+template <typename Container, typename UnaryFunctor, typename StreamT,
+          typename T = detail::ValueOfRange<Container>>
+inline void interleaveComma(const Container &c, StreamT &os,
+                            UnaryFunctor each_fn) {
+  interleave(c, os, each_fn, ", ");
+}
+template <typename Container, typename StreamT,
+          typename T = detail::ValueOfRange<Container>>
+inline void interleaveComma(const Container &c, StreamT &os) {
+  interleaveComma(c, os, [&](const T &a) { os << a; });
+}
+
 //===----------------------------------------------------------------------===//
 //     Extra additions to <memory>
 //===----------------------------------------------------------------------===//
 
 struct FreeDeleter {
   void operator()(void* v) {
     ::free(v);
   }

mlir/docs/Tutorials/Toy/Ch-6.md

 
 ### Conversion Target
 
 For this conversion, aside from the top-level module, we will be lowering
 everything to the LLVM dialect.
 
 ```c++
   mlir::ConversionTarget target(getContext());
-  target.addLegalDialect<mlir::LLVM::LLVMDialect>();
+  target.addLegalDialect<mlir::LLVMDialect>();
   target.addLegalOp<mlir::ModuleOp, mlir::ModuleTerminatorOp>();
 ```
 
 ### Type Converter
 
 This lowering will also transform the MemRef types which are currently being
 operated on into a representation in LLVM. To perform this conversion, we use a
 TypeConverter as part of the lowering. This converter specifies how one type

mlir/docs/Tutorials/Toy/Ch-7.md

 /// Print an instance of a type registered to the toy dialect.
 void ToyDialect::printType(mlir::Type type,
                            mlir::DialectAsmPrinter &printer) const {
   // Currently the only toy type is a struct type.
   StructType structType = type.cast<StructType>();
 
   // Print the struct type according to the parser format.
   printer << "struct<";
-  mlir::interleaveComma(structType.getElementTypes(), printer);
+  llvm::interleaveComma(structType.getElementTypes(), printer);
   printer << '>';
 }
 ```
 
 Before moving on, let's look at a quick of example showcasing the functionality
 we have now:
 
 ```toy

mlir/examples/toy/Ch1/parser/AST.cpp

void printLitHelper(ExprAST *litOrNum) {
   if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
-  mlir::interleaveComma(literal->getDims(), llvm::errs());
+  llvm::interleaveComma(literal->getDims(), llvm::errs());
   llvm::errs() << ">";
 
   // Now print the content, recursing on every element of the list
   llvm::errs() << "[ ";
-  mlir::interleaveComma(literal->getValues(), llvm::errs(),
+  llvm::interleaveComma(literal->getValues(), llvm::errs(),
                         [&](auto &elt) { printLitHelper(elt.get()); });
   llvm::errs() << "]";
 }
 
 /// Print a literal, see the recursive helper above for the implementation.
 void ASTDumper::dump(LiteralExprAST *node) {
   INDENT();
   llvm::errs() << "Literal: ";
void ASTDumper::dump(PrintExprAST *node) {
   dump(node->getArg());
   indent();
   llvm::errs() << "]\n";
 }
 
 /// Print type: only the shape is printed in between '<' and '>'
 void ASTDumper::dump(const VarType &type) {
   llvm::errs() << "<";
-  mlir::interleaveComma(type.shape, llvm::errs());
+  llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
   llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
   indent();
   llvm::errs() << "Params: [";
-  mlir::interleaveComma(node->getArgs(), llvm::errs(),
+  llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.
 void ASTDumper::dump(FunctionAST *node) {
   INDENT();
   llvm::errs() << "Function \n";

mlir/examples/toy/Ch2/parser/AST.cpp

void printLitHelper(ExprAST *litOrNum) {
   if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
-  mlir::interleaveComma(literal->getDims(), llvm::errs());
+  llvm::interleaveComma(literal->getDims(), llvm::errs());
   llvm::errs() << ">";
 
   // Now print the content, recursing on every element of the list
   llvm::errs() << "[ ";
-  mlir::interleaveComma(literal->getValues(), llvm::errs(),
+  llvm::interleaveComma(literal->getValues(), llvm::errs(),
                         [&](auto &elt) { printLitHelper(elt.get()); });
   llvm::errs() << "]";
 }
 
 /// Print a literal, see the recursive helper above for the implementation.
 void ASTDumper::dump(LiteralExprAST *node) {
   INDENT();
   llvm::errs() << "Literal: ";
void ASTDumper::dump(PrintExprAST *node) {
   dump(node->getArg());
   indent();
   llvm::errs() << "]\n";
 }
 
 /// Print type: only the shape is printed in between '<' and '>'
 void ASTDumper::dump(const VarType &type) {
   llvm::errs() << "<";
-  mlir::interleaveComma(type.shape, llvm::errs());
+  llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
   llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
   indent();
   llvm::errs() << "Params: [";
-  mlir::interleaveComma(node->getArgs(), llvm::errs(),
+  llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.
 void ASTDumper::dump(FunctionAST *node) {
   INDENT();
   llvm::errs() << "Function \n";

mlir/examples/toy/Ch3/parser/AST.cpp

void printLitHelper(ExprAST *litOrNum) {
   if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
-  mlir::interleaveComma(literal->getDims(), llvm::errs());
+  llvm::interleaveComma(literal->getDims(), llvm::errs());
   llvm::errs() << ">";
 
   // Now print the content, recursing on every element of the list
   llvm::errs() << "[ ";
-  mlir::interleaveComma(literal->getValues(), llvm::errs(),
+  llvm::interleaveComma(literal->getValues(), llvm::errs(),
                         [&](auto &elt) { printLitHelper(elt.get()); });
   llvm::errs() << "]";
 }
 
 /// Print a literal, see the recursive helper above for the implementation.
 void ASTDumper::dump(LiteralExprAST *node) {
   INDENT();
   llvm::errs() << "Literal: ";
void ASTDumper::dump(PrintExprAST *node) {
   dump(node->getArg());
   indent();
   llvm::errs() << "]\n";
 }
 
 /// Print type: only the shape is printed in between '<' and '>'
 void ASTDumper::dump(const VarType &type) {
   llvm::errs() << "<";
-  mlir::interleaveComma(type.shape, llvm::errs());
+  llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
   llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
   indent();
   llvm::errs() << "Params: [";
-  mlir::interleaveComma(node->getArgs(), llvm::errs(),
+  llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.
 void ASTDumper::dump(FunctionAST *node) {
   INDENT();
   llvm::errs() << "Function \n";

mlir/examples/toy/Ch4/parser/AST.cpp

void printLitHelper(ExprAST *litOrNum) {
   if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
-  mlir::interleaveComma(literal->getDims(), llvm::errs());
+  llvm::interleaveComma(literal->getDims(), llvm::errs());
   llvm::errs() << ">";
 
   // Now print the content, recursing on every element of the list
   llvm::errs() << "[ ";
-  mlir::interleaveComma(literal->getValues(), llvm::errs(),
+  llvm::interleaveComma(literal->getValues(), llvm::errs(),
                         [&](auto &elt) { printLitHelper(elt.get()); });
   llvm::errs() << "]";
 }
 
 /// Print a literal, see the recursive helper above for the implementation.
 void ASTDumper::dump(LiteralExprAST *node) {
   INDENT();
   llvm::errs() << "Literal: ";
void ASTDumper::dump(PrintExprAST *node) {
   dump(node->getArg());
   indent();
   llvm::errs() << "]\n";
 }
 
 /// Print type: only the shape is printed in between '<' and '>'
 void ASTDumper::dump(const VarType &type) {
   llvm::errs() << "<";
-  mlir::interleaveComma(type.shape, llvm::errs());
+  llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
   llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
   indent();
   llvm::errs() << "Params: [";
-  mlir::interleaveComma(node->getArgs(), llvm::errs(),
+  llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.
 void ASTDumper::dump(FunctionAST *node) {
   INDENT();
   llvm::errs() << "Function \n";

mlir/examples/toy/Ch5/parser/AST.cpp

void printLitHelper(ExprAST *litOrNum) {
   if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
-  mlir::interleaveComma(literal->getDims(), llvm::errs());
+  llvm::interleaveComma(literal->getDims(), llvm::errs());
   llvm::errs() << ">";
 
   // Now print the content, recursing on every element of the list
   llvm::errs() << "[ ";
-  mlir::interleaveComma(literal->getValues(), llvm::errs(),
+  llvm::interleaveComma(literal->getValues(), llvm::errs(),
                         [&](auto &elt) { printLitHelper(elt.get()); });
   llvm::errs() << "]";
 }
 
 /// Print a literal, see the recursive helper above for the implementation.
 void ASTDumper::dump(LiteralExprAST *node) {
   INDENT();
   llvm::errs() << "Literal: ";
void ASTDumper::dump(PrintExprAST *node) {
   dump(node->getArg());
   indent();
   llvm::errs() << "]\n";
 }
 
 /// Print type: only the shape is printed in between '<' and '>'
 void ASTDumper::dump(const VarType &type) {
   llvm::errs() << "<";
-  mlir::interleaveComma(type.shape, llvm::errs());
+  llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
   llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
   indent();
   llvm::errs() << "Params: [";
-  mlir::interleaveComma(node->getArgs(), llvm::errs(),
+  llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.
 void ASTDumper::dump(FunctionAST *node) {
   INDENT();
   llvm::errs() << "Function \n";

mlir/examples/toy/Ch6/parser/AST.cpp

void printLitHelper(ExprAST *litOrNum) {
   if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
-  mlir::interleaveComma(literal->getDims(), llvm::errs());
+  llvm::interleaveComma(literal->getDims(), llvm::errs());
   llvm::errs() << ">";
 
   // Now print the content, recursing on every element of the list
   llvm::errs() << "[ ";
-  mlir::interleaveComma(literal->getValues(), llvm::errs(),
+  llvm::interleaveComma(literal->getValues(), llvm::errs(),
                         [&](auto &elt) { printLitHelper(elt.get()); });
   llvm::errs() << "]";
 }
 
 /// Print a literal, see the recursive helper above for the implementation.
 void ASTDumper::dump(LiteralExprAST *node) {
   INDENT();
   llvm::errs() << "Literal: ";
void ASTDumper::dump(PrintExprAST *node) {
   dump(node->getArg());
   indent();
   llvm::errs() << "]\n";
 }
 
 /// Print type: only the shape is printed in between '<' and '>'
 void ASTDumper::dump(const VarType &type) {
   llvm::errs() << "<";
-  mlir::interleaveComma(type.shape, llvm::errs());
+  llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
   llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
   indent();
   llvm::errs() << "Params: [";
-  mlir::interleaveComma(node->getArgs(), llvm::errs(),
+  llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.
 void ASTDumper::dump(FunctionAST *node) {
   INDENT();
   llvm::errs() << "Function \n";

mlir/examples/toy/Ch7/mlir/Dialect.cpp

 /// Print an instance of a type registered to the toy dialect.
 void ToyDialect::printType(mlir::Type type,
                            mlir::DialectAsmPrinter &printer) const {
   // Currently the only toy type is a struct type.
   StructType structType = type.cast<StructType>();
 
   // Print the struct type according to the parser format.
   printer << "struct<";
-  mlir::interleaveComma(structType.getElementTypes(), printer);
+  llvm::interleaveComma(structType.getElementTypes(), printer);
   printer << '>';
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd op method definitions
 //===----------------------------------------------------------------------===//
 
 #define GET_OP_CLASSES
 #include "toy/Ops.cpp.inc"

mlir/examples/toy/Ch7/parser/AST.cpp

void printLitHelper(ExprAST *litOrNum) {
   if (auto num = llvm::dyn_cast<NumberExprAST>(litOrNum)) {
     llvm::errs() << num->getValue();
     return;
   }
   auto *literal = llvm::cast<LiteralExprAST>(litOrNum);
 
   // Print the dimension for this literal first
   llvm::errs() << "<";
-  mlir::interleaveComma(literal->getDims(), llvm::errs());
+  llvm::interleaveComma(literal->getDims(), llvm::errs());
   llvm::errs() << ">";
 
   // Now print the content, recursing on every element of the list
   llvm::errs() << "[ ";
-  mlir::interleaveComma(literal->getValues(), llvm::errs(),
+  llvm::interleaveComma(literal->getValues(), llvm::errs(),
                         [&](auto &elt) { printLitHelper(elt.get()); });
   llvm::errs() << "]";
 }
 
 /// Print a literal, see the recursive helper above for the implementation.
 void ASTDumper::dump(LiteralExprAST *node) {
   INDENT();
   llvm::errs() << "Literal: ";

 }
 
 /// Print type: only the shape is printed in between '<' and '>'
 void ASTDumper::dump(const VarType &type) {
   llvm::errs() << "<";
   if (!type.name.empty())
     llvm::errs() << type.name;
   else
-    mlir::interleaveComma(type.shape, llvm::errs());
+    llvm::interleaveComma(type.shape, llvm::errs());
   llvm::errs() << ">";
 }
 
 /// Print a function prototype, first the function name, and then the list of
 /// parameters names.
 void ASTDumper::dump(PrototypeAST *node) {
   INDENT();
   llvm::errs() << "Proto '" << node->getName() << "' " << loc(node) << "'\n";
   indent();
   llvm::errs() << "Params: [";
-  mlir::interleaveComma(node->getArgs(), llvm::errs(),
+  llvm::interleaveComma(node->getArgs(), llvm::errs(),
                         [](auto &arg) { llvm::errs() << arg->getName(); });
   llvm::errs() << "]\n";
 }
 
 /// Print a function, first the prototype and then the body.
 void ASTDumper::dump(FunctionAST *node) {
   INDENT();
   llvm::errs() << "Function \n";

mlir/include/mlir/IR/Diagnostics.h

public:
   template <typename T> Diagnostic &operator<<(ArrayRef<T> range) {
     return appendRange(range);
   }
 
   /// Append a range to the diagnostic. The default delimiter between elements
   /// is ','.
   template <typename T, template <typename> class Container>
   Diagnostic &appendRange(const Container<T> &c, const char *delim = ", ") {
-    interleave(
-        c, [&](const detail::ValueOfRange<Container<T>> &a) { *this << a; },
-        [&]() { *this << delim; });
+    llvm::interleave(
+        c, [this](const auto &a) { *this << a; }, [&]() { *this << delim; });
     return *this;
   }
 
   /// Append arguments to the diagnostic.
   template <typename Arg1, typename Arg2, typename... Args>
   Diagnostic &append(Arg1 &&arg1, Arg2 &&arg2, Args &&... args) {
     append(std::forward<Arg1>(arg1));
     return append(std::forward<Arg2>(arg2), std::forward<Args>(args)...);

mlir/include/mlir/IR/OpImplementation.h

public:
   template <typename TypeRange>
   void printArrowTypeList(TypeRange &&types) {
     auto &os = getStream() << " -> ";
 
     bool wrapped = !llvm::hasSingleElement(types) ||
                    (*types.begin()).template isa<FunctionType>();
     if (wrapped)
       os << '(';
-    interleaveComma(types, *this);
+    llvm::interleaveComma(types, *this);
     if (wrapped)
       os << ')';
   }
 
   /// Print the complete type of an operation in functional form.
   void printFunctionalType(Operation *op) {
     printFunctionalType(op->getOperandTypes(), op->getResultTypes());
   }
   /// Print the two given type ranges in a functional form.
   template <typename InputRangeT, typename ResultRangeT>
   void printFunctionalType(InputRangeT &&inputs, ResultRangeT &&results) {
     auto &os = getStream();
     os << "(";
-    interleaveComma(inputs, *this);
+    llvm::interleaveComma(inputs, *this);
     os << ")";
     printArrowTypeList(results);
   }
 
   /// Print the given string as a symbol reference, i.e. a form representable by
   /// a SymbolRefAttr. A symbol reference is represented as a string prefixed
   /// with '@'. The reference is surrounded with ""'s and escaped if it has any
   /// special or non-printable characters in it.

 inline OpAsmPrinter &operator<<(OpAsmPrinter &p, Block *value) {
   p.printSuccessor(value);
   return p;
 }
 
 template <typename ValueRangeT>
 inline OpAsmPrinter &operator<<(OpAsmPrinter &p,
                                 const ValueTypeRange<ValueRangeT> &types) {
-  interleaveComma(types, p);
+  llvm::interleaveComma(types, p);
   return p;
 }
 inline OpAsmPrinter &operator<<(OpAsmPrinter &p, ArrayRef<Type> types) {
-  interleaveComma(types, p);
+  llvm::interleaveComma(types, p);
   return p;
 }
 
 //===----------------------------------------------------------------------===//
 // OpAsmParser
 //===----------------------------------------------------------------------===//
 
 /// The OpAsmParser has methods for interacting with the asm parser: parsing

mlir/include/mlir/Pass/PassOptions.h

private:
     const llvm::cl::Option *getOption() const final { return this; }
 
     /// Print the name and value of this option to the given stream.
     void print(raw_ostream &os) final {
       os << this->ArgStr << '=';
       auto printElementFn = [&](const DataType &value) {
         printValue(os, this->getParser(), value);
       };
-      interleave(*this, os, printElementFn, ",");
+      llvm::interleave(*this, os, printElementFn, ",");
     }
 
     /// Copy the value from the given option into this one.
     void copyValueFrom(const OptionBase &other) final {
       *this = static_cast<const ListOption<DataType, OptionParser> &>(other);
     }
   };
 

mlir/include/mlir/Support/STLExtras.h

 #ifndef MLIR_SUPPORT_STLEXTRAS_H
 #define MLIR_SUPPORT_STLEXTRAS_H
 
 #include "mlir/Support/LLVM.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace mlir {
 
-namespace detail {
-template <typename RangeT>
-using ValueOfRange = typename std::remove_reference<decltype(
-    *std::begin(std::declval<RangeT &>()))>::type;
-} // end namespace detail
-
-/// An STL-style algorithm similar to std::for_each that applies a second
-/// functor between every pair of elements.
-///
-/// This provides the control flow logic to, for example, print a
-/// comma-separated list:
-/// \code
-///   interleave(names.begin(), names.end(),
-///              [&](StringRef name) { os << name; },
-///              [&] { os << ", "; });
-/// \endcode
-template <typename ForwardIterator, typename UnaryFunctor,
-          typename NullaryFunctor,
-          typename = typename std::enable_if<
-              !std::is_constructible<StringRef, UnaryFunctor>::value &&
-              !std::is_constructible<StringRef, NullaryFunctor>::value>::type>
-inline void interleave(ForwardIterator begin, ForwardIterator end,
-                       UnaryFunctor each_fn, NullaryFunctor between_fn) {
-  if (begin == end)
-    return;
-  each_fn(*begin);
-  ++begin;
-  for (; begin != end; ++begin) {
-    between_fn();
-    each_fn(*begin);
-  }
-}
-
-template <typename Container, typename UnaryFunctor, typename NullaryFunctor,
-          typename = typename std::enable_if<
-              !std::is_constructible<StringRef, UnaryFunctor>::value &&
-              !std::is_constructible<StringRef, NullaryFunctor>::value>::type>
-inline void interleave(const Container &c, UnaryFunctor each_fn,
-                       NullaryFunctor between_fn) {
-  interleave(c.begin(), c.end(), each_fn, between_fn);
-}
-
-/// Overload of interleave for the common case of string separator.
-template <typename Container, typename UnaryFunctor, typename raw_ostream,
-          typename T = detail::ValueOfRange<Container>>
-inline void interleave(const Container &c, raw_ostream &os,
-                       UnaryFunctor each_fn, const StringRef &separator) {
-  interleave(c.begin(), c.end(), each_fn, [&] { os << separator; });
-}
-template <typename Container, typename raw_ostream,
-          typename T = detail::ValueOfRange<Container>>
-inline void interleave(const Container &c, raw_ostream &os,
-                       const StringRef &separator) {
-  interleave(
-      c, os, [&](const T &a) { os << a; }, separator);
-}
-
-template <typename Container, typename UnaryFunctor, typename raw_ostream,
-          typename T = detail::ValueOfRange<Container>>
-inline void interleaveComma(const Container &c, raw_ostream &os,
-                            UnaryFunctor each_fn) {
-  interleave(c, os, each_fn, ", ");
-}
-template <typename Container, typename raw_ostream,
-          typename T = detail::ValueOfRange<Container>>
-inline void interleaveComma(const Container &c, raw_ostream &os) {
-  interleaveComma(c, os, [&](const T &a) { os << a; });
-}
-
 } // end namespace mlir
 
 #endif // MLIR_SUPPORT_STLEXTRAS_H

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

static void print(OpAsmPrinter &p, AffineParallelOp op) {
   bool elideSteps = true;
   for (auto attr : op.steps()) {
     auto step = attr.cast<IntegerAttr>().getInt();
     elideSteps &= (step == 1);
     steps.push_back(step);
   }
   if (!elideSteps) {
     p << " step (";
-    interleaveComma(steps, p);
+    llvm::interleaveComma(steps, p);
     p << ')';
   }
   p.printRegion(op.region(), /*printEntryBlockArgs=*/false,
                 /*printBlockTerminators=*/false);
   p.printOptionalAttrDict(
       op.getAttrs(),
       /*elidedAttrs=*/{AffineParallelOp::getLowerBoundsMapAttrName(),
                        AffineParallelOp::getUpperBoundsMapAttrName(),

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

 }
 
 static void printAttributions(OpAsmPrinter &p, StringRef keyword,
                               ArrayRef<BlockArgument> values) {
   if (values.empty())
     return;
 
   p << ' ' << keyword << '(';
-  interleaveComma(values, p,
-                  [&p](BlockArgument v) { p << v << " : " << v.getType(); });
+  llvm::interleaveComma(
+      values, p, [&p](BlockArgument v) { p << v << " : " << v.getType(); });
   p << ')';
 }
 
 /// Prints a GPU Func op.
 static void printGPUFuncOp(OpAsmPrinter &p, GPUFuncOp op) {
   p << GPUFuncOp::getOperationName() << ' ';
   p.printSymbolName(op.getName());
 

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

if (auto memref = t.dyn_cast<MemRefType>()) {
     for (auto size : memref.getShape())
       if (size < 0)
         ss << "sx";
       else
         ss << size << "x";
     appendMangledType(ss, memref.getElementType());
   } else if (auto vec = t.dyn_cast<VectorType>()) {
     ss << "vector";
-    interleave(
+    llvm::interleave(
         vec.getShape(), [&](int64_t i) { ss << i; }, [&]() { ss << "x"; });
     appendMangledType(ss, vec.getElementType());
   } else if (t.isSignlessIntOrIndexOrFloat()) {
     ss << t;
   } else {
     llvm_unreachable("Invalid type for linalg library name mangling");
   }
 }
 
 std::string mlir::linalg::generateLibraryCallName(Operation *op) {
   assert(isa<LinalgOp>(op));
   std::string name(op->getName().getStringRef().str());
   name.reserve(128);
   std::replace(name.begin(), name.end(), '.', '_');
   llvm::raw_string_ostream ss(name);
   ss << "_";
   auto types = op->getOperandTypes();
-  interleave(
+  llvm::interleave(
       types.begin(), types.end(), [&](Type t) { appendMangledType(ss, t); },
       [&]() { ss << "_"; });
   return ss.str();
 }
 
 // TODO(ntv, rriddle): Consider making all this boilerplate easy to autogenerate
 // with Tablegen. This seems a desirable property in the context of OpInterfaces
 // where a Linalg "named" op **isa** LinalgOp.

mlir/lib/Dialect/LoopOps/LoopOps.cpp

static void print(OpAsmPrinter &p, ForOp op) {
   p << op.getOperationName() << " " << op.getInductionVar() << " = "
     << op.lowerBound() << " to " << op.upperBound() << " step " << op.step();
 
   if (op.hasIterOperands()) {
     p << " iter_args(";
     auto regionArgs = op.getRegionIterArgs();
     auto operands = op.getIterOperands();
 
-    mlir::interleaveComma(llvm::zip(regionArgs, operands), p, [&](auto it) {
+    llvm::interleaveComma(llvm::zip(regionArgs, operands), p, [&](auto it) {
       p << std::get<0>(it) << " = " << std::get<1>(it);
     });
     p << ")";
     p << " -> (" << op.getResultTypes() << ")";
     printBlockTerminators = true;
   }
   p.printRegion(op.region(),
                 /*printEntryBlockArgs=*/false,

mlir/lib/Dialect/Quant/IR/TypeParser.cpp

static void printUniformQuantizedPerAxisType(UniformQuantizedPerAxisType type,
   out << ":" << type.getExpressedType() << ":";
   out << type.getQuantizedDimension();
   out << ", ";
 
   // scheme specific parameters
   ArrayRef<double> scales = type.getScales();
   ArrayRef<int64_t> zeroPoints = type.getZeroPoints();
   out << "{";
-  interleave(
+  llvm::interleave(
       llvm::seq<size_t>(0, scales.size()), out,
       [&](size_t index) {
         printQuantParams(scales[index], zeroPoints[index], out);
       },
       ",");
   out << "}>";
 }
 

mlir/lib/Dialect/SPIRV/SPIRVDialect.cpp

if (type.hasLayout() || !decorations.empty()) {
       if (type.hasLayout()) {
         os << type.getOffset(i);
         if (!decorations.empty())
           os << ", ";
       }
       auto eachFn = [&os](spirv::Decoration decoration) {
         os << stringifyDecoration(decoration);
       };
-      interleaveComma(decorations, os, eachFn);
+      llvm::interleaveComma(decorations, os, eachFn);
       os << "]";
     }
   };
-  interleaveComma(llvm::seq<unsigned>(0, type.getNumElements()), os,
+  llvm::interleaveComma(llvm::seq<unsigned>(0, type.getNumElements()), os,
                         printMember);
   os << ">";
 }
 
 void SPIRVDialect::printType(Type type, DialectAsmPrinter &os) const {
   switch (type.getKind()) {
   case TypeKind::Array:
     print(type.cast<ArrayType>(), os);
     return;

 //===----------------------------------------------------------------------===//
 // Attribute Printing
 //===----------------------------------------------------------------------===//
 
 static void print(spirv::VerCapExtAttr triple, DialectAsmPrinter &printer) {
   auto &os = printer.getStream();
   printer << spirv::VerCapExtAttr::getKindName() << "<"
           << spirv::stringifyVersion(triple.getVersion()) << ", [";
-  interleaveComma(triple.getCapabilities(), os, [&](spirv::Capability cap) {
-    os << spirv::stringifyCapability(cap);
-  });
+  llvm::interleaveComma(
+      triple.getCapabilities(), os,
+      [&](spirv::Capability cap) { os << spirv::stringifyCapability(cap); });
   printer << "], [";
-  interleaveComma(triple.getExtensionsAttr(), os, [&](Attribute attr) {
+  llvm::interleaveComma(triple.getExtensionsAttr(), os, [&](Attribute attr) {
     os << attr.cast<StringAttr>().getValue();
   });
   printer << "]>";
 }
 
 static void print(spirv::TargetEnvAttr targetEnv, DialectAsmPrinter &printer) {
   printer << spirv::TargetEnvAttr::getKindName() << "<#spv.";
   print(targetEnv.getTripleAttr(), printer);

mlir/lib/Dialect/SPIRV/SPIRVOps.cpp

 }
 
 static void print(spirv::BranchConditionalOp branchOp, OpAsmPrinter &printer) {
   printer << spirv::BranchConditionalOp::getOperationName() << ' '
           << branchOp.condition();
 
   if (auto weights = branchOp.branch_weights()) {
     printer << " [";
-    interleaveComma(weights->getValue(), printer, [&](Attribute a) {
+    llvm::interleaveComma(weights->getValue(), printer, [&](Attribute a) {
       printer << a.cast<IntegerAttr>().getInt();
     });
     printer << "]";
   }
 
   printer << ", ";
   printer.printSuccessorAndUseList(branchOp.getTrueBlock(),
                                    branchOp.getTrueBlockArguments());

 
 static void print(spirv::EntryPointOp entryPointOp, OpAsmPrinter &printer) {
   printer << spirv::EntryPointOp::getOperationName() << " \""
           << stringifyExecutionModel(entryPointOp.execution_model()) << "\" ";
   printer.printSymbolName(entryPointOp.fn());
   auto interfaceVars = entryPointOp.interface().getValue();
   if (!interfaceVars.empty()) {
     printer << ", ";
-    interleaveComma(interfaceVars, printer);
+    llvm::interleaveComma(interfaceVars, printer);
   }
 }
 
 static LogicalResult verify(spirv::EntryPointOp entryPointOp) {
   // Checks for fn and interface symbol reference are done in spirv::ModuleOp
   // verification.
   return success();
 }
static void print(spirv::ExecutionModeOp execModeOp, OpAsmPrinter &printer) {
   printer << spirv::ExecutionModeOp::getOperationName() << " ";
   printer.printSymbolName(execModeOp.fn());
   printer << " \"" << stringifyExecutionMode(execModeOp.execution_mode())
           << "\"";
   auto values = execModeOp.values();
   if (!values.size())
     return;
   printer << ", ";
-  interleaveComma(values, printer, [&](Attribute a) {
+  llvm::interleaveComma(values, printer, [&](Attribute a) {
     printer << a.cast<IntegerAttr>().getInt();
   });
 }
 
 //===----------------------------------------------------------------------===//
 // spv.func
 //===----------------------------------------------------------------------===//
 

mlir/lib/Dialect/Vector/VectorOps.cpp

return failure(
       parser.addTypeToList(TupleType::get(types, ctx), result.types));
 }
 
 static void print(OpAsmPrinter &p, TupleOp op) {
   p << op.getOperationName() << ' ';
   p.printOperands(op.getOperands());
   p.printOptionalAttrDict(op.getAttrs());
   p << " : ";
-  interleaveComma(op.getOperation()->getOperandTypes(), p);
+  llvm::interleaveComma(op.getOperation()->getOperandTypes(), p);
 }
 
 static LogicalResult verify(TupleOp op) { return success(); }
 
 //===----------------------------------------------------------------------===//
 // TransposeOp
 //===----------------------------------------------------------------------===//
 

mlir/lib/IR/AsmPrinter.cpp

explicit ModulePrinter(ModulePrinter &printer)
       : os(printer.os), printerFlags(printer.printerFlags),
         state(printer.state) {}
 
   /// Returns the output stream of the printer.
   raw_ostream &getStream() { return os; }
 
   template <typename Container, typename UnaryFunctor>
   inline void interleaveComma(const Container &c, UnaryFunctor each_fn) const {
-    mlir::interleaveComma(c, os, each_fn);
+    llvm::interleaveComma(c, os, each_fn);
   }
 
   /// This enum describes the different kinds of elision for the type of an
   /// attribute when printing it.
   enum class AttrTypeElision {
     /// The type must not be elided,
     Never,
     /// The type may be elided when it matches the default used in the parser

mlir/lib/IR/FunctionImplementation.cpp

 static void printFunctionResultList(OpAsmPrinter &p, ArrayRef<Type> types,
                                     ArrayRef<ArrayRef<NamedAttribute>> attrs) {
   assert(!types.empty() && "Should not be called for empty result list.");
   auto &os = p.getStream();
   bool needsParens =
       types.size() > 1 || types[0].isa<FunctionType>() || !attrs[0].empty();
   if (needsParens)
     os << '(';
-  interleaveComma(llvm::zip(types, attrs), os,
-                  [&](const std::tuple<Type, ArrayRef<NamedAttribute>> &t) {
-                    p.printType(std::get<0>(t));
-                    p.printOptionalAttrDict(std::get<1>(t));
-                  });
+  llvm::interleaveComma(
+      llvm::zip(types, attrs), os,
   if (needsParens)
     os << ')';
 }
 
 /// Print the signature of the function-like operation `op`.  Assumes `op` has
 /// the FunctionLike trait and passed the verification.
 void mlir::impl::printFunctionSignature(OpAsmPrinter &p, Operation *op,
                                         ArrayRef<Type> argTypes,

mlir/lib/Pass/Pass.cpp

void Pass::copyOptionValuesFrom(const Pass *other) {
   passOptions.copyOptionValuesFrom(other->passOptions);
 }
 
 /// Prints out the pass in the textual representation of pipelines. If this is
 /// an adaptor pass, print with the op_name(sub_pass,...) format.
 void Pass::printAsTextualPipeline(raw_ostream &os) {
   // Special case for adaptors to use the 'op_name(sub_passes)' format.
   if (auto *adaptor = getAdaptorPassBase(this)) {
-    interleaveComma(adaptor->getPassManagers(), os, [&](OpPassManager &pm) {
+    llvm::interleaveComma(adaptor->getPassManagers(), os,
+                          [&](OpPassManager &pm) {
                             os << pm.getOpName() << "(";
                             pm.printAsTextualPipeline(os);
                             os << ")";
                           });
     return;
   }
   // Otherwise, print the pass argument followed by its options. If the pass
   // doesn't have an argument, print the name of the pass to give some indicator
   // of what pass was run.
   StringRef argument = getArgument();
   if (!argument.empty())
     os << argument;

 /// Prints out the passes of the pass manager as the textual representation
 /// of pipelines.
 void OpPassManager::printAsTextualPipeline(raw_ostream &os) {
   // Filter out passes that are not part of the public pipeline.
   auto filteredPasses = llvm::make_filter_range(
       impl->passes, [](const std::unique_ptr<Pass> &pass) {
         return !isa<VerifierPass>(pass);
       });
-  interleaveComma(filteredPasses, os, [&](const std::unique_ptr<Pass> &pass) {
+  llvm::interleaveComma(filteredPasses, os,
+                        [&](const std::unique_ptr<Pass> &pass) {
                           pass->printAsTextualPipeline(os);
                         });
 }
 
 //===----------------------------------------------------------------------===//
 // OpToOpPassAdaptor
 //===----------------------------------------------------------------------===//
 
 /// Utility to run the given operation and analysis manager on a provided op
 /// pass manager.
llvm::array_pod_sort(rhs.mgrs.begin(), rhs.mgrs.end(),
                              rhs->getOpName().getStringRef());
                        });
 }
 
 /// Returns the adaptor pass name.
 std::string OpToOpPassAdaptorBase::getName() {
   std::string name = "Pipeline Collection : [";
   llvm::raw_string_ostream os(name);
-  interleaveComma(getPassManagers(), os, [&](OpPassManager &pm) {
+  llvm::interleaveComma(getPassManagers(), os, [&](OpPassManager &pm) {
     os << '\'' << pm.getOpName() << '\'';
   });
   os << ']';
   return os.str();
 }
 
 OpToOpPassAdaptor::OpToOpPassAdaptor(OpPassManager &&mgr)
     : OpToOpPassAdaptorBase(std::move(mgr)) {}

mlir/lib/Pass/PassRegistry.cpp

void detail::PassOptions::print(raw_ostream &os) {
   SmallVector<OptionBase *, 4> orderedOps(options.begin(), options.end());
   auto compareOptionArgs = [](OptionBase *const *lhs, OptionBase *const *rhs) {
     return (*lhs)->getArgStr().compare((*rhs)->getArgStr());
   };
   llvm::array_pod_sort(orderedOps.begin(), orderedOps.end(), compareOptionArgs);
 
   // Interleave the options with ' '.
   os << '{';
-  interleave(
+  llvm::interleave(
       orderedOps, os, [&](OptionBase *option) { option->print(os); }, " ");
   os << '}';
 }
 
 /// Print the help string for the options held by this struct. `descIndent` is
 /// the indent within the stream that the descriptions should be aligned.
 void detail::PassOptions::printHelp(size_t indent, size_t descIndent) const {
   // Sort the options to make the ordering deterministic.

mlir/lib/Transforms/DialectConversion.cpp

 LogicalResult
 OperationLegalizer::legalizePattern(Operation *op, RewritePattern *pattern,
                                     ConversionPatternRewriter &rewriter) {
   auto &rewriterImpl = rewriter.getImpl();
   LLVM_DEBUG({
     auto &os = rewriterImpl.logger;
     os.getOStream() << "\n";
     os.startLine() << "* Pattern : '" << pattern->getRootKind() << " -> (";
-    interleaveComma(pattern->getGeneratedOps(), llvm::dbgs());
+    llvm::interleaveComma(pattern->getGeneratedOps(), llvm::dbgs());
     os.getOStream() << ")' {\n";
     os.indent();
   });
 
   // Ensure that we don't cycle by not allowing the same pattern to be
   // applied twice in the same recursion stack if it is not known to be safe.
   if (!pattern->hasBoundedRewriteRecursion() &&
       !appliedPatterns.insert(pattern).second) {

mlir/lib/Transforms/ViewOpGraph.cpp

std::string DOTGraphTraits<Block *>::getNodeLabel(Operation *op, Block *b) {
   raw_string_ostream os(ostr);
   os << op->getName() << "\n";
 
   if (!op->getLoc().isa<UnknownLoc>()) {
     os << op->getLoc() << "\n";
   }
 
   // Print resultant types
-  interleaveComma(op->getResultTypes(), os);
+  llvm::interleaveComma(op->getResultTypes(), os);
   os << "\n";
 
   // A value used to elide large container attribute.
   int64_t largeAttrLimit = getLargeAttributeSizeLimit();
   for (auto attr : op->getAttrs()) {
     os << '\n' << attr.first << ": ";
     // Always emit splat attributes.
     if (attr.second.isa<SplatElementsAttr>()) {

mlir/test/lib/Dialect/Affine/TestVectorizationUtils.cpp

for (auto m : matches) {
     // purpose of this test. If we need to test more intricate behavior in the
     // future we can always extend.
     auto superVectorType = opInst->getResult(0).getType().cast<VectorType>();
     auto ratio = shapeRatio(superVectorType, subVectorType);
     if (!ratio.hasValue()) {
       opInst->emitRemark("NOT MATCHED");
     } else {
       outs << "\nmatched: " << *opInst << " with shape ratio: ";
-      interleaveComma(MutableArrayRef<int64_t>(*ratio), outs);
+      llvm::interleaveComma(MutableArrayRef<int64_t>(*ratio), outs);
     }
   }
 }
 
 static NestedPattern patternTestSlicingOps() {
   using matcher::Op;
   // Match all operations with the kTestSlicingOpName name.
   auto filter = [](Operation &op) {

mlir/test/lib/Dialect/SPIRV/TestAvailability.cpp

f.getOperation()->walk([&](Operation *op) {
     if (auto maxVersion = dyn_cast<spirv::QueryMaxVersionInterface>(op))
       os << opName << " max version: "
          << spirv::stringifyVersion(maxVersion.getMaxVersion()) << "\n";
 
     if (auto extension = dyn_cast<spirv::QueryExtensionInterface>(op)) {
       os << opName << " extensions: [";
       for (const auto &exts : extension.getExtensions()) {
         os << " [";
-        interleaveComma(exts, os, [&](spirv::Extension ext) {
+        llvm::interleaveComma(exts, os, [&](spirv::Extension ext) {
           os << spirv::stringifyExtension(ext);
         });
         os << "]";
       }
       os << " ]\n";
     }
 
     if (auto capability = dyn_cast<spirv::QueryCapabilityInterface>(op)) {
       os << opName << " capabilities: [";
       for (const auto &caps : capability.getCapabilities()) {
         os << " [";
-        interleaveComma(caps, os, [&](spirv::Capability cap) {
+        llvm::interleaveComma(caps, os, [&](spirv::Capability cap) {
           os << spirv::stringifyCapability(cap);
         });
         os << "]";
       }
       os << " ]\n";
     }
     os.flush();
 

mlir/test/lib/Transforms/TestMemRefStrideCalculation.cpp

if (failed(getStridesAndOffset(memrefType, strides, offset))) {
       return;
     }
     llvm::outs() << "MemRefType offset: ";
     if (offset == MemRefType::getDynamicStrideOrOffset())
       llvm::outs() << "?";
     else
       llvm::outs() << offset;
     llvm::outs() << " strides: ";
-    interleaveComma(strides, llvm::outs(), [&](int64_t v) {
+    llvm::interleaveComma(strides, llvm::outs(), [&](int64_t v) {
       if (v == MemRefType::getDynamicStrideOrOffset())
         llvm::outs() << "?";
       else
         llvm::outs() << v;
     });
     llvm::outs() << "\n";
   });
   llvm::outs().flush();
 }
 
 namespace mlir {
 void registerTestMemRefStrideCalculation() {
   PassRegistration<TestMemRefStrideCalculation> pass(
       "test-memref-stride-calculation", "Test operation constant folding");
 }
 } // namespace mlir

mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-gen.cpp

const char *referenceReferenceIteratorsFmt =
       R"FMT(
     llvm::Optional<SmallVector<StringRef, 8>> {0}::referenceIterators() {
       return SmallVector<StringRef, 8>{{ {1} };
     })FMT";
 
   std::string iteratorsStr;
   llvm::raw_string_ostream ss(iteratorsStr);
   unsigned pos = 0;
-  interleaveComma(state.dims, ss, [&](std::pair<StringRef, AffineExpr> p) {
+  llvm::interleaveComma(
+      state.dims, ss, [&](std::pair<StringRef, AffineExpr> p) {
         bool reduction = false;
         for (auto &expr : state.expressions) {
           visitPostorder(*expr, [&](const Expression &e) {
             if (auto *pTensorExpr = dyn_cast<TensorExpr>(&e)) {
               if (pTensorExpr->reductionDimensions.count(pos) > 0)
                 reduction = true;
             }
           });
           if (reduction)
             break;
         }
         ss << (reduction ? "getReductionIteratorTypeName()"
                          : "getParallelIteratorTypeName()");
         pos++;
       });
   ss.flush();
 
   os << llvm::formatv(referenceReferenceIteratorsFmt, opId, iteratorsStr);
 }
 
 /// Print the C++ StructuredOpsInterface impl of `referenceIndexingMaps`.
 void TCParser::printReferenceIndexingMaps(llvm::raw_ostream &os, StringRef opId,
                                           ComprehensionParsingState &state) {
   const char *referenceIndexingMapsFmt =
       R"FMT(
   llvm::Optional<SmallVector<AffineMap, 8>> {0}::referenceIndexingMaps() {
     MLIRContext *context = getContext();
     AffineExpr {1};
     bindDims(context, {1});
     return SmallVector<AffineMap, 8>{{ {2} };
   })FMT";
 
   std::string dimsStr;
   llvm::raw_string_ostream ss(dimsStr);
-  interleaveComma(state.dims, ss,
-                  [&](std::pair<StringRef, AffineExpr> p) { ss << p.second; });
+  llvm::interleaveComma(
+      state.dims, ss,
   ss.flush();
 
   std::string mapsStr;
   llvm::raw_string_ostream mapsStringStream(mapsStr);
   SmallVector<TensorUse, 4> orderedUses(state.orderedTensorArgs.size());
   for (auto it : state.orderedTensorArgs)
     orderedUses[it.second] = it.first;
-  interleaveComma(orderedUses, mapsStringStream, [&](TensorUse u) {
+  llvm::interleaveComma(orderedUses, mapsStringStream, [&](TensorUse u) {
     assert(u.indexingMap);
     const char *mapFmt = "\n\tAffineMap::get({0}, 0, {1})";
     if (u.indexingMap.isEmpty()) {
       mapsStringStream << llvm::formatv(mapFmt, state.dims.size(), "context");
       return;
     }
 
     std::string exprsStr;
     llvm::raw_string_ostream exprsStringStream(exprsStr);
     exprsStringStream << "{";
-    interleaveComma(u.indexingMap.getResults(), exprsStringStream);
+    llvm::interleaveComma(u.indexingMap.getResults(), exprsStringStream);
     exprsStringStream << "}";
     exprsStringStream.flush();
 
     mapsStringStream << llvm::formatv(mapFmt, state.dims.size(), exprsStr);
   });
   mapsStringStream.flush();
 
   os << llvm::formatv(referenceIndexingMapsFmt, opId, dimsStr, mapsStr);
if (auto *pUse = dyn_cast<TensorUse>(&e)) {
       return;
     }
     auto *pTensorExpr = cast<TensorExpr>(&e);
     if (subExprsMap.count(pTensorExpr) > 0) {
       os << "_" << subExprsMap[pTensorExpr];
     } else {
       std::string subExprs;
       llvm::raw_string_ostream subExprsStringStream(subExprs);
-      interleaveComma(pTensorExpr->expressions, subExprsStringStream,
+      llvm::interleaveComma(pTensorExpr->expressions, subExprsStringStream,
                             [&](const std::unique_ptr<Expression> &e) {
                               printExpr(subExprsStringStream, *e);
                             });
       subExprsStringStream.flush();
       const char *tensorExprFmt = "\n    ValueHandle _{0} = {1}({2});";
       os << llvm::formatv(tensorExprFmt, ++count, pTensorExpr->opId, subExprs);
       subExprsMap[pTensorExpr] = count;
     }
   };
 
   const char *regionBuilderFmt = R"FMT(
   void {0}::regionBuilder(ArrayRef<BlockArgument> args) {
     using namespace edsc;
     using namespace intrinsics;
     ValueHandle {1};
     {2}
     (linalg_yield(ValueRange{ {3} }));
   })FMT";
 
   unsigned idx = 0;
   std::string valueHandleStr;
   llvm::raw_string_ostream valueHandleStringStream(valueHandleStr);
-  interleaveComma(state.orderedTensorArgs, valueHandleStringStream, [&](auto) {
+  llvm::interleaveComma(
+      state.orderedTensorArgs, valueHandleStringStream, [&](auto) {
         valueHandleStringStream << "_" << idx << "(args[" << idx << "])";
         idx++;
       });
 
   std::string expressionsStr;
   llvm::raw_string_ostream expressionStringStream(expressionsStr);
   for (auto &expr : state.expressions)
     visitPostorder(*expr, [&](const Expression &e) {
       if (e.kind == Expression::Kind::TensorExpr)
         printExpr(expressionStringStream, e);
     });
 
   std::string yieldStr;
   llvm::raw_string_ostream yieldStringStream(yieldStr);
-  interleaveComma(state.expressions, yieldStringStream,
+  llvm::interleaveComma(state.expressions, yieldStringStream,
                         [&](const std::unique_ptr<Expression> &e) {
                           printExpr(yieldStringStream, *e);
                         });
 
   valueHandleStringStream.flush();
   expressionStringStream.flush();
   yieldStringStream.flush();
 
   os << llvm::formatv(regionBuilderFmt, opId, valueHandleStr, expressionsStr,
                       yieldStr);
 }

mlir/tools/mlir-tblgen/LLVMIRIntrinsicGen.cpp

private:
   const llvm::Record &record;
 };
 } // namespace
 
 /// Prints the elements in "range" separated by commas and surrounded by "[]".
 template <typename Range>
 void printBracketedRange(const Range &range, llvm::raw_ostream &os) {
   os << '[';
-  mlir::interleaveComma(range, os);
+  llvm::interleaveComma(range, os);
   os << ']';
 }
 
 /// Emits ODS (TableGen-based) code for `record` representing an LLVM intrinsic.
 /// Returns true on error, false on success.
 static bool emitIntrinsic(const llvm::Record &record, llvm::raw_ostream &os) {
   LLVMIntrinsic intr(record);
 
os << "def LLVM_" << intr.getProperRecordName() << " : " << opBaseClass
      << "<\"" << intr.getOperationName() << "\", ";
   printBracketedRange(intr.getOverloadableResultsIdxs().set_bits(), os);
   os << ", ";
   printBracketedRange(intr.getOverloadableOperandsIdxs().set_bits(), os);
   os << ", ";
   printBracketedRange(traits, os);
   os << ", " << (intr.getNumResults() == 0 ? 0 : 1) << ">, Arguments<(ins"
      << (operands.empty() ? "" : " ");
-  mlir::interleaveComma(operands, os);
+  llvm::interleaveComma(operands, os);
   os << ")>;\n\n";
 
   return false;
 }
 
 /// Traverses the list of TableGen definitions derived from the "Intrinsic"
 /// class and generates MLIR ODS definitions for those intrinsics that have
 /// the name matching the filter.

mlir/tools/mlir-tblgen/OpDefinitionsGen.cpp

for (int i = 0, e = op.getNumOperands(); i < e; ++i) {
     body << "  " << builderOpState << ".addOperands(" << argName << ");\n";
   }
 
   // If the operation has the operand segment size attribute, add it here.
   if (op.getTrait("OpTrait::AttrSizedOperandSegments")) {
     body << "  " << builderOpState
          << ".addAttribute(\"operand_segment_sizes\", "
             "odsBuilder->getI32VectorAttr({";
-    interleaveComma(llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) {
+    llvm::interleaveComma(
+        llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) {
           if (op.getOperand(i).isOptional())
             body << "(" << getArgumentName(op, i) << " ? 1 : 0)";
           else if (op.getOperand(i).isVariadic())
-        body << "static_cast<int32_t>(" << getArgumentName(op, i) << ".size())";
+            body << "static_cast<int32_t>(" << getArgumentName(op, i)
+                 << ".size())";
           else
             body << "1";
         });
     body << "}));\n";
   }
 
   // Push all attributes to the result.
   for (const auto &namedAttr : op.getAttributes()) {
     auto &attr = namedAttr.attr;
     if (!attr.isDerivedAttr()) {
       bool emitNotNullCheck = attr.isOptional();
if (!opTrait || !opTrait->shouldDeclareMethods())
       continue;
     auto interface = opTrait->getOpInterface();
     for (auto method : interface.getMethods()) {
       // Don't declare if the method has a body or a default implementation.
       if (method.getBody() || method.getDefaultImplementation())
         continue;
       std::string args;
       llvm::raw_string_ostream os(args);
-      mlir::interleaveComma(method.getArguments(), os,
+      llvm::interleaveComma(method.getArguments(), os,
                             [&](const OpInterfaceMethod::Argument &arg) {
                               os << arg.type << " " << arg.name;
                             });
       opClass.newMethod(method.getReturnType(), method.getName(), os.str(),
                         method.isStatic() ? OpMethod::MP_Static
                                           : OpMethod::MP_None,
                         /*declOnly=*/true);
     }
for (auto *def : defs) {
     }
   }
 }
 
 // Emits a comma-separated list of the ops.
 static void emitOpList(const std::vector<Record *> &defs, raw_ostream &os) {
   IfDefScope scope("GET_OP_LIST", os);
 
-  interleave(
+  llvm::interleave(
       // TODO: We are constructing the Operator wrapper instance just for
       // getting it's qualified class name here. Reduce the overhead by having a
       // lightweight version of Operator class just for that purpose.
       defs, [&os](Record *def) { os << Operator(def).getQualCppClassName(); },
       [&os]() { os << ",\n"; });
 }
 
 static bool emitOpDecls(const RecordKeeper &recordKeeper, raw_ostream &os) {

mlir/tools/mlir-tblgen/OpFormatGen.cpp

if (allOperands) {
       return;
     }
 
     // Otherwise, use llvm::concat to merge the disjoint operand lists together.
     // llvm::concat does not allow the case of a single range, so guard it here.
     body << "  if (parser.resolveOperands(";
     if (op.getNumOperands() > 1) {
       body << "llvm::concat<const OpAsmParser::OperandType>(";
-      interleaveComma(op.getOperands(), body, [&](auto &operand) {
+      llvm::interleaveComma(op.getOperands(), body, [&](auto &operand) {
         body << operand.name << "Operands";
       });
       body << ")";
     } else {
       body << op.operand_begin()->name << "Operands";
     }
     body << ", allOperandTypes, parser.getNameLoc(), result.operands))\n"
          << "    return failure();\n";
     return;
   }
   // Handle the case where all of the operands were grouped together.
   if (allOperands) {
     body << "  if (parser.resolveOperands(allOperands, ";
 
     // Group all of the operand types together to perform the resolution all at
     // once. Use llvm::concat to perform the merge. llvm::concat does not allow
     // the case of a single range, so guard it here.
     if (op.getNumOperands() > 1) {
       body << "llvm::concat<const Type>(";
-      interleaveComma(llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) {
+      llvm::interleaveComma(
+          llvm::seq<int>(0, op.getNumOperands()), body, [&](int i) {
             body << "ArrayRef<Type>(";
             emitTypeResolver(operandTypes[i], op.getOperand(i).name);
             body << ")";
           });
       body << ")";
     } else {
       emitTypeResolver(operandTypes.front(), op.getOperand(0).name);
     }
 
     body << ", allOperandLoc, result.operands))\n"
          << "    return failure();\n";
     return;
body << "  result.addAttribute(\"operand_segment_sizes\", "
          << "builder.getI32VectorAttr({";
     auto interleaveFn = [&](const NamedTypeConstraint &operand) {
       // If the operand is variadic emit the parsed size.
       if (operand.isVariableLength())
         body << "static_cast<int32_t>(" << operand.name << "Operands.size())";
       else
         body << "1";
     };
-    interleaveComma(op.getOperands(), body, interleaveFn);
+    llvm::interleaveComma(op.getOperands(), body, interleaveFn);
     body << "}));\n";
   }
 }
 
 //===----------------------------------------------------------------------===//
 // PrinterGen
 
 /// Generate the printer for the 'attr-dict' directive.
 static void genAttrDictPrinter(OperationFormat &fmt, Operator &op,
                                OpMethodBody &body, bool withKeyword) {
   // Collect all of the attributes used in the format, these will be elided.
   SmallVector<const NamedAttribute *, 1> usedAttributes;
   for (auto &it : fmt.elements)
     if (auto *attr = dyn_cast<AttributeVariable>(it.get()))
       usedAttributes.push_back(attr->getVar());
 
   body << "  p.printOptionalAttrDict" << (withKeyword ? "WithKeyword" : "")
        << "(getAttrs(), /*elidedAttrs=*/{";
   // Elide the variadic segment size attributes if necessary.
   if (!fmt.allOperands && op.getTrait("OpTrait::AttrSizedOperandSegments"))
     body << "\"operand_segment_sizes\", ";
-  interleaveComma(usedAttributes, body, [&](const NamedAttribute *attr) {
+  llvm::interleaveComma(usedAttributes, body, [&](const NamedAttribute *attr) {
     body << "\"" << attr->name << "\"";
   });
   body << "});\n";
 }
 
 /// Generate the printer for a literal value. `shouldEmitSpace` is true if a
 /// space should be emitted before this element. `lastWasPunctuation` is true if
 /// the previous element was a punctuation literal.
if (operand->getVar()->isOptional()) {
       body << "  if (Value value = " << operand->getVar()->name << "())\n"
            << "    p << value;\n";
     } else {
       body << "  p << " << operand->getVar()->name << "();\n";
     }
   } else if (auto *successor = dyn_cast<SuccessorVariable>(element)) {
     const NamedSuccessor *var = successor->getVar();
     if (var->isVariadic())
-      body << "  interleaveComma(" << var->name << "(), p);\n";
+      body << "  llvm::interleaveComma(" << var->name << "(), p);\n";
     else
       body << "  p << " << var->name << "();\n";
   } else if (isa<OperandsDirective>(element)) {
     body << "  p << getOperation()->getOperands();\n";
   } else if (isa<SuccessorsDirective>(element)) {
-    body << "  interleaveComma(getOperation()->getSuccessors(), p);\n";
+    body << "  llvm::interleaveComma(getOperation()->getSuccessors(), p);\n";
   } else if (auto *dir = dyn_cast<TypeDirective>(element)) {
     body << "  p << ";
     genTypeOperandPrinter(dir->getOperand(), body) << ";\n";
   } else if (auto *dir = dyn_cast<FunctionalTypeDirective>(element)) {
     body << "  p.printFunctionalType(";
     genTypeOperandPrinter(dir->getInputs(), body) << ", ";
     genTypeOperandPrinter(dir->getResults(), body) << ");\n";
   } else {

mlir/tools/mlir-tblgen/OpInterfacesGen.cpp

 // Emit the method name and argument list for the given method. If
 // 'addOperationArg' is true, then an Operation* argument is added to the
 // beginning of the argument list.
 static void emitMethodNameAndArgs(const OpInterfaceMethod &method,
                                   raw_ostream &os, bool addOperationArg) {
   os << method.getName() << '(';
   if (addOperationArg)
     os << "Operation *tablegen_opaque_op" << (method.arg_empty() ? "" : ", ");
-  interleaveComma(method.getArguments(), os,
+  llvm::interleaveComma(method.getArguments(), os,
                         [&](const OpInterfaceMethod::Argument &arg) {
                           os << arg.type << " " << arg.name;
                         });
   os << ')';
 }
 
 // Get an array of all OpInterface definitions but exclude those subclassing
 // "DeclareOpInterfaceMethods".
 static std::vector<Record *>
 getAllOpInterfaceDefinitions(const RecordKeeper &recordKeeper) {
   std::vector<Record *> defs =
static void emitInterfaceDef(OpInterface &interface, raw_ostream &os) {
   for (auto &method : interface.getMethods()) {
     os << method.getReturnType() << " " << interfaceName << "::";
     emitMethodNameAndArgs(method, os, /*addOperationArg=*/false);
 
     // Forward to the method on the concrete operation type.
     os << " {\n      return getImpl()->" << method.getName() << '(';
     if (!method.isStatic())
       os << "getOperation()" << (method.arg_empty() ? "" : ", ");
-    interleaveComma(
+    llvm::interleaveComma(
         method.getArguments(), os,
         [&](const OpInterfaceMethod::Argument &arg) { os << arg.name; });
     os << ");\n  }\n";
   }
 }
 
 static bool emitInterfaceDefs(const RecordKeeper &recordKeeper,
                               raw_ostream &os) {
if (auto body = method.getBody()) {
       continue;
     }
 
     // Forward to the method on the concrete operation type.
     os << "      return " << (method.isStatic() ? "ConcreteOp::" : "op.");
 
     // Add the arguments to the call.
     os << method.getName() << '(';
-    interleaveComma(
+    llvm::interleaveComma(
         method.getArguments(), os,
         [&](const OpInterfaceMethod::Argument &arg) { os << arg.name; });
     os << ");\n    }\n";
   }
   os << "  };\n";
 }
 
 static void emitTraitDecl(OpInterface &interface, raw_ostream &os,
static void emitInterfaceDoc(const Record &interfaceDef, raw_ostream &os) {
   for (const auto &method : interface.getMethods()) {
     // Emit the method name.
     os << "#### `" << method.getName() << "`\n\n```c++\n";
 
     // Emit the method signature.
     if (method.isStatic())
       os << "static ";
     emitCPPType(method.getReturnType(), os) << method.getName() << '(';
-    interleaveComma(method.getArguments(), os,
+    llvm::interleaveComma(method.getArguments(), os,
                           [&](const OpInterfaceMethod::Argument &arg) {
                             emitCPPType(arg.type, os) << arg.name;
                           });
     os << ");\n```\n";
 
     // Emit the description.
     if (auto description = method.getDescription())
       mlir::tblgen::emitDescription(*description, os);
 
     // If the body is not provided, this method must be provided by the
     // operation.

mlir/tools/mlir-tblgen/RewriterGen.cpp

os << formatv(R"(struct {0} : public RewritePattern {
       : RewritePattern("{1}", {{)",
                 rewriteName, rootName);
   // Sort result operators by name.
   llvm::SmallVector<const Operator *, 4> sortedResultOps(resultOps.begin(),
                                                          resultOps.end());
   llvm::sort(sortedResultOps, [&](const Operator *lhs, const Operator *rhs) {
     return lhs->getOperationName() < rhs->getOperationName();
   });
-  interleaveComma(sortedResultOps, os, [&](const Operator *op) {
+  llvm::interleaveComma(sortedResultOps, os, [&](const Operator *op) {
     os << '"' << op->getOperationName() << '"';
   });
   os << formatv(R"(}, {0}, context) {{})", pattern.getBenefit()) << "\n";
 
   // Emit matchAndRewrite() function.
   os << R"(
   LogicalResult matchAndRewrite(Operation *op0,
                                      PatternRewriter &rewriter) const override {

mlir/tools/mlir-tblgen/SPIRVUtilsGen.cpp

for (const EnumAttrCase &enumerant : enumAttr.getAllCases()) {
     const Record &def = enumerant.getDef();
     if (!def.getValue("implies"))
       continue;
 
     std::vector<Record *> impliedCapsDefs = def.getValueAsListOfDefs("implies");
     os << "  case Capability::" << enumerant.getSymbol()
        << ": {static const Capability implies[" << impliedCapsDefs.size()
        << "] = {";
-    mlir::interleaveComma(impliedCapsDefs, os, [&](const Record *capDef) {
+    llvm::interleaveComma(impliedCapsDefs, os, [&](const Record *capDef) {
       os << "Capability::" << EnumAttrCase(capDef).getSymbol();
     });
     os << "}; return ArrayRef<Capability>(implies, " << impliedCapsDefs.size()
        << "); }\n";
   }
   os << "  }\n";
   os << "}\n";