[Support] Format provider improvements

[vinograd47]

Summary

Remove std::forward call for iterator_range iterator de-reference.
It fixes formatting usage for some tricky cases, like special ranges,
which de-reference to value type.

[Hardcode84]

Why I am here? What's going on?

[vinograd47]

@Hardcode84 Sorry for confusion, added you by mistake.

[vinograd47]

Suppress clang-tidy diagnostic about class member name.

It is a common name for compile-time checks implemented via template classes : SomeSheck<T>::value.

[sammccall]

Can you add a test for whatever this is fixing?

llvm/include/llvm/Support/FormatProviders.h

405

As you say this only affects cases where operator* returns something other than reference.
I can't see this breaking anything without breaking the build, so if all tests pass I think we're good.

llvm/include/llvm/Support/FormatVariadicDetails.h

87–88

nit: I don't think it's worth adding suppression comments for the naming lint, since there are *so* many places using the "wrong" style in LLVM.

88

why this change?
this seems like it should only affect:

• cases where operator<< has a weird signature (like non-const reference, or by value but not copyable)
• weird cases due to conversions affecting deduction (but seems as likely to break things as fix them)

All else equal, I think it's preferable to ensure operator<< has the expected signature.

[vinograd47]

Added a test for the case, which this change fixes.

[vinograd47]

llvm/include/llvm/Support/FormatVariadicDetails.h

87–88

Without the suppression CI fails on the affected line. I believe it runs checks only on modified code and it started to complain about this case, since I've touched it.

If I remove the suppression comment, CI will fail.

88

Added information and test for the second change (has_StreamOperator). It fixes another issue - stream operator, which accepts object by non-const reference.

The issue comes from MLIR project, which use non-const API for Operation class. It is intentional design choice (https://mlir.llvm.org/docs/Rationale/UsageOfConst/) and affects all methods of the class including printing.

While such API is not very common for C++, I think the format utilities should not restrict and refuse such cases. That's why I've made has_StreamOperator check more general.

Added an unit test for such scenario.

[vinograd47]

Rebased and fixes clang-tidy warnings in the new test.

[sammccall]

llvm/include/llvm/Support/FormatVariadicDetails.h

87–88

If I remove the suppression comment, CI will fail.

AFAIK, the clang-tidy linter is not intended to be considered blocking, and there hasn't been a consensus to add lint suppression comments in LLVM.

(@kuhnel @goncharov FYI that this is being seen as a reason to add these comments to changes in files that already do not follow the naming style)

88

I think the format utilities should not restrict and refuse such cases

I disagree - LLVM in general (including Support) is const-correct. If MLIR chooses not to be const-correct, that code should expect to have to const_cast at API boundaries with common code.

A non-const operator<< is unusual, and can have meaning beyond "I don't care about const". e.g. there are at least two operator<< in LLVM that actually mutate their RHS argument.

[vinograd47]

llvm/include/llvm/Support/FormatVariadicDetails.h

88

I can agree with you in general, but not in this particular case. This formatting API is just a some kind of decorator over other APIs (like << operator with stream). It forwards its arguments as is to underlying API. So it only need to check that the stream << std::forward<T>(arg) expression is valid C++ code. Such details as const correctness is the details of this underlying code. As long as stream << std::forward<T>(arg) is valid expression, I don't see a reason to forbid it in formatv function.

[vinograd47]

One more comment.

Even while has_StreamOperator checks only for const correct stream operator,
the formatv implementation still might call non-const version if presented
(due to perfect forwarding).

So, IMHO, either formatv should be stricter or has_StreamOperator should be
relaxed.

[vinograd47]

@sammccall Could we have some agreement? As I mentioned in the last comment, even while has_StreamOperator checks for const correct version of operator << with streams, formatv implementation can call non-const version if it is available due to perfect forwarding.

[vinograd47]

Rebased and added a test for range with non-reference return value.

[vinograd47]

Rebased to restart CI.

[vinograd47]

Fixed clang-tidy issues in new tests.

[vinograd47]

@sammccall @zturner ping

[vinograd47]

Rebased

[vinograd47]

@sammccall @zturner

I've excluded questionable part (non-const references support) from the patch.
Could you please take a look one more time?

[vinograd47]

Rebased to re-run pre-commit CI

[vinograd47]

@sammccall @zturner Gentle remainder :) Could you please take a look one more time to this patch? I've excluded questionable part from it.

[sammccall]

Sorry for the delay :-(

llvm/include/llvm/Support/FormatProviders.h

 /// to format the value type.
 ///
 /// Note that attempting to format an `iterator_range<T>` where no format
 /// provider can be found for T will result in a compile error.
 ///
 
 template <typename IterT> class format_provider<llvm::iterator_range<IterT>> {
   using value = typename std::iterator_traits<IterT>::value_type;
-  using reference = typename std::iterator_traits<IterT>::reference;
 
   static StringRef consumeOneOption(StringRef &Style, char Indicator,
                                     StringRef Default) {
     if (Style.empty())
       return Default;
     if (Style.front() != Indicator)
       return Default;
     Style = Style.drop_front();
public:
   static void format(const llvm::iterator_range<IterT> &V,
                      llvm::raw_ostream &Stream, StringRef Style) {
     StringRef Sep;
     StringRef ArgStyle;
     std::tie(Sep, ArgStyle) = parseOptions(Style);
     auto Begin = V.begin();
     auto End = V.end();
     if (Begin != End) {
-      auto Adapter =
-          detail::build_format_adapter(std::forward<reference>(*Begin));
+      auto Adapter = detail::build_format_adapter(*Begin);
       Adapter.format(Stream, ArgStyle);
       ++Begin;
     }
     while (Begin != End) {
       Stream << Sep;
-      auto Adapter =
-          detail::build_format_adapter(std::forward<reference>(*Begin));
+      auto Adapter = detail::build_format_adapter(*Begin);
       Adapter.format(Stream, ArgStyle);
       ++Begin;
     }
   }
 };
 }
 
 #endif

llvm/include/llvm/Support/FormatVariadicDetails.h

public:
 
   static bool const value =
       (sizeof(test<llvm::format_provider<Decayed>>(nullptr)) == 1);
 };
 
 // Test if raw_ostream& << T -> raw_ostream& is findable via ADL.
 template <class T> class has_StreamOperator {
 public:
-  using ConstRefT = const std::decay_t<T> &;
-
   template <typename U>
   static char test(
       std::enable_if_t<std::is_same<decltype(std::declval<llvm::raw_ostream &>()
                                              << std::declval<U>()),
                                     llvm::raw_ostream &>::value,
                        int *>);
 
   template <typename U> static double test(...);
 
-  static bool const value = (sizeof(test<ConstRefT>(nullptr)) == 1);
+  // NOLINTNEXTLINE(readability-identifier-naming)
+  static bool const value = (sizeof(test<T>(nullptr)) == 1);
 };
 
 // Simple template that decides whether a type T should use the member-function
 // based format() invocation.
 template <typename T>
 struct uses_format_member
     : public std::integral_constant<
           bool,

llvm/unittests/Support/FormatVariadicTest.cpp

 
 TEST(FormatVariadicTest, FormatError) {
   auto E1 = make_error<StringError>("X", inconvertibleErrorCode());
   EXPECT_EQ("X", formatv("{0}", E1).str());
   EXPECT_TRUE(E1.isA<StringError>()); // not consumed
   EXPECT_EQ("X", formatv("{0}", fmt_consume(std::move(E1))).str());
   EXPECT_FALSE(E1.isA<StringError>()); // consumed
 }
+
+TEST(FormatVariadicTest, FormatFilterRange) {
+  std::vector<int> vec{0, 1, 2};
+  auto range = map_range(vec, [](int v) { return v + 1; });
+  EXPECT_EQ("1, 2, 3", formatv("{0}", range).str());
+}
+
+namespace {
+
+class IntegerValuesRange final
+    : public indexed_accessor_range<IntegerValuesRange, NoneType, int, int *,
+                                    int> {
+public:
+  using indexed_accessor_range<IntegerValuesRange, NoneType, int, int *,
+                               int>::indexed_accessor_range;
+
+  static int dereference(const NoneType &, ptrdiff_t index) {
+    return static_cast<int>(index);
+  }
+};
+
+TEST(FormatVariadicTest, FormatRangeNonRef) {
+  IntegerValuesRange range(None, 0, 3);
+  EXPECT_EQ("0, 1, 2",
+            formatv("{0}", make_range(range.begin(), range.end())).str());
+}
+
+class PassByRef {
+public:
+  int Val = 0;
+  PassByRef(int Val) : Val(Val) {}
+};
+
+raw_ostream &operator<<(raw_ostream &OS, PassByRef &Obj) {
+  return OS << Obj.Val;
+}
+
+static_assert(detail::has_StreamOperator<PassByRef &>::value, "");
+static_assert(detail::uses_stream_operator<PassByRef &>::value, "");
+
+TEST(FormatVariadicTest, StreamOperatorPassByRef) {
+  PassByRef Obj(10);
+  EXPECT_EQ("10", formatv("{0}", Obj).str());
+}
+
+} // namespace