Pull interleaved range out of Format.h

Author: kuhar

llvm/include/llvm/Support/Format.h

@@ -256,90 +256,6 @@ format_bytes_with_ascii(ArrayRef<uint8_t> Bytes,
                         ByteGroupSize, Upper, true);
 }
 
-/// The base class for printing interleaved ranges. Provides a virtual function
-/// to be used by the '<<' operator in raw_ostream. This class is not intended
-/// to be copied or used in polymorphic containers.
-class InterleavedRangeBase {
-protected:
-  ~InterleavedRangeBase() = default; // Disallow polymorphic deletion.
-  InterleavedRangeBase() = default;
-  InterleavedRangeBase(const InterleavedRangeBase &) = delete; // Disallow copy.
-  virtual void home(); // Out of line virtual method to anchor the vtable.
-
-  /// Appends the interleaved range to the output stream `OS`.
-  virtual void printInterleaved(raw_ostream &OS) const = 0;
-
-  friend class raw_ostream;
-};
-
-/// The concrete class template for interleaved ranges. Supports specifying the
-/// separator and, optionally, the prefix and suffix to be printed surrounding
-/// the range.
-/// Uses the operator '<<' of the range element type for printing. The range
-/// type itself does not have to have an '<<' operator defined.
-template <typename Range>
-class InterleavedRange final : public InterleavedRangeBase {
-  const Range &TheRange;
-  StringRef Separator;
-  StringRef Prefix;
-  StringRef Suffix;
-
-  virtual void printInterleaved(raw_ostream &OS) const override {
-    if (!Prefix.empty())
-      OS << Prefix;
-    llvm::interleave(TheRange, OS, Separator);
-    if (!Suffix.empty())
-      OS << Suffix;
-  }
-
-public:
-  InterleavedRange(const Range &R, StringRef Separator, StringRef Prefix,
-                   StringRef Suffix)
-      : TheRange(R), Separator(Separator), Prefix(Prefix), Suffix(Suffix) {}
-
-  std::string str() const {
-    std::string Result;
-    raw_string_ostream Stream(Result);
-    Stream << *this;
-    Stream.flush();
-    return Result;
-  }
-
-  operator std::string() const { return str(); }
-};
-
-/// interleaved - Output range \p R as a sequence of interleaved elements.
-/// Requires the range element type to be printable using
-/// `raw_ostream& operator<<`. The \p Separator and \p Prefix / \p Suffix can be
-/// customized. Examples:
-/// ```c++
-///   SmallVector<int> Vals = {1, 2, 3};
-///   OS << interleaved(Vals);                 // ==> "1, 2, 3"
-///   OS << interleaved(Vals, ";");            // ==> "1;2;3"
-///   OS << interleaved(Vals, " ", "{", "}");  // ==> "{1 2 3}"
-/// ```
-template <typename Range>
-InterleavedRange<Range> interleaved(const Range &R, StringRef Separator = ", ",
-                                    StringRef Prefix = "",
-                                    StringRef Suffix = "") {
-  return {R, Separator, Prefix, Suffix};
-}
-
-/// interleaved - Output range \p R as an array of interleaved elements.
-/// Requires the range element type to be printable using
-/// `raw_ostream& operator<<`. The \p Separator can be customized. Examples:
-/// ```c++
-///   SmallVector<int> Vals = {1, 2, 3};
-///   OS << interleaved_array(Vals);       // ==> "[1, 2, 3]"
-///   OS << interleaved_array(Vals, ";");  // ==> "[1;2;3]"
-///   OS << interleaved_array(Vals, " ");  // ==> "[1 2 3]"
-/// ```
-template <typename Range>
-InterleavedRange<Range> interleaved_array(const Range &R,
-                                          StringRef Separator = ", ") {
-  return {R, Separator, "[", "]"};
-}
-
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Support/InterleavedRange.h

@@ -0,0 +1,102 @@
+//===- InterleavedRange.h - Output stream formatting for ranges -----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Implements format objects for printing ranges to output streams.
+// For example:
+// ```c++
+//    ArrayRef<Type> Types = ...;
+//    OS << "Types: " << interleaved(Types); // ==> "Types: i32, f16, i8"
+//    ArrayRef<int> Values = ...;
+//    OS << "Values: " << interleaved_array(Values); // ==> "Values: [1, 2, 3]"
+// ```
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_INTERLEAVED_RANGE_H
+#define LLVM_SUPPORT_INTERLEAVED_RANGE_H
+
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
+#include <cassert>
+#include <cstdio>
+
+namespace llvm {
+
+/// Format object class for interleaved ranges. Supports specifying the
+/// separator and, optionally, the prefix and suffix to be printed surrounding
+/// the range.
+/// Uses the operator '<<' of the range element type for printing. The range
+/// type itself does not have to have an '<<' operator defined.
+template <typename Range> class InterleavedRange {
+  const Range &TheRange;
+  StringRef Separator;
+  StringRef Prefix;
+  StringRef Suffix;
+
+public:
+  InterleavedRange(const Range &R, StringRef Separator, StringRef Prefix,
+                   StringRef Suffix)
+      : TheRange(R), Separator(Separator), Prefix(Prefix), Suffix(Suffix) {}
+
+  friend raw_ostream &operator<<(raw_ostream &OS,
+                                 const InterleavedRange &Interleaved) {
+    if (!Interleaved.Prefix.empty())
+      OS << Interleaved.Prefix;
+    llvm::interleave(Interleaved.TheRange, OS, Interleaved.Separator);
+    if (!Interleaved.Suffix.empty())
+      OS << Interleaved.Suffix;
+    return OS;
+  }
+
+  std::string str() const {
+    std::string Result;
+    raw_string_ostream Stream(Result);
+    Stream << *this;
+    Stream.flush();
+    return Result;
+  }
+
+  operator std::string() const { return str(); }
+};
+
+/// interleaved - Output range `R` as a sequence of interleaved elements.
+/// Requires the range element type to be printable using
+/// `raw_ostream& operator<<`. The `Separator` and `Prefix` / `Suffix` can be
+/// customized. Examples:
+/// ```c++
+///   SmallVector<int> Vals = {1, 2, 3};
+///   OS << interleaved(Vals);                 // ==> "1, 2, 3"
+///   OS << interleaved(Vals, ";");            // ==> "1;2;3"
+///   OS << interleaved(Vals, " ", "{", "}");  // ==> "{1 2 3}"
+/// ```
+template <typename Range>
+InterleavedRange<Range> interleaved(const Range &R, StringRef Separator = ", ",
+                                    StringRef Prefix = "",
+                                    StringRef Suffix = "") {
+  return {R, Separator, Prefix, Suffix};
+}
+
+/// interleaved - Output range `R` as an array of interleaved elements.
+/// Requires the range element type to be printable using
+/// `raw_ostream& operator<<`. The `Separator` can be customized. Examples:
+/// ```c++
+///   SmallVector<int> Vals = {1, 2, 3};
+///   OS << interleaved_array(Vals);       // ==> "[1, 2, 3]"
+///   OS << interleaved_array(Vals, ";");  // ==> "[1;2;3]"
+///   OS << interleaved_array(Vals, " ");  // ==> "[1 2 3]"
+/// ```
+template <typename Range>
+InterleavedRange<Range> interleaved_array(const Range &R,
+                                          StringRef Separator = ", ") {
+  return {R, Separator, "[", "]"};
+}
+
+} // end namespace llvm
+
+#endif // LLVM_SUPPORT_INTERLEAVED_RANGE_H

llvm/include/llvm/Support/raw_ostream.h

@@ -29,13 +29,12 @@
 namespace llvm {
 
 class Duration;
-template <class T> class [[nodiscard]] Expected;
 class formatv_object_base;
 class format_object_base;
 class FormattedString;
 class FormattedNumber;
 class FormattedBytes;
-class InterleavedRangeBase;
+template <class T> class [[nodiscard]] Expected;
 
 namespace sys {
 namespace fs {
@@ -319,9 +318,6 @@ class raw_ostream {
   // Formatted output, see the format_bytes() function in Support/Format.h.
   raw_ostream &operator<<(const FormattedBytes &);
 
-  // Formatted output, see the interleaved() function in Support/Format.h.
-  raw_ostream &operator<<(const InterleavedRangeBase &);
-
   /// indent - Insert 'NumSpaces' spaces.
   raw_ostream &indent(unsigned NumSpaces);
 

llvm/lib/Support/raw_ostream.cpp

@@ -471,12 +471,6 @@ raw_ostream &raw_ostream::operator<<(const FormattedBytes &FB) {
   return *this;
 }
 
-raw_ostream &
-raw_ostream::operator<<(const InterleavedRangeBase &InterleavedRange) {
-  InterleavedRange.printInterleaved(*this);
-  return *this;
-}
-
 template <char C>
 static raw_ostream &write_padding(raw_ostream &OS, unsigned NumChars) {
   static const char Chars[] = {C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C,
@@ -561,10 +555,8 @@ void raw_ostream::anchor() {}
 //===----------------------------------------------------------------------===//
 
 // Out of line virtual method.
-void format_object_base::home() {}
-
-// Out of line virtual method.
-void InterleavedRangeBase::home() {}
+void format_object_base::home() {
+}
 
 //===----------------------------------------------------------------------===//
 //  raw_fd_ostream

llvm/unittests/Support/InterleavedRangeTest.cpp

@@ -7,7 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/Format.h"
+#include "llvm/Support/InterleavedRange.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"