[libc++][NFC] Replace typedefs with using in the math headers

[Mordante]

Thanks for addressing this, LGTM!

[philnik]

Rebased

libcxx/include/__math/exponential_functions.h

 }
 
 inline _LIBCPP_HIDE_FROM_ABI long double pow(long double __x, long double __y) _NOEXCEPT {
   return __builtin_powl(__x, __y);
 }
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 inline _LIBCPP_HIDE_FROM_ABI __promote<_A1, _A2>::type pow(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type __result_type;
+  using __result_type = typename __promote<_A1, _A2>::type;
   static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
   return __math::pow((__result_type)__x, (__result_type)__y);
 }
 
 } // namespace __math
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MATH_EXPONENTIAL_FUNCTIONS_H

libcxx/include/__math/fdim.h

 }
 
 inline _LIBCPP_HIDE_FROM_ABI long double fdim(long double __x, long double __y) _NOEXCEPT {
   return __builtin_fdiml(__x, __y);
 }
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 inline _LIBCPP_HIDE_FROM_ABI __promote<_A1, _A2>::type fdim(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type __result_type;
+  using __result_type = typename __promote<_A1, _A2>::type;
   static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
   return __math::fdim((__result_type)__x, (__result_type)__y);
 }
 
 } // namespace __math
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MATH_FDIM_H

libcxx/include/__math/fma.h

inline _LIBCPP_HIDE_FROM_ABI long double fma(long double __x, long double __y, long double __z) _NOEXCEPT {
   return __builtin_fmal(__x, __y, __z);
 }
 
 template <class _A1,
           class _A2,
           class _A3,
           __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value && is_arithmetic<_A3>::value, int> = 0>
 inline _LIBCPP_HIDE_FROM_ABI __promote<_A1, _A2, _A3>::type fma(_A1 __x, _A2 __y, _A3 __z) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2, _A3>::type __result_type;
+  using __result_type = typename __promote<_A1, _A2, _A3>::type;
   static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value &&
                    _IsSame<_A3, __result_type>::value)),
                 "");
   return __builtin_fma((__result_type)__x, (__result_type)__y, (__result_type)__z);
 }
 
 } // namespace __math
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MATH_FMA_H

libcxx/include/__math/hypot.h

 }
 
 inline _LIBCPP_HIDE_FROM_ABI long double hypot(long double __x, long double __y) _NOEXCEPT {
   return __builtin_hypotl(__x, __y);
 }
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 inline _LIBCPP_HIDE_FROM_ABI __promote<_A1, _A2>::type hypot(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type __result_type;
+  using __result_type = typename __promote<_A1, _A2>::type;
   static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
   return __math::hypot((__result_type)__x, (__result_type)__y);
 }
 
 } // namespace __math
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MATH_HYPOT_H

libcxx/include/__math/inverse_trigonometric_functions.h

 }
 
 inline _LIBCPP_HIDE_FROM_ABI long double atan2(long double __y, long double __x) _NOEXCEPT {
   return __builtin_atan2l(__y, __x);
 }
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 inline _LIBCPP_HIDE_FROM_ABI __promote<_A1, _A2>::type atan2(_A1 __y, _A2 __x) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type __result_type;
+  using __result_type = typename __promote<_A1, _A2>::type;
   static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
   return __math::atan2((__result_type)__y, (__result_type)__x);
 }
 
 } // namespace __math
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MATH_INVERSE_TRIGONOMETRIC_FUNCTIONS_H

libcxx/include/__math/min_max.h

 }
 
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double fmax(long double __x, long double __y) _NOEXCEPT {
   return __builtin_fmaxl(__x, __y);
 }
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI __promote<_A1, _A2>::type fmax(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type __result_type;
+  using __result_type = typename __promote<_A1, _A2>::type;
   static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
   return __math::fmax((__result_type)__x, (__result_type)__y);
 }
 
 // fmin
 
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI float fmin(float __x, float __y) _NOEXCEPT {
   return __builtin_fminf(__x, __y);
 }
 
 template <class = int>
 _LIBCPP_NODISCARD_EXT _LIBCPP_HIDE_FROM_ABI double fmin(double __x, double __y) _NOEXCEPT {
   return __builtin_fmin(__x, __y);
 }
 
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI long double fmin(long double __x, long double __y) _NOEXCEPT {
   return __builtin_fminl(__x, __y);
 }
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI __promote<_A1, _A2>::type fmin(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type __result_type;
+  using __result_type = typename __promote<_A1, _A2>::type;
   static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
   return __math::fmin((__result_type)__x, (__result_type)__y);
 }
 
 } // namespace __math
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MATH_MIN_MAX_H

libcxx/include/__math/modulo.h

 }
 
 inline _LIBCPP_HIDE_FROM_ABI long double fmod(long double __x, long double __y) _NOEXCEPT {
   return __builtin_fmodl(__x, __y);
 }
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 inline _LIBCPP_HIDE_FROM_ABI __promote<_A1, _A2>::type fmod(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type __result_type;
+  using __result_type = typename __promote<_A1, _A2>::type;
   static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
   return __math::fmod((__result_type)__x, (__result_type)__y);
 }
 
 // modf
 
 inline _LIBCPP_HIDE_FROM_ABI float modf(float __x, float* __y) _NOEXCEPT { return __builtin_modff(__x, __y); }
 

libcxx/include/__math/remainder.h

 }
 
 inline _LIBCPP_HIDE_FROM_ABI long double remainder(long double __x, long double __y) _NOEXCEPT {
   return __builtin_remainderl(__x, __y);
 }
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 inline _LIBCPP_HIDE_FROM_ABI __promote<_A1, _A2>::type remainder(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type __result_type;
+  using __result_type = typename __promote<_A1, _A2>::type;
   static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
   return __math::remainder((__result_type)__x, (__result_type)__y);
 }
 
 // remquo
 
 inline _LIBCPP_HIDE_FROM_ABI float remquo(float __x, float __y, int* __z) _NOEXCEPT {
   return __builtin_remquof(__x, __y, __z);
 }
 
 template <class = int>
 _LIBCPP_HIDE_FROM_ABI double remquo(double __x, double __y, int* __z) _NOEXCEPT {
   return __builtin_remquo(__x, __y, __z);
 }
 
 inline _LIBCPP_HIDE_FROM_ABI long double remquo(long double __x, long double __y, int* __z) _NOEXCEPT {
   return __builtin_remquol(__x, __y, __z);
 }
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 inline _LIBCPP_HIDE_FROM_ABI __promote<_A1, _A2>::type remquo(_A1 __x, _A2 __y, int* __z) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type __result_type;
+  using __result_type = typename __promote<_A1, _A2>::type;
   static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
   return __math::remquo((__result_type)__x, (__result_type)__y, __z);
 }
 
 } // namespace __math
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MATH_REMAINDER_H

libcxx/include/__math/rounding_functions.h

 }
 
 inline _LIBCPP_HIDE_FROM_ABI long double nextafter(long double __x, long double __y) _NOEXCEPT {
   return __builtin_nextafterl(__x, __y);
 }
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 inline _LIBCPP_HIDE_FROM_ABI __promote<_A1, _A2>::type nextafter(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type __result_type;
+  using __result_type = typename __promote<_A1, _A2>::type;
   static_assert((!(_IsSame<_A1, __result_type>::value && _IsSame<_A2, __result_type>::value)), "");
   return __math::nextafter((__result_type)__x, (__result_type)__y);
 }
 
 // nexttoward
 
 inline _LIBCPP_HIDE_FROM_ABI float nexttoward(float __x, long double __y) _NOEXCEPT {
   return __builtin_nexttowardf(__x, __y);

libcxx/include/__math/traits.h

 _LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnormal(_A1 __x) _NOEXCEPT {
   return __x != 0;
 }
 
 // isgreater
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isgreater(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type type;
+  using type = typename __promote<_A1, _A2>::type;
   return __builtin_isgreater((type)__x, (type)__y);
 }
 
 // isgreaterequal
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type type;
+  using type = typename __promote<_A1, _A2>::type;
   return __builtin_isgreaterequal((type)__x, (type)__y);
 }
 
 // isless
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isless(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type type;
+  using type = typename __promote<_A1, _A2>::type;
   return __builtin_isless((type)__x, (type)__y);
 }
 
 // islessequal
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool islessequal(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type type;
+  using type = typename __promote<_A1, _A2>::type;
   return __builtin_islessequal((type)__x, (type)__y);
 }
 
 // islessgreater
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool islessgreater(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type type;
+  using type = typename __promote<_A1, _A2>::type;
   return __builtin_islessgreater((type)__x, (type)__y);
 }
 
 // isunordered
 
 template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_arithmetic<_A2>::value, int> = 0>
 _LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI bool isunordered(_A1 __x, _A2 __y) _NOEXCEPT {
-  typedef typename __promote<_A1, _A2>::type type;
+  using type = typename __promote<_A1, _A2>::type;
   return __builtin_isunordered((type)__x, (type)__y);
 }
 
 } // namespace __math
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MATH_TRAITS_H