[compiler-rt] aad74dc - [compiler-rt] FuzzedDataProvider: modernize outdated trait patterns (#127811)

[via llvm-commits]

Author: l0rinc
Date: 2025-02-21T10:17:26+01:00
New Revision: aad74dc971f789b2974fde4181f87ee20db2998d

URL: https://github.com/llvm/llvm-project/commit/aad74dc971f789b2974fde4181f87ee20db2998d
DIFF: https://github.com/llvm/llvm-project/commit/aad74dc971f789b2974fde4181f87ee20db2998d.diff

LOG: [compiler-rt] FuzzedDataProvider: modernize outdated trait patterns (#127811)

Added: 
    

Modified: 
    compiler-rt/include/fuzzer/FuzzedDataProvider.h

Removed: 
    


################################################################################
diff  --git a/compiler-rt/include/fuzzer/FuzzedDataProvider.h b/compiler-rt/include/fuzzer/FuzzedDataProvider.h
index e57b95b6304a9..11f2fbdb8c854 100644
--- a/compiler-rt/include/fuzzer/FuzzedDataProvider.h
+++ b/compiler-rt/include/fuzzer/FuzzedDataProvider.h
@@ -203,7 +203,7 @@ template <typename T> T FuzzedDataProvider::ConsumeIntegral() {
 // be less than or equal to |max|.
 template <typename T>
 T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
-  static_assert(std::is_integral<T>::value, "An integral type is required.");
+  static_assert(std::is_integral_v<T>, "An integral type is required.");
   static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
 
   if (min > max)
@@ -271,14 +271,14 @@ T FuzzedDataProvider::ConsumeFloatingPointInRange(T min, T max) {
 // Returns a floating point number in the range [0.0, 1.0]. If there's no
 // input data left, always returns 0.
 template <typename T> T FuzzedDataProvider::ConsumeProbability() {
-  static_assert(std::is_floating_point<T>::value,
+  static_assert(std::is_floating_point_v<T>,
                 "A floating point type is required.");
 
   // Use 
diff erent integral types for 
diff erent floating point types in order
   // to provide better density of the resulting values.
   using IntegralType =
-      typename std::conditional<(sizeof(T) <= sizeof(uint32_t)), uint32_t,
-                                uint64_t>::type;
+      typename std::conditional_t<(sizeof(T) <= sizeof(uint32_t)), uint32_t,
+                                  uint64_t>;
 
   T result = static_cast<T>(ConsumeIntegral<IntegralType>());
   result /= static_cast<T>(std::numeric_limits<IntegralType>::max());
@@ -294,7 +294,7 @@ inline bool FuzzedDataProvider::ConsumeBool() {
 // also contain |kMaxValue| aliased to its largest (inclusive) value. Such as:
 // enum class Foo { SomeValue, OtherValue, kMaxValue = OtherValue };
 template <typename T> T FuzzedDataProvider::ConsumeEnum() {
-  static_assert(std::is_enum<T>::value, "|T| must be an enum type.");
+  static_assert(std::is_enum_v<T>, "|T| must be an enum type.");
   return static_cast<T>(
       ConsumeIntegralInRange<uint32_t>(0, static_cast<uint32_t>(T::kMaxValue)));
 }