1 //===- FormatVariadicDetails.h - Helpers for FormatVariadic.h ----*- C++-*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef LLVM_SUPPORT_FORMATVARIADICDETAILS_H
10 #define LLVM_SUPPORT_FORMATVARIADICDETAILS_H
11 
12 #include "llvm/ADT/StringRef.h"
13 #include "llvm/ADT/STLExtras.h"
14 #include "llvm/Support/raw_ostream.h"
15 
16 #include <type_traits>
17 
18 namespace llvm {
19 template <typename T, typename Enable = void> struct format_provider {};
20 class Error;
21 
22 namespace detail {
23 class format_adapter {
24   virtual void anchor();
25 
26 protected:
27   virtual ~format_adapter() = default;
28 
29 public:
30   virtual void format(raw_ostream &S, StringRef Options) = 0;
31 };
32 
33 template <typename T> class provider_format_adapter : public format_adapter {
34   T Item;
35 
36 public:
37   explicit provider_format_adapter(T &&Item) : Item(std::forward<T>(Item)) {}
38 
39   void format(llvm::raw_ostream &S, StringRef Options) override {
40     format_provider<std::decay_t<T>>::format(Item, S, Options);
41   }
42 };
43 
44 template <typename T>
45 class stream_operator_format_adapter : public format_adapter {
46   T Item;
47 
48 public:
49   explicit stream_operator_format_adapter(T &&Item)
50       : Item(std::forward<T>(Item)) {}
51 
52   void format(llvm::raw_ostream &S, StringRef) override { S << Item; }
53 };
54 
55 template <typename T> class missing_format_adapter;
56 
57 // Test if format_provider<T> is defined on T and contains a member function
58 // with the signature:
59 //   static void format(const T&, raw_stream &, StringRef);
60 //
61 template <class T> class has_FormatProvider {
62 public:
63   using Decayed = std::decay_t<T>;
64   typedef void (*Signature_format)(const Decayed &, llvm::raw_ostream &,
65                                    StringRef);
66 
67   template <typename U>
68   static char test(SameType<Signature_format, &U::format> *);
69 
70   template <typename U> static double test(...);
71 
72   static bool const value =
73       (sizeof(test<llvm::format_provider<Decayed>>(nullptr)) == 1);
74 };
75 
76 // Test if raw_ostream& << T -> raw_ostream& is findable via ADL.
77 template <class T> class has_StreamOperator {
78 public:
79   using ConstRefT = const std::decay_t<T> &;
80 
81   template <typename U>
82   static char test(std::enable_if_t<
83                    std::is_same_v<decltype(std::declval<llvm::raw_ostream &>()
84                                            << std::declval<U>()),
85                                   llvm::raw_ostream &>,
86                    int *>);
87 
88   template <typename U> static double test(...);
89 
90   static bool const value = (sizeof(test<ConstRefT>(nullptr)) == 1);
91 };
92 
93 // Simple template that decides whether a type T should use the member-function
94 // based format() invocation.
95 template <typename T>
96 struct uses_format_member
97     : public std::integral_constant<
98           bool, std::is_base_of_v<format_adapter, std::remove_reference_t<T>>> {
99 };
100 
101 // Simple template that decides whether a type T should use the format_provider
102 // based format() invocation.  The member function takes priority, so this test
103 // will only be true if there is not ALSO a format member.
104 template <typename T>
105 struct uses_format_provider
106     : public std::integral_constant<
107           bool, !uses_format_member<T>::value && has_FormatProvider<T>::value> {
108 };
109 
110 // Simple template that decides whether a type T should use the operator<<
111 // based format() invocation.  This takes last priority.
112 template <typename T>
113 struct uses_stream_operator
114     : public std::integral_constant<bool, !uses_format_member<T>::value &&
115                                               !uses_format_provider<T>::value &&
116                                               has_StreamOperator<T>::value> {};
117 
118 // Simple template that decides whether a type T has neither a member-function
119 // nor format_provider based implementation that it can use.  Mostly used so
120 // that the compiler spits out a nice diagnostic when a type with no format
121 // implementation can be located.
122 template <typename T>
123 struct uses_missing_provider
124     : public std::integral_constant<bool, !uses_format_member<T>::value &&
125                                               !uses_format_provider<T>::value &&
126                                               !uses_stream_operator<T>::value> {
127 };
128 
129 template <typename T>
130 std::enable_if_t<uses_format_member<T>::value, T>
131 build_format_adapter(T &&Item) {
132   return std::forward<T>(Item);
133 }
134 
135 template <typename T>
136 std::enable_if_t<uses_format_provider<T>::value, provider_format_adapter<T>>
137 build_format_adapter(T &&Item) {
138   return provider_format_adapter<T>(std::forward<T>(Item));
139 }
140 
141 template <typename T>
142 std::enable_if_t<uses_stream_operator<T>::value,
143                  stream_operator_format_adapter<T>>
144 build_format_adapter(T &&Item) {
145   // If the caller passed an Error by value, then stream_operator_format_adapter
146   // would be responsible for consuming it.
147   // Make the caller opt into this by calling fmt_consume().
148   static_assert(
149       !std::is_same_v<llvm::Error, std::remove_cv_t<T>>,
150       "llvm::Error-by-value must be wrapped in fmt_consume() for formatv");
151   return stream_operator_format_adapter<T>(std::forward<T>(Item));
152 }
153 
154 template <typename T>
155 std::enable_if_t<uses_missing_provider<T>::value, missing_format_adapter<T>>
156 build_format_adapter(T &&) {
157   return missing_format_adapter<T>();
158 }
159 }
160 }
161 
162 #endif
163