diff --git a/.gitignore b/.gitignore
index 2635026a69db..d858abad2d34 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,3 +18,4 @@ build/
 cmake_install.cmake
 fmt-*.cmake
 fmt.pc
+.gradle/
diff --git a/include/fmt/base.h b/include/fmt/base.h
index f91f8e825354..e1f8f5122cc0 100644
--- a/include/fmt/base.h
+++ b/include/fmt/base.h
@@ -448,8 +448,8 @@ template <typename T> constexpr const char* narrow(const T*) { return nullptr; }
 constexpr FMT_ALWAYS_INLINE const char* narrow(const char* s) { return s; }
 
 template <typename Char>
-FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2, std::size_t n)
-    -> int {
+FMT_CONSTEXPR auto compare(const Char* s1, const Char* s2,
+                           std::size_t n) -> int {
   if (!is_constant_evaluated() && sizeof(Char) == 1) return memcmp(s1, s2, n);
   for (; n != 0; ++s1, ++s2, --n) {
     if (*s1 < *s2) return -1;
@@ -1088,16 +1088,16 @@ struct use_format_as_member<
     T, bool_constant<std::is_arithmetic<format_as_member_result<T>>::value>>
     : std::true_type {};
 
-template <typename T, typename U = remove_const_t<T>>
+template <typename T, typename UT = remove_const_t<T>>
 using use_formatter =
     bool_constant<(std::is_class<T>::value || std::is_enum<T>::value ||
                    std::is_union<T>::value || std::is_array<T>::value) &&
                   !has_to_string_view<T>::value && !is_named_arg<T>::value &&
                   !use_format_as<T>::value && !use_format_as_member<T>::value>;
 
-template <typename Char, typename T, typename U = remove_const_t<T>>
+template <typename Char, typename T, typename UT = remove_const_t<T>>
 auto has_formatter_impl(T* p, buffered_context<Char>* ctx = nullptr)
-    -> decltype(formatter<U, Char>().format(*p, *ctx), std::true_type());
+    -> decltype(formatter<UT, Char>().format(*p, *ctx), std::true_type());
 template <typename Char> auto has_formatter_impl(...) -> std::false_type;
 
 // T can be const-qualified to check if it is const-formattable.
@@ -1129,8 +1129,9 @@ template <typename Char> struct type_mapper {
       -> conditional_t<N <= 64, unsigned long long, void>;
 
   template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
-  static auto map(T) -> conditional_t<
-      std::is_same<T, char>::value || std::is_same<T, Char>::value, Char, void>;
+  static auto map(T) -> conditional_t<std::is_same<T, char>::value ||
+                                          std::is_same<T, Char>::value,
+                                      Char, void>;
 
   static auto map(float) -> float;
   static auto map(double) -> double;
@@ -1336,10 +1337,9 @@ template <typename Char> struct parse_dynamic_spec_result {
 
 // Parses integer | "{" [arg_id] "}".
 template <typename Char>
-FMT_CONSTEXPR auto parse_dynamic_spec(const Char* begin, const Char* end,
-                                      int& value, arg_ref<Char>& ref,
-                                      parse_context<Char>& ctx)
-    -> parse_dynamic_spec_result<Char> {
+FMT_CONSTEXPR auto parse_dynamic_spec(
+    const Char* begin, const Char* end, int& value, arg_ref<Char>& ref,
+    parse_context<Char>& ctx) -> parse_dynamic_spec_result<Char> {
   FMT_ASSERT(begin != end, "");
   auto kind = arg_id_kind::none;
   if ('0' <= *begin && *begin <= '9') {
@@ -1399,8 +1399,8 @@ enum class state { start, align, sign, hash, zero, width, precision, locale };
 template <typename Char>
 FMT_CONSTEXPR auto parse_format_specs(const Char* begin, const Char* end,
                                       dynamic_format_specs<Char>& specs,
-                                      parse_context<Char>& ctx, type arg_type)
-    -> const Char* {
+                                      parse_context<Char>& ctx,
+                                      type arg_type) -> const Char* {
   auto c = '\0';
   if (end - begin > 1) {
     auto next = to_ascii(begin[1]);
@@ -1535,10 +1535,8 @@ FMT_CONSTEXPR auto parse_format_specs(const Char* begin, const Char* end,
 }
 
 template <typename Char, typename Handler>
-FMT_CONSTEXPR FMT_INLINE auto parse_replacement_field(const Char* begin,
-                                                      const Char* end,
-                                                      Handler&& handler)
-    -> const Char* {
+FMT_CONSTEXPR FMT_INLINE auto parse_replacement_field(
+    const Char* begin, const Char* end, Handler&& handler) -> const Char* {
   ++begin;
   if (begin == end) {
     handler.on_error("invalid format string");
@@ -1674,8 +1672,8 @@ class format_string_checker {
     on_format_specs(id, begin, begin);  // Call parse() on empty specs.
   }
 
-  FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin, const Char* end)
-      -> const Char* {
+  FMT_CONSTEXPR auto on_format_specs(int id, const Char* begin,
+                                     const Char* end) -> const Char* {
     context_.advance_to(begin);
     if (id >= 0 && id < NUM_ARGS) return parse_funcs_[id](context_);
     while (begin != end && *begin != '}') ++begin;
@@ -1764,14 +1762,14 @@ template <typename T> class buffer {
   }
 
   /// Appends data to the end of the buffer.
-  template <typename U>
+  template <typename UT>
 // Workaround for MSVC2019 to fix error C2893: Failed to specialize function
 // template 'void fmt::v11::detail::buffer<T>::append(const U *,const U *)'.
 #if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1940
   FMT_CONSTEXPR20
 #endif
       void
-      append(const U* begin, const U* end) {
+      append(const UT* begin, const UT* end) {
     while (begin != end) {
       auto count = to_unsigned(end - begin);
       try_reserve(size_ + count);
@@ -1972,8 +1970,8 @@ struct is_back_insert_iterator<basic_appender<T>> : std::true_type {};
 // An optimized version of std::copy with the output value type (T).
 template <typename T, typename InputIt, typename OutputIt,
           FMT_ENABLE_IF(is_back_insert_iterator<OutputIt>::value)>
-FMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end, OutputIt out)
-    -> OutputIt {
+FMT_CONSTEXPR20 auto copy(InputIt begin, InputIt end,
+                          OutputIt out) -> OutputIt {
   get_container(out).append(begin, end);
   return out;
 }
@@ -2325,8 +2323,8 @@ template <typename T, typename Char, type TYPE> struct native_formatter {
 
   FMT_PRAGMA_CLANG(diagnostic ignored "-Wundefined-inline")
   template <typename FormatContext>
-  FMT_CONSTEXPR auto format(const T& val, FormatContext& ctx) const
-      -> decltype(ctx.out());
+  FMT_CONSTEXPR auto format(const T& val,
+                            FormatContext& ctx) const -> decltype(ctx.out());
 };
 
 template <typename T, typename Enable = void>
@@ -2466,8 +2464,8 @@ template <typename Context> class basic_format_arg {
   }
 
   auto format_custom(const char_type* parse_begin,
-                     parse_context<char_type>& parse_ctx, Context& ctx)
-      -> bool {
+                     parse_context<char_type>& parse_ctx,
+                     Context& ctx) -> bool {
     if (type_ != detail::type::custom_type) return false;
     parse_ctx.advance_to(parse_begin);
     value_.custom.format(value_.custom.value, parse_ctx, ctx);
@@ -2755,8 +2753,8 @@ inline auto arg(const Char* name, const T& arg) -> detail::named_arg<Char, T> {
 template <typename OutputIt,
           FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>,
                                                    char>::value)>
-auto vformat_to(OutputIt&& out, string_view fmt, format_args args)
-    -> remove_cvref_t<OutputIt> {
+auto vformat_to(OutputIt&& out, string_view fmt,
+                format_args args) -> remove_cvref_t<OutputIt> {
   auto&& buf = detail::get_buffer<char>(out);
   detail::vformat_to(buf, fmt, args, {});
   return detail::get_iterator(buf, out);
@@ -2775,8 +2773,8 @@ auto vformat_to(OutputIt&& out, string_view fmt, format_args args)
 template <typename OutputIt, typename... T,
           FMT_ENABLE_IF(detail::is_output_iterator<remove_cvref_t<OutputIt>,
                                                    char>::value)>
-FMT_INLINE auto format_to(OutputIt&& out, format_string<T...> fmt, T&&... args)
-    -> remove_cvref_t<OutputIt> {
+FMT_INLINE auto format_to(OutputIt&& out, format_string<T...> fmt,
+                          T&&... args) -> remove_cvref_t<OutputIt> {
   return vformat_to(out, fmt.str, vargs<T...>{{args...}});
 }
 
@@ -2789,8 +2787,8 @@ template <typename OutputIt> struct format_to_n_result {
 
 template <typename OutputIt, typename... T,
           FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
-auto vformat_to_n(OutputIt out, size_t n, string_view fmt, format_args args)
-    -> format_to_n_result<OutputIt> {
+auto vformat_to_n(OutputIt out, size_t n, string_view fmt,
+                  format_args args) -> format_to_n_result<OutputIt> {
   using traits = detail::fixed_buffer_traits;
   auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
   detail::vformat_to(buf, fmt, args, {});
@@ -2824,15 +2822,15 @@ struct format_to_result {
 };
 
 template <size_t N>
-auto vformat_to(char (&out)[N], string_view fmt, format_args args)
-    -> format_to_result {
+auto vformat_to(char (&out)[N], string_view fmt,
+                format_args args) -> format_to_result {
   auto result = vformat_to_n(out, N, fmt, args);
   return {result.out, result.size > N};
 }
 
 template <size_t N, typename... T>
-FMT_INLINE auto format_to(char (&out)[N], format_string<T...> fmt, T&&... args)
-    -> format_to_result {
+FMT_INLINE auto format_to(char (&out)[N], format_string<T...> fmt,
+                          T&&... args) -> format_to_result {
   auto result = vformat_to_n(out, N, fmt.str, vargs<T...>{{args...}});
   return {result.out, result.size > N};
 }
diff --git a/include/fmt/printf.h b/include/fmt/printf.h
index e72684018546..ac13fc0e9c82 100644
--- a/include/fmt/printf.h
+++ b/include/fmt/printf.h
@@ -139,10 +139,10 @@ template <typename T, typename Context> class arg_converter {
     if (type_ != 's') operator()<bool>(value);
   }
 
-  template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
-  void operator()(U value) {
+  template <typename UT, FMT_ENABLE_IF(std::is_integral<UT>::value)>
+  void operator()(UT value) {
     bool is_signed = type_ == 'd' || type_ == 'i';
-    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
+    using target_type = conditional_t<std::is_same<T, void>::value, UT, T>;
     if (const_check(sizeof(target_type) <= sizeof(int))) {
       // Extra casts are used to silence warnings.
       using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
@@ -157,12 +157,12 @@ template <typename T, typename Context> class arg_converter {
       if (is_signed)
         arg_ = static_cast<long long>(value);
       else
-        arg_ = static_cast<typename make_unsigned_or_bool<U>::type>(value);
+        arg_ = static_cast<typename make_unsigned_or_bool<UT>::type>(value);
     }
   }
 
-  template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
-  void operator()(U) {}  // No conversion needed for non-integral types.
+  template <typename UT, FMT_ENABLE_IF(!std::is_integral<UT>::value)>
+  void operator()(UT) {}  // No conversion needed for non-integral types.
 };
 
 // Converts an integer argument to T for printf, if T is an integral type.
@@ -229,8 +229,8 @@ class printf_width_handler {
 // Workaround for a bug with the XL compiler when initializing
 // printf_arg_formatter's base class.
 template <typename Char>
-auto make_arg_formatter(basic_appender<Char> iter, format_specs& s)
-    -> arg_formatter<Char> {
+auto make_arg_formatter(basic_appender<Char> iter,
+                        format_specs& s) -> arg_formatter<Char> {
   return {iter, s, locale_ref()};
 }
 
@@ -371,8 +371,8 @@ auto parse_header(const Char*& it, const Char* end, format_specs& specs,
   return arg_index;
 }
 
-inline auto parse_printf_presentation_type(char c, type t, bool& upper)
-    -> presentation_type {
+inline auto parse_printf_presentation_type(char c, type t,
+                                           bool& upper) -> presentation_type {
   using pt = presentation_type;
   constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
   switch (c) {
diff --git a/include/fmt/ranges.h b/include/fmt/ranges.h
index c6020abee61a..dd74918c97df 100644
--- a/include/fmt/ranges.h
+++ b/include/fmt/ranges.h
@@ -27,7 +27,7 @@ enum class range_format { disabled, map, set, sequence, string, debug_string };
 namespace detail {
 
 template <typename T> class is_map {
-  template <typename U> static auto check(U*) -> typename U::mapped_type;
+  template <typename UT> static auto check(UT*) -> typename UT::mapped_type;
   template <typename> static void check(...);
 
  public:
@@ -36,7 +36,7 @@ template <typename T> class is_map {
 };
 
 template <typename T> class is_set {
-  template <typename U> static auto check(U*) -> typename U::key_type;
+  template <typename UT> static auto check(UT*) -> typename UT::key_type;
   template <typename> static void check(...);
 
  public:
@@ -115,8 +115,8 @@ struct is_range_<T, void>
 
 // tuple_size and tuple_element check.
 template <typename T> class is_tuple_like_ {
-  template <typename U, typename V = typename std::remove_cv<U>::type>
-  static auto check(U* p) -> decltype(std::tuple_size<V>::value, 0);
+  template <typename UT, typename VT = typename std::remove_cv<UT>::type>
+  static auto check(UT* p) -> decltype(std::tuple_size<VT>::value, 0);
   template <typename> static void check(...);
 
  public:
@@ -163,11 +163,12 @@ template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
   static auto all_true(...) -> std::false_type;
 
   template <size_t... Is>
-  static auto check(index_sequence<Is...>) -> decltype(all_true(
-      index_sequence<Is...>{},
-      integer_sequence<bool,
-                       (is_formattable<typename std::tuple_element<Is, T>::type,
-                                       C>::value)...>{}));
+  static auto check(index_sequence<Is...>)
+      -> decltype(all_true(
+          index_sequence<Is...>{},
+          integer_sequence<
+              bool, (is_formattable<typename std::tuple_element<Is, T>::type,
+                                    C>::value)...>{}));
 
  public:
   static constexpr const bool value =
@@ -333,8 +334,8 @@ struct formatter<Tuple, Char,
   }
 
   template <typename FormatContext>
-  auto format(const Tuple& value, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
+  auto format(const Tuple& value,
+              FormatContext& ctx) const -> decltype(ctx.out()) {
     ctx.advance_to(detail::copy<Char>(opening_bracket_, ctx.out()));
     detail::for_each2(
         formatters_, value,
@@ -388,8 +389,8 @@ struct range_formatter<
       detail::string_literal<Char, ']'>{};
   bool is_debug = false;
 
-  template <typename Output, typename It, typename Sentinel, typename U = T,
-            FMT_ENABLE_IF(std::is_same<U, Char>::value)>
+  template <typename Output, typename It, typename Sentinel, typename UT = T,
+            FMT_ENABLE_IF(std::is_same<UT, Char>::value)>
   auto write_debug_string(Output& out, It it, Sentinel end) const -> Output {
     auto buf = basic_memory_buffer<Char>();
     for (; it != end; ++it) buf.push_back(*it);
@@ -399,8 +400,8 @@ struct range_formatter<
         out, basic_string_view<Char>(buf.data(), buf.size()), specs);
   }
 
-  template <typename Output, typename It, typename Sentinel, typename U = T,
-            FMT_ENABLE_IF(!std::is_same<U, Char>::value)>
+  template <typename Output, typename It, typename Sentinel, typename UT = T,
+            FMT_ENABLE_IF(!std::is_same<UT, Char>::value)>
   auto write_debug_string(Output& out, It, Sentinel) const -> Output {
     return out;
   }
@@ -525,8 +526,8 @@ struct formatter<
   }
 
   template <typename FormatContext>
-  auto format(range_type& range, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
+  auto format(range_type& range,
+              FormatContext& ctx) const -> decltype(ctx.out()) {
     return range_formatter_.format(range, ctx);
   }
 };
@@ -610,8 +611,8 @@ struct formatter<
   }
 
   template <typename FormatContext>
-  auto format(range_type& range, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
+  auto format(range_type& range,
+              FormatContext& ctx) const -> decltype(ctx.out()) {
     auto out = ctx.out();
     if (detail::const_check(range_format_kind<R, Char>::value ==
                             range_format::debug_string))
@@ -658,8 +659,8 @@ struct formatter<join_view<It, Sentinel, Char>, Char> {
   }
 
   template <typename FormatContext>
-  auto format(view_ref& value, FormatContext& ctx) const
-      -> decltype(ctx.out()) {
+  auto format(view_ref& value,
+              FormatContext& ctx) const -> decltype(ctx.out()) {
     auto it = std::forward<view_ref>(value).begin;
     auto out = ctx.out();
     if (it == value.end) return out;
@@ -697,9 +698,9 @@ auto join(It begin, Sentinel end, string_view sep) -> join_view<It, Sentinel> {
  *     // Output: 01, 02, 03
  */
 template <typename Range>
-auto join(Range&& r, string_view sep)
-    -> join_view<decltype(detail::range_begin(r)),
-                 decltype(detail::range_end(r))> {
+auto join(Range&& r,
+          string_view sep) -> join_view<decltype(detail::range_begin(r)),
+                                        decltype(detail::range_end(r))> {
   return {detail::range_begin(r), detail::range_end(r), sep};
 }
 
@@ -780,7 +781,8 @@ namespace detail {
 // Check if T has an interface like a container adaptor (e.g. std::stack,
 // std::queue, std::priority_queue).
 template <typename T> class is_container_adaptor_like {
-  template <typename U> static auto check(U* p) -> typename U::container_type;
+  template <typename UT>
+  static auto check(UT* p) -> typename UT::container_type;
   template <typename> static void check(...);
 
  public:
@@ -826,8 +828,8 @@ FMT_BEGIN_EXPORT
  *     // Output: 1, a
  */
 template <typename... T>
-FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
-    -> tuple_join_view<char, T...> {
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple,
+                        string_view sep) -> tuple_join_view<char, T...> {
   return {tuple, sep};
 }
 
@@ -841,8 +843,8 @@ FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
  *     // Output: "1, 2, 3"
  */
 template <typename T>
-auto join(std::initializer_list<T> list, string_view sep)
-    -> join_view<const T*, const T*> {
+auto join(std::initializer_list<T> list,
+          string_view sep) -> join_view<const T*, const T*> {
   return join(std::begin(list), std::end(list), sep);
 }