diff --git a/src/corelib/kernel/qmetatype.h b/src/corelib/kernel/qmetatype.h
index 4c92a52f9e..44c6672c50 100644
--- a/src/corelib/kernel/qmetatype.h
+++ b/src/corelib/kernel/qmetatype.h
@@ -1262,7 +1262,7 @@ namespace QtPrivate {
                      | (IsEnumOrFlags<T>::value ? QMetaType::IsEnumeration : 0)
                      | (IsGadgetHelper<T>::IsGadgetOrDerivedFrom ? QMetaType::IsGadget : 0)
                      | (IsPointerToGadgetHelper<T>::IsGadgetOrDerivedFrom ? QMetaType::PointerToGadget : 0)
-                     | (QTypeInfo<T>::isPointer ? QMetaType::IsPointer : 0)
+                     | (std::is_pointer_v<T> ? QMetaType::IsPointer : 0)
                      | (IsUnsignedEnum<T> ? QMetaType::IsUnsignedEnumeration : 0)
                      | (IsQmlListType<T> ? QMetaType::IsQmlList : 0)
                      | (std::is_const_v<std::remove_pointer_t<T>> ? QMetaType::IsConst : 0)
diff --git a/src/corelib/thread/qbasicatomic.h b/src/corelib/thread/qbasicatomic.h
index 93f9648a14..d03c270ed6 100644
--- a/src/corelib/thread/qbasicatomic.h
+++ b/src/corelib/thread/qbasicatomic.h
@@ -30,7 +30,7 @@ public:
     typedef T Type;
     typedef QAtomicOps<T> Ops;
     // static check that this is a valid integer
-    static_assert(QTypeInfo<T>::isIntegral, "template parameter is not an integral type");
+    static_assert(std::is_integral_v<T>, "template parameter is not an integral type");
     static_assert(QAtomicOpsSupport<sizeof(T)>::IsSupported, "template parameter is an integral of a size not supported on this platform");
 
     typename Ops::Type _q_value;
diff --git a/src/corelib/thread/qgenericatomic.h b/src/corelib/thread/qgenericatomic.h
index 4f4f959f43..b8a022a2ac 100644
--- a/src/corelib/thread/qgenericatomic.h
+++ b/src/corelib/thread/qgenericatomic.h
@@ -264,7 +264,7 @@ QT_WARNING_POP
     }
 
     template <typename T> static Q_ALWAYS_INLINE
-    T fetchAndAndRelaxed(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
+    T fetchAndAndRelaxed(T &_q_value, typename std::enable_if<std::is_integral_v<T>, T>::type operand) noexcept
     {
         // implement fetchAndAnd on top of testAndSet
         T tmp = BaseClass::loadRelaxed(_q_value);
@@ -275,7 +275,7 @@ QT_WARNING_POP
     }
 
     template <typename T> static Q_ALWAYS_INLINE
-    T fetchAndAndAcquire(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
+    T fetchAndAndAcquire(T &_q_value, typename std::enable_if<std::is_integral_v<T>, T>::type operand) noexcept
     {
         T tmp = BaseClass::fetchAndAndRelaxed(_q_value, operand);
         BaseClass::acquireMemoryFence(_q_value);
@@ -283,21 +283,21 @@ QT_WARNING_POP
     }
 
     template <typename T> static Q_ALWAYS_INLINE
-    T fetchAndAndRelease(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
+    T fetchAndAndRelease(T &_q_value, typename std::enable_if<std::is_integral_v<T>, T>::type operand) noexcept
     {
         BaseClass::releaseMemoryFence(_q_value);
         return BaseClass::fetchAndAndRelaxed(_q_value, operand);
     }
 
     template <typename T> static Q_ALWAYS_INLINE
-    T fetchAndAndOrdered(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
+    T fetchAndAndOrdered(T &_q_value, typename std::enable_if<std::is_integral_v<T>, T>::type operand) noexcept
     {
         BaseClass::orderedMemoryFence(_q_value);
         return BaseClass::fetchAndAndRelaxed(_q_value, operand);
     }
 
     template <typename T> static Q_ALWAYS_INLINE
-    T fetchAndOrRelaxed(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
+    T fetchAndOrRelaxed(T &_q_value, typename std::enable_if<std::is_integral_v<T>, T>::type operand) noexcept
     {
         // implement fetchAndOr on top of testAndSet
         T tmp = BaseClass::loadRelaxed(_q_value);
@@ -308,7 +308,7 @@ QT_WARNING_POP
     }
 
     template <typename T> static Q_ALWAYS_INLINE
-    T fetchAndOrAcquire(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
+    T fetchAndOrAcquire(T &_q_value, typename std::enable_if<std::is_integral_v<T>, T>::type operand) noexcept
     {
         T tmp = BaseClass::fetchAndOrRelaxed(_q_value, operand);
         BaseClass::acquireMemoryFence(_q_value);
@@ -316,21 +316,21 @@ QT_WARNING_POP
     }
 
     template <typename T> static Q_ALWAYS_INLINE
-    T fetchAndOrRelease(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
+    T fetchAndOrRelease(T &_q_value, typename std::enable_if<std::is_integral_v<T>, T>::type operand) noexcept
     {
         BaseClass::releaseMemoryFence(_q_value);
         return BaseClass::fetchAndOrRelaxed(_q_value, operand);
     }
 
     template <typename T> static Q_ALWAYS_INLINE
-    T fetchAndOrOrdered(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
+    T fetchAndOrOrdered(T &_q_value, typename std::enable_if<std::is_integral_v<T>, T>::type operand) noexcept
     {
         BaseClass::orderedMemoryFence(_q_value);
         return BaseClass::fetchAndOrRelaxed(_q_value, operand);
     }
 
     template <typename T> static Q_ALWAYS_INLINE
-    T fetchAndXorRelaxed(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
+    T fetchAndXorRelaxed(T &_q_value, typename std::enable_if<std::is_integral_v<T>, T>::type operand) noexcept
     {
         // implement fetchAndXor on top of testAndSet
         T tmp = BaseClass::loadRelaxed(_q_value);
@@ -341,7 +341,7 @@ QT_WARNING_POP
     }
 
     template <typename T> static Q_ALWAYS_INLINE
-    T fetchAndXorAcquire(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
+    T fetchAndXorAcquire(T &_q_value, typename std::enable_if<std::is_integral_v<T>, T>::type operand) noexcept
     {
         T tmp = BaseClass::fetchAndXorRelaxed(_q_value, operand);
         BaseClass::acquireMemoryFence(_q_value);
@@ -349,14 +349,14 @@ QT_WARNING_POP
     }
 
     template <typename T> static Q_ALWAYS_INLINE
-    T fetchAndXorRelease(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
+    T fetchAndXorRelease(T &_q_value, typename std::enable_if<std::is_integral_v<T>, T>::type operand) noexcept
     {
         BaseClass::releaseMemoryFence(_q_value);
         return BaseClass::fetchAndXorRelaxed(_q_value, operand);
     }
 
     template <typename T> static Q_ALWAYS_INLINE
-    T fetchAndXorOrdered(T &_q_value, typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type operand) noexcept
+    T fetchAndXorOrdered(T &_q_value, typename std::enable_if<std::is_integral_v<T>, T>::type operand) noexcept
     {
         BaseClass::orderedMemoryFence(_q_value);
         return BaseClass::fetchAndXorRelaxed(_q_value, operand);
diff --git a/src/corelib/thread/qthread_unix.cpp b/src/corelib/thread/qthread_unix.cpp
index 8db27e8209..563c032db4 100644
--- a/src/corelib/thread/qthread_unix.cpp
+++ b/src/corelib/thread/qthread_unix.cpp
@@ -141,25 +141,25 @@ static void clear_thread_data()
 }
 
 template <typename T>
-static typename std::enable_if<QTypeInfo<T>::isIntegral, Qt::HANDLE>::type to_HANDLE(T id)
+static typename std::enable_if<std::is_integral_v<T>, Qt::HANDLE>::type to_HANDLE(T id)
 {
     return reinterpret_cast<Qt::HANDLE>(static_cast<intptr_t>(id));
 }
 
 template <typename T>
-static typename std::enable_if<QTypeInfo<T>::isIntegral, T>::type from_HANDLE(Qt::HANDLE id)
+static typename std::enable_if<std::is_integral_v<T>, T>::type from_HANDLE(Qt::HANDLE id)
 {
     return static_cast<T>(reinterpret_cast<intptr_t>(id));
 }
 
 template <typename T>
-static typename std::enable_if<QTypeInfo<T>::isPointer, Qt::HANDLE>::type to_HANDLE(T id)
+static typename std::enable_if<std::is_pointer_v<T>, Qt::HANDLE>::type to_HANDLE(T id)
 {
     return id;
 }
 
 template <typename T>
-static typename std::enable_if<QTypeInfo<T>::isPointer, T>::type from_HANDLE(Qt::HANDLE id)
+static typename std::enable_if<std::is_pointer_v<T>, T>::type from_HANDLE(Qt::HANDLE id)
 {
     return static_cast<T>(id);
 }