Index: include/llvm/Support/FormatAdapters.h
===================================================================
--- include/llvm/Support/FormatAdapters.h
+++ include/llvm/Support/FormatAdapters.h
@@ -17,57 +17,58 @@
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
-template <typename T> class AdapterBase {
+template <typename T> class FormatAdapter : public detail::format_adapter {
 protected:
-  explicit AdapterBase(T &&Item) : Item(Item) {}
+  explicit FormatAdapter(T Item) : Item(Item) {}
 
   T Item;
+
   static_assert(!detail::uses_missing_provider<T>::value,
                 "Item does not have a format provider!");
 };
 
 namespace detail {
-template <typename T> class AlignAdapter : public AdapterBase<T> {
+template <typename T> class AlignAdapter final : public FormatAdapter<T> {
   AlignStyle Where;
   size_t Amount;
 
 public:
   AlignAdapter(T &&Item, AlignStyle Where, size_t Amount)
-      : AdapterBase<T>(std::forward<T>(Item)), Where(Where), Amount(Amount) {}
+      : FormatAdapter<T>(std::forward<T>(Item)), Where(Where), Amount(Amount) {}
 
   void format(llvm::raw_ostream &Stream, StringRef Style) {
-    auto Wrapper = detail::build_format_wrapper(std::forward<T>(this->Item));
-    FmtAlign(Wrapper, Where, Amount).format(Stream, Style);
+    auto Adapter = detail::build_format_adapter(std::forward<T>(this->Item));
+    FmtAlign(Adapter, Where, Amount).format(Stream, Style);
   }
 };
 
-template <typename T> class PadAdapter : public AdapterBase<T> {
+template <typename T> class PadAdapter final : public FormatAdapter<T> {
   size_t Left;
   size_t Right;
 
 public:
   PadAdapter(T &&Item, size_t Left, size_t Right)
-      : AdapterBase<T>(std::forward<T>(Item)), Left(Left), Right(Right) {}
+      : FormatAdapter<T>(std::forward<T>(Item)), Left(Left), Right(Right) {}
 
   void format(llvm::raw_ostream &Stream, StringRef Style) {
-    auto Wrapper = detail::build_format_wrapper(std::forward<T>(this->Item));
+    auto Adapter = detail::build_format_adapter(std::forward<T>(this->Item));
     Stream.indent(Left);
-    Wrapper.format(Stream, Style);
+    Adapter.format(Stream, Style);
     Stream.indent(Right);
   }
 };
 
-template <typename T> class RepeatAdapter : public AdapterBase<T> {
+template <typename T> class RepeatAdapter final : public FormatAdapter<T> {
   size_t Count;
 
 public:
   RepeatAdapter(T &&Item, size_t Count)
-      : AdapterBase<T>(std::forward<T>(Item)), Count(Count) {}
+      : FormatAdapter<T>(std::forward<T>(Item)), Count(Count) {}
 
   void format(llvm::raw_ostream &Stream, StringRef Style) {
-    auto Wrapper = detail::build_format_wrapper(std::forward<T>(this->Item));
+    auto Adapter = detail::build_format_adapter(std::forward<T>(this->Item));
     for (size_t I = 0; I < Count; ++I) {
-      Wrapper.format(Stream, Style);
+      Adapter.format(Stream, Style);
     }
   }
 };
@@ -89,4 +90,4 @@
 }
 }
 
-#endif
\ No newline at end of file
+#endif
Index: include/llvm/Support/FormatCommon.h
===================================================================
--- include/llvm/Support/FormatCommon.h
+++ include/llvm/Support/FormatCommon.h
@@ -18,12 +18,12 @@
 enum class AlignStyle { Left, Center, Right };
 
 struct FmtAlign {
-  detail::format_wrapper &Wrapper;
+  detail::format_adapter &Adapter;
   AlignStyle Where;
   size_t Amount;
 
-  FmtAlign(detail::format_wrapper &Wrapper, AlignStyle Where, size_t Amount)
-      : Wrapper(Wrapper), Where(Where), Amount(Amount) {}
+  FmtAlign(detail::format_adapter &Adapter, AlignStyle Where, size_t Amount)
+      : Adapter(Adapter), Where(Where), Amount(Amount) {}
 
   void format(raw_ostream &S, StringRef Options) {
     // If we don't need to align, we can format straight into the underlying
@@ -32,13 +32,13 @@
     // TODO: Make the format method return the number of bytes written, that
     // way we can also skip the intermediate stream for left-aligned output.
     if (Amount == 0) {
-      Wrapper.format(S, Options);
+      Adapter.format(S, Options);
       return;
     }
     SmallString<64> Item;
     raw_svector_ostream Stream(Item);
 
-    Wrapper.format(Stream, Options);
+    Adapter.format(Stream, Options);
     if (Amount <= Item.size()) {
       S << Item;
       return;
@@ -66,4 +66,4 @@
 };
 }
 
-#endif
\ No newline at end of file
+#endif
Index: include/llvm/Support/FormatProviders.h
===================================================================
--- include/llvm/Support/FormatProviders.h
+++ include/llvm/Support/FormatProviders.h
@@ -394,16 +394,16 @@
     auto Begin = V.begin();
     auto End = V.end();
     if (Begin != End) {
-      auto Wrapper =
-          detail::build_format_wrapper(std::forward<reference>(*Begin));
-      Wrapper.format(Stream, ArgStyle);
+      auto Adapter =
+          detail::build_format_adapter(std::forward<reference>(*Begin));
+      Adapter.format(Stream, ArgStyle);
       ++Begin;
     }
     while (Begin != End) {
       Stream << Sep;
-      auto Wrapper =
-          detail::build_format_wrapper(std::forward<reference>(*Begin));
-      Wrapper.format(Stream, ArgStyle);
+      auto Adapter =
+          detail::build_format_adapter(std::forward<reference>(*Begin));
+      Adapter.format(Stream, ArgStyle);
       ++Begin;
     }
   }
Index: include/llvm/Support/FormatVariadic.h
===================================================================
--- include/llvm/Support/FormatVariadic.h
+++ include/llvm/Support/FormatVariadic.h
@@ -71,15 +71,15 @@
   // parameters in a template class that derives from a non-template superclass.
   // Essentially, we are converting a std::tuple<Derived<Ts...>> to a
   // std::vector<Base*>.
-  struct create_wrappers {
+  struct create_adapters {
     template <typename... Ts>
-    std::vector<detail::format_wrapper *> operator()(Ts &... Items) {
-      return std::vector<detail::format_wrapper *>{&Items...};
+    std::vector<detail::format_adapter *> operator()(Ts &... Items) {
+      return std::vector<detail::format_adapter *>{&Items...};
     }
   };
 
   StringRef Fmt;
-  std::vector<detail::format_wrapper *> Wrappers;
+  std::vector<detail::format_adapter *> Adapters;
   std::vector<ReplacementItem> Replacements;
 
   static bool consumeFieldLayout(StringRef &Spec, AlignStyle &Where,
@@ -91,7 +91,7 @@
 public:
   formatv_object_base(StringRef Fmt, std::size_t ParamCount)
       : Fmt(Fmt), Replacements(parseFormatString(Fmt)) {
-    Wrappers.reserve(ParamCount);
+    Adapters.reserve(ParamCount);
   }
 
   void format(raw_ostream &S) const {
@@ -102,12 +102,12 @@
         S << R.Spec;
         continue;
       }
-      if (R.Index >= Wrappers.size()) {
+      if (R.Index >= Adapters.size()) {
         S << R.Spec;
         continue;
       }
 
-      auto W = Wrappers[R.Index];
+      auto W = Adapters[R.Index];
 
       FmtAlign Align(*W, R.Where, R.Align);
       Align.format(S, R.Options);
@@ -138,7 +138,7 @@
 };
 
 template <typename Tuple> class formatv_object : public formatv_object_base {
-  // Storage for the parameter wrappers.  Since the base class erases the type
+  // Storage for the parameter adapters.  Since the base class erases the type
   // of the parameters, we have to own the storage for the parameters here, and
   // have the base class store type-erased pointers into this tuple.
   Tuple Parameters;
@@ -147,7 +147,7 @@
   formatv_object(StringRef Fmt, Tuple &&Params)
       : formatv_object_base(Fmt, std::tuple_size<Tuple>::value),
         Parameters(std::move(Params)) {
-    Wrappers = apply_tuple(create_wrappers(), Parameters);
+    Adapters = apply_tuple(create_adapters(), Parameters);
   }
 };
 
@@ -234,12 +234,12 @@
 //
 template <typename... Ts>
 inline auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object<decltype(
-    std::make_tuple(detail::build_format_wrapper(std::forward<Ts>(Vals))...))> {
+    std::make_tuple(detail::build_format_adapter(std::forward<Ts>(Vals))...))> {
   using ParamTuple = decltype(
-      std::make_tuple(detail::build_format_wrapper(std::forward<Ts>(Vals))...));
+      std::make_tuple(detail::build_format_adapter(std::forward<Ts>(Vals))...));
   return formatv_object<ParamTuple>(
       Fmt,
-      std::make_tuple(detail::build_format_wrapper(std::forward<Ts>(Vals))...));
+      std::make_tuple(detail::build_format_adapter(std::forward<Ts>(Vals))...));
 }
 
 } // end namespace llvm
Index: include/llvm/Support/FormatVariadicDetails.h
===================================================================
--- include/llvm/Support/FormatVariadicDetails.h
+++ include/llvm/Support/FormatVariadicDetails.h
@@ -19,83 +19,26 @@
 template <typename T, typename Enable = void> struct format_provider {};
 
 namespace detail {
-
-class format_wrapper {
+class format_adapter {
 protected:
-  virtual ~format_wrapper() {}
+  virtual ~format_adapter() {}
 
 public:
-  virtual void format(llvm::raw_ostream &S, StringRef Options) = 0;
+  virtual void format(raw_ostream &S, StringRef Options) = 0;
 };
 
-template <typename T> class member_format_wrapper : public format_wrapper {
+template <typename T> class provider_format_adapter : public format_adapter {
   T Item;
 
 public:
-  explicit member_format_wrapper(T &&Item) : Item(Item) {}
-
-  void format(llvm::raw_ostream &S, StringRef Options) override {
-    Item.format(S, Options);
-  }
-};
-
-template <typename T> class provider_format_wrapper : public format_wrapper {
-  T Item;
-
-public:
-  explicit provider_format_wrapper(T &&Item) : Item(Item) {}
+  explicit provider_format_adapter(T &&Item) : Item(Item) {}
 
   void format(llvm::raw_ostream &S, StringRef Options) override {
     format_provider<typename std::decay<T>::type>::format(Item, S, Options);
   }
 };
 
-template <typename T> class missing_format_wrapper;
-
-// Test if T is a class that contains a member function with the signature:
-//
-// void format(raw_ostream &, StringRef);
-//
-// It is assumed T is a non-reference type.
-template <class T, class Enable = void> class has_FormatMember {
-public:
-  static bool const value = false;
-};
-
-template <class T>
-class has_FormatMember<T,
-                       typename std::enable_if<std::is_class<T>::value &&
-                                               std::is_const<T>::value>::type> {
-  using CleanT = typename std::remove_volatile<T>::type;
-  using Signature_format = void (CleanT::*)(llvm::raw_ostream &S,
-                                            StringRef Options) const;
-
-  template <typename U>
-  static char test2(SameType<Signature_format, &U::format> *);
-
-  template <typename U> static double test2(...);
-
-public:
-  static bool const value = (sizeof(test2<CleanT>(nullptr)) == 1);
-};
-
-template <class T>
-class has_FormatMember<
-    T, typename std::enable_if<std::is_class<T>::value &&
-                               !std::is_const<T>::value>::type> {
-  using CleanT = typename std::remove_cv<T>::type;
-  using Signature_format = void (CleanT::*)(llvm::raw_ostream &S,
-                                            StringRef Options);
-
-  template <typename U>
-  static char test2(SameType<Signature_format, &U::format> *);
-
-  template <typename U> static double test2(...);
-
-public:
-  static bool const value =
-      (sizeof(test2<CleanT>(nullptr)) == 1) || has_FormatMember<const T>::value;
-};
+template <typename T> class missing_format_adapter;
 
 // Test if format_provider<T> is defined on T and contains a member function
 // with the signature:
@@ -122,7 +65,8 @@
 struct uses_format_member
     : public std::integral_constant<
           bool,
-          has_FormatMember<typename std::remove_reference<T>::type>::value> {};
+          std::is_base_of<format_adapter,
+                          typename std::remove_reference<T>::type>::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
@@ -144,24 +88,23 @@
                                         !uses_format_provider<T>::value> {};
 
 template <typename T>
-typename std::enable_if<uses_format_member<T>::value,
-                        member_format_wrapper<T>>::type
-build_format_wrapper(T &&Item) {
-  return member_format_wrapper<T>(std::forward<T>(Item));
+typename std::enable_if<uses_format_member<T>::value, T>::type
+build_format_adapter(T &&Item) {
+  return std::forward<T>(Item);
 }
 
 template <typename T>
 typename std::enable_if<uses_format_provider<T>::value,
-                        provider_format_wrapper<T>>::type
-build_format_wrapper(T &&Item) {
-  return provider_format_wrapper<T>(std::forward<T>(Item));
+                        provider_format_adapter<T>>::type
+build_format_adapter(T &&Item) {
+  return provider_format_adapter<T>(std::forward<T>(Item));
 }
 
 template <typename T>
 typename std::enable_if<uses_missing_provider<T>::value,
-                        missing_format_wrapper<T>>::type
-build_format_wrapper(T &&Item) {
-  return missing_format_wrapper<T>();
+                        missing_format_adapter<T>>::type
+build_format_adapter(T &&Item) {
+  return missing_format_adapter<T>();
 }
 }
 }
Index: unittests/Support/FormatVariadicTest.cpp
===================================================================
--- unittests/Support/FormatVariadicTest.cpp
+++ unittests/Support/FormatVariadicTest.cpp
@@ -15,12 +15,9 @@
 
 // Compile-time tests for the uses_format_member template
 namespace {
-struct ConstFormat {
-  void format(raw_ostream &OS, StringRef Opt) const { OS << "ConstFormat"; }
-};
-
-struct Format {
-  void format(raw_ostream &OS, StringRef Opt) { OS << "Format"; }
+struct Format : public FormatAdapter<int> {
+  Format(int N) : FormatAdapter<int>(N) {}
+  void format(raw_ostream &OS, StringRef Opt) override { OS << "Format"; }
 };
 
 using detail::uses_format_member;
@@ -28,18 +25,10 @@
 static_assert(uses_format_member<Format>::value, "");
 static_assert(uses_format_member<Format &>::value, "");
 static_assert(uses_format_member<Format &&>::value, "");
-static_assert(!uses_format_member<const Format>::value, "");
-static_assert(!uses_format_member<const Format &>::value, "");
-static_assert(!uses_format_member<const volatile Format>::value, "");
-static_assert(!uses_format_member<const volatile Format &>::value, "");
-
-static_assert(uses_format_member<ConstFormat>::value, "");
-static_assert(uses_format_member<ConstFormat &>::value, "");
-static_assert(uses_format_member<ConstFormat &&>::value, "");
-static_assert(uses_format_member<const ConstFormat>::value, "");
-static_assert(uses_format_member<const ConstFormat &>::value, "");
-static_assert(uses_format_member<const volatile ConstFormat>::value, "");
-static_assert(uses_format_member<const volatile ConstFormat &>::value, "");
+static_assert(uses_format_member<const Format>::value, "");
+static_assert(uses_format_member<const Format &>::value, "");
+static_assert(uses_format_member<const volatile Format>::value, "");
+static_assert(uses_format_member<const volatile Format &>::value, "");
 }
 
 TEST(FormatVariadicTest, EmptyFormatString) {
@@ -535,12 +524,10 @@
 }
 
 TEST(FormatVariadicTest, Adapter) {
-  class Negative {
-    int N;
-
+  class Negative: public FormatAdapter<int> {
   public:
-    explicit Negative(int N) : N(N) {}
-    void format(raw_ostream &S, StringRef Options) const { S << -N; }
+    explicit Negative(int N) : FormatAdapter<int>(N) {}
+    void format(raw_ostream &S, StringRef Options) override { S << -Item; }
   };
 
   EXPECT_EQ("-7", formatv("{0}", Negative(7)).str());
@@ -567,24 +554,13 @@
 }
 
 TEST(FormatVariadicTest, FormatMember) {
-  EXPECT_EQ("Format", formatv("{0}", Format()).str());
+  EXPECT_EQ("Format", formatv("{0}", Format(1)).str());
 
-  Format var;
+  Format var(1);
   EXPECT_EQ("Format", formatv("{0}", var).str());
   EXPECT_EQ("Format", formatv("{0}", std::move(var)).str());
 
   // Not supposed to compile
-  // const Format cvar{};
+  // const Format cvar(1);
   // EXPECT_EQ("Format", formatv("{0}", cvar).str());
 }
-
-TEST(FormatVariadicTest, FormatMemberConst) {
-  EXPECT_EQ("ConstFormat", formatv("{0}", ConstFormat()).str());
-
-  ConstFormat var;
-  EXPECT_EQ("ConstFormat", formatv("{0}", var).str());
-  EXPECT_EQ("ConstFormat", formatv("{0}", std::move(var)).str());
-
-  const ConstFormat cvar{};
-  EXPECT_EQ("ConstFormat", formatv("{0}", cvar).str());
-}