Restoring authorship annotation for <[email protected]>. Commit 2 of 2.

1 files changed, 173 insertions, 173 deletions

diff --git a/contrib/libs/llvm12/include/llvm/Support/FormatVariadicDetails.h b/contrib/libs/llvm12/include/llvm/Support/FormatVariadicDetails.h
index 8ff7b47573d..d91a37feb2a 100644
--- a/contrib/libs/llvm12/include/llvm/Support/FormatVariadicDetails.h
+++ b/contrib/libs/llvm12/include/llvm/Support/FormatVariadicDetails.h
@@ -1,173 +1,173 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- FormatVariadicDetails.h - Helpers for FormatVariadic.h ----*- C++-*-===// 
-// 
-// 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 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_SUPPORT_FORMATVARIADIC_DETAILS_H 
-#define LLVM_SUPPORT_FORMATVARIADIC_DETAILS_H 
- 
-#include "llvm/ADT/StringRef.h" 
-#include "llvm/Support/raw_ostream.h" 
- 
-#include <type_traits> 
- 
-namespace llvm { 
-template <typename T, typename Enable = void> struct format_provider {}; 
-class Error; 
- 
-namespace detail { 
-class format_adapter { 
-  virtual void anchor(); 
- 
-protected: 
-  virtual ~format_adapter() {} 
- 
-public: 
-  virtual void format(raw_ostream &S, StringRef Options) = 0; 
-}; 
- 
-template <typename T> class provider_format_adapter : public format_adapter { 
-  T Item; 
- 
-public: 
-  explicit provider_format_adapter(T &&Item) : Item(std::forward<T>(Item)) {} 
- 
-  void format(llvm::raw_ostream &S, StringRef Options) override { 
-    format_provider<std::decay_t<T>>::format(Item, S, Options); 
-  } 
-}; 
- 
-template <typename T> 
-class stream_operator_format_adapter : public format_adapter { 
-  T Item; 
- 
-public: 
-  explicit stream_operator_format_adapter(T &&Item) 
-      : Item(std::forward<T>(Item)) {} 
- 
-  void format(llvm::raw_ostream &S, StringRef Options) override { S << Item; } 
-}; 
- 
-template <typename T> class missing_format_adapter; 
- 
-// Test if format_provider<T> is defined on T and contains a member function 
-// with the signature: 
-//   static void format(const T&, raw_stream &, StringRef); 
-// 
-template <class T> class has_FormatProvider { 
-public: 
-  using Decayed = std::decay_t<T>; 
-  typedef void (*Signature_format)(const Decayed &, llvm::raw_ostream &, 
-                                   StringRef); 
- 
-  template <typename U> 
-  static char test(SameType<Signature_format, &U::format> *); 
- 
-  template <typename U> static double test(...); 
- 
-  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); 
-}; 
- 
-// 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, 
-          std::is_base_of<format_adapter, std::remove_reference_t<T>>::value> { 
-}; 
- 
-// Simple template that decides whether a type T should use the format_provider 
-// based format() invocation.  The member function takes priority, so this test 
-// will only be true if there is not ALSO a format member. 
-template <typename T> 
-struct uses_format_provider 
-    : public std::integral_constant< 
-          bool, !uses_format_member<T>::value && has_FormatProvider<T>::value> { 
-}; 
- 
-// Simple template that decides whether a type T should use the operator<< 
-// based format() invocation.  This takes last priority. 
-template <typename T> 
-struct uses_stream_operator 
-    : public std::integral_constant<bool, !uses_format_member<T>::value && 
-                                              !uses_format_provider<T>::value && 
-                                              has_StreamOperator<T>::value> {}; 
- 
-// Simple template that decides whether a type T has neither a member-function 
-// nor format_provider based implementation that it can use.  Mostly used so 
-// that the compiler spits out a nice diagnostic when a type with no format 
-// implementation can be located. 
-template <typename T> 
-struct uses_missing_provider 
-    : public std::integral_constant<bool, !uses_format_member<T>::value && 
-                                              !uses_format_provider<T>::value && 
-                                              !uses_stream_operator<T>::value> { 
-}; 
- 
-template <typename T> 
-std::enable_if_t<uses_format_member<T>::value, T> 
-build_format_adapter(T &&Item) { 
-  return std::forward<T>(Item); 
-} 
- 
-template <typename T> 
-std::enable_if_t<uses_format_provider<T>::value, provider_format_adapter<T>> 
-build_format_adapter(T &&Item) { 
-  return provider_format_adapter<T>(std::forward<T>(Item)); 
-} 
- 
-template <typename T> 
-std::enable_if_t<uses_stream_operator<T>::value, 
-                 stream_operator_format_adapter<T>> 
-build_format_adapter(T &&Item) { 
-  // If the caller passed an Error by value, then stream_operator_format_adapter 
-  // would be responsible for consuming it. 
-  // Make the caller opt into this by calling fmt_consume(). 
-  static_assert( 
-      !std::is_same<llvm::Error, std::remove_cv_t<T>>::value, 
-      "llvm::Error-by-value must be wrapped in fmt_consume() for formatv"); 
-  return stream_operator_format_adapter<T>(std::forward<T>(Item)); 
-} 
- 
-template <typename T> 
-std::enable_if_t<uses_missing_provider<T>::value, missing_format_adapter<T>> 
-build_format_adapter(T &&Item) { 
-  return missing_format_adapter<T>(); 
-} 
-} 
-} 
- 
-#endif 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- FormatVariadicDetails.h - Helpers for FormatVariadic.h ----*- C++-*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_FORMATVARIADIC_DETAILS_H
+#define LLVM_SUPPORT_FORMATVARIADIC_DETAILS_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <type_traits>
+
+namespace llvm {
+template <typename T, typename Enable = void> struct format_provider {};
+class Error;
+
+namespace detail {
+class format_adapter {
+  virtual void anchor();
+
+protected:
+  virtual ~format_adapter() {}
+
+public:
+  virtual void format(raw_ostream &S, StringRef Options) = 0;
+};
+
+template <typename T> class provider_format_adapter : public format_adapter {
+  T Item;
+
+public:
+  explicit provider_format_adapter(T &&Item) : Item(std::forward<T>(Item)) {}
+
+  void format(llvm::raw_ostream &S, StringRef Options) override {
+    format_provider<std::decay_t<T>>::format(Item, S, Options);
+  }
+};
+
+template <typename T>
+class stream_operator_format_adapter : public format_adapter {
+  T Item;
+
+public:
+  explicit stream_operator_format_adapter(T &&Item)
+      : Item(std::forward<T>(Item)) {}
+
+  void format(llvm::raw_ostream &S, StringRef Options) override { S << Item; }
+};
+
+template <typename T> class missing_format_adapter;
+
+// Test if format_provider<T> is defined on T and contains a member function
+// with the signature:
+//   static void format(const T&, raw_stream &, StringRef);
+//
+template <class T> class has_FormatProvider {
+public:
+  using Decayed = std::decay_t<T>;
+  typedef void (*Signature_format)(const Decayed &, llvm::raw_ostream &,
+                                   StringRef);
+
+  template <typename U>
+  static char test(SameType<Signature_format, &U::format> *);
+
+  template <typename U> static double test(...);
+
+  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);
+};
+
+// 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,
+          std::is_base_of<format_adapter, std::remove_reference_t<T>>::value> {
+};
+
+// Simple template that decides whether a type T should use the format_provider
+// based format() invocation.  The member function takes priority, so this test
+// will only be true if there is not ALSO a format member.
+template <typename T>
+struct uses_format_provider
+    : public std::integral_constant<
+          bool, !uses_format_member<T>::value && has_FormatProvider<T>::value> {
+};
+
+// Simple template that decides whether a type T should use the operator<<
+// based format() invocation.  This takes last priority.
+template <typename T>
+struct uses_stream_operator
+    : public std::integral_constant<bool, !uses_format_member<T>::value &&
+                                              !uses_format_provider<T>::value &&
+                                              has_StreamOperator<T>::value> {};
+
+// Simple template that decides whether a type T has neither a member-function
+// nor format_provider based implementation that it can use.  Mostly used so
+// that the compiler spits out a nice diagnostic when a type with no format
+// implementation can be located.
+template <typename T>
+struct uses_missing_provider
+    : public std::integral_constant<bool, !uses_format_member<T>::value &&
+                                              !uses_format_provider<T>::value &&
+                                              !uses_stream_operator<T>::value> {
+};
+
+template <typename T>
+std::enable_if_t<uses_format_member<T>::value, T>
+build_format_adapter(T &&Item) {
+  return std::forward<T>(Item);
+}
+
+template <typename T>
+std::enable_if_t<uses_format_provider<T>::value, provider_format_adapter<T>>
+build_format_adapter(T &&Item) {
+  return provider_format_adapter<T>(std::forward<T>(Item));
+}
+
+template <typename T>
+std::enable_if_t<uses_stream_operator<T>::value,
+                 stream_operator_format_adapter<T>>
+build_format_adapter(T &&Item) {
+  // If the caller passed an Error by value, then stream_operator_format_adapter
+  // would be responsible for consuming it.
+  // Make the caller opt into this by calling fmt_consume().
+  static_assert(
+      !std::is_same<llvm::Error, std::remove_cv_t<T>>::value,
+      "llvm::Error-by-value must be wrapped in fmt_consume() for formatv");
+  return stream_operator_format_adapter<T>(std::forward<T>(Item));
+}
+
+template <typename T>
+std::enable_if_t<uses_missing_provider<T>::value, missing_format_adapter<T>>
+build_format_adapter(T &&Item) {
+  return missing_format_adapter<T>();
+}
+}
+}
+
+#endif
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif