From c929684e336ca7657a1dd787efaa1bea12c3286f Mon Sep 17 00:00:00 2001
From: Christopher Di Bella <cjdb.ns@gmail.com>
Date: Sat, 1 Jun 2019 14:57:06 +0100
Subject: [PATCH 01/16] inlines count_code_points(basic_string_view<char8_t)

count_code_points(basic_string_view<char8_t>) was defined in
fmt/format-inl.h, and only declared in fmt/format.h, but not defined
in src/format.cc. This commit moves the overload to fmt/format.h and
inlines it.
---
 include/fmt/format-inl.h | 9 ---------
 include/fmt/format.h     | 9 ++++++++-
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/include/fmt/format-inl.h b/include/fmt/format-inl.h
index 8f9d58f7b40e..24c6c77bcdcd 100644
--- a/include/fmt/format-inl.h
+++ b/include/fmt/format-inl.h
@@ -200,15 +200,6 @@ void report_error(FormatFunc func, int error_code,
 }
 }  // namespace
 
-FMT_FUNC size_t internal::count_code_points(basic_string_view<char8_t> s) {
-  const char8_t* data = s.data();
-  size_t num_code_points = 0;
-  for (size_t i = 0, size = s.size(); i != size; ++i) {
-    if ((data[i] & 0xc0) != 0x80) ++num_code_points;
-  }
-  return num_code_points;
-}
-
 #if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
 namespace internal {
 
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 72be49bc2072..7e4cf3be9044 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -766,7 +766,14 @@ inline size_t count_code_points(basic_string_view<Char> s) {
 }
 
 // Counts the number of code points in a UTF-8 string.
-FMT_API size_t count_code_points(basic_string_view<char8_t> s);
+inline size_t count_code_points(basic_string_view<char8_t> s) {
+  const char8_t* data = s.data();
+  size_t num_code_points = 0;
+  for (size_t i = 0, size = s.size(); i != size; ++i) {
+    if ((data[i] & 0xc0) != 0x80) ++num_code_points;
+  }
+  return num_code_points;
+}
 
 inline char8_t to_char8_t(char c) { return static_cast<char8_t>(c); }
 

From c56b17029afb2c1f163f295f3333f9a07bb3dbe6 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 1 Jun 2019 06:47:48 -0700
Subject: [PATCH 02/16] Add msvc2019 to CI

---
 support/appveyor-build.py | 19 +++++++++++--------
 support/appveyor.yml      | 16 ++++++++++++----
 2 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/support/appveyor-build.py b/support/appveyor-build.py
index 2cfcb03a414b..654461032673 100644
--- a/support/appveyor-build.py
+++ b/support/appveyor-build.py
@@ -23,14 +23,17 @@
     # Add MSBuild 14.0 to PATH as described in
     # http://help.appveyor.com/discussions/problems/2229-v140-not-found-on-vs2105rc.
     os.environ['PATH'] = r'C:\Program Files (x86)\MSBuild\15.0\Bin;' + path
-    if image == 'Visual Studio 2013':
-        generator = 'Visual Studio 12 2013'
-    elif image == 'Visual Studio 2015':
-        generator = 'Visual Studio 14 2015'
-    elif image == 'Visual Studio 2017':
-        generator = 'Visual Studio 15 2017'
-    if platform == 'x64':
-        generator += ' Win64'
+    if image == 'Visual Studio 2019':
+        generator = 'Visual Studio 16 2019'
+        if platform == 'x64':
+            cmake_command.extend(['-A', 'x64'])
+    else:
+        if image == 'Visual Studio 2015':
+            generator = 'Visual Studio 14 2015'
+        elif image == 'Visual Studio 2017':
+            generator = 'Visual Studio 15 2017'
+        if platform == 'x64':
+            generator += ' Win64'
     cmake_command.append('-G' + generator)
     build_command = ['cmake', '--build', '.', '--config', config, '--', '/m:4']
     test_command = ['ctest', '-C', config]
diff --git a/support/appveyor.yml b/support/appveyor.yml
index 525cbe0e2a64..f53e4383998b 100644
--- a/support/appveyor.yml
+++ b/support/appveyor.yml
@@ -4,19 +4,27 @@ configuration:
 
 clone_depth: 1
 
-platform:
-  - Win32
-  - x64
-
 image:
   - Visual Studio 2015
+  - Visual Studio 2019
   - Visual Studio 2017
 
+platform:
+  - Win32
+  - x64
+
 environment:
   CTEST_OUTPUT_ON_FAILURE: 1
   MSVC_DEFAULT_OPTIONS: ON
   BUILD: msvc
 
+matrix:
+  exclude:
+    - image: Visual Studio 2015
+      platform: Win32
+    - image: Visual Studio 2019
+      platform: Win32
+
 before_build:
  - mkdir build
  - cd build

From 87e4ea2906d1134346de8d88c9e88e9c8cee0742 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 1 Jun 2019 08:24:36 -0700
Subject: [PATCH 03/16] Fix a warning

---
 test/CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 02d6a8588f97..ace5ed67a3c9 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -26,7 +26,7 @@ if (MSVC)
   target_compile_definitions(gmock PUBLIC _VARIADIC_MAX=10)
   
   # Disable MSVC warnings of _CRT_INSECURE_DEPRECATE functions.
-  target_compile_definitions(gmock PUBLIC _CRT_SECURE_NO_WARNINGS)
+  target_compile_definitions(gmock PRIVATE _CRT_SECURE_NO_WARNINGS)
   if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     # Disable MSVC warnings of POSIX functions.
     target_compile_options(gmock PUBLIC -Wno-deprecated-declarations)

From 78daa50ffc5caf7aedd51d1b2d491e48568bf5ac Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 1 Jun 2019 09:07:49 -0700
Subject: [PATCH 04/16] Fix handling of chrono durations with minimal signed
 rep

---
 include/fmt/chrono.h | 33 +++++++++++++++++++++++++--------
 test/chrono-test.cc  |  5 ++++-
 2 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/include/fmt/chrono.h b/include/fmt/chrono.h
index f57aef387c3f..738f1beadd59 100644
--- a/include/fmt/chrono.h
+++ b/include/fmt/chrono.h
@@ -401,6 +401,17 @@ inline T mod(T x, int y) {
   return std::fmod(x, y);
 }
 
+// If T is an integral type, maps T to its unsigned counterpart, otherwise
+// leaves it unchanged (unlike std::make_unsigned).
+template <typename T, bool INTEGRAL = std::is_integral<T>::value>
+struct make_unsigned_or_unchanged {
+  using type = T;
+};
+
+template <typename T> struct make_unsigned_or_unchanged<T, true> {
+  using type = typename std::make_unsigned<T>::type;
+};
+
 template <typename Rep, typename Period,
           typename std::enable_if<std::is_integral<Rep>::value, int>::type = 0>
 inline std::chrono::duration<Rep, std::milli> get_milliseconds(
@@ -438,21 +449,27 @@ struct chrono_formatter {
   FormatContext& context;
   OutputIt out;
   int precision;
-  typedef typename std::conditional<std::is_integral<Rep>::value &&
-                                        sizeof(Rep) < sizeof(int),
-                                    int, Rep>::type rep;
+  // rep is unsigned to avoid overflow.
+  using rep = typename std::conditional<
+      std::is_integral<Rep>::value && sizeof(Rep) < sizeof(int), unsigned,
+      typename make_unsigned_or_unchanged<Rep>::type>::type;
   rep val;
   typedef std::chrono::duration<rep> seconds;
   seconds s;
   typedef std::chrono::duration<rep, std::milli> milliseconds;
+  bool negative;
 
   typedef typename FormatContext::char_type char_type;
 
   explicit chrono_formatter(FormatContext& ctx, OutputIt o,
                             std::chrono::duration<Rep, Period> d)
-      : context(ctx), out(o), val(d.count()) {
-    if (d.count() < 0) d = -d;
-    s = std::chrono::duration_cast<seconds>(d);
+      : context(ctx), out(o), val(d.count()), negative(false) {
+    if (d.count() < 0) {
+      val = -val;
+      negative = true;
+    }
+    s = std::chrono::duration_cast<seconds>(
+        std::chrono::duration<rep, Period>(val));
   }
 
   Rep hour() const { return mod((s.count() / 3600), 24); }
@@ -474,9 +491,9 @@ struct chrono_formatter {
   }
 
   void write_sign() {
-    if (val < 0) {
+    if (negative) {
       *out++ = '-';
-      val = -val;
+      negative = false;
     }
   }
 
diff --git a/test/chrono-test.cc b/test/chrono-test.cc
index abb8cb8bbe1f..a9412c90e248 100644
--- a/test/chrono-test.cc
+++ b/test/chrono-test.cc
@@ -306,7 +306,7 @@ TEST(ChronoTest, InvalidColons) {
                fmt::format_error);
 }
 
-TEST(ChronoTest, NegativeDuration) {
+TEST(ChronoTest, NegativeDurations) {
   EXPECT_EQ("-12345", fmt::format("{:%Q}", std::chrono::seconds(-12345)));
   EXPECT_EQ("-03:25:45",
             fmt::format("{:%H:%M:%S}", std::chrono::seconds(-12345)));
@@ -316,6 +316,9 @@ TEST(ChronoTest, NegativeDuration) {
   EXPECT_EQ("-00.127",
             fmt::format("{:%S}",
                         std::chrono::duration<signed char, std::milli>{-127}));
+  auto min = std::numeric_limits<int>::min();
+  EXPECT_EQ(fmt::format("{}", min),
+            fmt::format("{:%Q}", std::chrono::duration<int>(min)));
 }
 
 TEST(ChronoTest, SpecialDurations) {

From 67feef558969b9819987c6e55751075b8279c347 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 1 Jun 2019 09:35:02 -0700
Subject: [PATCH 05/16] Make enable_if_t more std-like and move to fmt
 namespace

---
 include/fmt/core.h       | 12 ++++++++----
 include/fmt/format-inl.h |  2 +-
 include/fmt/format.h     |  2 +-
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index a733e4ef01ab..6e73481f8e62 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -199,6 +199,11 @@
 #endif
 
 FMT_BEGIN_NAMESPACE
+
+// An implementation of enable_if_t for pre-C++14 systems.
+template <bool B, class T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
 namespace internal {
 
 #if defined(FMT_USE_STRING_VIEW)
@@ -210,10 +215,9 @@ using std_string_view = std::experimental::basic_string_view<Char>;
 template <typename T> struct std_string_view {};
 #endif
 
-// An enable_if helper to be used in template parameters. enable_if in template
-// parameters results in much shorter symbols: https://godbolt.org/z/sWw4vP.
-template <bool B> using enable_if_t = typename std::enable_if<B, int>::type;
-#define FMT_ENABLE_IF(...) internal::enable_if_t<__VA_ARGS__> = 0
+// An enable_if helper to be used in template parameters which results in much
+// shorter symbols: https://godbolt.org/z/sWw4vP.
+#define FMT_ENABLE_IF(...) enable_if_t<__VA_ARGS__, int> = 0
 
 #if (__cplusplus >= 201703L ||                          \
      (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)) && \
diff --git a/include/fmt/format-inl.h b/include/fmt/format-inl.h
index 24c6c77bcdcd..28027a592091 100644
--- a/include/fmt/format-inl.h
+++ b/include/fmt/format-inl.h
@@ -674,7 +674,7 @@ template <int GRISU_VERSION> struct grisu_shortest_handler {
   }
 };
 
-template <typename Double, enable_if_t<sizeof(Double) == sizeof(uint64_t)>>
+template <typename Double, enable_if_t<sizeof(Double) == sizeof(uint64_t), int>>
 FMT_API bool grisu_format(Double value, buffer<char>& buf, int precision,
                           unsigned options, int& exp) {
   FMT_ASSERT(value >= 0, "value is negative");
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 7e4cf3be9044..42846f902cd6 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -2245,7 +2245,7 @@ FMT_CONSTEXPR bool do_check_format_string(basic_string_view<Char> s,
 }
 
 template <typename... Args, typename S,
-          internal::enable_if_t<is_compile_string<S>::value>>
+          enable_if_t<is_compile_string<S>::value, int>>
 void check_format_string(S format_str) {
   typedef typename S::char_type char_t;
   FMT_CONSTEXPR_DECL bool invalid_format =

From 2833c76f223289a9de47c64d0c29a21a9d81ba7e Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 1 Jun 2019 12:14:27 -0700
Subject: [PATCH 06/16] Move char_t to template param to reduce symbol size

---
 include/fmt/core.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 6e73481f8e62..e9cea5701434 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -1443,11 +1443,11 @@ inline std::basic_string<Char> vformat(
     std::string message = fmt::format("The answer is {}", 42);
   \endrst
 */
-// Use SFINAE instead of static_assert because of color overload of fmt::format.
+// Pass fmt::char_t as a default template parameter instead of using
+// std::basic_string<fmt::char_t<S>> to reduce the symbol size.
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline std::basic_string<FMT_CHAR(S)> format(const S& format_str,
-                                             const Args&... args) {
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+inline std::basic_string<Char> format(const S& format_str, const Args&... args) {
   return internal::vformat(to_string_view(format_str),
                            {internal::make_args_checked(format_str, args...)});
 }

From 4c650057a06bf9565014269bd74a1635fdd57226 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 1 Jun 2019 12:32:24 -0700
Subject: [PATCH 07/16] FMT_CHAR -> char_t

---
 include/fmt/core.h | 29 ++++++++++++++++-------------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index e9cea5701434..7bc20af0fa06 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -1352,9 +1352,10 @@ template <typename... Args, typename S,
           FMT_ENABLE_IF(is_compile_string<S>::value)>
 void check_format_string(S);
 
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline format_arg_store<typename buffer_context<FMT_CHAR(S)>::type, Args...>
+template <
+    typename S, typename... Args,
+    typename Char = enable_if_t<internal::is_string<S>::value, fmt::char_t<S>>>
+inline format_arg_store<typename buffer_context<Char>::type, Args...>
 make_args_checked(const S& format_str, const Args&... args) {
   internal::check_format_string<Args...>(format_str);
   return {args...};
@@ -1386,8 +1387,8 @@ typename buffer_context<Char>::type::iterator vformat_to(
     fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
   \endrst
  */
-template <typename S, typename T>
-inline internal::named_arg<T, FMT_CHAR(S)> arg(const S& name, const T& arg) {
+template <typename S, typename T, typename Char = char_t<S>>
+inline internal::named_arg<T, Char> arg(const S& name, const T& arg) {
   static_assert(internal::is_string<S>::value, "");
   return {name, arg};
 }
@@ -1405,11 +1406,12 @@ template <typename Char>
 struct is_contiguous<internal::buffer<Char>> : std::true_type {};
 
 /** Formats a string and writes the output to ``out``. */
-template <typename Container, typename S>
-typename std::enable_if<is_contiguous<Container>::value,
-                        std::back_insert_iterator<Container>>::type
-vformat_to(std::back_insert_iterator<Container> out, const S& format_str,
-           basic_format_args<typename buffer_context<FMT_CHAR(S)>::type> args) {
+template <
+    typename Container, typename S,
+    typename Char = enable_if_t<is_contiguous<Container>::value, char_t<S>>>
+std::back_insert_iterator<Container> vformat_to(
+    std::back_insert_iterator<Container> out, const S& format_str,
+    basic_format_args<typename buffer_context<Char>::type> args) {
   internal::container_buffer<Container> buf(internal::get_container(out));
   internal::vformat_to(buf, to_string_view(format_str), args);
   return out;
@@ -1425,8 +1427,8 @@ inline std::back_insert_iterator<Container> format_to(
                     {internal::make_args_checked(format_str, args...)});
 }
 
-template <typename S, typename Char = FMT_CHAR(S),
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
+template <typename S,
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
 inline std::basic_string<Char> vformat(
     const S& format_str,
     basic_format_args<typename buffer_context<Char>::type> args) {
@@ -1447,7 +1449,8 @@ inline std::basic_string<Char> vformat(
 // std::basic_string<fmt::char_t<S>> to reduce the symbol size.
 template <typename S, typename... Args,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline std::basic_string<Char> format(const S& format_str, const Args&... args) {
+inline std::basic_string<Char> format(const S& format_str,
+                                      const Args&... args) {
   return internal::vformat(to_string_view(format_str),
                            {internal::make_args_checked(format_str, args...)});
 }

From 5b7bbf88537f704005e3e71d9d4fda57e880e416 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 1 Jun 2019 15:01:04 -0700
Subject: [PATCH 08/16] Revert "FMT_CHAR -> char_t"

This reverts commit 4c650057a06bf9565014269bd74a1635fdd57226.
---
 include/fmt/core.h | 29 +++++++++++++----------------
 1 file changed, 13 insertions(+), 16 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 7bc20af0fa06..e9cea5701434 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -1352,10 +1352,9 @@ template <typename... Args, typename S,
           FMT_ENABLE_IF(is_compile_string<S>::value)>
 void check_format_string(S);
 
-template <
-    typename S, typename... Args,
-    typename Char = enable_if_t<internal::is_string<S>::value, fmt::char_t<S>>>
-inline format_arg_store<typename buffer_context<Char>::type, Args...>
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(internal::is_string<S>::value)>
+inline format_arg_store<typename buffer_context<FMT_CHAR(S)>::type, Args...>
 make_args_checked(const S& format_str, const Args&... args) {
   internal::check_format_string<Args...>(format_str);
   return {args...};
@@ -1387,8 +1386,8 @@ typename buffer_context<Char>::type::iterator vformat_to(
     fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
   \endrst
  */
-template <typename S, typename T, typename Char = char_t<S>>
-inline internal::named_arg<T, Char> arg(const S& name, const T& arg) {
+template <typename S, typename T>
+inline internal::named_arg<T, FMT_CHAR(S)> arg(const S& name, const T& arg) {
   static_assert(internal::is_string<S>::value, "");
   return {name, arg};
 }
@@ -1406,12 +1405,11 @@ template <typename Char>
 struct is_contiguous<internal::buffer<Char>> : std::true_type {};
 
 /** Formats a string and writes the output to ``out``. */
-template <
-    typename Container, typename S,
-    typename Char = enable_if_t<is_contiguous<Container>::value, char_t<S>>>
-std::back_insert_iterator<Container> vformat_to(
-    std::back_insert_iterator<Container> out, const S& format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
+template <typename Container, typename S>
+typename std::enable_if<is_contiguous<Container>::value,
+                        std::back_insert_iterator<Container>>::type
+vformat_to(std::back_insert_iterator<Container> out, const S& format_str,
+           basic_format_args<typename buffer_context<FMT_CHAR(S)>::type> args) {
   internal::container_buffer<Container> buf(internal::get_container(out));
   internal::vformat_to(buf, to_string_view(format_str), args);
   return out;
@@ -1427,8 +1425,8 @@ inline std::back_insert_iterator<Container> format_to(
                     {internal::make_args_checked(format_str, args...)});
 }
 
-template <typename S,
-          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+template <typename S, typename Char = FMT_CHAR(S),
+          FMT_ENABLE_IF(internal::is_string<S>::value)>
 inline std::basic_string<Char> vformat(
     const S& format_str,
     basic_format_args<typename buffer_context<Char>::type> args) {
@@ -1449,8 +1447,7 @@ inline std::basic_string<Char> vformat(
 // std::basic_string<fmt::char_t<S>> to reduce the symbol size.
 template <typename S, typename... Args,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline std::basic_string<Char> format(const S& format_str,
-                                      const Args&... args) {
+inline std::basic_string<Char> format(const S& format_str, const Args&... args) {
   return internal::vformat(to_string_view(format_str),
                            {internal::make_args_checked(format_str, args...)});
 }

From 9df0e2d1f160980d2ae86ccd95f167e8dcb2ff43 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 2 Jun 2019 07:30:26 -0700
Subject: [PATCH 09/16] Implement string parsing

---
 test/scan-test.cc | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/test/scan-test.cc b/test/scan-test.cc
index 42417748211e..f9edcecfcfc3 100644
--- a/test/scan-test.cc
+++ b/test/scan-test.cc
@@ -21,6 +21,7 @@ struct scan_arg {
     unsigned* uint_value;
     long long* long_long_value;
     unsigned long long* ulong_long_value;
+    std::string* string;
     // TODO: more types
   };
 
@@ -31,6 +32,7 @@ struct scan_arg {
       : arg_type(long_long_type), long_long_value(&value) {}
   scan_arg(unsigned long long& value)
       : arg_type(ulong_long_type), ulong_long_value(&value) {}
+  scan_arg(std::string& value) : arg_type(string_type), string(&value) {}
 };
 }  // namespace internal
 
@@ -112,6 +114,11 @@ struct scan_handler : error_handler {
     case ulong_long_type:
       *arg_.ulong_long_value = read_uint<unsigned long long>();
       break;
+    case string_type: {
+      while (begin_ != end_ && *begin_ != ' ')
+        arg_.string->push_back(*begin_++);
+      break;
+    }
     default:
       assert(false);
     }
@@ -178,6 +185,11 @@ TEST(ScanTest, ReadULongLong) {
   EXPECT_THROW_MSG(fmt::scan("-42", "{}", n), fmt::format_error,
                    "invalid input");
 }
+TEST(ScanTest, ReadString) {
+  std::string s;
+  fmt::scan("foo", "{}", s);
+  EXPECT_EQ(s, "foo");
+}
 
 TEST(ScanTest, InvalidFormat) {
   EXPECT_THROW_MSG(fmt::scan("", "{}"), fmt::format_error,
@@ -185,3 +197,11 @@ TEST(ScanTest, InvalidFormat) {
   EXPECT_THROW_MSG(fmt::scan("", "{"), fmt::format_error,
                    "invalid format string");
 }
+
+TEST(ScanTest, Example) {
+  std::string key;
+  int value;
+  fmt::scan("answer = 42", "{} = {}", key, value);
+  EXPECT_EQ(key, "answer");
+  EXPECT_EQ(value, 42);
+}

From af2c73772ce8e06b266650849b4232c25d1fe63f Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 2 Jun 2019 11:11:28 -0700
Subject: [PATCH 10/16] Implement parsing of string_views

---
 test/scan-test.cc | 52 ++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 40 insertions(+), 12 deletions(-)

diff --git a/test/scan-test.cc b/test/scan-test.cc
index f9edcecfcfc3..82e83249a2d4 100644
--- a/test/scan-test.cc
+++ b/test/scan-test.cc
@@ -14,25 +14,40 @@
 
 FMT_BEGIN_NAMESPACE
 namespace internal {
+enum class scan_type {
+  none_type,
+  int_type,
+  uint_type,
+  long_long_type,
+  ulong_long_type,
+  string_type,
+  string_view_type
+};
+
 struct scan_arg {
-  type arg_type;
+  scan_type arg_type;
   union {
     int* int_value;
     unsigned* uint_value;
     long long* long_long_value;
     unsigned long long* ulong_long_value;
     std::string* string;
+    fmt::string_view* string_view;
     // TODO: more types
   };
 
-  scan_arg() : arg_type(none_type) {}
-  scan_arg(int& value) : arg_type(int_type), int_value(&value) {}
-  scan_arg(unsigned& value) : arg_type(uint_type), uint_value(&value) {}
+  scan_arg() : arg_type(scan_type::none_type) {}
+  scan_arg(int& value) : arg_type(scan_type::int_type), int_value(&value) {}
+  scan_arg(unsigned& value)
+      : arg_type(scan_type::uint_type), uint_value(&value) {}
   scan_arg(long long& value)
-      : arg_type(long_long_type), long_long_value(&value) {}
+      : arg_type(scan_type::long_long_type), long_long_value(&value) {}
   scan_arg(unsigned long long& value)
-      : arg_type(ulong_long_type), ulong_long_value(&value) {}
-  scan_arg(std::string& value) : arg_type(string_type), string(&value) {}
+      : arg_type(scan_type::ulong_long_type), ulong_long_value(&value) {}
+  scan_arg(std::string& value)
+      : arg_type(scan_type::string_type), string(&value) {}
+  scan_arg(fmt::string_view& value)
+      : arg_type(scan_type::string_view_type), string_view(&value) {}
 };
 }  // namespace internal
 
@@ -102,22 +117,28 @@ struct scan_handler : error_handler {
 
   void on_replacement_field(const char*) {
     switch (arg_.arg_type) {
-    case int_type:
+    case scan_type::int_type:
       *arg_.int_value = read_int();
       break;
-    case uint_type:
+    case scan_type::uint_type:
       *arg_.uint_value = read_uint();
       break;
-    case long_long_type:
+    case scan_type::long_long_type:
       *arg_.long_long_value = read_int<long long>();
       break;
-    case ulong_long_type:
+    case scan_type::ulong_long_type:
       *arg_.ulong_long_value = read_uint<unsigned long long>();
       break;
-    case string_type: {
+    case scan_type::string_type:
       while (begin_ != end_ && *begin_ != ' ')
         arg_.string->push_back(*begin_++);
       break;
+    case scan_type::string_view_type: {
+      auto s = begin_;
+      while (begin_ != end_ && *begin_ != ' ')
+        ++begin_;
+      *arg_.string_view = fmt::string_view(s, begin_ - s);
+      break;
     }
     default:
       assert(false);
@@ -185,12 +206,19 @@ TEST(ScanTest, ReadULongLong) {
   EXPECT_THROW_MSG(fmt::scan("-42", "{}", n), fmt::format_error,
                    "invalid input");
 }
+
 TEST(ScanTest, ReadString) {
   std::string s;
   fmt::scan("foo", "{}", s);
   EXPECT_EQ(s, "foo");
 }
 
+TEST(ScanTest, ReadStringView) {
+  fmt::string_view s;
+  fmt::scan("foo", "{}", s);
+  EXPECT_EQ(s, "foo");
+}
+
 TEST(ScanTest, InvalidFormat) {
   EXPECT_THROW_MSG(fmt::scan("", "{}"), fmt::format_error,
                    "argument index out of range");

From 76ef39fc50ec156346f93aa2c72f4a72ba175c88 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 2 Jun 2019 13:19:33 -0700
Subject: [PATCH 11/16] Update vagrant config

---
 support/Vagrantfile | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/support/Vagrantfile b/support/Vagrantfile
index d18aec3c2e0f..0cd16a5caef9 100644
--- a/support/Vagrantfile
+++ b/support/Vagrantfile
@@ -1,19 +1,18 @@
 # -*- mode: ruby -*-
 # vi: set ft=ruby :
 
-# A vagrant config for testing against gcc-4.4.
+# A vagrant config for testing against gcc-4.8.
 Vagrant.configure("2") do |config|
-  config.vm.box = "bento/ubuntu-10.04"
+  config.vm.box = "ubuntu/trusty64"
 
   config.vm.provider "virtualbox" do |vb|
     vb.memory = "4096"
   end
 
   config.vm.provision "shell", inline: <<-SHELL
-    sed -i 's/us.archive/old-releases/' /etc/apt/sources.list
     apt-get update
     apt-get install -y g++ make wget
-    wget -q https://www.dropbox.com/s/ssvomsla6bkx2wl/cmake-3.14.4-Linux-x86_64.tar.gz
+    wget -q https://github.com/Kitware/CMake/releases/download/v3.14.5/cmake-3.14.4-Linux-x86_64.tar.gz
     tar xzf cmake-3.14.4-Linux-x86_64.tar.gz
     ln -s `pwd`/cmake-3.14.4-Linux-x86_64/bin/cmake /usr/local/bin
   SHELL

From 89d6c959b203fca96ec240d2c255867b7f1959a5 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 2 Jun 2019 13:24:32 -0700
Subject: [PATCH 12/16] Fix cmake link

---
 support/Vagrantfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/support/Vagrantfile b/support/Vagrantfile
index 0cd16a5caef9..67360e1e277c 100644
--- a/support/Vagrantfile
+++ b/support/Vagrantfile
@@ -12,7 +12,7 @@ Vagrant.configure("2") do |config|
   config.vm.provision "shell", inline: <<-SHELL
     apt-get update
     apt-get install -y g++ make wget
-    wget -q https://github.com/Kitware/CMake/releases/download/v3.14.5/cmake-3.14.4-Linux-x86_64.tar.gz
+    wget -q https://github.com/Kitware/CMake/releases/download/v3.14.4/cmake-3.14.4-Linux-x86_64.tar.gz
     tar xzf cmake-3.14.4-Linux-x86_64.tar.gz
     ln -s `pwd`/cmake-3.14.4-Linux-x86_64/bin/cmake /usr/local/bin
   SHELL

From 56d2b91108b78dbbd688488ea1f76e452fa2a9e9 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 2 Jun 2019 13:57:19 -0700
Subject: [PATCH 13/16] Install git

---
 support/Vagrantfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/support/Vagrantfile b/support/Vagrantfile
index 67360e1e277c..de0fcb9efafa 100644
--- a/support/Vagrantfile
+++ b/support/Vagrantfile
@@ -11,7 +11,7 @@ Vagrant.configure("2") do |config|
 
   config.vm.provision "shell", inline: <<-SHELL
     apt-get update
-    apt-get install -y g++ make wget
+    apt-get install -y g++ make wget git
     wget -q https://github.com/Kitware/CMake/releases/download/v3.14.4/cmake-3.14.4-Linux-x86_64.tar.gz
     tar xzf cmake-3.14.4-Linux-x86_64.tar.gz
     ln -s `pwd`/cmake-3.14.4-Linux-x86_64/bin/cmake /usr/local/bin

From 4d4b8c238d0ef7ed242d3fed550a3e85cbedd4e1 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sat, 1 Jun 2019 12:32:24 -0700
Subject: [PATCH 14/16] FMT_CHAR -> char_t

---
 include/fmt/color.h   | 27 +++++++++++-------------
 include/fmt/core.h    | 48 ++++++++++++++++++++++++++-----------------
 include/fmt/format.h  | 38 ++++++++++++++++++----------------
 include/fmt/locale.h  | 29 +++++++++++++-------------
 include/fmt/ostream.h | 10 ++++-----
 include/fmt/prepare.h |  8 ++++----
 include/fmt/printf.h  | 33 +++++++++++++----------------
 7 files changed, 99 insertions(+), 94 deletions(-)

diff --git a/include/fmt/color.h b/include/fmt/color.h
index b29ab0821920..5c9b04917555 100644
--- a/include/fmt/color.h
+++ b/include/fmt/color.h
@@ -556,7 +556,7 @@ std::basic_string<Char> vformat(
 }
 }  // namespace internal
 
-template <typename S, typename Char = typename internal::char_t<S>::type>
+template <typename S, typename Char = char_t<S> >
 void vprint(std::FILE* f, const text_style& ts, const S& format,
             basic_format_args<typename buffer_context<Char>::type> args) {
   bool has_style = false;
@@ -587,13 +587,12 @@ void vprint(std::FILE* f, const text_style& ts, const S& format,
     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
                "Elapsed time: {0:.2f} seconds", 1.23);
  */
-template <typename String, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<String>::value)>
-void print(std::FILE* f, const text_style& ts, const String& format_str,
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(internal::is_string<S>::value)>
+void print(std::FILE* f, const text_style& ts, const S& format_str,
            const Args&... args) {
   internal::check_format_string<Args...>(format_str);
-  typedef typename internal::char_t<String>::type char_t;
-  typedef typename buffer_context<char_t>::type context_t;
+  typedef typename buffer_context<char_t<S> >::type context_t;
   format_arg_store<context_t, Args...> as{args...};
   vprint(f, ts, format_str, basic_format_args<context_t>(as));
 }
@@ -605,14 +604,13 @@ void print(std::FILE* f, const text_style& ts, const String& format_str,
     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
                "Elapsed time: {0:.2f} seconds", 1.23);
  */
-template <typename String, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<String>::value)>
-void print(const text_style& ts, const String& format_str,
-           const Args&... args) {
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(internal::is_string<S>::value)>
+void print(const text_style& ts, const S& format_str, const Args&... args) {
   return print(stdout, ts, format_str, args...);
 }
 
-template <typename S, typename Char = FMT_CHAR(S)>
+template <typename S, typename Char = char_t<S> >
 inline std::basic_string<Char> vformat(
     const text_style& ts, const S& format_str,
     basic_format_args<typename buffer_context<Char>::type> args) {
@@ -631,10 +629,9 @@ inline std::basic_string<Char> vformat(
                                       "The answer is {}", 42);
   \endrst
 */
-template <typename S, typename... Args>
-inline std::basic_string<FMT_CHAR(S)> format(const text_style& ts,
-                                             const S& format_str,
-                                             const Args&... args) {
+template <typename S, typename... Args, typename Char = char_t<S> >
+inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
+                                      const Args&... args) {
   return internal::vformat(ts, to_string_view(format_str),
                            {internal::make_args_checked(format_str, args...)});
 }
diff --git a/include/fmt/core.h b/include/fmt/core.h
index e9cea5701434..3298b05fcb23 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -617,7 +617,7 @@ struct is_string
 template <> struct is_string<std::FILE*>;
 template <> struct is_string<const std::FILE*>;
 
-template <typename S> struct char_t {
+template <typename S> struct char_t_impl {
   typedef decltype(to_string_view(std::declval<S>())) result;
   typedef typename result::char_type type;
 };
@@ -883,7 +883,7 @@ FMT_CONSTEXPR11 init<C, basic_string_view<typename C::char_type>, string_type>
 make_value(const S& val) {
   // Handle adapted strings.
   static_assert(std::is_same<typename C::char_type,
-                             typename internal::char_t<S>::type>::value,
+                             typename internal::char_t_impl<S>::type>::value,
                 "mismatch between char-types of context and argument");
   return to_string_view(val);
 }
@@ -1311,8 +1311,7 @@ struct wformat_args : basic_format_args<wformat_context> {
 };
 
 /** String's character type. */
-template <typename S> using char_t = typename internal::char_t<S>::type;
-#define FMT_CHAR(S) fmt::char_t<S>
+template <typename S> using char_t = typename internal::char_t_impl<S>::type;
 
 namespace internal {
 template <typename Context>
@@ -1353,8 +1352,8 @@ template <typename... Args, typename S,
 void check_format_string(S);
 
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline format_arg_store<typename buffer_context<FMT_CHAR(S)>::type, Args...>
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+inline format_arg_store<typename buffer_context<Char>::type, Args...>
 make_args_checked(const S& format_str, const Args&... args) {
   internal::check_format_string<Args...>(format_str);
   return {args...};
@@ -1386,8 +1385,8 @@ typename buffer_context<Char>::type::iterator vformat_to(
     fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
   \endrst
  */
-template <typename S, typename T>
-inline internal::named_arg<T, FMT_CHAR(S)> arg(const S& name, const T& arg) {
+template <typename S, typename T, typename Char = char_t<S>>
+inline internal::named_arg<T, Char> arg(const S& name, const T& arg) {
   static_assert(internal::is_string<S>::value, "");
   return {name, arg};
 }
@@ -1404,13 +1403,23 @@ struct is_contiguous<std::basic_string<Char>> : std::true_type {};
 template <typename Char>
 struct is_contiguous<internal::buffer<Char>> : std::true_type {};
 
+template <typename OutputIt>
+struct is_contiguous_back_insert_iterator : std::false_type {};
+
+template <typename Container>
+struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>>
+    : is_contiguous<Container> {};
+
 /** Formats a string and writes the output to ``out``. */
-template <typename Container, typename S>
-typename std::enable_if<is_contiguous<Container>::value,
-                        std::back_insert_iterator<Container>>::type
-vformat_to(std::back_insert_iterator<Container> out, const S& format_str,
-           basic_format_args<typename buffer_context<FMT_CHAR(S)>::type> args) {
-  internal::container_buffer<Container> buf(internal::get_container(out));
+template <typename OutputIt, typename S,
+          typename Char = enable_if_t<
+              is_contiguous_back_insert_iterator<OutputIt>::value, char_t<S>>>
+OutputIt vformat_to(
+    OutputIt out, const S& format_str,
+    basic_format_args<typename buffer_context<Char>::type> args) {
+  using container = typename std::remove_reference<decltype(
+      internal::get_container(out))>::type;
+  internal::container_buffer<container> buf((internal::get_container(out)));
   internal::vformat_to(buf, to_string_view(format_str), args);
   return out;
 }
@@ -1425,8 +1434,8 @@ inline std::back_insert_iterator<Container> format_to(
                     {internal::make_args_checked(format_str, args...)});
 }
 
-template <typename S, typename Char = FMT_CHAR(S),
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
+template <typename S,
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
 inline std::basic_string<Char> vformat(
     const S& format_str,
     basic_format_args<typename buffer_context<Char>::type> args) {
@@ -1443,11 +1452,12 @@ inline std::basic_string<Char> vformat(
     std::string message = fmt::format("The answer is {}", 42);
   \endrst
 */
-// Pass fmt::char_t as a default template parameter instead of using
-// std::basic_string<fmt::char_t<S>> to reduce the symbol size.
+// Pass char_t as a default template parameter instead of using
+// std::basic_string<char_t<S>> to reduce the symbol size.
 template <typename S, typename... Args,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline std::basic_string<Char> format(const S& format_str, const Args&... args) {
+inline std::basic_string<Char> format(const S& format_str,
+                                      const Args&... args) {
   return internal::vformat(to_string_view(format_str),
                            {internal::make_args_checked(format_str, args...)});
 }
diff --git a/include/fmt/format.h b/include/fmt/format.h
index 42846f902cd6..c8ce2f39bf26 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -1805,10 +1805,11 @@ struct string_view_metadata {
       : offset_(view.data() - primary_string.data()), size_(view.size()) {}
   FMT_CONSTEXPR string_view_metadata(std::size_t offset, std::size_t size)
       : offset_(offset), size_(size) {}
-  template <typename S, FMT_ENABLE_IF(internal::is_string<S>::value)>
-  FMT_CONSTEXPR basic_string_view<FMT_CHAR(S)> to_view(S&& str) const {
+  template <typename S, typename Char = enable_if_t<
+                            internal::is_string<S>::value, char_t<S>>>
+  FMT_CONSTEXPR basic_string_view<Char> to_view(S&& str) const {
     const auto view = to_string_view(str);
-    return basic_string_view<FMT_CHAR(S)>(view.data() + offset_, size_);
+    return basic_string_view<Char>(view.data() + offset_, size_);
   }
 
   std::size_t offset_;
@@ -3384,7 +3385,7 @@ typename buffer_context<Char>::type::iterator internal::vformat_to(
                                           args);
 }
 
-template <typename S, typename Char = FMT_CHAR(S),
+template <typename S, typename Char = char_t<S>,
           FMT_ENABLE_IF(internal::is_string<S>::value)>
 inline typename buffer_context<Char>::type::iterator vformat_to(
     internal::buffer<Char>& buf, const S& format_str,
@@ -3393,12 +3394,12 @@ inline typename buffer_context<Char>::type::iterator vformat_to(
 }
 
 template <typename S, typename... Args, std::size_t SIZE = inline_buffer_size,
-          typename Char = typename internal::char_t<S>::type>
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
 inline typename buffer_context<Char>::type::iterator format_to(
     basic_memory_buffer<Char, SIZE>& buf, const S& format_str,
     const Args&... args) {
   internal::check_format_string<Args...>(format_str);
-  typedef typename buffer_context<Char>::type context;
+  using context = typename buffer_context<Char>::type;
   format_arg_store<context, Args...> as{args...};
   return internal::vformat_to(buf, to_string_view(format_str),
                               basic_format_args<context>(as));
@@ -3459,12 +3460,13 @@ struct format_args_t {
       type;
 };
 
-template <typename String, typename OutputIt, typename... Args,
-          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
+template <typename S, typename OutputIt, typename... Args,
+          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value &&
+                        !is_contiguous_back_insert_iterator<OutputIt>::value)>
 inline OutputIt vformat_to(
-    OutputIt out, const String& format_str,
-    typename format_args_t<OutputIt, FMT_CHAR(String)>::type args) {
-  typedef output_range<OutputIt, FMT_CHAR(String)> range;
+    OutputIt out, const S& format_str,
+    typename format_args_t<OutputIt, char_t<S>>::type args) {
+  typedef output_range<OutputIt, char_t<S>> range;
   return vformat_to<arg_formatter<range>>(range(out),
                                           to_string_view(format_str), args);
 }
@@ -3481,13 +3483,13 @@ inline OutputIt vformat_to(
  \endrst
  */
 template <typename OutputIt, typename S, typename... Args>
-inline
-    typename std::enable_if<internal::is_string<S>::value &&
-                                internal::is_output_iterator<OutputIt>::value,
-                            OutputIt>::type
-    format_to(OutputIt out, const S& format_str, const Args&... args) {
+inline OutputIt format_to(OutputIt out, const S& format_str,
+                          const Args&... args) {
+  static_assert(internal::is_output_iterator<OutputIt>::value &&
+                    internal::is_string<S>::value,
+                "");
   internal::check_format_string<Args...>(format_str);
-  typedef typename format_context_t<OutputIt, FMT_CHAR(S)>::type context;
+  typedef typename format_context_t<OutputIt, char_t<S>>::type context;
   format_arg_store<context, Args...> as{args...};
   return vformat_to(out, to_string_view(format_str),
                     basic_format_args<context>(as));
@@ -3542,7 +3544,7 @@ inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n,
                                                 const S& format_str,
                                                 const Args&... args) {
   internal::check_format_string<Args...>(format_str);
-  typedef FMT_CHAR(S) Char;
+  using Char = char_t<S>;
   format_arg_store<typename format_to_n_context<OutputIt, Char>::type, Args...>
   as(args...);
   return vformat_to_n(out, n, to_string_view(format_str),
diff --git a/include/fmt/locale.h b/include/fmt/locale.h
index aeb352170ebd..b6b4cf901c3e 100644
--- a/include/fmt/locale.h
+++ b/include/fmt/locale.h
@@ -34,38 +34,39 @@ std::basic_string<Char> vformat(
 }
 }  // namespace internal
 
-template <typename S, typename Char = FMT_CHAR(S)>
+template <typename S, typename Char = char_t<S>>
 inline std::basic_string<Char> vformat(
     const std::locale& loc, const S& format_str,
     basic_format_args<typename buffer_context<Char>::type> args) {
   return internal::vformat(loc, to_string_view(format_str), args);
 }
 
-template <typename S, typename... Args>
-inline std::basic_string<FMT_CHAR(S)> format(const std::locale& loc,
-                                             const S& format_str,
-                                             const Args&... args) {
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline std::basic_string<Char> format(const std::locale& loc,
+                                      const S& format_str,
+                                      const Args&... args) {
   return internal::vformat(loc, to_string_view(format_str),
                            {internal::make_args_checked(format_str, args...)});
 }
 
-template <typename String, typename OutputIt, typename... Args,
-          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value)>
-inline OutputIt vformat_to(
-    OutputIt out, const std::locale& loc, const String& format_str,
-    typename format_args_t<OutputIt, FMT_CHAR(String)>::type args) {
-  typedef output_range<OutputIt, FMT_CHAR(String)> range;
+template <typename S, typename OutputIt, typename... Args,
+          typename Char = enable_if_t<
+              internal::is_output_iterator<OutputIt>::value, char_t<S>>>
+inline OutputIt vformat_to(OutputIt out, const std::locale& loc,
+                           const S& format_str,
+                           typename format_args_t<OutputIt, Char>::type args) {
+  using range = output_range<OutputIt, Char>;
   return vformat_to<arg_formatter<range>>(
       range(out), to_string_view(format_str), args, internal::locale_ref(loc));
 }
 
 template <typename OutputIt, typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value&&
-                            internal::is_output_iterator<OutputIt>::value)>
+          FMT_ENABLE_IF(internal::is_output_iterator<OutputIt>::value&&
+                            internal::is_string<S>::value)>
 inline OutputIt format_to(OutputIt out, const std::locale& loc,
                           const S& format_str, const Args&... args) {
   internal::check_format_string<Args...>(format_str);
-  typedef typename format_context_t<OutputIt, FMT_CHAR(S)>::type context;
+  using context = typename format_context_t<OutputIt, char_t<S>>::type;
   format_arg_store<context, Args...> as{args...};
   return vformat_to(out, loc, to_string_view(format_str),
                     basic_format_args<context>(as));
diff --git a/include/fmt/ostream.h b/include/fmt/ostream.h
index 47d81a90500f..0399108f148d 100644
--- a/include/fmt/ostream.h
+++ b/include/fmt/ostream.h
@@ -120,13 +120,13 @@ struct convert_to_int<
 };
 
 template <typename Char>
-inline void vprint(
-    std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
+void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
+            basic_format_args<typename buffer_context<Char>::type> args) {
   basic_memory_buffer<Char> buffer;
   internal::vformat_to(buffer, format_str, args);
   internal::write(os, buffer);
 }
+
 /**
   \rst
   Prints formatted data to the stream *os*.
@@ -137,8 +137,8 @@ inline void vprint(
   \endrst
  */
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline void print(std::basic_ostream<FMT_CHAR(S)>& os, const S& format_str,
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+inline void print(std::basic_ostream<Char>& os, const S& format_str,
                   const Args&... args) {
   vprint(os, to_string_view(format_str),
          {internal::make_args_checked(format_str, args...)});
diff --git a/include/fmt/prepare.h b/include/fmt/prepare.h
index 7bfe73d43a08..7f4ff082b9da 100644
--- a/include/fmt/prepare.h
+++ b/include/fmt/prepare.h
@@ -185,8 +185,8 @@ class format_preparation_handler : public internal::error_handler {
 template <typename Format, typename PreparedPartsProvider, typename... Args>
 class prepared_format {
  public:
-  typedef FMT_CHAR(Format) char_type;
-  typedef format_part<char_type> format_part_t;
+  using char_type = char_t<Format>;
+  using format_part_t = format_part<char_type>;
 
   prepared_format(Format f)
       : format_(std::move(f)), parts_provider_(to_string_view(format_)) {}
@@ -351,7 +351,7 @@ class prepared_format {
 
 template <typename Format> class compiletime_prepared_parts_type_provider {
  private:
-  typedef FMT_CHAR(Format) char_type;
+  using char_type = char_t<Format>;
 
   class count_handler {
    private:
@@ -649,7 +649,7 @@ class parts_container {
 // Delegate preparing to preparator, to take advantage of a partial
 // specialization.
 template <typename Format, typename... Args> struct preparator {
-  typedef parts_container<FMT_CHAR(Format)> container;
+  typedef parts_container<char_t<Format>> container;
   typedef typename basic_prepared_format<Format, container, Args...>::type
       prepared_format_type;
 
diff --git a/include/fmt/printf.h b/include/fmt/printf.h
index f879dc830018..3dbf1fc0da4a 100644
--- a/include/fmt/printf.h
+++ b/include/fmt/printf.h
@@ -608,7 +608,7 @@ inline format_arg_store<wprintf_context, Args...> make_wprintf_args(
   return {args...};
 }
 
-template <typename S, typename Char = FMT_CHAR(S)>
+template <typename S, typename Char = char_t<S>>
 inline std::basic_string<Char> vsprintf(
     const S& format,
     basic_format_args<
@@ -629,16 +629,14 @@ inline std::basic_string<Char> vsprintf(
   \endrst
 */
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline std::basic_string<FMT_CHAR(S)> sprintf(const S& format,
-                                              const Args&... args) {
-  typedef internal::buffer<FMT_CHAR(S)> buffer;
-  typedef typename basic_printf_context_t<buffer>::type context;
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
+inline std::basic_string<Char> sprintf(const S& format, const Args&... args) {
+  using context = typename basic_printf_context_t<internal::buffer<Char>>::type;
   format_arg_store<context, Args...> as{args...};
   return vsprintf(to_string_view(format), basic_format_args<context>(as));
 }
 
-template <typename S, typename Char = FMT_CHAR(S)>
+template <typename S, typename Char = char_t<S>>
 inline int vfprintf(
     std::FILE* f, const S& format,
     basic_format_args<
@@ -662,15 +660,14 @@ inline int vfprintf(
   \endrst
  */
 template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
+          typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
 inline int fprintf(std::FILE* f, const S& format, const Args&... args) {
-  typedef internal::buffer<FMT_CHAR(S)> buffer;
-  typedef typename basic_printf_context_t<buffer>::type context;
+  using context = typename basic_printf_context_t<internal::buffer<Char>>::type;
   format_arg_store<context, Args...> as{args...};
   return vfprintf(f, to_string_view(format), basic_format_args<context>(as));
 }
 
-template <typename S, typename Char = FMT_CHAR(S)>
+template <typename S, typename Char = char_t<S>>
 inline int vprintf(
     const S& format,
     basic_format_args<
@@ -692,13 +689,13 @@ template <typename S, typename... Args,
           FMT_ENABLE_IF(internal::is_string<S>::value)>
 inline int printf(const S& format_str, const Args&... args) {
   internal::check_format_string<Args...>(format_str);
-  typedef internal::buffer<FMT_CHAR(S)> buffer;
-  typedef typename basic_printf_context_t<buffer>::type context;
+  using buffer = internal::buffer<char_t<S>>;
+  using context = typename basic_printf_context_t<buffer>::type;
   format_arg_store<context, Args...> as{args...};
   return vprintf(to_string_view(format_str), basic_format_args<context>(as));
 }
 
-template <typename S, typename Char = FMT_CHAR(S)>
+template <typename S, typename Char = char_t<S>>
 inline int vfprintf(
     std::basic_ostream<Char>& os, const S& format,
     basic_format_args<
@@ -731,13 +728,11 @@ typename ArgFormatter::iterator vprintf(internal::buffer<Char>& out,
     fmt::fprintf(cerr, "Don't %s!", "panic");
   \endrst
  */
-template <typename S, typename... Args,
-          FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline int fprintf(std::basic_ostream<FMT_CHAR(S)>& os, const S& format_str,
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline int fprintf(std::basic_ostream<Char>& os, const S& format_str,
                    const Args&... args) {
   internal::check_format_string<Args...>(format_str);
-  typedef internal::buffer<FMT_CHAR(S)> buffer;
-  typedef typename basic_printf_context_t<buffer>::type context;
+  using context = typename basic_printf_context_t<internal::buffer<Char>>::type;
   format_arg_store<context, Args...> as{args...};
   return vfprintf(os, to_string_view(format_str),
                   basic_format_args<context>(as));

From ec6651087d05e8a3e4e886e2673a492ee3a0db88 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 2 Jun 2019 16:04:17 -0700
Subject: [PATCH 15/16] Remove old is_constructible workarounds and replace
 typedefs with using

---
 include/fmt/core.h   | 114 +++++++++++++++++--------------------------
 include/fmt/printf.h |   9 ++--
 test/core-test.cc    |  20 ++++----
 3 files changed, 57 insertions(+), 86 deletions(-)

diff --git a/include/fmt/core.h b/include/fmt/core.h
index 3298b05fcb23..524c47d4cae1 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -204,6 +204,10 @@ FMT_BEGIN_NAMESPACE
 template <bool B, class T = void>
 using enable_if_t = typename std::enable_if<B, T>::type;
 
+// An enable_if helper to be used in template parameters which results in much
+// shorter symbols: https://godbolt.org/z/sWw4vP.
+#define FMT_ENABLE_IF(...) enable_if_t<__VA_ARGS__, int> = 0
+
 namespace internal {
 
 #if defined(FMT_USE_STRING_VIEW)
@@ -215,10 +219,6 @@ using std_string_view = std::experimental::basic_string_view<Char>;
 template <typename T> struct std_string_view {};
 #endif
 
-// An enable_if helper to be used in template parameters which results in much
-// shorter symbols: https://godbolt.org/z/sWw4vP.
-#define FMT_ENABLE_IF(...) enable_if_t<__VA_ARGS__, int> = 0
-
 #if (__cplusplus >= 201703L ||                          \
      (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)) && \
     __cpp_lib_is_invocable >= 201703L
@@ -266,8 +266,8 @@ template <typename T> class buffer {
   virtual void grow(std::size_t capacity) = 0;
 
  public:
-  typedef T value_type;
-  typedef const T& const_reference;
+  using value_type = T;
+  using const_reference = const T&;
 
   virtual ~buffer() {}
 
@@ -334,7 +334,7 @@ class container_buffer : public buffer<typename Container::value_type> {
 // Extracts a reference to the container from back_insert_iterator.
 template <typename Container>
 inline Container& get_container(std::back_insert_iterator<Container> it) {
-  typedef std::back_insert_iterator<Container> bi_iterator;
+  using bi_iterator = std::back_insert_iterator<Container>;
   struct accessor : bi_iterator {
     accessor(bi_iterator iter) : bi_iterator(iter) {}
     using bi_iterator::container;
@@ -349,23 +349,6 @@ struct error_handler {
   // This function is intentionally not constexpr to give a compile-time error.
   FMT_API FMT_NORETURN void on_error(const char* message);
 };
-
-// GCC 4.6.x cannot expand `T...`.
-#if FMT_GCC_VERSION && FMT_GCC_VERSION < 407
-typedef char yes[1];
-typedef char no[2];
-
-template <typename T, typename V> struct is_constructible {
-  template <typename U>
-  static yes& test(int (*)[sizeof(new U(std::declval<V>()))]);
-  template <typename U> static no& test(...);
-  enum { value = sizeof(test<T>(nullptr)) == sizeof(yes) };
-};
-#else
-template <typename... T>
-struct is_constructible : std::is_constructible<T...> {};
-#endif
-struct dummy_formatter_arg {};  // Workaround broken is_constructible in MSVC.
 }  // namespace internal
 
 /**
@@ -381,8 +364,8 @@ template <typename Char> class basic_string_view {
   size_t size_;
 
  public:
-  typedef Char char_type;
-  typedef const Char* iterator;
+  using char_type = Char;
+  using iterator = const Char*;
 
   FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {}
 
@@ -455,8 +438,8 @@ template <typename Char> class basic_string_view {
   }
 };
 
-typedef basic_string_view<char> string_view;
-typedef basic_string_view<wchar_t> wstring_view;
+using string_view = basic_string_view<char>;
+using wstring_view = basic_string_view<wchar_t>;
 
 /**
   \rst
@@ -525,8 +508,8 @@ class basic_parse_context : private ErrorHandler {
   int next_arg_id_;
 
  public:
-  typedef Char char_type;
-  typedef typename basic_string_view<Char>::iterator iterator;
+  using char_type = Char;
+  using iterator = typename basic_string_view<Char>::iterator;
 
   explicit FMT_CONSTEXPR basic_parse_context(basic_string_view<Char> format_str,
                                              ErrorHandler eh = ErrorHandler())
@@ -567,11 +550,11 @@ class basic_parse_context : private ErrorHandler {
   FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; }
 };
 
-typedef basic_parse_context<char> format_parse_context;
-typedef basic_parse_context<wchar_t> wformat_parse_context;
+using format_parse_context = basic_parse_context<char>;
+using wformat_parse_context = basic_parse_context<wchar_t>;
 
-FMT_DEPRECATED typedef basic_parse_context<char> parse_context;
-FMT_DEPRECATED typedef basic_parse_context<wchar_t> wparse_context;
+using parse_context FMT_DEPRECATED = basic_parse_context<char>;
+using wparse_context FMT_DEPRECATED = basic_parse_context<wchar_t>;
 
 template <typename Context> class basic_format_arg;
 template <typename Context> class basic_format_args;
@@ -579,7 +562,7 @@ template <typename Context> class basic_format_args;
 // A formatter for objects of type T.
 template <typename T, typename Char = char, typename Enable = void>
 struct formatter {
-  explicit formatter(internal::dummy_formatter_arg);
+  formatter() = delete;
 };
 
 template <typename T, typename Char, typename Enable = void>
@@ -669,18 +652,14 @@ template <typename Context> struct custom_value {
                  Context& ctx);
 };
 
-template <typename T, typename Context> struct is_formattable {
-  enum {
-    value =
-        !is_constructible<typename Context::template formatter_type<T>::type,
-                          internal::dummy_formatter_arg>::value
-  };
-};
+template <typename T, typename Context>
+using is_formattable =
+    std::is_constructible<typename Context::template formatter_type<T>>;
 
 // A formatting argument value.
 template <typename Context> class value {
  public:
-  typedef typename Context::char_type char_type;
+  using char_type = typename Context::char_type;
 
   union {
     int int_value;
@@ -727,7 +706,7 @@ template <typename Context> class value {
     custom.format = &format_custom_arg<
         T, typename std::conditional<
                is_formattable<T, Context>::value,
-               typename Context::template formatter_type<T>::type,
+               typename Context::template formatter_type<T>,
                internal::fallback_formatter<T, char_type>>::type>;
   }
 
@@ -779,12 +758,12 @@ FMT_MAKE_VALUE_SAME(uint_type, unsigned)
 
 // To minimize the number of types we need to deal with, long is translated
 // either to int or to long long depending on its size.
-typedef std::conditional<sizeof(long) == sizeof(int), int, long long>::type
-    long_type;
+using long_type =
+    std::conditional<sizeof(long) == sizeof(int), int, long long>::type;
 FMT_MAKE_VALUE((sizeof(long) == sizeof(int) ? int_type : long_long_type), long,
                long_type)
-typedef std::conditional<sizeof(unsigned long) == sizeof(unsigned), unsigned,
-                         unsigned long long>::type ulong_type;
+using ulong_type = std::conditional<sizeof(unsigned long) == sizeof(unsigned),
+                                    unsigned, unsigned long long>::type;
 FMT_MAKE_VALUE((sizeof(unsigned long) == sizeof(unsigned) ? uint_type
                                                           : ulong_long_type),
                unsigned long, ulong_type)
@@ -849,9 +828,10 @@ inline init<C, int, int_type> make_value(const T& val) {
   return static_cast<int>(val);
 }
 
-template <typename C, typename T, typename Char = typename C::char_type,
-          FMT_ENABLE_IF(is_constructible<basic_string_view<Char>, T>::value &&
-                        !internal::is_string<T>::value)>
+template <
+    typename C, typename T, typename Char = typename C::char_type,
+    FMT_ENABLE_IF(std::is_constructible<basic_string_view<Char>, T>::value &&
+                  !internal::is_string<T>::value)>
 inline init<C, basic_string_view<Char>, string_type> make_value(const T& val) {
   return basic_string_view<Char>(val);
 }
@@ -864,7 +844,7 @@ template <
     FMT_ENABLE_IF(!convert_to_int<U, Char>::value &&
                   !std::is_same<U, Char>::value &&
                   !std::is_convertible<U, basic_string_view<Char>>::value &&
-                  !is_constructible<basic_string_view<Char>, U>::value &&
+                  !std::is_constructible<basic_string_view<Char>, U>::value &&
                   !internal::is_string<U>::value)>
 inline init<C, const T&, custom_type> make_value(const T& val) {
   return val;
@@ -913,7 +893,7 @@ template <typename Context> class basic_format_arg {
   friend class basic_format_args<Context>;
   friend class internal::arg_map<Context>;
 
-  typedef typename Context::char_type char_type;
+  using char_type = typename Context::char_type;
 
  public:
   class handle {
@@ -952,7 +932,7 @@ struct monostate {};
 template <typename Visitor, typename Context>
 FMT_CONSTEXPR internal::invoke_result_t<Visitor, int> visit_format_arg(
     Visitor&& vis, const basic_format_arg<Context>& arg) {
-  typedef typename Context::char_type char_type;
+  using char_type = typename Context::char_type;
   switch (arg.type_) {
   case internal::none_type:
     break;
@@ -1001,7 +981,7 @@ template <typename Context> class arg_map {
   arg_map(const arg_map&) = delete;
   void operator=(const arg_map&) = delete;
 
-  typedef typename Context::char_type char_type;
+  using char_type = typename Context::char_type;
 
   struct entry {
     basic_string_view<char_type> name;
@@ -1084,7 +1064,7 @@ inline basic_format_arg<Context> make_arg(const T& value) {
 template <typename OutputIt, typename Char> class basic_format_context {
  public:
   /** The character type for the output. */
-  typedef Char char_type;
+  using char_type = Char;
 
  private:
   OutputIt out_;
@@ -1096,13 +1076,9 @@ template <typename OutputIt, typename Char> class basic_format_context {
   void operator=(const basic_format_context&) = delete;
 
  public:
-  typedef OutputIt iterator;
-  typedef basic_format_arg<basic_format_context> format_arg;
-
-  // using formatter_type = formatter<T, char_type>;
-  template <typename T> struct formatter_type {
-    typedef formatter<T, char_type> type;
-  };
+  using iterator = OutputIt;
+  using format_arg = basic_format_arg<basic_format_context> ;
+  template <typename T> using formatter_type = formatter<T, char_type>;
 
   /**
    Constructs a ``basic_format_context`` object. References to the arguments are
@@ -1137,8 +1113,8 @@ template <typename Char> struct buffer_context {
       std::back_insert_iterator<internal::buffer<Char>>, Char>
       type;
 };
-typedef buffer_context<char>::type format_context;
-typedef buffer_context<wchar_t>::type wformat_context;
+using format_context = buffer_context<char>::type;
+using wformat_context = buffer_context<wchar_t>::type;
 
 /**
   \rst
@@ -1154,8 +1130,8 @@ template <typename Context, typename... Args> class format_arg_store {
   // Packed is a macro on MinGW so use IS_PACKED instead.
   static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args;
 
-  typedef typename std::conditional<IS_PACKED, internal::value<Context>,
-                                    basic_format_arg<Context>>::type value_type;
+  using value_type = typename std::conditional<IS_PACKED, internal::value<Context>,
+                                    basic_format_arg<Context>>::type;
 
   // If the arguments are not packed, add one more element to mark the end.
   static const size_t DATA_SIZE =
@@ -1213,8 +1189,8 @@ inline format_arg_store<Context, Args...> make_format_args(
 /** Formatting arguments. */
 template <typename Context> class basic_format_args {
  public:
-  typedef unsigned size_type;
-  typedef basic_format_arg<Context> format_arg;
+  using size_type = unsigned;
+  using format_arg = basic_format_arg<Context>;
 
  private:
   // To reduce compiled code size per formatting function call, types of first
diff --git a/include/fmt/printf.h b/include/fmt/printf.h
index 3dbf1fc0da4a..29f36323a55c 100644
--- a/include/fmt/printf.h
+++ b/include/fmt/printf.h
@@ -329,12 +329,9 @@ template <typename T> struct printf_formatter {
 template <typename OutputIt, typename Char> class basic_printf_context {
  public:
   /** The character type for the output. */
-  typedef Char char_type;
-  typedef basic_format_arg<basic_printf_context> format_arg;
-
-  template <typename T> struct formatter_type {
-    typedef printf_formatter<T> type;
-  };
+  using char_type = Char;
+  using format_arg = basic_format_arg<basic_printf_context>;
+  template <typename T> using formatter_type = printf_formatter<T>;
 
  private:
   typedef basic_format_specs<char_type> format_specs;
diff --git a/test/core-test.cc b/test/core-test.cc
index 5f210b8d955c..ff868e14535e 100644
--- a/test/core-test.cc
+++ b/test/core-test.cc
@@ -209,17 +209,15 @@ struct custom_context {
   typedef char char_type;
 
   template <typename T> struct formatter_type {
-    struct type {
-      template <typename ParseContext>
-      auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-        return ctx.begin();
-      }
-
-      const char* format(const T&, custom_context& ctx) {
-        ctx.called = true;
-        return nullptr;
-      }
-    };
+    template <typename ParseContext>
+    auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+      return ctx.begin();
+    }
+
+    const char* format(const T&, custom_context& ctx) {
+      ctx.called = true;
+      return nullptr;
+    }
   };
 
   bool called;

From d54e64b3c813067c5dec5097e70f28a847f9eff4 Mon Sep 17 00:00:00 2001
From: Victor Zverovich <victor.zverovich@gmail.com>
Date: Sun, 2 Jun 2019 17:13:50 -0700
Subject: [PATCH 16/16] Make buffer_context an alias template

---
 include/fmt/color.h      | 16 ++++++-------
 include/fmt/core.h       | 49 ++++++++++++++++++----------------------
 include/fmt/format-inl.h |  2 +-
 include/fmt/format.h     | 19 ++++++++--------
 include/fmt/locale.h     | 12 +++++-----
 include/fmt/ostream.h    |  2 +-
 include/fmt/prepare.h    |  4 ++--
 test/format              |  3 +--
 8 files changed, 50 insertions(+), 57 deletions(-)

diff --git a/include/fmt/color.h b/include/fmt/color.h
index 5c9b04917555..bc534805bec1 100644
--- a/include/fmt/color.h
+++ b/include/fmt/color.h
@@ -526,9 +526,9 @@ template <> struct is_string<std::FILE*> : std::false_type {};
 template <> struct is_string<const std::FILE*> : std::false_type {};
 
 template <typename Char>
-std::basic_string<Char> vformat(
-    const text_style& ts, basic_string_view<Char> format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
+std::basic_string<Char> vformat(const text_style& ts,
+                                basic_string_view<Char> format_str,
+                                basic_format_args<buffer_context<Char> > args) {
   basic_memory_buffer<Char> buffer;
   bool has_style = false;
   if (ts.has_emphasis()) {
@@ -558,7 +558,7 @@ std::basic_string<Char> vformat(
 
 template <typename S, typename Char = char_t<S> >
 void vprint(std::FILE* f, const text_style& ts, const S& format,
-            basic_format_args<typename buffer_context<Char>::type> args) {
+            basic_format_args<buffer_context<Char> > args) {
   bool has_style = false;
   if (ts.has_emphasis()) {
     has_style = true;
@@ -592,9 +592,9 @@ template <typename S, typename... Args,
 void print(std::FILE* f, const text_style& ts, const S& format_str,
            const Args&... args) {
   internal::check_format_string<Args...>(format_str);
-  typedef typename buffer_context<char_t<S> >::type context_t;
-  format_arg_store<context_t, Args...> as{args...};
-  vprint(f, ts, format_str, basic_format_args<context_t>(as));
+  using context = buffer_context<char_t<S> >;
+  format_arg_store<context, Args...> as{args...};
+  vprint(f, ts, format_str, basic_format_args<context>(as));
 }
 
 /**
@@ -613,7 +613,7 @@ void print(const text_style& ts, const S& format_str, const Args&... args) {
 template <typename S, typename Char = char_t<S> >
 inline std::basic_string<Char> vformat(
     const text_style& ts, const S& format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
+    basic_format_args<buffer_context<Char> > args) {
   return internal::vformat(ts, to_string_view(format_str), args);
 }
 
diff --git a/include/fmt/core.h b/include/fmt/core.h
index 524c47d4cae1..58c716d85f15 100644
--- a/include/fmt/core.h
+++ b/include/fmt/core.h
@@ -1077,7 +1077,7 @@ template <typename OutputIt, typename Char> class basic_format_context {
 
  public:
   using iterator = OutputIt;
-  using format_arg = basic_format_arg<basic_format_context> ;
+  using format_arg = basic_format_arg<basic_format_context>;
   template <typename T> using formatter_type = formatter<T, char_type>;
 
   /**
@@ -1108,13 +1108,12 @@ template <typename OutputIt, typename Char> class basic_format_context {
   internal::locale_ref locale() { return loc_; }
 };
 
-template <typename Char> struct buffer_context {
-  typedef basic_format_context<
-      std::back_insert_iterator<internal::buffer<Char>>, Char>
-      type;
-};
-using format_context = buffer_context<char>::type;
-using wformat_context = buffer_context<wchar_t>::type;
+template <typename Char>
+using buffer_context =
+    basic_format_context<std::back_insert_iterator<internal::buffer<Char>>,
+                         Char>;
+using format_context = buffer_context<char>;
+using wformat_context = buffer_context<wchar_t>;
 
 /**
   \rst
@@ -1130,8 +1129,9 @@ template <typename Context, typename... Args> class format_arg_store {
   // Packed is a macro on MinGW so use IS_PACKED instead.
   static const bool IS_PACKED = NUM_ARGS < internal::max_packed_args;
 
-  using value_type = typename std::conditional<IS_PACKED, internal::value<Context>,
-                                    basic_format_arg<Context>>::type;
+  using value_type =
+      typename std::conditional<IS_PACKED, internal::value<Context>,
+                                basic_format_arg<Context>>::type;
 
   // If the arguments are not packed, add one more element to mark the end.
   static const size_t DATA_SIZE =
@@ -1301,8 +1301,7 @@ template <typename Char> struct named_arg_base {
   basic_string_view<Char> name;
 
   // Serialized value<context>.
-  mutable char
-      data[sizeof(basic_format_arg<typename buffer_context<Char>::type>)];
+  mutable char data[sizeof(basic_format_arg<buffer_context<Char>>)];
 
   named_arg_base(basic_string_view<Char> nm) : name(nm) {}
 
@@ -1329,21 +1328,20 @@ void check_format_string(S);
 
 template <typename S, typename... Args,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline format_arg_store<typename buffer_context<Char>::type, Args...>
-make_args_checked(const S& format_str, const Args&... args) {
+inline format_arg_store<buffer_context<Char>, Args...> make_args_checked(
+    const S& format_str, const Args&... args) {
   internal::check_format_string<Args...>(format_str);
   return {args...};
 }
 
 template <typename Char>
-std::basic_string<Char> vformat(
-    basic_string_view<Char> format_str,
-    basic_format_args<typename buffer_context<Char>::type> args);
+std::basic_string<Char> vformat(basic_string_view<Char> format_str,
+                                basic_format_args<buffer_context<Char>> args);
 
 template <typename Char>
-typename buffer_context<Char>::type::iterator vformat_to(
+typename buffer_context<Char>::iterator vformat_to(
     internal::buffer<Char>& buf, basic_string_view<Char> format_str,
-    basic_format_args<typename buffer_context<Char>::type> args);
+    basic_format_args<buffer_context<Char>> args);
 }  // namespace internal
 
 /**
@@ -1387,12 +1385,10 @@ struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>>
     : is_contiguous<Container> {};
 
 /** Formats a string and writes the output to ``out``. */
-template <typename OutputIt, typename S,
-          typename Char = enable_if_t<
-              is_contiguous_back_insert_iterator<OutputIt>::value, char_t<S>>>
-OutputIt vformat_to(
-    OutputIt out, const S& format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
+template <typename OutputIt, typename S, typename Char = char_t<S>,
+          FMT_ENABLE_IF(is_contiguous_back_insert_iterator<OutputIt>::value)>
+OutputIt vformat_to(OutputIt out, const S& format_str,
+                    basic_format_args<buffer_context<Char>> args) {
   using container = typename std::remove_reference<decltype(
       internal::get_container(out))>::type;
   internal::container_buffer<container> buf((internal::get_container(out)));
@@ -1413,8 +1409,7 @@ inline std::back_insert_iterator<Container> format_to(
 template <typename S,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
 inline std::basic_string<Char> vformat(
-    const S& format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
+    const S& format_str, basic_format_args<buffer_context<Char>> args) {
   return internal::vformat(to_string_view(format_str), args);
 }
 
diff --git a/include/fmt/format-inl.h b/include/fmt/format-inl.h
index 28027a592091..fa5eb6f3610c 100644
--- a/include/fmt/format-inl.h
+++ b/include/fmt/format-inl.h
@@ -953,7 +953,7 @@ FMT_FUNC void report_windows_error(int error_code,
 FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
   memory_buffer buffer;
   internal::vformat_to(buffer, format_str,
-                       basic_format_args<buffer_context<char>::type>(args));
+                       basic_format_args<buffer_context<char>>(args));
   fwrite_fully(buffer.data(), 1, buffer.size(), f);
 }
 
diff --git a/include/fmt/format.h b/include/fmt/format.h
index c8ce2f39bf26..82f7092d00c1 100644
--- a/include/fmt/format.h
+++ b/include/fmt/format.h
@@ -3046,7 +3046,7 @@ class format_int {
 template <typename T, typename Char>
 struct formatter<T, Char,
                  typename std::enable_if<internal::format_type<
-                     typename buffer_context<Char>::type, T>::value>::type> {
+                     buffer_context<Char>, T>::value>::type> {
   FMT_CONSTEXPR formatter() : format_str_(nullptr) {}
 
   // Parses format specifiers stopping either at the end of the range or at the
@@ -3055,8 +3055,7 @@ struct formatter<T, Char,
   FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext& ctx) {
     format_str_ = ctx.begin();
     typedef internal::dynamic_specs_handler<ParseContext> handler_type;
-    auto type =
-        internal::get_type<typename buffer_context<Char>::type, T>::value;
+    auto type = internal::get_type<buffer_context<Char>, T>::value;
     internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
                                                   type);
     auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);
@@ -3377,9 +3376,9 @@ std::basic_string<Char> to_string(const basic_memory_buffer<Char, SIZE>& buf) {
 }
 
 template <typename Char>
-typename buffer_context<Char>::type::iterator internal::vformat_to(
+typename buffer_context<Char>::iterator internal::vformat_to(
     internal::buffer<Char>& buf, basic_string_view<Char> format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
+    basic_format_args<buffer_context<Char>> args) {
   typedef back_insert_range<internal::buffer<Char>> range;
   return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str),
                                           args);
@@ -3387,19 +3386,19 @@ typename buffer_context<Char>::type::iterator internal::vformat_to(
 
 template <typename S, typename Char = char_t<S>,
           FMT_ENABLE_IF(internal::is_string<S>::value)>
-inline typename buffer_context<Char>::type::iterator vformat_to(
+inline typename buffer_context<Char>::iterator vformat_to(
     internal::buffer<Char>& buf, const S& format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
+    basic_format_args<buffer_context<Char>> args) {
   return internal::vformat_to(buf, to_string_view(format_str), args);
 }
 
 template <typename S, typename... Args, std::size_t SIZE = inline_buffer_size,
           typename Char = enable_if_t<internal::is_string<S>::value, char_t<S>>>
-inline typename buffer_context<Char>::type::iterator format_to(
+inline typename buffer_context<Char>::iterator format_to(
     basic_memory_buffer<Char, SIZE>& buf, const S& format_str,
     const Args&... args) {
   internal::check_format_string<Args...>(format_str);
-  using context = typename buffer_context<Char>::type;
+  using context = buffer_context<Char>;
   format_arg_store<context, Args...> as{args...};
   return internal::vformat_to(buf, to_string_view(format_str),
                               basic_format_args<context>(as));
@@ -3554,7 +3553,7 @@ inline format_to_n_result<OutputIt> format_to_n(OutputIt out, std::size_t n,
 template <typename Char>
 inline std::basic_string<Char> internal::vformat(
     basic_string_view<Char> format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
+    basic_format_args<buffer_context<Char>> args) {
   basic_memory_buffer<Char> buffer;
   internal::vformat_to(buffer, format_str, args);
   return fmt::to_string(buffer);
diff --git a/include/fmt/locale.h b/include/fmt/locale.h
index b6b4cf901c3e..f3e3d6762191 100644
--- a/include/fmt/locale.h
+++ b/include/fmt/locale.h
@@ -15,19 +15,19 @@ FMT_BEGIN_NAMESPACE
 
 namespace internal {
 template <typename Char>
-typename buffer_context<Char>::type::iterator vformat_to(
+typename buffer_context<Char>::iterator vformat_to(
     const std::locale& loc, buffer<Char>& buf,
     basic_string_view<Char> format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
+    basic_format_args<buffer_context<Char>> args) {
   typedef back_insert_range<buffer<Char>> range;
   return vformat_to<arg_formatter<range>>(buf, to_string_view(format_str), args,
                                           internal::locale_ref(loc));
 }
 
 template <typename Char>
-std::basic_string<Char> vformat(
-    const std::locale& loc, basic_string_view<Char> format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
+std::basic_string<Char> vformat(const std::locale& loc,
+                                basic_string_view<Char> format_str,
+                                basic_format_args<buffer_context<Char>> args) {
   basic_memory_buffer<Char> buffer;
   internal::vformat_to(loc, buffer, format_str, args);
   return fmt::to_string(buffer);
@@ -37,7 +37,7 @@ std::basic_string<Char> vformat(
 template <typename S, typename Char = char_t<S>>
 inline std::basic_string<Char> vformat(
     const std::locale& loc, const S& format_str,
-    basic_format_args<typename buffer_context<Char>::type> args) {
+    basic_format_args<buffer_context<Char>> args) {
   return internal::vformat(loc, to_string_view(format_str), args);
 }
 
diff --git a/include/fmt/ostream.h b/include/fmt/ostream.h
index 0399108f148d..4c2acf4ae96a 100644
--- a/include/fmt/ostream.h
+++ b/include/fmt/ostream.h
@@ -121,7 +121,7 @@ struct convert_to_int<
 
 template <typename Char>
 void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
-            basic_format_args<typename buffer_context<Char>::type> args) {
+            basic_format_args<buffer_context<Char>> args) {
   basic_memory_buffer<Char> buffer;
   internal::vformat_to(buffer, format_str, args);
   internal::write(os, buffer);
diff --git a/include/fmt/prepare.h b/include/fmt/prepare.h
index 7f4ff082b9da..9b30b5d6b760 100644
--- a/include/fmt/prepare.h
+++ b/include/fmt/prepare.h
@@ -239,14 +239,14 @@ class prepared_format {
   }
 
   template <std::size_t SIZE = inline_buffer_size>
-  inline typename buffer_context<char_type>::type::iterator format_to(
+  inline typename buffer_context<char_type>::iterator format_to(
       basic_memory_buffer<char_type, SIZE>& buf, const Args&... args) const {
     typedef back_insert_range<internal::buffer<char_type>> range;
     return this->vformat_to(range(buf), make_args_checked(format_, args...));
   }
 
  private:
-  typedef typename buffer_context<char_type>::type context;
+  typedef buffer_context<char_type> context;
 
   template <typename Range>
   typename context::iterator vformat_to(Range out,
diff --git a/test/format b/test/format
index 3aca2f34aff5..3f9f2f928b6b 100644
--- a/test/format
+++ b/test/format
@@ -643,8 +643,7 @@ struct formatter {
   FMT_CONSTEXPR typename ParseContext::iterator parse(ParseContext& ctx) {
     namespace internal = fmt::internal;
     typedef internal::dynamic_specs_handler<ParseContext> handler_type;
-    auto type =
-        internal::get_type<typename fmt::buffer_context<Char>::type, T>::value;
+    auto type = internal::get_type<fmt::buffer_context<Char>, T>::value;
     internal::specs_checker<handler_type> handler(handler_type(specs_, ctx),
                                                   type);
     auto it = parse_format_specs(ctx.begin(), ctx.end(), handler);