From 8d1f841e35de445e098f883dfa15a686057b1243 Mon Sep 17 00:00:00 2001
From: aelovikov-intel <andrei.elovikov@intel.com>
Date: Wed, 7 Dec 2022 08:42:55 -0800
Subject: [PATCH 1/2] [NFC][SYCL] Switch to std:: equivalents for utilities in
 stl_type_traits.hpp

Re-commits #7628 and #7668 that were previously reverted due to build
issues on RHEL systems. The issues were fixed by introducing
`SYCL_LIBDEVICE_GCC_TOOLCHAIN` cmake configuration option in #7771.
---
 sycl/include/CL/__spirv/spirv_ops.hpp         |   6 +-
 sycl/include/sycl/accessor.hpp                | 250 ++++----
 sycl/include/sycl/atomic.hpp                  |   8 +-
 sycl/include/sycl/atomic_ref.hpp              |  17 +-
 sycl/include/sycl/backend/opencl.hpp          |  14 +-
 sycl/include/sycl/buffer.hpp                  |  30 +-
 sycl/include/sycl/builtins.hpp                | 567 +++++++++---------
 sycl/include/sycl/context.hpp                 |   5 +-
 sycl/include/sycl/detail/array.hpp            |  10 +-
 sycl/include/sycl/detail/cg_types.hpp         |  12 +-
 sycl/include/sycl/detail/common.hpp           |   6 +-
 .../sycl/detail/generic_type_lists.hpp        |  51 +-
 .../sycl/detail/generic_type_traits.hpp       | 130 ++--
 sycl/include/sycl/detail/helpers.hpp          |  10 +-
 .../sycl/detail/image_accessor_util.hpp       |  19 +-
 .../sycl/detail/property_list_base.hpp        |  24 +-
 sycl/include/sycl/detail/spirv.hpp            |  94 +--
 sycl/include/sycl/detail/stl_type_traits.hpp  |  40 +-
 .../sycl/detail/sycl_mem_obj_allocator.hpp    |   4 +-
 sycl/include/sycl/detail/type_list.hpp        |  30 +-
 sycl/include/sycl/detail/type_traits.hpp      |  69 ++-
 sycl/include/sycl/detail/vector_traits.hpp    |   6 +-
 sycl/include/sycl/device.hpp                  |   5 +-
 .../ext/intel/esimd/detail/memory_intrin.hpp  |   2 +-
 .../ext/intel/esimd/detail/simd_obj_impl.hpp  |   2 +-
 .../ext/intel/esimd/detail/simd_view_impl.hpp |  17 +-
 .../sycl/ext/intel/esimd/detail/sycl_util.hpp |   2 +-
 sycl/include/sycl/ext/intel/esimd/memory.hpp  |  10 +-
 sycl/include/sycl/ext/intel/esimd/simd.hpp    |   4 +-
 .../ext/intel/experimental/esimd/math.hpp     |   4 +-
 .../ext/intel/experimental/fpga_utils.hpp     |   4 +-
 .../ext/oneapi/accessor_property_list.hpp     |  26 +-
 .../sycl/ext/oneapi/atomic_accessor.hpp       |   6 +-
 sycl/include/sycl/ext/oneapi/atomic_ref.hpp   |  20 +-
 .../sycl/ext/oneapi/backend/level_zero.hpp    |  14 +-
 .../oneapi/device_global/device_global.hpp    |   6 +-
 .../ext/oneapi/device_global/properties.hpp   |   2 +-
 .../sycl/ext/oneapi/experimental/builtins.hpp |   8 +-
 .../ext/oneapi/experimental/group_sort.hpp    |   7 +-
 .../ext/oneapi/experimental/spec_constant.hpp |   7 +-
 .../experimental/user_defined_reductions.hpp  |  10 +-
 sycl/include/sycl/ext/oneapi/functional.hpp   |  12 +-
 .../sycl/ext/oneapi/group_algorithm.hpp       | 288 +++++----
 .../oneapi/kernel_properties/properties.hpp   |   7 +-
 .../sycl/ext/oneapi/properties/properties.hpp |   9 +-
 .../ext/oneapi/properties/property_utils.hpp  |  17 +-
 .../ext/oneapi/properties/property_value.hpp  |   4 +-
 sycl/include/sycl/ext/oneapi/sub_group.hpp    |   8 +-
 .../sycl/ext/oneapi/sub_group_mask.hpp        |  20 +-
 sycl/include/sycl/group.hpp                   |  40 +-
 sycl/include/sycl/group_algorithm.hpp         | 224 +++----
 sycl/include/sycl/handler.hpp                 |  61 +-
 sycl/include/sycl/id.hpp                      |   6 +-
 sycl/include/sycl/image.hpp                   |  18 +-
 sycl/include/sycl/interop_handle.hpp          |   4 +-
 sycl/include/sycl/item.hpp                    |  12 +-
 sycl/include/sycl/kernel_bundle.hpp           |   6 +-
 sycl/include/sycl/known_identity.hpp          |  97 +--
 sycl/include/sycl/multi_ptr.hpp               | 122 ++--
 sycl/include/sycl/nd_item.hpp                 |   8 +-
 sycl/include/sycl/property_list.hpp           |   6 +-
 sycl/include/sycl/queue.hpp                   |  12 +-
 sycl/include/sycl/range.hpp                   |   8 +-
 sycl/include/sycl/reduction.hpp               | 112 ++--
 sycl/include/sycl/stream.hpp                  |  40 +-
 sycl/include/sycl/types.hpp                   | 276 +++++----
 sycl/source/detail/buffer_impl.hpp            |   2 +-
 sycl/source/detail/builtins_geometric.cpp     |  25 +-
 sycl/source/detail/builtins_relational.cpp    |   7 +-
 sycl/source/detail/pi.cpp                     |   2 +-
 sycl/source/detail/sycl_mem_obj_t.hpp         |   4 +-
 71 files changed, 1464 insertions(+), 1551 deletions(-)

diff --git a/sycl/include/CL/__spirv/spirv_ops.hpp b/sycl/include/CL/__spirv/spirv_ops.hpp
index bac846bcb225b..ef2fc51ce7a2e 100644
--- a/sycl/include/CL/__spirv/spirv_ops.hpp
+++ b/sycl/include/CL/__spirv/spirv_ops.hpp
@@ -358,7 +358,7 @@ __spirv_ImageSampleExplicitLod(SampledType, TempArgT, int, float);
 // of atomic min/max based on the type
 #define __SPIRV_ATOMIC_MINMAX(AS, Op)                                          \
   template <typename T>                                                        \
-  typename sycl::detail::enable_if_t<                                          \
+  typename std::enable_if_t<                                                   \
       std::is_integral<T>::value && std::is_signed<T>::value, T>               \
       __spirv_Atomic##Op(AS T *Ptr, __spv::Scope::Flag Memory,                 \
                          __spv::MemorySemanticsMask::Flag Semantics,           \
@@ -366,7 +366,7 @@ __spirv_ImageSampleExplicitLod(SampledType, TempArgT, int, float);
     return __spirv_AtomicS##Op(Ptr, Memory, Semantics, Value);                 \
   }                                                                            \
   template <typename T>                                                        \
-  typename sycl::detail::enable_if_t<                                          \
+  typename std::enable_if_t<                                                   \
       std::is_integral<T>::value && !std::is_signed<T>::value, T>              \
       __spirv_Atomic##Op(AS T *Ptr, __spv::Scope::Flag Memory,                 \
                          __spv::MemorySemanticsMask::Flag Semantics,           \
@@ -374,7 +374,7 @@ __spirv_ImageSampleExplicitLod(SampledType, TempArgT, int, float);
     return __spirv_AtomicU##Op(Ptr, Memory, Semantics, Value);                 \
   }                                                                            \
   template <typename T>                                                        \
-  typename sycl::detail::enable_if_t<std::is_floating_point<T>::value, T>      \
+  typename std::enable_if_t<std::is_floating_point<T>::value, T>               \
       __spirv_Atomic##Op(AS T *Ptr, __spv::Scope::Flag Memory,                 \
                          __spv::MemorySemanticsMask::Flag Semantics,           \
                          T Value) {                                            \
diff --git a/sycl/include/sycl/accessor.hpp b/sycl/include/sycl/accessor.hpp
index 3f6cbaf429f78..51a4cb7998b58 100644
--- a/sycl/include/sycl/accessor.hpp
+++ b/sycl/include/sycl/accessor.hpp
@@ -338,24 +338,22 @@ class accessor_common {
       MIDs[0] = Index;
     }
 
-    template <int CurDims = SubDims,
-              typename = detail::enable_if_t<(CurDims > 1)>>
+    template <int CurDims = SubDims, typename = std::enable_if_t<(CurDims > 1)>>
     auto operator[](size_t Index) {
       MIDs[Dims - CurDims] = Index;
       return AccessorSubscript<CurDims - 1, AccType>(MAccessor, MIDs);
     }
 
     template <int CurDims = SubDims,
-              typename = detail::enable_if_t<
-                  CurDims == 1 && (IsAccessReadOnly || IsAccessAnyWrite)>>
+              typename = std::enable_if_t<CurDims == 1 && (IsAccessReadOnly ||
+                                                           IsAccessAnyWrite)>>
     typename AccType::reference operator[](size_t Index) const {
       MIDs[Dims - CurDims] = Index;
       return MAccessor[MIDs];
     }
 
     template <int CurDims = SubDims>
-    typename detail::enable_if_t<CurDims == 1 && IsAccessAtomic,
-                                 atomic<DataT, AS>>
+    typename std::enable_if_t<CurDims == 1 && IsAccessAtomic, atomic<DataT, AS>>
     operator[](size_t Index) const {
       MIDs[Dims - CurDims] = Index;
       return MAccessor[MIDs];
@@ -740,7 +738,7 @@ class image_accessor
   // accessor(image<dimensions, AllocatorT> &imageRef);
   template <
       typename AllocatorT, int Dims = Dimensions,
-      typename = detail::enable_if_t<(Dims > 0 && Dims <= 3) && IsHostImageAcc>>
+      typename = std::enable_if_t<(Dims > 0 && Dims <= 3) && IsHostImageAcc>>
   image_accessor(image<Dims, AllocatorT> &ImageRef, int ImageElementSize)
 #ifdef __SYCL_DEVICE_ONLY__
   {
@@ -766,9 +764,8 @@ class image_accessor
   // template <typename AllocatorT>
   // accessor(image<dimensions, AllocatorT> &imageRef,
   //          handler &commandGroupHandlerRef);
-  template <
-      typename AllocatorT, int Dims = Dimensions,
-      typename = detail::enable_if_t<(Dims > 0 && Dims <= 3) && IsImageAcc>>
+  template <typename AllocatorT, int Dims = Dimensions,
+            typename = std::enable_if_t<(Dims > 0 && Dims <= 3) && IsImageAcc>>
   image_accessor(image<Dims, AllocatorT> &ImageRef,
                  handler &CommandGroupHandlerRef, int ImageElementSize)
 #ifdef __SYCL_DEVICE_ONLY__
@@ -822,17 +819,17 @@ class image_accessor
   size_t get_count() const { return size(); }
   size_t size() const noexcept { return get_range<Dimensions>().size(); }
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<Dims == 1>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<Dims == 1>>
   range<1> get_range() const {
     int Range = getRangeInternal();
     return range<1>(Range);
   }
-  template <int Dims = Dimensions, typename = detail::enable_if_t<Dims == 2>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<Dims == 2>>
   range<2> get_range() const {
     int2 Range = getRangeInternal();
     return range<2>(Range[0], Range[1]);
   }
-  template <int Dims = Dimensions, typename = detail::enable_if_t<Dims == 3>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<Dims == 3>>
   range<3> get_range() const {
     int3 Range = getRangeInternal();
     return range<3>(Range[0], Range[1], Range[2]);
@@ -843,7 +840,7 @@ class image_accessor
   size_t get_count() const { return size(); };
   size_t size() const noexcept { return MImageCount; };
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<(Dims > 0)>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<(Dims > 0)>>
   range<Dims> get_range() const {
     return detail::convertToArrayOfN<Dims, 1>(getAccessRange());
   }
@@ -855,7 +852,7 @@ class image_accessor
   // || (accessTarget == access::target::host_image && ( accessMode ==
   // access::mode::read || accessMode == access::mode::read_write))
   template <typename CoordT, int Dims = Dimensions,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 (Dims > 0) && (IsValidCoordDataT<Dims, CoordT>::value) &&
                 (detail::is_genint<CoordT>::value) &&
                 ((IsImageAcc && IsImageAccessReadOnly) ||
@@ -875,7 +872,7 @@ class image_accessor
   // || (accessTarget == access::target::host_image && ( accessMode ==
   // access::mode::read || accessMode == access::mode::read_write))
   template <typename CoordT, int Dims = Dimensions,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 (Dims > 0) && (IsValidCoordDataT<Dims, CoordT>::value) &&
                 ((IsImageAcc && IsImageAccessReadOnly) ||
                  (IsHostImageAcc && IsImageAccessAnyRead))>>
@@ -899,7 +896,7 @@ class image_accessor
   // access::mode::write || accessMode == access::mode::discard_write ||
   // accessMode == access::mode::read_write))
   template <typename CoordT, int Dims = Dimensions,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 (Dims > 0) && (detail::is_genint<CoordT>::value) &&
                 (IsValidCoordDataT<Dims, CoordT>::value) &&
                 ((IsImageAcc && IsImageAccessWriteOnly) ||
@@ -955,22 +952,22 @@ class __image_array_slice__ {
       : MBaseAcc(BaseAcc), MIdx(Idx) {}
 
   template <typename CoordT, int Dims = Dimensions,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 (Dims > 0) && (IsValidCoordDataT<Dims, CoordT>::value)>>
   DataT read(const CoordT &Coords) const {
     return MBaseAcc.read(getAdjustedCoords(Coords));
   }
 
   template <typename CoordT, int Dims = Dimensions,
-            typename = detail::enable_if_t<
-                (Dims > 0) && IsValidCoordDataT<Dims, CoordT>::value>>
+            typename = std::enable_if_t<(Dims > 0) &&
+                                        IsValidCoordDataT<Dims, CoordT>::value>>
   DataT read(const CoordT &Coords, const sampler &Smpl) const {
     return MBaseAcc.read(getAdjustedCoords(Coords), Smpl);
   }
 
   template <typename CoordT, int Dims = Dimensions,
-            typename = detail::enable_if_t<
-                (Dims > 0) && IsValidCoordDataT<Dims, CoordT>::value>>
+            typename = std::enable_if_t<(Dims > 0) &&
+                                        IsValidCoordDataT<Dims, CoordT>::value>>
   void write(const CoordT &Coords, const DataT &Color) const {
     return MBaseAcc.write(getAdjustedCoords(Coords), Color);
   }
@@ -980,12 +977,12 @@ class __image_array_slice__ {
   size_t get_count() const { return size(); }
   size_t size() const noexcept { return get_range<Dimensions>().size(); }
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<Dims == 1>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<Dims == 1>>
   range<1> get_range() const {
     int2 Count = MBaseAcc.getRangeInternal();
     return range<1>(Count.x());
   }
-  template <int Dims = Dimensions, typename = detail::enable_if_t<Dims == 2>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<Dims == 2>>
   range<2> get_range() const {
     int3 Count = MBaseAcc.getRangeInternal();
     return range<2>(Count.x(), Count.y());
@@ -1000,7 +997,7 @@ class __image_array_slice__ {
   }
 
   template <int Dims = Dimensions,
-            typename = detail::enable_if_t<(Dims == 1 || Dims == 2)>>
+            typename = std::enable_if_t<(Dims == 1 || Dims == 2)>>
   range<Dims> get_range() const {
     return detail::convertToArrayOfN<Dims, 1>(MBaseAcc.getAccessRange());
   }
@@ -1308,7 +1305,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 public:
   // implicit conversion between const / non-const types for read only accessors
   template <typename DataT_,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 IsAccessReadOnly && !std::is_same_v<DataT_, DataT> &&
                 std::is_same_v<std::remove_const_t<DataT_>,
                                std::remove_const_t<DataT>>>>
@@ -1324,7 +1321,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   // implicit conversion from read_write T accessor to read only T (const)
   // accessor
   template <typename DataT_, access::mode AccessMode_,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 (AccessMode_ == access_mode::read_write) && IsAccessReadOnly &&
                 std::is_same_v<std::remove_const_t<DataT_>,
                                std::remove_const_t<DataT>>>>
@@ -1338,7 +1335,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   }
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename detail::enable_if_t<
+            typename std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 std::is_same<T, DataT>::value && Dims == 0 &&
                 (IsHostBuf || IsHostTask || (IsGlobalBuf || IsConstantBuf))> * =
@@ -1371,7 +1368,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename... PropTypes,
-            typename detail::enable_if_t<
+            typename std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 std::is_same<T, DataT>::value && Dims == 0 &&
                 (IsHostBuf || IsHostTask || (IsGlobalBuf || IsConstantBuf))> * =
@@ -1404,7 +1401,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   }
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = typename detail::enable_if_t<
+            typename = typename std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 std::is_same<T, DataT>::value && (Dims == 0) &&
                 (IsGlobalBuf || IsHostBuf || IsConstantBuf || IsHostTask)>>
@@ -1436,7 +1433,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename... PropTypes,
-            typename = typename detail::enable_if_t<
+            typename = typename std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 std::is_same<T, DataT>::value && (Dims == 0) &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1468,7 +1465,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 #endif
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value &&
                 (IsHostBuf || IsHostTask || (IsGlobalBuf || IsConstantBuf))>>
@@ -1502,7 +1499,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename... PropTypes,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value &&
                 (IsHostBuf || IsHostTask || (IsGlobalBuf || IsConstantBuf))>>
@@ -1537,7 +1534,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename TagT,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value && IsValidTag<TagT>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1551,7 +1548,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename TagT, typename... PropTypes,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value && IsValidTag<TagT>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1565,7 +1562,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   }
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1598,7 +1595,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename... PropTypes,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1632,7 +1629,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename TagT,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value && IsValidTag<TagT>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1646,7 +1643,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename TagT, typename... PropTypes,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value && IsValidTag<TagT>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1661,7 +1658,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   }
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value &&
                 (IsHostBuf || IsHostTask || (IsGlobalBuf || IsConstantBuf))>>
@@ -1673,7 +1670,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename... PropTypes,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value &&
                 (IsHostBuf || IsHostTask || (IsGlobalBuf || IsConstantBuf))>>
@@ -1686,7 +1683,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename TagT,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value && IsValidTag<TagT>::value &&
                 (IsGlobalBuf || IsConstantBuf)>>
@@ -1700,7 +1697,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename TagT, typename... PropTypes,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value && IsValidTag<TagT>::value &&
                 (IsGlobalBuf || IsConstantBuf)>>
@@ -1715,7 +1712,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   }
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1728,7 +1725,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename... PropTypes,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1743,7 +1740,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename TagT,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value && IsValidTag<TagT>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1759,7 +1756,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename TagT, typename... PropTypes,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value && IsValidTag<TagT>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1775,7 +1772,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   }
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value &&
                 (IsHostBuf || IsHostTask || (IsGlobalBuf || IsConstantBuf))>>
@@ -1815,7 +1812,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename... PropTypes,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value &&
                 (IsHostBuf || IsHostTask || (IsGlobalBuf || IsConstantBuf))>>
@@ -1857,7 +1854,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename TagT,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value && IsValidTag<TagT>::value &&
                 (IsGlobalBuf || IsConstantBuf)>>
@@ -1871,7 +1868,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename TagT, typename... PropTypes,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value && IsValidTag<TagT>::value &&
                 (IsGlobalBuf || IsConstantBuf)>>
@@ -1886,7 +1883,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   }
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1927,7 +1924,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename... PropTypes,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1969,7 +1966,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename TagT,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsRunTimePropertyListT<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value && IsValidTag<TagT>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -1985,7 +1982,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
             typename TagT, typename... PropTypes,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 detail::IsCxPropertyList<PropertyListT>::value &&
                 IsSameAsBuffer<T, Dims>::value && IsValidTag<TagT>::value &&
                 (IsGlobalBuf || IsConstantBuf || IsHostBuf || IsHostTask)>>
@@ -2051,12 +2048,12 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   bool empty() const noexcept { return size() == 0; }
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<(Dims > 0)>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<(Dims > 0)>>
   range<Dimensions> get_range() const {
     return detail::convertToArrayOfN<Dimensions, 1>(getAccessRange());
   }
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<(Dims > 0)>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<(Dims > 0)>>
   id<Dimensions> get_offset() const {
     static_assert(
         !(PropertyListT::template has_property<
@@ -2066,54 +2063,54 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   }
 
   template <int Dims = Dimensions, typename RefT = RefType,
-            typename = detail::enable_if_t<Dims == 0 && (IsAccessAnyWrite ||
-                                                         IsAccessReadOnly)>>
+            typename = std::enable_if_t<Dims == 0 &&
+                                        (IsAccessAnyWrite || IsAccessReadOnly)>>
   operator reference() const {
     const size_t LinearIndex = getLinearIndex(id<AdjustedDim>());
     return *(getQualifiedPtr() + LinearIndex);
   }
 
   template <int Dims = Dimensions,
-            typename = detail::enable_if_t<AccessMode != access_mode::atomic &&
-                                           !IsAccessReadOnly && Dims == 0>>
+            typename = std::enable_if_t<AccessMode != access_mode::atomic &&
+                                        !IsAccessReadOnly && Dims == 0>>
   const accessor &operator=(const value_type &Other) const {
     *getQualifiedPtr() = Other;
     return *this;
   }
 
   template <int Dims = Dimensions,
-            typename = detail::enable_if_t<AccessMode != access_mode::atomic &&
-                                           !IsAccessReadOnly && Dims == 0>>
+            typename = std::enable_if_t<AccessMode != access_mode::atomic &&
+                                        !IsAccessReadOnly && Dims == 0>>
   const accessor &operator=(value_type &&Other) const {
     *getQualifiedPtr() = std::move(Other);
     return *this;
   }
 
   template <int Dims = Dimensions,
-            typename = detail::enable_if_t<(Dims > 0) && (IsAccessAnyWrite ||
-                                                          IsAccessReadOnly)>>
+            typename = std::enable_if_t<(Dims > 0) &&
+                                        (IsAccessAnyWrite || IsAccessReadOnly)>>
   reference operator[](id<Dimensions> Index) const {
     const size_t LinearIndex = getLinearIndex(Index);
     return getQualifiedPtr()[LinearIndex];
   }
 
   template <int Dims = Dimensions>
-  operator typename detail::enable_if_t<Dims == 0 &&
-                                            AccessMode == access::mode::atomic,
+  operator typename std::enable_if_t<Dims == 0 &&
+                                         AccessMode == access::mode::atomic,
 #ifdef __ENABLE_USM_ADDR_SPACE__
-                                        atomic<DataT>
+                                     atomic<DataT>
 #else
-                                        atomic<DataT, AS>
+                                     atomic<DataT, AS>
 #endif
-                                        >() const {
+                                     >() const {
     const size_t LinearIndex = getLinearIndex(id<AdjustedDim>());
     return atomic<DataT, AS>(multi_ptr<DataT, AS, access::decorated::yes>(
         getQualifiedPtr() + LinearIndex));
   }
 
   template <int Dims = Dimensions>
-  typename detail::enable_if_t<(Dims > 0) && AccessMode == access::mode::atomic,
-                               atomic<DataT, AS>>
+  typename std::enable_if_t<(Dims > 0) && AccessMode == access::mode::atomic,
+                            atomic<DataT, AS>>
   operator[](id<Dimensions> Index) const {
     const size_t LinearIndex = getLinearIndex(Index);
     return atomic<DataT, AS>(multi_ptr<DataT, AS, access::decorated::yes>(
@@ -2121,20 +2118,20 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   }
 
   template <int Dims = Dimensions>
-  typename detail::enable_if_t<Dims == 1 && AccessMode == access::mode::atomic,
-                               atomic<DataT, AS>>
+  typename std::enable_if_t<Dims == 1 && AccessMode == access::mode::atomic,
+                            atomic<DataT, AS>>
   operator[](size_t Index) const {
     const size_t LinearIndex = getLinearIndex(id<AdjustedDim>(Index));
     return atomic<DataT, AS>(multi_ptr<DataT, AS, access::decorated::yes>(
         getQualifiedPtr() + LinearIndex));
   }
-  template <int Dims = Dimensions, typename = detail::enable_if_t<(Dims > 1)>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<(Dims > 1)>>
   auto operator[](size_t Index) const {
     return AccessorSubscript<Dims - 1>(*this, Index);
   }
 
   template <access::target AccessTarget_ = AccessTarget,
-            typename = detail::enable_if_t<
+            typename = std::enable_if_t<
                 (AccessTarget_ == access::target::host_buffer) ||
                 (AccessTarget_ == access::target::host_task)>>
 #if SYCL_LANGUAGE_VERSION >= 202001
@@ -2148,14 +2145,14 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
   template <
       access::target AccessTarget_ = AccessTarget,
-      typename = detail::enable_if_t<AccessTarget_ == access::target::device>>
+      typename = std::enable_if_t<AccessTarget_ == access::target::device>>
   global_ptr<DataT> get_pointer() const {
     return global_ptr<DataT>(getPointerAdjusted());
   }
 
   template <access::target AccessTarget_ = AccessTarget,
-            typename = detail::enable_if_t<AccessTarget_ ==
-                                           access::target::constant_buffer>>
+            typename = std::enable_if_t<AccessTarget_ ==
+                                        access::target::constant_buffer>>
   constant_ptr<DataT> get_pointer() const {
     return constant_ptr<DataT>(getPointerAdjusted());
   }
@@ -2169,7 +2166,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   // code. This restriction is not listed in the core spec and will be added in
   // future versions.
   template <typename Property>
-  typename sycl::detail::enable_if_t<
+  typename std::enable_if_t<
       !ext::oneapi::is_compile_time_property<Property>::value, bool>
   has_property() const noexcept {
 #ifndef __SYCL_DEVICE_ONLY__
@@ -2183,7 +2180,7 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   // code. This restriction is not listed in the core spec and will be added in
   // future versions.
   template <typename Property,
-            typename = typename sycl::detail::enable_if_t<
+            typename = typename std::enable_if_t<
                 !ext::oneapi::is_compile_time_property<Property>::value>>
   Property get_property() const {
 #ifndef __SYCL_DEVICE_ONLY__
@@ -2586,12 +2583,11 @@ class __SYCL_SPECIAL_CLASS local_accessor_base :
   using reference = DataT &;
   using const_reference = const DataT &;
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<Dims == 0>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<Dims == 0>>
   local_accessor_base(handler &, const detail::code_location CodeLoc =
                                      detail::code_location::current())
 #ifdef __SYCL_DEVICE_ONLY__
-      : impl(range<AdjustedDim>{1}) {
-  }
+      : impl(range<AdjustedDim>{1}){}
 #else
       : LocalAccessorBaseHost(range<3>{1, 1, 1}, AdjustedDim, sizeof(DataT)) {
     detail::constructorNotification(nullptr, LocalAccessorBaseHost::impl.get(),
@@ -2600,10 +2596,10 @@ class __SYCL_SPECIAL_CLASS local_accessor_base :
   }
 #endif
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<Dims == 0>>
-  local_accessor_base(
-      handler &, const property_list &propList,
-      const detail::code_location CodeLoc = detail::code_location::current())
+        template <int Dims = Dimensions, typename = std::enable_if_t<Dims == 0>>
+        local_accessor_base(handler &, const property_list &propList,
+                            const detail::code_location CodeLoc =
+                                detail::code_location::current())
 #ifdef __SYCL_DEVICE_ONLY__
       : impl(range<AdjustedDim>{1}) {
     (void)propList;
@@ -2617,13 +2613,12 @@ class __SYCL_SPECIAL_CLASS local_accessor_base :
   }
 #endif
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<(Dims > 0)>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<(Dims > 0)>>
   local_accessor_base(
       range<Dimensions> AllocationSize, handler &,
       const detail::code_location CodeLoc = detail::code_location::current())
 #ifdef __SYCL_DEVICE_ONLY__
-      : impl(AllocationSize) {
-  }
+      : impl(AllocationSize){}
 #else
       : LocalAccessorBaseHost(detail::convertToArrayOfN<3, 1>(AllocationSize),
                               AdjustedDim, sizeof(DataT)) {
@@ -2633,11 +2628,12 @@ class __SYCL_SPECIAL_CLASS local_accessor_base :
   }
 #endif
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<(Dims > 0)>>
-  local_accessor_base(
-      range<Dimensions> AllocationSize, handler &,
-      const property_list &propList,
-      const detail::code_location CodeLoc = detail::code_location::current())
+        template <int Dims = Dimensions,
+                  typename = std::enable_if_t<(Dims > 0)>>
+        local_accessor_base(range<Dimensions> AllocationSize, handler &,
+                            const property_list &propList,
+                            const detail::code_location CodeLoc =
+                                detail::code_location::current())
 #ifdef __SYCL_DEVICE_ONLY__
       : impl(AllocationSize) {
     (void)propList;
@@ -2657,32 +2653,32 @@ class __SYCL_SPECIAL_CLASS local_accessor_base :
   size_t get_count() const { return size(); }
   size_t size() const noexcept { return getSize().size(); }
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<(Dims > 0)>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<(Dims > 0)>>
   range<Dims> get_range() const {
     return detail::convertToArrayOfN<Dims, 1>(getSize());
   }
 
   template <int Dims = Dimensions,
-            typename = detail::enable_if_t<Dims == 0 && IsAccessAnyWrite>>
+            typename = std::enable_if_t<Dims == 0 && IsAccessAnyWrite>>
   operator RefType() const {
     return *getQualifiedPtr();
   }
 
   template <int Dims = Dimensions,
-            typename = detail::enable_if_t<(Dims > 0) && IsAccessAnyWrite>>
+            typename = std::enable_if_t<(Dims > 0) && IsAccessAnyWrite>>
   RefType operator[](id<Dimensions> Index) const {
     const size_t LinearIndex = getLinearIndex(Index);
     return getQualifiedPtr()[LinearIndex];
   }
 
   template <int Dims = Dimensions,
-            typename = detail::enable_if_t<Dims == 1 && IsAccessAnyWrite>>
+            typename = std::enable_if_t<Dims == 1 && IsAccessAnyWrite>>
   RefType operator[](size_t Index) const {
     return getQualifiedPtr()[Index];
   }
 
   template <int Dims = Dimensions>
-  operator typename detail::enable_if_t<
+  operator typename std::enable_if_t<
       Dims == 0 && AccessMode == access::mode::atomic, atomic<DataT, AS>>()
       const {
     return atomic<DataT, AS>(
@@ -2690,8 +2686,8 @@ class __SYCL_SPECIAL_CLASS local_accessor_base :
   }
 
   template <int Dims = Dimensions>
-  typename detail::enable_if_t<(Dims > 0) && AccessMode == access::mode::atomic,
-                               atomic<DataT, AS>>
+  typename std::enable_if_t<(Dims > 0) && AccessMode == access::mode::atomic,
+                            atomic<DataT, AS>>
   operator[](id<Dimensions> Index) const {
     const size_t LinearIndex = getLinearIndex(Index);
     return atomic<DataT, AS>(multi_ptr<DataT, AS, access::decorated::yes>(
@@ -2699,14 +2695,14 @@ class __SYCL_SPECIAL_CLASS local_accessor_base :
   }
 
   template <int Dims = Dimensions>
-  typename detail::enable_if_t<Dims == 1 && AccessMode == access::mode::atomic,
-                               atomic<DataT, AS>>
+  typename std::enable_if_t<Dims == 1 && AccessMode == access::mode::atomic,
+                            atomic<DataT, AS>>
   operator[](size_t Index) const {
     return atomic<DataT, AS>(multi_ptr<DataT, AS, access::decorated::yes>(
         getQualifiedPtr() + Index));
   }
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<(Dims > 1)>>
+  template <int Dims = Dimensions, typename = std::enable_if_t<(Dims > 1)>>
   typename AccessorCommonT::template AccessorSubscript<
       Dims - 1,
       local_accessor_base<DataT, Dimensions, AccessMode, IsPlaceholder>>
@@ -2878,15 +2874,15 @@ class __SYCL_EBO __SYCL_SPECIAL_CLASS __SYCL_TYPE(local_accessor) local_accessor
 #endif
   }
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<
-                                       !std::is_const_v<DataT> && Dims == 0>>
+  template <int Dims = Dimensions,
+            typename = std::enable_if_t<!std::is_const_v<DataT> && Dims == 0>>
   const local_accessor &operator=(const value_type &Other) const {
     *local_acc::getQualifiedPtr() = Other;
     return *this;
   }
 
-  template <int Dims = Dimensions, typename = detail::enable_if_t<
-                                       !std::is_const_v<DataT> && Dims == 0>>
+  template <int Dims = Dimensions,
+            typename = std::enable_if_t<!std::is_const_v<DataT> && Dims == 0>>
   const local_accessor &operator=(value_type &&Other) const {
     *local_acc::getQualifiedPtr() = std::move(Other);
     return *this;
@@ -3120,7 +3116,7 @@ class __SYCL_EBO host_accessor
   // -------+---------+-------+----+----------+--------------
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = typename detail::enable_if_t<
+            typename = typename std::enable_if_t<
                 std::is_same<T, DataT>::value && Dims == 0>>
   host_accessor(
       buffer<T, 1, AllocatorT> &BufferRef,
@@ -3129,7 +3125,7 @@ class __SYCL_EBO host_accessor
       : AccessorT(BufferRef, PropertyList, CodeLoc) {}
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
+            typename = std::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
   host_accessor(
       buffer<T, Dims, AllocatorT> &BufferRef,
       const property_list &PropertyList = {},
@@ -3137,7 +3133,7 @@ class __SYCL_EBO host_accessor
       : AccessorT(BufferRef, PropertyList, CodeLoc) {}
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
+            typename = std::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
   host_accessor(
       buffer<T, Dims, AllocatorT> &BufferRef, mode_tag_t<AccessMode>,
       const property_list &PropertyList = {},
@@ -3145,7 +3141,7 @@ class __SYCL_EBO host_accessor
       : host_accessor(BufferRef, PropertyList, CodeLoc) {}
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
+            typename = std::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
   host_accessor(
       buffer<T, Dims, AllocatorT> &BufferRef, handler &CommandGroupHandler,
       const property_list &PropertyList = {},
@@ -3153,7 +3149,7 @@ class __SYCL_EBO host_accessor
       : AccessorT(BufferRef, CommandGroupHandler, PropertyList, CodeLoc) {}
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
+            typename = std::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
   host_accessor(
       buffer<T, Dims, AllocatorT> &BufferRef, handler &CommandGroupHandler,
       mode_tag_t<AccessMode>, const property_list &PropertyList = {},
@@ -3161,7 +3157,7 @@ class __SYCL_EBO host_accessor
       : host_accessor(BufferRef, CommandGroupHandler, PropertyList, CodeLoc) {}
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
+            typename = std::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
   host_accessor(
       buffer<T, Dims, AllocatorT> &BufferRef, range<Dimensions> AccessRange,
       const property_list &PropertyList = {},
@@ -3169,7 +3165,7 @@ class __SYCL_EBO host_accessor
       : AccessorT(BufferRef, AccessRange, {}, PropertyList, CodeLoc) {}
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
+            typename = std::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
   host_accessor(
       buffer<T, Dims, AllocatorT> &BufferRef, range<Dimensions> AccessRange,
       mode_tag_t<AccessMode>, const property_list &PropertyList = {},
@@ -3177,7 +3173,7 @@ class __SYCL_EBO host_accessor
       : host_accessor(BufferRef, AccessRange, {}, PropertyList, CodeLoc) {}
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
+            typename = std::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
   host_accessor(
       buffer<T, Dims, AllocatorT> &BufferRef, handler &CommandGroupHandler,
       range<Dimensions> AccessRange, const property_list &PropertyList = {},
@@ -3186,7 +3182,7 @@ class __SYCL_EBO host_accessor
                   CodeLoc) {}
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
+            typename = std::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
   host_accessor(
       buffer<T, Dims, AllocatorT> &BufferRef, handler &CommandGroupHandler,
       range<Dimensions> AccessRange, mode_tag_t<AccessMode>,
@@ -3196,7 +3192,7 @@ class __SYCL_EBO host_accessor
                       PropertyList, CodeLoc) {}
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
+            typename = std::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
   host_accessor(
       buffer<T, Dims, AllocatorT> &BufferRef, range<Dimensions> AccessRange,
       id<Dimensions> AccessOffset, const property_list &PropertyList = {},
@@ -3205,7 +3201,7 @@ class __SYCL_EBO host_accessor
   }
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
+            typename = std::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
   host_accessor(
       buffer<T, Dims, AllocatorT> &BufferRef, range<Dimensions> AccessRange,
       id<Dimensions> AccessOffset, mode_tag_t<AccessMode>,
@@ -3215,7 +3211,7 @@ class __SYCL_EBO host_accessor
                       CodeLoc) {}
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
+            typename = std::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
   host_accessor(
       buffer<T, Dims, AllocatorT> &BufferRef, handler &CommandGroupHandler,
       range<Dimensions> AccessRange, id<Dimensions> AccessOffset,
@@ -3225,7 +3221,7 @@ class __SYCL_EBO host_accessor
                   PropertyList, CodeLoc) {}
 
   template <typename T = DataT, int Dims = Dimensions, typename AllocatorT,
-            typename = detail::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
+            typename = std::enable_if_t<IsSameAsBuffer<T, Dims>::value>>
   host_accessor(
       buffer<T, Dims, AllocatorT> &BufferRef, handler &CommandGroupHandler,
       range<Dimensions> AccessRange, id<Dimensions> AccessOffset,
@@ -3235,8 +3231,8 @@ class __SYCL_EBO host_accessor
                       PropertyList, CodeLoc) {}
 
   template <int Dims = Dimensions,
-            typename = detail::enable_if_t<AccessMode != access_mode::atomic &&
-                                           !IsAccessReadOnly && Dims == 0>>
+            typename = std::enable_if_t<AccessMode != access_mode::atomic &&
+                                        !IsAccessReadOnly && Dims == 0>>
   const host_accessor &
   operator=(const typename AccessorT::value_type &Other) const {
     *AccessorT::getQualifiedPtr() = Other;
@@ -3244,8 +3240,8 @@ class __SYCL_EBO host_accessor
   }
 
   template <int Dims = Dimensions,
-            typename = detail::enable_if_t<AccessMode != access_mode::atomic &&
-                                           !IsAccessReadOnly && Dims == 0>>
+            typename = std::enable_if_t<AccessMode != access_mode::atomic &&
+                                        !IsAccessReadOnly && Dims == 0>>
   const host_accessor &operator=(typename AccessorT::value_type &&Other) const {
     *AccessorT::getQualifiedPtr() = std::move(Other);
     return *this;
diff --git a/sycl/include/sycl/atomic.hpp b/sycl/include/sycl/atomic.hpp
index 697907dc0c45b..beb9174941e30 100644
--- a/sycl/include/sycl/atomic.hpp
+++ b/sycl/include/sycl/atomic.hpp
@@ -210,7 +210,7 @@ class __SYCL2020_DEPRECATED(
 #ifdef __ENABLE_USM_ADDR_SPACE__
   // Create atomic in global_space with one from ext_intel_global_device_space
   template <access::address_space _Space = addressSpace,
-            typename = typename detail::enable_if_t<
+            typename = typename std::enable_if_t<
                 _Space == addressSpace &&
                 addressSpace == access::address_space::global_space>>
   atomic(const atomic<T, access::address_space::ext_intel_global_device_space>
@@ -219,7 +219,7 @@ class __SYCL2020_DEPRECATED(
   }
 
   template <access::address_space _Space = addressSpace,
-            typename = typename detail::enable_if_t<
+            typename = typename std::enable_if_t<
                 _Space == addressSpace &&
                 addressSpace == access::address_space::global_space>>
   atomic(
@@ -235,13 +235,13 @@ class __SYCL2020_DEPRECATED(
 
 #ifdef __SYCL_DEVICE_ONLY__
   template <typename T2 = T>
-  detail::enable_if_t<!std::is_same<cl_float, T2>::value, T>
+  std::enable_if_t<!std::is_same<cl_float, T2>::value, T>
   load(memory_order Order = memory_order::relaxed) const {
     return __spirv_AtomicLoad(Ptr, SpirvScope,
                               detail::getSPIRVMemorySemanticsMask(Order));
   }
   template <typename T2 = T>
-  detail::enable_if_t<std::is_same<cl_float, T2>::value, T>
+  std::enable_if_t<std::is_same<cl_float, T2>::value, T>
   load(memory_order Order = memory_order::relaxed) const {
     auto *TmpPtr = reinterpret_cast<typename multi_ptr<
         cl_int, addressSpace, access::decorated::yes>::pointer>(Ptr);
diff --git a/sycl/include/sycl/atomic_ref.hpp b/sycl/include/sycl/atomic_ref.hpp
index d3297b2708e38..b33a45f0d6be7 100644
--- a/sycl/include/sycl/atomic_ref.hpp
+++ b/sycl/include/sycl/atomic_ref.hpp
@@ -50,9 +50,9 @@ template <sycl::access::address_space AS> struct IsValidAtomicRefAddressSpace {
 
 // DefaultOrder parameter is limited to read-modify-write orders
 template <memory_order Order>
-using IsValidDefaultOrder = bool_constant<Order == memory_order::relaxed ||
-                                          Order == memory_order::acq_rel ||
-                                          Order == memory_order::seq_cst>;
+using IsValidDefaultOrder = std::bool_constant<Order == memory_order::relaxed ||
+                                               Order == memory_order::acq_rel ||
+                                               Order == memory_order::seq_cst>;
 
 template <memory_order ReadModifyWriteOrder> struct memory_order_traits;
 
@@ -90,7 +90,7 @@ inline constexpr memory_order getLoadOrder(memory_order order) {
 template <typename T, typename = void> struct bit_equal;
 
 template <typename T>
-struct bit_equal<T, typename detail::enable_if_t<std::is_integral<T>::value>> {
+struct bit_equal<T, typename std::enable_if_t<std::is_integral<T>::value>> {
   bool operator()(const T &lhs, const T &rhs) { return lhs == rhs; }
 };
 
@@ -275,7 +275,7 @@ template <typename T, bool IsAspectAtomic64AttrUsed, memory_order DefaultOrder,
           memory_scope DefaultScope, access::address_space AddressSpace>
 class atomic_ref_impl<T, IsAspectAtomic64AttrUsed, DefaultOrder, DefaultScope,
                       AddressSpace,
-                      typename detail::enable_if_t<std::is_integral<T>::value>>
+                      typename std::enable_if_t<std::is_integral<T>::value>>
     : public atomic_ref_base<T, DefaultOrder, DefaultScope, AddressSpace> {
 
 public:
@@ -423,7 +423,7 @@ template <typename T, bool IsAspectAtomic64AttrUsed, memory_order DefaultOrder,
           memory_scope DefaultScope, access::address_space AddressSpace>
 class atomic_ref_impl<
     T, IsAspectAtomic64AttrUsed, DefaultOrder, DefaultScope, AddressSpace,
-    typename detail::enable_if_t<std::is_floating_point<T>::value>>
+    typename std::enable_if_t<std::is_floating_point<T>::value>>
     : public atomic_ref_base<T, DefaultOrder, DefaultScope, AddressSpace> {
 
 public:
@@ -536,7 +536,7 @@ class atomic_ref_impl<
 class [[__sycl_detail__::__uses_aspects__(aspect::atomic64)]] atomic_ref_impl<
 #endif
     T, /*IsAspectAtomic64AttrUsed = */ true, DefaultOrder, DefaultScope,
-    AddressSpace, typename detail::enable_if_t<std::is_integral<T>::value>>
+    AddressSpace, typename std::enable_if_t<std::is_integral<T>::value>>
     : public atomic_ref_impl<T, /*IsAspectAtomic64AttrUsed = */ false,
                              DefaultOrder, DefaultScope, AddressSpace> {
 public:
@@ -556,8 +556,7 @@ class atomic_ref_impl<
 class [[__sycl_detail__::__uses_aspects__(aspect::atomic64)]] atomic_ref_impl<
 #endif
     T, /*IsAspectAtomic64AttrUsed = */ true, DefaultOrder, DefaultScope,
-    AddressSpace,
-    typename detail::enable_if_t<std::is_floating_point<T>::value>>
+    AddressSpace, typename std::enable_if_t<std::is_floating_point<T>::value>>
     : public atomic_ref_impl<T, /*IsAspectAtomic64AttrUsed = */ false,
                              DefaultOrder, DefaultScope, AddressSpace> {
 public:
diff --git a/sycl/include/sycl/backend/opencl.hpp b/sycl/include/sycl/backend/opencl.hpp
index f60dddd4b1d8d..bbf06d3a1eddc 100644
--- a/sycl/include/sycl/backend/opencl.hpp
+++ b/sycl/include/sycl/backend/opencl.hpp
@@ -33,7 +33,7 @@ __SYCL_EXPORT bool has_extension(const sycl::device &SyclDevice,
                                  const std::string &Extension);
 
 // Construction of SYCL platform.
-template <typename T, typename detail::enable_if_t<
+template <typename T, typename std::enable_if_t<
                           std::is_same<T, platform>::value> * = nullptr>
 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_platform free function")
 T make(typename detail::interop<backend::opencl, T>::type Interop) {
@@ -41,24 +41,24 @@ T make(typename detail::interop<backend::opencl, T>::type Interop) {
 }
 
 // Construction of SYCL device.
-template <typename T, typename detail::enable_if_t<
-                          std::is_same<T, device>::value> * = nullptr>
+template <typename T,
+          typename std::enable_if_t<std::is_same<T, device>::value> * = nullptr>
 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_device free function")
 T make(typename detail::interop<backend::opencl, T>::type Interop) {
   return make_device(detail::pi::cast<pi_native_handle>(Interop));
 }
 
 // Construction of SYCL context.
-template <typename T, typename detail::enable_if_t<
-                          std::is_same<T, context>::value> * = nullptr>
+template <typename T, typename std::enable_if_t<std::is_same<T, context>::value>
+                          * = nullptr>
 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_context free function")
 T make(typename detail::interop<backend::opencl, T>::type Interop) {
   return make_context(detail::pi::cast<pi_native_handle>(Interop));
 }
 
 // Construction of SYCL queue.
-template <typename T, typename detail::enable_if_t<
-                          std::is_same<T, queue>::value> * = nullptr>
+template <typename T,
+          typename std::enable_if_t<std::is_same<T, queue>::value> * = nullptr>
 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_queue free function")
 T make(const context &Context,
        typename detail::interop<backend::opencl, T>::type Interop) {
diff --git a/sycl/include/sycl/buffer.hpp b/sycl/include/sycl/buffer.hpp
index cfb19822528d5..955e108f64880 100644
--- a/sycl/include/sycl/buffer.hpp
+++ b/sycl/include/sycl/buffer.hpp
@@ -140,8 +140,8 @@ class __SYCL_EXPORT buffer_plain {
 /// \ingroup sycl_api
 template <typename T, int dimensions = 1,
           typename AllocatorT = buffer_allocator<std::remove_const_t<T>>,
-          typename __Enabled = typename detail::enable_if_t<(dimensions > 0) &&
-                                                            (dimensions <= 3)>>
+          typename __Enabled =
+              typename std::enable_if_t<(dimensions > 0) && (dimensions <= 3)>>
 class buffer : public detail::buffer_plain,
                public detail::OwnerLessBase<buffer<T, dimensions, AllocatorT>> {
   // TODO check is_device_copyable<T>::value after converting sycl::vec into a
@@ -155,21 +155,21 @@ class buffer : public detail::buffer_plain,
   using const_reference = const value_type &;
   using allocator_type = AllocatorT;
   template <int dims>
-  using EnableIfOneDimension = typename detail::enable_if_t<1 == dims>;
+  using EnableIfOneDimension = typename std::enable_if_t<1 == dims>;
   // using same requirement for contiguous container as std::span
   template <class Container>
   using EnableIfContiguous =
-      detail::void_t<detail::enable_if_t<std::is_convertible<
-                         detail::remove_pointer_t<
-                             decltype(std::declval<Container>().data())> (*)[],
-                         const T (*)[]>::value>,
-                     decltype(std::declval<Container>().size())>;
+      std::void_t<std::enable_if_t<std::is_convertible<
+                      detail::remove_pointer_t<
+                          decltype(std::declval<Container>().data())> (*)[],
+                      const T (*)[]>::value>,
+                  decltype(std::declval<Container>().size())>;
   template <class It>
-  using EnableIfItInputIterator = detail::enable_if_t<
+  using EnableIfItInputIterator = std::enable_if_t<
       std::is_convertible<typename std::iterator_traits<It>::iterator_category,
                           std::input_iterator_tag>::value>;
   template <typename ItA, typename ItB>
-  using EnableIfSameNonConstIterators = typename detail::enable_if_t<
+  using EnableIfSameNonConstIterators = typename std::enable_if_t<
       std::is_same<ItA, ItB>::value && !std::is_const<ItA>::value, ItA>;
 
   std::array<size_t, 3> rangeToArray(range<3> &r) { return {r[0], r[1], r[2]}; }
@@ -344,9 +344,9 @@ class buffer : public detail::buffer_plain,
               using IteratorValueType =
                   detail::iterator_value_type_t<InputIterator>;
               using IteratorNonConstValueType =
-                  detail::remove_const_t<IteratorValueType>;
+                  std::remove_const_t<IteratorValueType>;
               using IteratorPointerToNonConstValueType =
-                  detail::add_pointer_t<IteratorNonConstValueType>;
+                  std::add_pointer_t<IteratorNonConstValueType>;
               std::copy(first, last,
                         static_cast<IteratorPointerToNonConstValueType>(ToPtr));
             },
@@ -377,9 +377,9 @@ class buffer : public detail::buffer_plain,
               using IteratorValueType =
                   detail::iterator_value_type_t<InputIterator>;
               using IteratorNonConstValueType =
-                  detail::remove_const_t<IteratorValueType>;
+                  std::remove_const_t<IteratorValueType>;
               using IteratorPointerToNonConstValueType =
-                  detail::add_pointer_t<IteratorNonConstValueType>;
+                  std::add_pointer_t<IteratorNonConstValueType>;
               std::copy(first, last,
                         static_cast<IteratorPointerToNonConstValueType>(ToPtr));
             },
@@ -588,7 +588,7 @@ class buffer : public detail::buffer_plain,
   }
 
   template <template <typename WeakT> class WeakPtrT, typename WeakT>
-  detail::enable_if_t<
+  std::enable_if_t<
       std::is_convertible<WeakPtrT<WeakT>, std::weak_ptr<WeakT>>::value>
   set_final_data_internal(WeakPtrT<WeakT> FinalData) {
     std::weak_ptr<WeakT> TempFinalData(FinalData);
diff --git a/sycl/include/sycl/builtins.hpp b/sycl/include/sycl/builtins.hpp
index 8f0a8d3b6a794..f633aad4231b7 100644
--- a/sycl/include/sycl/builtins.hpp
+++ b/sycl/include/sycl/builtins.hpp
@@ -320,206 +320,203 @@ __SYCL_MATH_FUNCTION_3_OVERLOAD(mad) __SYCL_MATH_FUNCTION_3_OVERLOAD(mix)
 
     // svgenfloat acos (svgenfloat x)
     template <typename T>
-    detail::enable_if_t<detail::is_svgenfloat<T>::value, T> acos(T x) __NOEXC {
+    std::enable_if_t<detail::is_svgenfloat<T>::value, T> acos(T x) __NOEXC {
   return __sycl_std::__invoke_acos<T>(x);
 }
 
 // svgenfloat acosh (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> acosh(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> acosh(T x) __NOEXC {
   return __sycl_std::__invoke_acosh<T>(x);
 }
 
 // svgenfloat acospi (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> acospi(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> acospi(T x) __NOEXC {
   return __sycl_std::__invoke_acospi<T>(x);
 }
 
 // svgenfloat asin (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> asin(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> asin(T x) __NOEXC {
   return __sycl_std::__invoke_asin<T>(x);
 }
 
 // svgenfloat asinh (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> asinh(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> asinh(T x) __NOEXC {
   return __sycl_std::__invoke_asinh<T>(x);
 }
 
 // svgenfloat asinpi (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> asinpi(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> asinpi(T x) __NOEXC {
   return __sycl_std::__invoke_asinpi<T>(x);
 }
 
 // svgenfloat atan (svgenfloat y_over_x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T>
-atan(T y_over_x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> atan(T y_over_x) __NOEXC {
   return __sycl_std::__invoke_atan<T>(y_over_x);
 }
 
 // svgenfloat atan2 (svgenfloat y, svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> atan2(T y,
-                                                              T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> atan2(T y, T x) __NOEXC {
   return __sycl_std::__invoke_atan2<T>(y, x);
 }
 
 // svgenfloat atanh (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> atanh(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> atanh(T x) __NOEXC {
   return __sycl_std::__invoke_atanh<T>(x);
 }
 
 // svgenfloat atanpi (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> atanpi(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> atanpi(T x) __NOEXC {
   return __sycl_std::__invoke_atanpi<T>(x);
 }
 
 // svgenfloat atan2pi (svgenfloat y, svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> atan2pi(T y,
-                                                                T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> atan2pi(T y, T x) __NOEXC {
   return __sycl_std::__invoke_atan2pi<T>(y, x);
 }
 
 // svgenfloat cbrt (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> cbrt(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> cbrt(T x) __NOEXC {
   return __sycl_std::__invoke_cbrt<T>(x);
 }
 
 // svgenfloat ceil (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> ceil(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> ceil(T x) __NOEXC {
   return __sycl_std::__invoke_ceil<T>(x);
 }
 
 // svgenfloat copysign (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> copysign(T x,
-                                                                 T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> copysign(T x,
+                                                              T y) __NOEXC {
   return __sycl_std::__invoke_copysign<T>(x, y);
 }
 
 // svgenfloat cos (svgenfloat x)
 template <typename T>
-detail::enable_if_t<__FAST_MATH_GENFLOAT(T), T> cos(T x) __NOEXC {
+std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> cos(T x) __NOEXC {
   return __sycl_std::__invoke_cos<T>(x);
 }
 
 // svgenfloat cosh (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> cosh(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> cosh(T x) __NOEXC {
   return __sycl_std::__invoke_cosh<T>(x);
 }
 
 // svgenfloat cospi (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> cospi(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> cospi(T x) __NOEXC {
   return __sycl_std::__invoke_cospi<T>(x);
 }
 
 // svgenfloat erfc (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> erfc(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> erfc(T x) __NOEXC {
   return __sycl_std::__invoke_erfc<T>(x);
 }
 
 // svgenfloat erf (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> erf(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> erf(T x) __NOEXC {
   return __sycl_std::__invoke_erf<T>(x);
 }
 
 // svgenfloat exp (svgenfloat x )
 template <typename T>
-detail::enable_if_t<__FAST_MATH_GENFLOAT(T), T> exp(T x) __NOEXC {
+std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> exp(T x) __NOEXC {
   return __sycl_std::__invoke_exp<T>(x);
 }
 
 // svgenfloat exp2 (svgenfloat x)
 template <typename T>
-detail::enable_if_t<__FAST_MATH_GENFLOAT(T), T> exp2(T x) __NOEXC {
+std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> exp2(T x) __NOEXC {
   return __sycl_std::__invoke_exp2<T>(x);
 }
 
 // svgenfloat exp10 (svgenfloat x)
 template <typename T>
-detail::enable_if_t<__FAST_MATH_GENFLOAT(T), T> exp10(T x) __NOEXC {
+std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> exp10(T x) __NOEXC {
   return __sycl_std::__invoke_exp10<T>(x);
 }
 
 // svgenfloat expm1 (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> expm1(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> expm1(T x) __NOEXC {
   return __sycl_std::__invoke_expm1<T>(x);
 }
 
 // svgenfloat fabs (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> fabs(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> fabs(T x) __NOEXC {
   return __sycl_std::__invoke_fabs<T>(x);
 }
 
 // svgenfloat fdim (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> fdim(T x, T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> fdim(T x, T y) __NOEXC {
   return __sycl_std::__invoke_fdim<T>(x, y);
 }
 
 // svgenfloat floor (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> floor(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> floor(T x) __NOEXC {
   return __sycl_std::__invoke_floor<T>(x);
 }
 
 // svgenfloat fma (svgenfloat a, svgenfloat b, svgenfloat c)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> fma(T a, T b,
-                                                            T c) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> fma(T a, T b,
+                                                         T c) __NOEXC {
   return __sycl_std::__invoke_fma<T>(a, b, c);
 }
 
 // svgenfloat fmax (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> fmax(T x, T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> fmax(T x, T y) __NOEXC {
   return __sycl_std::__invoke_fmax<T>(x, y);
 }
 
 // svgenfloat fmax (svgenfloat x, sgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_vgenfloat<T>::value, T>
+std::enable_if_t<detail::is_vgenfloat<T>::value, T>
 fmax(T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_fmax<T>(x, T(y));
 }
 
 // svgenfloat fmin (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> fmin(T x, T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> fmin(T x, T y) __NOEXC {
   return __sycl_std::__invoke_fmin<T>(x, y);
 }
 
 // svgenfloat fmin (svgenfloat x, sgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_vgenfloat<T>::value, T>
+std::enable_if_t<detail::is_vgenfloat<T>::value, T>
 fmin(T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_fmin<T>(x, T(y));
 }
 
 // svgenfloat fmod (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> fmod(T x, T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> fmod(T x, T y) __NOEXC {
   return __sycl_std::__invoke_fmod<T>(x, y);
 }
 
 // svgenfloat fract (svgenfloat x, genfloatptr iptr)
 template <typename T, typename T2>
-detail::enable_if_t<
+std::enable_if_t<
     detail::is_svgenfloat<T>::value && detail::is_genfloatptr<T2>::value, T>
 fract(T x, T2 iptr) __NOEXC {
   detail::check_vector_size<T, T2>();
@@ -528,7 +525,7 @@ fract(T x, T2 iptr) __NOEXC {
 
 // svgenfloat frexp (svgenfloat x, genintptr exp)
 template <typename T, typename T2>
-detail::enable_if_t<
+std::enable_if_t<
     detail::is_svgenfloat<T>::value && detail::is_genintptr<T2>::value, T>
 frexp(T x, T2 exp) __NOEXC {
   detail::check_vector_size<T, T2>();
@@ -537,14 +534,13 @@ frexp(T x, T2 exp) __NOEXC {
 
 // svgenfloat hypot (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> hypot(T x,
-                                                              T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> hypot(T x, T y) __NOEXC {
   return __sycl_std::__invoke_hypot<T>(x, y);
 }
 
 // genint ilogb (svgenfloat x)
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::change_base_type_t<T, int> ilogb(T x) __NOEXC {
   return __sycl_std::__invoke_ilogb<detail::change_base_type_t<T, int>>(x);
 }
@@ -553,22 +549,20 @@ detail::change_base_type_t<T, int> ilogb(T x) __NOEXC {
 // double ldexp (double x, int k)
 // half ldexp (half x, int k)
 template <typename T>
-detail::enable_if_t<detail::is_sgenfloat<T>::value, T> ldexp(T x,
-                                                             int k) __NOEXC {
+std::enable_if_t<detail::is_sgenfloat<T>::value, T> ldexp(T x, int k) __NOEXC {
   return __sycl_std::__invoke_ldexp<T>(x, k);
 }
 
 // vgenfloat ldexp (vgenfloat x, int k)
 template <typename T>
-detail::enable_if_t<detail::is_vgenfloat<T>::value, T> ldexp(T x,
-                                                             int k) __NOEXC {
+std::enable_if_t<detail::is_vgenfloat<T>::value, T> ldexp(T x, int k) __NOEXC {
   return __sycl_std::__invoke_ldexp<T>(x, vec<int, T::size()>(k));
 }
 
 // vgenfloat ldexp (vgenfloat x, genint k)
 template <typename T, typename T2>
-detail::enable_if_t<
-    detail::is_vgenfloat<T>::value && detail::is_intn<T2>::value, T>
+std::enable_if_t<detail::is_vgenfloat<T>::value && detail::is_intn<T2>::value,
+                 T>
 ldexp(T x, T2 k) __NOEXC {
   detail::check_vector_size<T, T2>();
   return __sycl_std::__invoke_ldexp<T>(x, k);
@@ -576,13 +570,13 @@ ldexp(T x, T2 k) __NOEXC {
 
 // svgenfloat lgamma (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> lgamma(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> lgamma(T x) __NOEXC {
   return __sycl_std::__invoke_lgamma<T>(x);
 }
 
 // svgenfloat lgamma_r (svgenfloat x, genintptr signp)
 template <typename T, typename T2>
-detail::enable_if_t<
+std::enable_if_t<
     detail::is_svgenfloat<T>::value && detail::is_genintptr<T2>::value, T>
 lgamma_r(T x, T2 signp) __NOEXC {
   detail::check_vector_size<T, T2>();
@@ -591,58 +585,56 @@ lgamma_r(T x, T2 signp) __NOEXC {
 
 // svgenfloat log (svgenfloat x)
 template <typename T>
-detail::enable_if_t<__FAST_MATH_GENFLOAT(T), T> log(T x) __NOEXC {
+std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> log(T x) __NOEXC {
   return __sycl_std::__invoke_log<T>(x);
 }
 
 // svgenfloat log2 (svgenfloat x)
 template <typename T>
-detail::enable_if_t<__FAST_MATH_GENFLOAT(T), T> log2(T x) __NOEXC {
+std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> log2(T x) __NOEXC {
   return __sycl_std::__invoke_log2<T>(x);
 }
 
 // svgenfloat log10 (svgenfloat x)
 template <typename T>
-detail::enable_if_t<__FAST_MATH_GENFLOAT(T), T> log10(T x) __NOEXC {
+std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> log10(T x) __NOEXC {
   return __sycl_std::__invoke_log10<T>(x);
 }
 
 // svgenfloat log1p (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> log1p(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> log1p(T x) __NOEXC {
   return __sycl_std::__invoke_log1p<T>(x);
 }
 
 // svgenfloat logb (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> logb(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> logb(T x) __NOEXC {
   return __sycl_std::__invoke_logb<T>(x);
 }
 
 // svgenfloat mad (svgenfloat a, svgenfloat b, svgenfloat c)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> mad(T a, T b,
-                                                            T c) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> mad(T a, T b,
+                                                         T c) __NOEXC {
   return __sycl_std::__invoke_mad<T>(a, b, c);
 }
 
 // svgenfloat maxmag (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> maxmag(T x,
-                                                               T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> maxmag(T x, T y) __NOEXC {
   return __sycl_std::__invoke_maxmag<T>(x, y);
 }
 
 // svgenfloat minmag (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> minmag(T x,
-                                                               T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> minmag(T x, T y) __NOEXC {
   return __sycl_std::__invoke_minmag<T>(x, y);
 }
 
 // svgenfloat modf (svgenfloat x, genfloatptr iptr)
 template <typename T, typename T2>
-detail::enable_if_t<
+std::enable_if_t<
     detail::is_svgenfloat<T>::value && detail::is_genfloatptr<T2>::value, T>
 modf(T x, T2 iptr) __NOEXC {
   detail::check_vector_size<T, T2>();
@@ -650,7 +642,7 @@ modf(T x, T2 iptr) __NOEXC {
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_nan_type<T>::value, T>>
+          typename = std::enable_if_t<detail::is_nan_type<T>::value, T>>
 detail::nan_return_t<T> nan(T nancode) __NOEXC {
   return __sycl_std::__invoke_nan<detail::nan_return_t<T>>(
       detail::convert_data_type<T, detail::nan_argument_base_t<T>>()(nancode));
@@ -658,20 +650,20 @@ detail::nan_return_t<T> nan(T nancode) __NOEXC {
 
 // svgenfloat nextafter (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> nextafter(T x,
-                                                                  T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> nextafter(T x,
+                                                               T y) __NOEXC {
   return __sycl_std::__invoke_nextafter<T>(x, y);
 }
 
 // svgenfloat pow (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> pow(T x, T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> pow(T x, T y) __NOEXC {
   return __sycl_std::__invoke_pow<T>(x, y);
 }
 
 // svgenfloat pown (svgenfloat x, genint y)
 template <typename T, typename T2>
-detail::enable_if_t<
+std::enable_if_t<
     detail::is_svgenfloat<T>::value && detail::is_genint<T2>::value, T>
 pown(T x, T2 y) __NOEXC {
   detail::check_vector_size<T, T2>();
@@ -680,20 +672,20 @@ pown(T x, T2 y) __NOEXC {
 
 // svgenfloat powr (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<__FAST_MATH_GENFLOAT(T), T> powr(T x, T y) __NOEXC {
+std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> powr(T x, T y) __NOEXC {
   return __sycl_std::__invoke_powr<T>(x, y);
 }
 
 // svgenfloat remainder (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> remainder(T x,
-                                                                  T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> remainder(T x,
+                                                               T y) __NOEXC {
   return __sycl_std::__invoke_remainder<T>(x, y);
 }
 
 // svgenfloat remquo (svgenfloat x, svgenfloat y, genintptr quo)
 template <typename T, typename T2>
-detail::enable_if_t<
+std::enable_if_t<
     detail::is_svgenfloat<T>::value && detail::is_genintptr<T2>::value, T>
 remquo(T x, T y, T2 quo) __NOEXC {
   detail::check_vector_size<T, T2>();
@@ -702,13 +694,13 @@ remquo(T x, T y, T2 quo) __NOEXC {
 
 // svgenfloat rint (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> rint(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> rint(T x) __NOEXC {
   return __sycl_std::__invoke_rint<T>(x);
 }
 
 // svgenfloat rootn (svgenfloat x, genint y)
 template <typename T, typename T2>
-detail::enable_if_t<
+std::enable_if_t<
     detail::is_svgenfloat<T>::value && detail::is_genint<T2>::value, T>
 rootn(T x, T2 y) __NOEXC {
   detail::check_vector_size<T, T2>();
@@ -717,25 +709,25 @@ rootn(T x, T2 y) __NOEXC {
 
 // svgenfloat round (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> round(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> round(T x) __NOEXC {
   return __sycl_std::__invoke_round<T>(x);
 }
 
 // svgenfloat rsqrt (svgenfloat x)
 template <typename T>
-detail::enable_if_t<__FAST_MATH_GENFLOAT(T), T> rsqrt(T x) __NOEXC {
+std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> rsqrt(T x) __NOEXC {
   return __sycl_std::__invoke_rsqrt<T>(x);
 }
 
 // svgenfloat sin (svgenfloat x)
 template <typename T>
-detail::enable_if_t<__FAST_MATH_GENFLOAT(T), T> sin(T x) __NOEXC {
+std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> sin(T x) __NOEXC {
   return __sycl_std::__invoke_sin<T>(x);
 }
 
 // svgenfloat sincos (svgenfloat x, genfloatptr cosval)
 template <typename T, typename T2>
-detail::enable_if_t<
+std::enable_if_t<
     detail::is_svgenfloat<T>::value && detail::is_genfloatptr<T2>::value, T>
 sincos(T x, T2 cosval) __NOEXC {
   detail::check_vector_size<T, T2>();
@@ -744,49 +736,49 @@ sincos(T x, T2 cosval) __NOEXC {
 
 // svgenfloat sinh (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> sinh(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> sinh(T x) __NOEXC {
   return __sycl_std::__invoke_sinh<T>(x);
 }
 
 // svgenfloat sinpi (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> sinpi(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> sinpi(T x) __NOEXC {
   return __sycl_std::__invoke_sinpi<T>(x);
 }
 
 // svgenfloat sqrt (svgenfloat x)
 template <typename T>
-detail::enable_if_t<__FAST_MATH_GENFLOAT(T), T> sqrt(T x) __NOEXC {
+std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> sqrt(T x) __NOEXC {
   return __sycl_std::__invoke_sqrt<T>(x);
 }
 
 // svgenfloat tan (svgenfloat x)
 template <typename T>
-detail::enable_if_t<__FAST_MATH_GENFLOAT(T), T> tan(T x) __NOEXC {
+std::enable_if_t<__FAST_MATH_GENFLOAT(T), T> tan(T x) __NOEXC {
   return __sycl_std::__invoke_tan<T>(x);
 }
 
 // svgenfloat tanh (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> tanh(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> tanh(T x) __NOEXC {
   return __sycl_std::__invoke_tanh<T>(x);
 }
 
 // svgenfloat tanpi (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> tanpi(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> tanpi(T x) __NOEXC {
   return __sycl_std::__invoke_tanpi<T>(x);
 }
 
 // svgenfloat tgamma (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> tgamma(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> tgamma(T x) __NOEXC {
   return __sycl_std::__invoke_tgamma<T>(x);
 }
 
 // svgenfloat trunc (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> trunc(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> trunc(T x) __NOEXC {
   return __sycl_std::__invoke_trunc<T>(x);
 }
 
@@ -882,8 +874,8 @@ nan(marray<T, N> nancode) __NOEXC {
 /* --------------- 4.13.5 Common functions. ---------------------------------*/
 // svgenfloat clamp (svgenfloat x, svgenfloat minval, svgenfloat maxval)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T>
-clamp(T x, T minval, T maxval) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> clamp(T x, T minval,
+                                                           T maxval) __NOEXC {
   return __sycl_std::__invoke_fclamp<T>(x, minval, maxval);
 }
 
@@ -891,7 +883,7 @@ clamp(T x, T minval, T maxval) __NOEXC {
 // vgenfloatf clamp (vgenfloatf x, float minval, float maxval)
 // vgenfloatd clamp (vgenfloatd x, double minval, double maxval)
 template <typename T>
-detail::enable_if_t<detail::is_vgenfloat<T>::value, T>
+std::enable_if_t<detail::is_vgenfloat<T>::value, T>
 clamp(T x, typename T::element_type minval,
       typename T::element_type maxval) __NOEXC {
   return __sycl_std::__invoke_fclamp<T>(x, T(minval), T(maxval));
@@ -899,20 +891,20 @@ clamp(T x, typename T::element_type minval,
 
 // svgenfloat degrees (svgenfloat radians)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T>
+std::enable_if_t<detail::is_svgenfloat<T>::value, T>
 degrees(T radians) __NOEXC {
   return __sycl_std::__invoke_degrees<T>(radians);
 }
 
 // svgenfloat abs (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> abs(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> abs(T x) __NOEXC {
   return __sycl_std::__invoke_fabs<T>(x);
 }
 
 // svgenfloat max (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T>(max)(T x, T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T>(max)(T x, T y) __NOEXC {
   return __sycl_std::__invoke_fmax_common<T>(x, y);
 }
 
@@ -920,14 +912,14 @@ detail::enable_if_t<detail::is_svgenfloat<T>::value, T>(max)(T x, T y) __NOEXC {
 // vgenfloatd max (vgenfloatd x, double y)
 // vgenfloath max (vgenfloath x, half y)
 template <typename T>
-detail::enable_if_t<detail::is_vgenfloat<T>::value, T>(max)(
+std::enable_if_t<detail::is_vgenfloat<T>::value, T>(max)(
     T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_fmax_common<T>(x, T(y));
 }
 
 // svgenfloat min (svgenfloat x, svgenfloat y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T>(min)(T x, T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T>(min)(T x, T y) __NOEXC {
   return __sycl_std::__invoke_fmin_common<T>(x, y);
 }
 
@@ -935,15 +927,15 @@ detail::enable_if_t<detail::is_svgenfloat<T>::value, T>(min)(T x, T y) __NOEXC {
 // vgenfloatd min (vgenfloatd x, double y)
 // vgenfloath min (vgenfloath x, half y)
 template <typename T>
-detail::enable_if_t<detail::is_vgenfloat<T>::value, T>(min)(
+std::enable_if_t<detail::is_vgenfloat<T>::value, T>(min)(
     T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_fmin_common<T>(x, T(y));
 }
 
 // svgenfloat mix (svgenfloat x, svgenfloat y, svgenfloat a)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> mix(T x, T y,
-                                                            T a) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> mix(T x, T y,
+                                                         T a) __NOEXC {
   return __sycl_std::__invoke_mix<T>(x, y, a);
 }
 
@@ -951,22 +943,21 @@ detail::enable_if_t<detail::is_svgenfloat<T>::value, T> mix(T x, T y,
 // vgenfloatd mix (vgenfloatd x, vgenfloatd y, double a)
 // vgenfloatd mix (vgenfloath x, vgenfloath y, half a)
 template <typename T>
-detail::enable_if_t<detail::is_vgenfloat<T>::value, T>
+std::enable_if_t<detail::is_vgenfloat<T>::value, T>
 mix(T x, T y, typename T::element_type a) __NOEXC {
   return __sycl_std::__invoke_mix<T>(x, y, T(a));
 }
 
 // svgenfloat radians (svgenfloat degrees)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T>
+std::enable_if_t<detail::is_svgenfloat<T>::value, T>
 radians(T degrees) __NOEXC {
   return __sycl_std::__invoke_radians<T>(degrees);
 }
 
 // svgenfloat step (svgenfloat edge, svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> step(T edge,
-                                                             T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> step(T edge, T x) __NOEXC {
   return __sycl_std::__invoke_step<T>(edge, x);
 }
 
@@ -974,14 +965,14 @@ detail::enable_if_t<detail::is_svgenfloat<T>::value, T> step(T edge,
 // vgenfloatd step (double edge, vgenfloatd x)
 // vgenfloatd step (half edge, vgenfloath x)
 template <typename T>
-detail::enable_if_t<detail::is_vgenfloat<T>::value, T>
+std::enable_if_t<detail::is_vgenfloat<T>::value, T>
 step(typename T::element_type edge, T x) __NOEXC {
   return __sycl_std::__invoke_step<T>(T(edge), x);
 }
 
 // svgenfloat smoothstep (svgenfloat edge0, svgenfloat edge1, svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T>
+std::enable_if_t<detail::is_svgenfloat<T>::value, T>
 smoothstep(T edge0, T edge1, T x) __NOEXC {
   return __sycl_std::__invoke_smoothstep<T>(edge0, edge1, x);
 }
@@ -990,7 +981,7 @@ smoothstep(T edge0, T edge1, T x) __NOEXC {
 // vgenfloatd smoothstep (double edge0, double edge1, vgenfloatd x)
 // vgenfloath smoothstep (half edge0, half edge1, vgenfloath x)
 template <typename T>
-detail::enable_if_t<detail::is_vgenfloat<T>::value, T>
+std::enable_if_t<detail::is_vgenfloat<T>::value, T>
 smoothstep(typename T::element_type edge0, typename T::element_type edge1,
            T x) __NOEXC {
   return __sycl_std::__invoke_smoothstep<T>(T(edge0), T(edge1), x);
@@ -998,7 +989,7 @@ smoothstep(typename T::element_type edge0, typename T::element_type edge1,
 
 // svgenfloat sign (svgenfloat x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloat<T>::value, T> sign(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloat<T>::value, T> sign(T x) __NOEXC {
   return __sycl_std::__invoke_sign<T>(x);
 }
 
@@ -1080,13 +1071,13 @@ __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD(
 /* --------------- 4.13.4 Integer functions. --------------------------------*/
 // ugeninteger abs (geninteger x)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T> abs(T x) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger<T>::value, T> abs(T x) __NOEXC {
   return __sycl_std::__invoke_u_abs<T>(x);
 }
 
 // igeninteger abs (geninteger x)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T> abs(T x) __NOEXC {
+std::enable_if_t<detail::is_igeninteger<T>::value, T> abs(T x) __NOEXC {
   auto res = __sycl_std::__invoke_s_abs<detail::make_unsigned_t<T>>(x);
   if constexpr (detail::is_vigeninteger<T>::value) {
     return res.template convert<detail::vector_element_t<T>>();
@@ -1096,78 +1087,73 @@ detail::enable_if_t<detail::is_igeninteger<T>::value, T> abs(T x) __NOEXC {
 
 // ugeninteger abs_diff (geninteger x, geninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T> abs_diff(T x,
-                                                                  T y) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger<T>::value, T> abs_diff(T x,
+                                                               T y) __NOEXC {
   return __sycl_std::__invoke_u_abs_diff<T>(x, y);
 }
 
 // ugeninteger abs_diff (geninteger x, geninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value,
-                    detail::make_unsigned_t<T>>
+std::enable_if_t<detail::is_igeninteger<T>::value, detail::make_unsigned_t<T>>
 abs_diff(T x, T y) __NOEXC {
   return __sycl_std::__invoke_s_abs_diff<detail::make_unsigned_t<T>>(x, y);
 }
 
 // geninteger add_sat (geninteger x, geninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T> add_sat(T x,
-                                                                 T y) __NOEXC {
+std::enable_if_t<detail::is_igeninteger<T>::value, T> add_sat(T x,
+                                                              T y) __NOEXC {
   return __sycl_std::__invoke_s_add_sat<T>(x, y);
 }
 
 // geninteger add_sat (geninteger x, geninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T> add_sat(T x,
-                                                                 T y) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger<T>::value, T> add_sat(T x,
+                                                              T y) __NOEXC {
   return __sycl_std::__invoke_u_add_sat<T>(x, y);
 }
 
 // geninteger hadd (geninteger x, geninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T> hadd(T x,
-                                                              T y) __NOEXC {
+std::enable_if_t<detail::is_igeninteger<T>::value, T> hadd(T x, T y) __NOEXC {
   return __sycl_std::__invoke_s_hadd<T>(x, y);
 }
 
 // geninteger hadd (geninteger x, geninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T> hadd(T x,
-                                                              T y) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger<T>::value, T> hadd(T x, T y) __NOEXC {
   return __sycl_std::__invoke_u_hadd<T>(x, y);
 }
 
 // geninteger rhadd (geninteger x, geninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T> rhadd(T x,
-                                                               T y) __NOEXC {
+std::enable_if_t<detail::is_igeninteger<T>::value, T> rhadd(T x, T y) __NOEXC {
   return __sycl_std::__invoke_s_rhadd<T>(x, y);
 }
 
 // geninteger rhadd (geninteger x, geninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T> rhadd(T x,
-                                                               T y) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger<T>::value, T> rhadd(T x, T y) __NOEXC {
   return __sycl_std::__invoke_u_rhadd<T>(x, y);
 }
 
 // geninteger clamp (geninteger x, geninteger minval, geninteger maxval)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T>
-clamp(T x, T minval, T maxval) __NOEXC {
+std::enable_if_t<detail::is_igeninteger<T>::value, T> clamp(T x, T minval,
+                                                            T maxval) __NOEXC {
   return __sycl_std::__invoke_s_clamp<T>(x, minval, maxval);
 }
 
 // geninteger clamp (geninteger x, geninteger minval, geninteger maxval)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T>
-clamp(T x, T minval, T maxval) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger<T>::value, T> clamp(T x, T minval,
+                                                            T maxval) __NOEXC {
   return __sycl_std::__invoke_u_clamp<T>(x, minval, maxval);
 }
 
 // geninteger clamp (geninteger x, sgeninteger minval, sgeninteger maxval)
 template <typename T>
-detail::enable_if_t<detail::is_vigeninteger<T>::value, T>
+std::enable_if_t<detail::is_vigeninteger<T>::value, T>
 clamp(T x, typename T::element_type minval,
       typename T::element_type maxval) __NOEXC {
   return __sycl_std::__invoke_s_clamp<T>(x, T(minval), T(maxval));
@@ -1175,7 +1161,7 @@ clamp(T x, typename T::element_type minval,
 
 // geninteger clamp (geninteger x, sgeninteger minval, sgeninteger maxval)
 template <typename T>
-detail::enable_if_t<detail::is_vugeninteger<T>::value, T>
+std::enable_if_t<detail::is_vugeninteger<T>::value, T>
 clamp(T x, typename T::element_type minval,
       typename T::element_type maxval) __NOEXC {
   return __sycl_std::__invoke_u_clamp<T>(x, T(minval), T(maxval));
@@ -1183,13 +1169,13 @@ clamp(T x, typename T::element_type minval,
 
 // geninteger clz (geninteger x)
 template <typename T>
-detail::enable_if_t<detail::is_geninteger<T>::value, T> clz(T x) __NOEXC {
+std::enable_if_t<detail::is_geninteger<T>::value, T> clz(T x) __NOEXC {
   return __sycl_std::__invoke_clz<T>(x);
 }
 
 // geninteger ctz (geninteger x)
 template <typename T>
-detail::enable_if_t<detail::is_geninteger<T>::value, T> ctz(T x) __NOEXC {
+std::enable_if_t<detail::is_geninteger<T>::value, T> ctz(T x) __NOEXC {
   return __sycl_std::__invoke_ctz<T>(x);
 }
 
@@ -1198,8 +1184,7 @@ namespace ext::intel {
 template <typename T>
 __SYCL_DEPRECATED(
     "'sycl::ext::intel::ctz' is deprecated, use 'sycl::ctz' instead")
-sycl::detail::enable_if_t<sycl::detail::is_geninteger<T>::value, T> ctz(
-    T x) __NOEXC {
+std::enable_if_t<sycl::detail::is_geninteger<T>::value, T> ctz(T x) __NOEXC {
   return sycl::ctz(x);
 }
 } // namespace ext::intel
@@ -1210,136 +1195,128 @@ using namespace ext::intel;
 
 // geninteger mad_hi (geninteger a, geninteger b, geninteger c)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T> mad_hi(T x, T y,
-                                                                T z) __NOEXC {
+std::enable_if_t<detail::is_igeninteger<T>::value, T> mad_hi(T x, T y,
+                                                             T z) __NOEXC {
   return __sycl_std::__invoke_s_mad_hi<T>(x, y, z);
 }
 
 // geninteger mad_hi (geninteger a, geninteger b, geninteger c)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T> mad_hi(T x, T y,
-                                                                T z) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger<T>::value, T> mad_hi(T x, T y,
+                                                             T z) __NOEXC {
   return __sycl_std::__invoke_u_mad_hi<T>(x, y, z);
 }
 
 // geninteger mad_sat (geninteger a, geninteger b, geninteger c)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T> mad_sat(T a, T b,
-                                                                 T c) __NOEXC {
+std::enable_if_t<detail::is_igeninteger<T>::value, T> mad_sat(T a, T b,
+                                                              T c) __NOEXC {
   return __sycl_std::__invoke_s_mad_sat<T>(a, b, c);
 }
 
 // geninteger mad_sat (geninteger a, geninteger b, geninteger c)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T> mad_sat(T a, T b,
-                                                                 T c) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger<T>::value, T> mad_sat(T a, T b,
+                                                              T c) __NOEXC {
   return __sycl_std::__invoke_u_mad_sat<T>(a, b, c);
 }
 
 // igeninteger max (igeninteger x, igeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T>(max)(T x,
-                                                              T y) __NOEXC {
+std::enable_if_t<detail::is_igeninteger<T>::value, T>(max)(T x, T y) __NOEXC {
   return __sycl_std::__invoke_s_max<T>(x, y);
 }
 
 // ugeninteger max (ugeninteger x, ugeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T>(max)(T x,
-                                                              T y) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger<T>::value, T>(max)(T x, T y) __NOEXC {
   return __sycl_std::__invoke_u_max<T>(x, y);
 }
 
 // igeninteger max (vigeninteger x, sigeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_vigeninteger<T>::value, T>(max)(
+std::enable_if_t<detail::is_vigeninteger<T>::value, T>(max)(
     T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_s_max<T>(x, T(y));
 }
 
 // vugeninteger max (vugeninteger x, sugeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_vugeninteger<T>::value, T>(max)(
+std::enable_if_t<detail::is_vugeninteger<T>::value, T>(max)(
     T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_u_max<T>(x, T(y));
 }
 
 // igeninteger min (igeninteger x, igeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T>(min)(T x,
-                                                              T y) __NOEXC {
+std::enable_if_t<detail::is_igeninteger<T>::value, T>(min)(T x, T y) __NOEXC {
   return __sycl_std::__invoke_s_min<T>(x, y);
 }
 
 // ugeninteger min (ugeninteger x, ugeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T>(min)(T x,
-                                                              T y) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger<T>::value, T>(min)(T x, T y) __NOEXC {
   return __sycl_std::__invoke_u_min<T>(x, y);
 }
 
 // vigeninteger min (vigeninteger x, sigeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_vigeninteger<T>::value, T>(min)(
+std::enable_if_t<detail::is_vigeninteger<T>::value, T>(min)(
     T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_s_min<T>(x, T(y));
 }
 
 // vugeninteger min (vugeninteger x, sugeninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_vugeninteger<T>::value, T>(min)(
+std::enable_if_t<detail::is_vugeninteger<T>::value, T>(min)(
     T x, typename T::element_type y) __NOEXC {
   return __sycl_std::__invoke_u_min<T>(x, T(y));
 }
 
 // geninteger mul_hi (geninteger x, geninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T> mul_hi(T x,
-                                                                T y) __NOEXC {
+std::enable_if_t<detail::is_igeninteger<T>::value, T> mul_hi(T x, T y) __NOEXC {
   return __sycl_std::__invoke_s_mul_hi<T>(x, y);
 }
 
 // geninteger mul_hi (geninteger x, geninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T> mul_hi(T x,
-                                                                T y) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger<T>::value, T> mul_hi(T x, T y) __NOEXC {
   return __sycl_std::__invoke_u_mul_hi<T>(x, y);
 }
 
 // geninteger rotate (geninteger v, geninteger i)
 template <typename T>
-detail::enable_if_t<detail::is_geninteger<T>::value, T> rotate(T v,
-                                                               T i) __NOEXC {
+std::enable_if_t<detail::is_geninteger<T>::value, T> rotate(T v, T i) __NOEXC {
   return __sycl_std::__invoke_rotate<T>(v, i);
 }
 
 // geninteger sub_sat (geninteger x, geninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger<T>::value, T> sub_sat(T x,
-                                                                 T y) __NOEXC {
+std::enable_if_t<detail::is_igeninteger<T>::value, T> sub_sat(T x,
+                                                              T y) __NOEXC {
   return __sycl_std::__invoke_s_sub_sat<T>(x, y);
 }
 
 // geninteger sub_sat (geninteger x, geninteger y)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger<T>::value, T> sub_sat(T x,
-                                                                 T y) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger<T>::value, T> sub_sat(T x,
+                                                              T y) __NOEXC {
   return __sycl_std::__invoke_u_sub_sat<T>(x, y);
 }
 
 // ugeninteger16bit upsample (ugeninteger8bit hi, ugeninteger8bit lo)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger8bit<T>::value,
-                    detail::make_larger_t<T>>
+std::enable_if_t<detail::is_ugeninteger8bit<T>::value, detail::make_larger_t<T>>
 upsample(T hi, T lo) __NOEXC {
   return __sycl_std::__invoke_u_upsample<detail::make_larger_t<T>>(hi, lo);
 }
 
 // igeninteger16bit upsample (igeninteger8bit hi, ugeninteger8bit lo)
 template <typename T, typename T2>
-detail::enable_if_t<detail::is_igeninteger8bit<T>::value &&
-                        detail::is_ugeninteger8bit<T2>::value,
-                    detail::make_larger_t<T>>
+std::enable_if_t<detail::is_igeninteger8bit<T>::value &&
+                     detail::is_ugeninteger8bit<T2>::value,
+                 detail::make_larger_t<T>>
 upsample(T hi, T2 lo) __NOEXC {
   detail::check_vector_size<T, T2>();
   return __sycl_std::__invoke_s_upsample<detail::make_larger_t<T>>(hi, lo);
@@ -1347,17 +1324,17 @@ upsample(T hi, T2 lo) __NOEXC {
 
 // ugeninteger32bit upsample (ugeninteger16bit hi, ugeninteger16bit lo)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger16bit<T>::value,
-                    detail::make_larger_t<T>>
+std::enable_if_t<detail::is_ugeninteger16bit<T>::value,
+                 detail::make_larger_t<T>>
 upsample(T hi, T lo) __NOEXC {
   return __sycl_std::__invoke_u_upsample<detail::make_larger_t<T>>(hi, lo);
 }
 
 // igeninteger32bit upsample (igeninteger16bit hi, ugeninteger16bit lo)
 template <typename T, typename T2>
-detail::enable_if_t<detail::is_igeninteger16bit<T>::value &&
-                        detail::is_ugeninteger16bit<T2>::value,
-                    detail::make_larger_t<T>>
+std::enable_if_t<detail::is_igeninteger16bit<T>::value &&
+                     detail::is_ugeninteger16bit<T2>::value,
+                 detail::make_larger_t<T>>
 upsample(T hi, T2 lo) __NOEXC {
   detail::check_vector_size<T, T2>();
   return __sycl_std::__invoke_s_upsample<detail::make_larger_t<T>>(hi, lo);
@@ -1365,17 +1342,17 @@ upsample(T hi, T2 lo) __NOEXC {
 
 // ugeninteger64bit upsample (ugeninteger32bit hi, ugeninteger32bit lo)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger32bit<T>::value,
-                    detail::make_larger_t<T>>
+std::enable_if_t<detail::is_ugeninteger32bit<T>::value,
+                 detail::make_larger_t<T>>
 upsample(T hi, T lo) __NOEXC {
   return __sycl_std::__invoke_u_upsample<detail::make_larger_t<T>>(hi, lo);
 }
 
 // igeninteger64bit upsample (igeninteger32bit hi, ugeninteger32bit lo)
 template <typename T, typename T2>
-detail::enable_if_t<detail::is_igeninteger32bit<T>::value &&
-                        detail::is_ugeninteger32bit<T2>::value,
-                    detail::make_larger_t<T>>
+std::enable_if_t<detail::is_igeninteger32bit<T>::value &&
+                     detail::is_ugeninteger32bit<T2>::value,
+                 detail::make_larger_t<T>>
 upsample(T hi, T2 lo) __NOEXC {
   detail::check_vector_size<T, T2>();
   return __sycl_std::__invoke_s_upsample<detail::make_larger_t<T>>(hi, lo);
@@ -1383,37 +1360,37 @@ upsample(T hi, T2 lo) __NOEXC {
 
 // geninteger popcount (geninteger x)
 template <typename T>
-detail::enable_if_t<detail::is_geninteger<T>::value, T> popcount(T x) __NOEXC {
+std::enable_if_t<detail::is_geninteger<T>::value, T> popcount(T x) __NOEXC {
   return __sycl_std::__invoke_popcount<T>(x);
 }
 
 // geninteger32bit mad24 (geninteger32bit x, geninteger32bit y,
 // geninteger32bit z)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger32bit<T>::value, T>
-mad24(T x, T y, T z) __NOEXC {
+std::enable_if_t<detail::is_igeninteger32bit<T>::value, T> mad24(T x, T y,
+                                                                 T z) __NOEXC {
   return __sycl_std::__invoke_s_mad24<T>(x, y, z);
 }
 
 // geninteger32bit mad24 (geninteger32bit x, geninteger32bit y,
 // geninteger32bit z)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger32bit<T>::value, T>
-mad24(T x, T y, T z) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger32bit<T>::value, T> mad24(T x, T y,
+                                                                 T z) __NOEXC {
   return __sycl_std::__invoke_u_mad24<T>(x, y, z);
 }
 
 // geninteger32bit mul24 (geninteger32bit x, geninteger32bit y)
 template <typename T>
-detail::enable_if_t<detail::is_igeninteger32bit<T>::value, T>
-mul24(T x, T y) __NOEXC {
+std::enable_if_t<detail::is_igeninteger32bit<T>::value, T> mul24(T x,
+                                                                 T y) __NOEXC {
   return __sycl_std::__invoke_s_mul24<T>(x, y);
 }
 
 // geninteger32bit mul24 (geninteger32bit x, geninteger32bit y)
 template <typename T>
-detail::enable_if_t<detail::is_ugeninteger32bit<T>::value, T>
-mul24(T x, T y) __NOEXC {
+std::enable_if_t<detail::is_ugeninteger32bit<T>::value, T> mul24(T x,
+                                                                 T y) __NOEXC {
   return __sycl_std::__invoke_u_mul24<T>(x, y);
 }
 
@@ -1682,8 +1659,7 @@ __SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_IU_OVERLOAD(upsample, 32bit)
 // half3 cross (half3 p0, half3 p1)
 // half4 cross (half4 p0, half4 p1)
 template <typename T>
-detail::enable_if_t<detail::is_gencross<T>::value, T> cross(T p0,
-                                                            T p1) __NOEXC {
+std::enable_if_t<detail::is_gencross<T>::value, T> cross(T p0, T p1) __NOEXC {
   return __sycl_std::__invoke_cross<T>(p0, p1);
 }
 
@@ -1691,131 +1667,129 @@ detail::enable_if_t<detail::is_gencross<T>::value, T> cross(T p0,
 // double dot (double p0, double p1)
 // half dot (half p0, half p1)
 template <typename T>
-detail::enable_if_t<detail::is_sgenfloat<T>::value, T> dot(T p0, T p1) __NOEXC {
+std::enable_if_t<detail::is_sgenfloat<T>::value, T> dot(T p0, T p1) __NOEXC {
   return p0 * p1;
 }
 
 // float dot (vgengeofloat p0, vgengeofloat p1)
 template <typename T>
-detail::enable_if_t<detail::is_vgengeofloat<T>::value, float>
-dot(T p0, T p1) __NOEXC {
+std::enable_if_t<detail::is_vgengeofloat<T>::value, float> dot(T p0,
+                                                               T p1) __NOEXC {
   return __sycl_std::__invoke_Dot<float>(p0, p1);
 }
 
 // double dot (vgengeodouble p0, vgengeodouble p1)
 template <typename T>
-detail::enable_if_t<detail::is_vgengeodouble<T>::value, double>
-dot(T p0, T p1) __NOEXC {
+std::enable_if_t<detail::is_vgengeodouble<T>::value, double> dot(T p0,
+                                                                 T p1) __NOEXC {
   return __sycl_std::__invoke_Dot<double>(p0, p1);
 }
 
 // half dot (vgengeohalf p0, vgengeohalf p1)
 template <typename T>
-detail::enable_if_t<detail::is_vgengeohalf<T>::value, half> dot(T p0,
-                                                                T p1) __NOEXC {
+std::enable_if_t<detail::is_vgengeohalf<T>::value, half> dot(T p0,
+                                                             T p1) __NOEXC {
   return __sycl_std::__invoke_Dot<half>(p0, p1);
 }
 
 // float distance (gengeofloat p0, gengeofloat p1)
 template <typename T,
-          typename = detail::enable_if_t<detail::is_gengeofloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_gengeofloat<T>::value, T>>
 float distance(T p0, T p1) __NOEXC {
   return __sycl_std::__invoke_distance<float>(p0, p1);
 }
 
 // double distance (gengeodouble p0, gengeodouble p1)
 template <typename T,
-          typename = detail::enable_if_t<detail::is_gengeodouble<T>::value, T>>
+          typename = std::enable_if_t<detail::is_gengeodouble<T>::value, T>>
 double distance(T p0, T p1) __NOEXC {
   return __sycl_std::__invoke_distance<double>(p0, p1);
 }
 
 // half distance (gengeohalf p0, gengeohalf p1)
 template <typename T,
-          typename = detail::enable_if_t<detail::is_gengeohalf<T>::value, T>>
+          typename = std::enable_if_t<detail::is_gengeohalf<T>::value, T>>
 half distance(T p0, T p1) __NOEXC {
   return __sycl_std::__invoke_distance<half>(p0, p1);
 }
 
 // float length (gengeofloat p)
 template <typename T,
-          typename = detail::enable_if_t<detail::is_gengeofloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_gengeofloat<T>::value, T>>
 float length(T p) __NOEXC {
   return __sycl_std::__invoke_length<float>(p);
 }
 
 // double length (gengeodouble p)
 template <typename T,
-          typename = detail::enable_if_t<detail::is_gengeodouble<T>::value, T>>
+          typename = std::enable_if_t<detail::is_gengeodouble<T>::value, T>>
 double length(T p) __NOEXC {
   return __sycl_std::__invoke_length<double>(p);
 }
 
 // half length (gengeohalf p)
 template <typename T,
-          typename = detail::enable_if_t<detail::is_gengeohalf<T>::value, T>>
+          typename = std::enable_if_t<detail::is_gengeohalf<T>::value, T>>
 half length(T p) __NOEXC {
   return __sycl_std::__invoke_length<half>(p);
 }
 
 // gengeofloat normalize (gengeofloat p)
 template <typename T>
-detail::enable_if_t<detail::is_gengeofloat<T>::value, T>
-normalize(T p) __NOEXC {
+std::enable_if_t<detail::is_gengeofloat<T>::value, T> normalize(T p) __NOEXC {
   return __sycl_std::__invoke_normalize<T>(p);
 }
 
 // gengeodouble normalize (gengeodouble p)
 template <typename T>
-detail::enable_if_t<detail::is_gengeodouble<T>::value, T>
-normalize(T p) __NOEXC {
+std::enable_if_t<detail::is_gengeodouble<T>::value, T> normalize(T p) __NOEXC {
   return __sycl_std::__invoke_normalize<T>(p);
 }
 
 // gengeohalf normalize (gengeohalf p)
 template <typename T>
-detail::enable_if_t<detail::is_gengeohalf<T>::value, T> normalize(T p) __NOEXC {
+std::enable_if_t<detail::is_gengeohalf<T>::value, T> normalize(T p) __NOEXC {
   return __sycl_std::__invoke_normalize<T>(p);
 }
 
 // float fast_distance (gengeofloat p0, gengeofloat p1)
 template <typename T,
-          typename = detail::enable_if_t<detail::is_gengeofloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_gengeofloat<T>::value, T>>
 float fast_distance(T p0, T p1) __NOEXC {
   return __sycl_std::__invoke_fast_distance<float>(p0, p1);
 }
 
 // double fast_distance (gengeodouble p0, gengeodouble p1)
 template <typename T,
-          typename = detail::enable_if_t<detail::is_gengeodouble<T>::value, T>>
+          typename = std::enable_if_t<detail::is_gengeodouble<T>::value, T>>
 double fast_distance(T p0, T p1) __NOEXC {
   return __sycl_std::__invoke_fast_distance<double>(p0, p1);
 }
 
 // float fast_length (gengeofloat p)
 template <typename T,
-          typename = detail::enable_if_t<detail::is_gengeofloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_gengeofloat<T>::value, T>>
 float fast_length(T p) __NOEXC {
   return __sycl_std::__invoke_fast_length<float>(p);
 }
 
 // double fast_length (gengeodouble p)
 template <typename T,
-          typename = detail::enable_if_t<detail::is_gengeodouble<T>::value, T>>
+          typename = std::enable_if_t<detail::is_gengeodouble<T>::value, T>>
 double fast_length(T p) __NOEXC {
   return __sycl_std::__invoke_fast_length<double>(p);
 }
 
 // gengeofloat fast_normalize (gengeofloat p)
 template <typename T>
-detail::enable_if_t<detail::is_gengeofloat<T>::value, T>
+std::enable_if_t<detail::is_gengeofloat<T>::value, T>
 fast_normalize(T p) __NOEXC {
   return __sycl_std::__invoke_fast_normalize<T>(p);
 }
 
 // gengeodouble fast_normalize (gengeodouble p)
 template <typename T>
-detail::enable_if_t<detail::is_gengeodouble<T>::value, T>
+std::enable_if_t<detail::is_gengeodouble<T>::value, T>
 fast_normalize(T p) __NOEXC {
   return __sycl_std::__invoke_fast_normalize<T>(p);
 }
@@ -1888,21 +1862,21 @@ fast_length(T p) __NOEXC {
 /* SYCL 2020  ---- 4.17.9 Relational functions. -----------------------------*/
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> isequal(T x, T y) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_FOrdEqual<detail::internal_rel_ret_t<T>>(x, y));
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> isnotequal(T x, T y) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_FUnordNotEqual<detail::internal_rel_ret_t<T>>(x, y));
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> isgreater(T x, T y) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_FOrdGreaterThan<detail::internal_rel_ret_t<T>>(x,
@@ -1910,7 +1884,7 @@ detail::common_rel_ret_t<T> isgreater(T x, T y) __NOEXC {
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> isgreaterequal(T x, T y) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_FOrdGreaterThanEqual<detail::internal_rel_ret_t<T>>(
@@ -1918,14 +1892,14 @@ detail::common_rel_ret_t<T> isgreaterequal(T x, T y) __NOEXC {
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> isless(T x, T y) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_FOrdLessThan<detail::internal_rel_ret_t<T>>(x, y));
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> islessequal(T x, T y) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_FOrdLessThanEqual<detail::internal_rel_ret_t<T>>(x,
@@ -1933,56 +1907,56 @@ detail::common_rel_ret_t<T> islessequal(T x, T y) __NOEXC {
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> islessgreater(T x, T y) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_FOrdNotEqual<detail::internal_rel_ret_t<T>>(x, y));
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> isfinite(T x) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_IsFinite<detail::internal_rel_ret_t<T>>(x));
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> isinf(T x) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_IsInf<detail::internal_rel_ret_t<T>>(x));
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> isnan(T x) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_IsNan<detail::internal_rel_ret_t<T>>(x));
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> isnormal(T x) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_IsNormal<detail::internal_rel_ret_t<T>>(x));
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> isordered(T x, T y) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_Ordered<detail::internal_rel_ret_t<T>>(x, y));
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> isunordered(T x, T y) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_Unordered<detail::internal_rel_ret_t<T>>(x, y));
 }
 
 template <typename T,
-          typename = detail::enable_if_t<detail::is_svgenfloat<T>::value, T>>
+          typename = std::enable_if_t<detail::is_svgenfloat<T>::value, T>>
 detail::common_rel_ret_t<T> signbit(T x) __NOEXC {
   return detail::RelConverter<T>::apply(
       __sycl_std::__invoke_SignBitSet<detail::internal_rel_ret_t<T>>(x));
@@ -2037,14 +2011,14 @@ using anyall_ret_t = int;
 
 // int any (sigeninteger x)
 template <typename T>
-detail::enable_if_t<detail::is_sigeninteger<T>::value, detail::anyall_ret_t>
+std::enable_if_t<detail::is_sigeninteger<T>::value, detail::anyall_ret_t>
 any(T x) __NOEXC {
   return detail::Boolean<1>(int(detail::msbIsSet(x)));
 }
 
 // int any (vigeninteger x)
 template <typename T>
-detail::enable_if_t<detail::is_vigeninteger<T>::value, int> any(T x) __NOEXC {
+std::enable_if_t<detail::is_vigeninteger<T>::value, int> any(T x) __NOEXC {
   return detail::rel_sign_bit_test_ret_t<T>(
       __sycl_std::__invoke_Any<detail::rel_sign_bit_test_ret_t<T>>(
           detail::rel_sign_bit_test_arg_t<T>(x)));
@@ -2052,14 +2026,14 @@ detail::enable_if_t<detail::is_vigeninteger<T>::value, int> any(T x) __NOEXC {
 
 // int all (sigeninteger x)
 template <typename T>
-detail::enable_if_t<detail::is_sigeninteger<T>::value, detail::anyall_ret_t>
+std::enable_if_t<detail::is_sigeninteger<T>::value, detail::anyall_ret_t>
 all(T x) __NOEXC {
   return detail::Boolean<1>(int(detail::msbIsSet(x)));
 }
 
 // int all (vigeninteger x)
 template <typename T>
-detail::enable_if_t<detail::is_vigeninteger<T>::value, int> all(T x) __NOEXC {
+std::enable_if_t<detail::is_vigeninteger<T>::value, int> all(T x) __NOEXC {
   return detail::rel_sign_bit_test_ret_t<T>(
       __sycl_std::__invoke_All<detail::rel_sign_bit_test_ret_t<T>>(
           detail::rel_sign_bit_test_arg_t<T>(x)));
@@ -2067,15 +2041,15 @@ detail::enable_if_t<detail::is_vigeninteger<T>::value, int> all(T x) __NOEXC {
 
 // gentype bitselect (gentype a, gentype b, gentype c)
 template <typename T>
-detail::enable_if_t<detail::is_gentype<T>::value, T> bitselect(T a, T b,
-                                                               T c) __NOEXC {
+std::enable_if_t<detail::is_gentype<T>::value, T> bitselect(T a, T b,
+                                                            T c) __NOEXC {
   return __sycl_std::__invoke_bitselect<T>(a, b, c);
 }
 
 // sgentype select (sgentype a, sgentype b, bool c)
 template <typename T>
-detail::enable_if_t<detail::is_sgentype<T>::value, T> select(T a, T b,
-                                                             bool c) __NOEXC {
+std::enable_if_t<detail::is_sgentype<T>::value, T> select(T a, T b,
+                                                          bool c) __NOEXC {
   constexpr size_t SizeT = sizeof(T);
 
   // sycl::select(sgentype a, sgentype b, bool c) calls OpenCL built-in
@@ -2101,7 +2075,7 @@ detail::enable_if_t<detail::is_sgentype<T>::value, T> select(T a, T b,
 
 // geninteger select (geninteger a, geninteger b, igeninteger c)
 template <typename T, typename T2>
-detail::enable_if_t<
+std::enable_if_t<
     detail::is_geninteger<T>::value && detail::is_igeninteger<T2>::value, T>
 select(T a, T b, T2 c) __NOEXC {
   detail::check_vector_size<T, T2>();
@@ -2110,7 +2084,7 @@ select(T a, T b, T2 c) __NOEXC {
 
 // geninteger select (geninteger a, geninteger b, ugeninteger c)
 template <typename T, typename T2>
-detail::enable_if_t<
+std::enable_if_t<
     detail::is_geninteger<T>::value && detail::is_ugeninteger<T2>::value, T>
 select(T a, T b, T2 c) __NOEXC {
   detail::check_vector_size<T, T2>();
@@ -2119,7 +2093,7 @@ select(T a, T b, T2 c) __NOEXC {
 
 // svgenfloatf select (svgenfloatf a, svgenfloatf b, genint c)
 template <typename T, typename T2>
-detail::enable_if_t<
+std::enable_if_t<
     detail::is_svgenfloatf<T>::value && detail::is_genint<T2>::value, T>
 select(T a, T b, T2 c) __NOEXC {
   detail::check_vector_size<T, T2>();
@@ -2128,7 +2102,7 @@ select(T a, T b, T2 c) __NOEXC {
 
 // svgenfloatf select (svgenfloatf a, svgenfloatf b, ugenint c)
 template <typename T, typename T2>
-detail::enable_if_t<
+std::enable_if_t<
     detail::is_svgenfloatf<T>::value && detail::is_ugenint<T2>::value, T>
 select(T a, T b, T2 c) __NOEXC {
   detail::check_vector_size<T, T2>();
@@ -2137,9 +2111,9 @@ select(T a, T b, T2 c) __NOEXC {
 
 // svgenfloatd select (svgenfloatd a, svgenfloatd b, igeninteger64 c)
 template <typename T, typename T2>
-detail::enable_if_t<detail::is_svgenfloatd<T>::value &&
-                        detail::is_igeninteger64bit<T2>::value,
-                    T>
+std::enable_if_t<detail::is_svgenfloatd<T>::value &&
+                     detail::is_igeninteger64bit<T2>::value,
+                 T>
 select(T a, T b, T2 c) __NOEXC {
   detail::check_vector_size<T, T2>();
   return __sycl_std::__invoke_select<T>(a, b, c);
@@ -2147,9 +2121,9 @@ select(T a, T b, T2 c) __NOEXC {
 
 // svgenfloatd select (svgenfloatd a, svgenfloatd b, ugeninteger64 c)
 template <typename T, typename T2>
-detail::enable_if_t<detail::is_svgenfloatd<T>::value &&
-                        detail::is_ugeninteger64bit<T2>::value,
-                    T>
+std::enable_if_t<detail::is_svgenfloatd<T>::value &&
+                     detail::is_ugeninteger64bit<T2>::value,
+                 T>
 select(T a, T b, T2 c) __NOEXC {
   detail::check_vector_size<T, T2>();
   return __sycl_std::__invoke_select<T>(a, b, c);
@@ -2157,9 +2131,9 @@ select(T a, T b, T2 c) __NOEXC {
 
 // svgenfloath select (svgenfloath a, svgenfloath b, igeninteger16 c)
 template <typename T, typename T2>
-detail::enable_if_t<detail::is_svgenfloath<T>::value &&
-                        detail::is_igeninteger16bit<T2>::value,
-                    T>
+std::enable_if_t<detail::is_svgenfloath<T>::value &&
+                     detail::is_igeninteger16bit<T2>::value,
+                 T>
 select(T a, T b, T2 c) __NOEXC {
   detail::check_vector_size<T, T2>();
   return __sycl_std::__invoke_select<T>(a, b, c);
@@ -2167,9 +2141,9 @@ select(T a, T b, T2 c) __NOEXC {
 
 // svgenfloath select (svgenfloath a, svgenfloath b, ugeninteger16 c)
 template <typename T, typename T2>
-detail::enable_if_t<detail::is_svgenfloath<T>::value &&
-                        detail::is_ugeninteger16bit<T2>::value,
-                    T>
+std::enable_if_t<detail::is_svgenfloath<T>::value &&
+                     detail::is_ugeninteger16bit<T2>::value,
+                 T>
 select(T a, T b, T2 c) __NOEXC {
   detail::check_vector_size<T, T2>();
   return __sycl_std::__invoke_select<T>(a, b, c);
@@ -2178,19 +2152,19 @@ select(T a, T b, T2 c) __NOEXC {
 // other marray relational functions
 
 template <typename T, size_t N>
-detail::enable_if_t<detail::is_sigeninteger<T>::value, bool>
+std::enable_if_t<detail::is_sigeninteger<T>::value, bool>
 any(marray<T, N> x) __NOEXC {
   return std::any_of(x.begin(), x.end(), [](T i) { return any(i); });
 }
 
 template <typename T, size_t N>
-detail::enable_if_t<detail::is_sigeninteger<T>::value, bool>
+std::enable_if_t<detail::is_sigeninteger<T>::value, bool>
 all(marray<T, N> x) __NOEXC {
   return std::all_of(x.begin(), x.end(), [](T i) { return all(i); });
 }
 
 template <typename T, size_t N>
-detail::enable_if_t<detail::is_gentype<T>::value, marray<T, N>>
+std::enable_if_t<detail::is_gentype<T>::value, marray<T, N>>
 bitselect(marray<T, N> a, marray<T, N> b, marray<T, N> c) __NOEXC {
   marray<T, N> res;
   for (int i = 0; i < N; i++) {
@@ -2200,7 +2174,7 @@ bitselect(marray<T, N> a, marray<T, N> b, marray<T, N> c) __NOEXC {
 }
 
 template <typename T, size_t N>
-detail::enable_if_t<detail::is_gentype<T>::value, marray<T, N>>
+std::enable_if_t<detail::is_gentype<T>::value, marray<T, N>>
 select(marray<T, N> a, marray<T, N> b, marray<bool, N> c) __NOEXC {
   marray<T, N> res;
   for (int i = 0; i < N; i++) {
@@ -2267,87 +2241,85 @@ __SYCL_NATIVE_MATH_FUNCTION_2_OVERLOAD(powr)
 
 // svgenfloatf cos (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> cos(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> cos(T x) __NOEXC {
   return __sycl_std::__invoke_native_cos<T>(x);
 }
 
 // svgenfloatf divide (svgenfloatf x, svgenfloatf y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> divide(T x,
-                                                                T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> divide(T x, T y) __NOEXC {
   return __sycl_std::__invoke_native_divide<T>(x, y);
 }
 
 // svgenfloatf exp (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp(T x) __NOEXC {
   return __sycl_std::__invoke_native_exp<T>(x);
 }
 
 // svgenfloatf exp2 (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp2(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp2(T x) __NOEXC {
   return __sycl_std::__invoke_native_exp2<T>(x);
 }
 
 // svgenfloatf exp10 (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp10(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp10(T x) __NOEXC {
   return __sycl_std::__invoke_native_exp10<T>(x);
 }
 
 // svgenfloatf log (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> log(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> log(T x) __NOEXC {
   return __sycl_std::__invoke_native_log<T>(x);
 }
 
 // svgenfloatf log2 (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> log2(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> log2(T x) __NOEXC {
   return __sycl_std::__invoke_native_log2<T>(x);
 }
 
 // svgenfloatf log10 (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> log10(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> log10(T x) __NOEXC {
   return __sycl_std::__invoke_native_log10<T>(x);
 }
 
 // svgenfloatf powr (svgenfloatf x, svgenfloatf y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> powr(T x,
-                                                              T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> powr(T x, T y) __NOEXC {
   return __sycl_std::__invoke_native_powr<T>(x, y);
 }
 
 // svgenfloatf recip (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> recip(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> recip(T x) __NOEXC {
   return __sycl_std::__invoke_native_recip<T>(x);
 }
 
 // svgenfloatf rsqrt (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> rsqrt(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> rsqrt(T x) __NOEXC {
   return __sycl_std::__invoke_native_rsqrt<T>(x);
 }
 
 // svgenfloatf sin (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> sin(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> sin(T x) __NOEXC {
   return __sycl_std::__invoke_native_sin<T>(x);
 }
 
 // svgenfloatf sqrt (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> sqrt(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> sqrt(T x) __NOEXC {
   return __sycl_std::__invoke_native_sqrt<T>(x);
 }
 
 // svgenfloatf tan (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> tan(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> tan(T x) __NOEXC {
   return __sycl_std::__invoke_native_tan<T>(x);
 }
 
@@ -2409,87 +2381,85 @@ __SYCL_HALF_PRECISION_MATH_FUNCTION_2_OVERLOAD(powr)
 
 // svgenfloatf cos (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> cos(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> cos(T x) __NOEXC {
   return __sycl_std::__invoke_half_cos<T>(x);
 }
 
 // svgenfloatf divide (svgenfloatf x, svgenfloatf y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> divide(T x,
-                                                                T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> divide(T x, T y) __NOEXC {
   return __sycl_std::__invoke_half_divide<T>(x, y);
 }
 
 // svgenfloatf exp (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp(T x) __NOEXC {
   return __sycl_std::__invoke_half_exp<T>(x);
 }
 
 // svgenfloatf exp2 (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp2(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp2(T x) __NOEXC {
   return __sycl_std::__invoke_half_exp2<T>(x);
 }
 
 // svgenfloatf exp10 (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp10(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp10(T x) __NOEXC {
   return __sycl_std::__invoke_half_exp10<T>(x);
 }
 
 // svgenfloatf log (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> log(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> log(T x) __NOEXC {
   return __sycl_std::__invoke_half_log<T>(x);
 }
 
 // svgenfloatf log2 (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> log2(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> log2(T x) __NOEXC {
   return __sycl_std::__invoke_half_log2<T>(x);
 }
 
 // svgenfloatf log10 (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> log10(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> log10(T x) __NOEXC {
   return __sycl_std::__invoke_half_log10<T>(x);
 }
 
 // svgenfloatf powr (svgenfloatf x, svgenfloatf y)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> powr(T x,
-                                                              T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> powr(T x, T y) __NOEXC {
   return __sycl_std::__invoke_half_powr<T>(x, y);
 }
 
 // svgenfloatf recip (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> recip(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> recip(T x) __NOEXC {
   return __sycl_std::__invoke_half_recip<T>(x);
 }
 
 // svgenfloatf rsqrt (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> rsqrt(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> rsqrt(T x) __NOEXC {
   return __sycl_std::__invoke_half_rsqrt<T>(x);
 }
 
 // svgenfloatf sin (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> sin(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> sin(T x) __NOEXC {
   return __sycl_std::__invoke_half_sin<T>(x);
 }
 
 // svgenfloatf sqrt (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> sqrt(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> sqrt(T x) __NOEXC {
   return __sycl_std::__invoke_half_sqrt<T>(x);
 }
 
 // svgenfloatf tan (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> tan(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> tan(T x) __NOEXC {
   return __sycl_std::__invoke_half_tan<T>(x);
 }
 
@@ -2528,74 +2498,73 @@ inline __SYCL_ALWAYS_INLINE
 
 // svgenfloatf cos (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> cos(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> cos(T x) __NOEXC {
   return native::cos(x);
 }
 
 // svgenfloatf exp (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp(T x) __NOEXC {
   return native::exp(x);
 }
 
 // svgenfloatf exp2 (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp2(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp2(T x) __NOEXC {
   return native::exp2(x);
 }
 
 // svgenfloatf exp10 (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp10(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> exp10(T x) __NOEXC {
   return native::exp10(x);
 }
 
 // svgenfloatf log(svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> log(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> log(T x) __NOEXC {
   return native::log(x);
 }
 
 // svgenfloatf log2 (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> log2(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> log2(T x) __NOEXC {
   return native::log2(x);
 }
 
 // svgenfloatf log10 (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> log10(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> log10(T x) __NOEXC {
   return native::log10(x);
 }
 
 // svgenfloatf powr (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> powr(T x,
-                                                              T y) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> powr(T x, T y) __NOEXC {
   return native::powr(x, y);
 }
 
 // svgenfloatf rsqrt (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> rsqrt(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> rsqrt(T x) __NOEXC {
   return native::rsqrt(x);
 }
 
 // svgenfloatf sin (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> sin(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> sin(T x) __NOEXC {
   return native::sin(x);
 }
 
 // svgenfloatf sqrt (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> sqrt(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> sqrt(T x) __NOEXC {
   return native::sqrt(x);
 }
 
 // svgenfloatf tan (svgenfloatf x)
 template <typename T>
-detail::enable_if_t<detail::is_svgenfloatf<T>::value, T> tan(T x) __NOEXC {
+std::enable_if_t<detail::is_svgenfloatf<T>::value, T> tan(T x) __NOEXC {
   return native::tan(x);
 }
 
diff --git a/sycl/include/sycl/context.hpp b/sycl/include/sycl/context.hpp
index 580a4eae12ce0..1b3be63396991 100644
--- a/sycl/include/sycl/context.hpp
+++ b/sycl/include/sycl/context.hpp
@@ -236,9 +236,8 @@ class __SYCL_EXPORT context : public detail::OwnerLessBase<context> {
   friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
 
   template <class T>
-  friend
-      typename detail::add_pointer_t<typename decltype(T::impl)::element_type>
-      detail::getRawSyclObjImpl(const T &SyclObject);
+  friend typename std::add_pointer_t<typename decltype(T::impl)::element_type>
+  detail::getRawSyclObjImpl(const T &SyclObject);
 
   template <class T>
   friend T detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
diff --git a/sycl/include/sycl/detail/array.hpp b/sycl/include/sycl/detail/array.hpp
index a61697a7e225d..91ccca296ab00 100644
--- a/sycl/include/sycl/detail/array.hpp
+++ b/sycl/include/sycl/detail/array.hpp
@@ -25,26 +25,26 @@ template <int dimensions = 1> class array {
   /* The following constructor is only available in the array struct
    * specialization where: dimensions==1 */
   template <int N = dimensions>
-  array(typename detail::enable_if_t<(N == 1), size_t> dim0 = 0)
+  array(typename std::enable_if_t<(N == 1), size_t> dim0 = 0)
       : common_array{dim0} {}
 
   /* The following constructors are only available in the array struct
    * specialization where: dimensions==2 */
   template <int N = dimensions>
-  array(typename detail::enable_if_t<(N == 2), size_t> dim0, size_t dim1)
+  array(typename std::enable_if_t<(N == 2), size_t> dim0, size_t dim1)
       : common_array{dim0, dim1} {}
 
-  template <int N = dimensions, detail::enable_if_t<(N == 2), size_t> = 0>
+  template <int N = dimensions, std::enable_if_t<(N == 2), size_t> = 0>
   array() : array(0, 0) {}
 
   /* The following constructors are only available in the array struct
    * specialization where: dimensions==3 */
   template <int N = dimensions>
-  array(typename detail::enable_if_t<(N == 3), size_t> dim0, size_t dim1,
+  array(typename std::enable_if_t<(N == 3), size_t> dim0, size_t dim1,
         size_t dim2)
       : common_array{dim0, dim1, dim2} {}
 
-  template <int N = dimensions, detail::enable_if_t<(N == 3), size_t> = 0>
+  template <int N = dimensions, std::enable_if_t<(N == 3), size_t> = 0>
   array() : array(0, 0, 0) {}
 
   // Conversion operators to derived classes
diff --git a/sycl/include/sycl/detail/cg_types.hpp b/sycl/include/sycl/detail/cg_types.hpp
index cef96878d2fe0..6965cfa7610b6 100644
--- a/sycl/include/sycl/detail/cg_types.hpp
+++ b/sycl/include/sycl/detail/cg_types.hpp
@@ -281,13 +281,13 @@ class HostKernel : public HostKernelBase {
   char *getPtr() override { return reinterpret_cast<char *>(&MKernel); }
 
   template <class ArgT = KernelArgType>
-  typename detail::enable_if_t<std::is_same<ArgT, void>::value>
+  typename std::enable_if_t<std::is_same<ArgT, void>::value>
   runOnHost(const NDRDescT &) {
     runKernelWithoutArg(MKernel);
   }
 
   template <class ArgT = KernelArgType>
-  typename detail::enable_if_t<std::is_same<ArgT, sycl::id<Dims>>::value>
+  typename std::enable_if_t<std::is_same<ArgT, sycl::id<Dims>>::value>
   runOnHost(const NDRDescT &NDRDesc) {
     sycl::range<Dims> Range(InitializedVal<Dims, range>::template get<0>());
     sycl::id<Dims> Offset;
@@ -312,7 +312,7 @@ class HostKernel : public HostKernelBase {
   }
 
   template <class ArgT = KernelArgType>
-  typename detail::enable_if_t<
+  typename std::enable_if_t<
       std::is_same<ArgT, item<Dims, /*Offset=*/false>>::value>
   runOnHost(const NDRDescT &NDRDesc) {
     sycl::id<Dims> ID;
@@ -330,7 +330,7 @@ class HostKernel : public HostKernelBase {
   }
 
   template <class ArgT = KernelArgType>
-  typename detail::enable_if_t<
+  typename std::enable_if_t<
       std::is_same<ArgT, item<Dims, /*Offset=*/true>>::value>
   runOnHost(const NDRDescT &NDRDesc) {
     sycl::range<Dims> Range(InitializedVal<Dims, range>::template get<0>());
@@ -356,7 +356,7 @@ class HostKernel : public HostKernelBase {
   }
 
   template <class ArgT = KernelArgType>
-  typename detail::enable_if_t<std::is_same<ArgT, nd_item<Dims>>::value>
+  typename std::enable_if_t<std::is_same<ArgT, nd_item<Dims>>::value>
   runOnHost(const NDRDescT &NDRDesc) {
     sycl::range<Dims> GroupSize(InitializedVal<Dims, range>::template get<0>());
     for (int I = 0; I < Dims; ++I) {
@@ -397,7 +397,7 @@ class HostKernel : public HostKernelBase {
   }
 
   template <typename ArgT = KernelArgType>
-  enable_if_t<std::is_same<ArgT, sycl::group<Dims>>::value>
+  std::enable_if_t<std::is_same<ArgT, sycl::group<Dims>>::value>
   runOnHost(const NDRDescT &NDRDesc) {
     sycl::range<Dims> NGroups(InitializedVal<Dims, range>::template get<0>());
 
diff --git a/sycl/include/sycl/detail/common.hpp b/sycl/include/sycl/detail/common.hpp
index 56d5f2856cee5..5ae2d301e02c4 100644
--- a/sycl/include/sycl/detail/common.hpp
+++ b/sycl/include/sycl/detail/common.hpp
@@ -30,11 +30,11 @@ namespace detail {
 // TODO: Align these checks with the SYCL specification when the behaviour
 // with void * is clarified.
 template <typename DataT>
-using EnableIfOutputPointerT = detail::enable_if_t<
+using EnableIfOutputPointerT = std::enable_if_t<
     /*is_output_iterator<DataT>::value &&*/ std::is_pointer<DataT>::value>;
 
 template <typename DataT>
-using EnableIfOutputIteratorT = detail::enable_if_t<
+using EnableIfOutputIteratorT = std::enable_if_t<
     /*is_output_iterator<DataT>::value &&*/ !std::is_pointer<DataT>::value>;
 
 #if !defined(NDEBUG) && (_MSC_VER > 1929 || __has_builtin(__builtin_FILE))
@@ -306,7 +306,7 @@ template <class Obj> decltype(Obj::impl) getSyclObjImpl(const Obj &SyclObject) {
 // must make sure the returned pointer is not captured in a field or otherwise
 // stored - i.e. must live only as on-stack value.
 template <class T>
-typename detail::add_pointer_t<typename decltype(T::impl)::element_type>
+typename std::add_pointer_t<typename decltype(T::impl)::element_type>
 getRawSyclObjImpl(const T &SyclObject) {
   return SyclObject.impl.get();
 }
diff --git a/sycl/include/sycl/detail/generic_type_lists.hpp b/sycl/include/sycl/detail/generic_type_lists.hpp
index d9fb70e5c86a9..0b9d89046b601 100644
--- a/sycl/include/sycl/detail/generic_type_lists.hpp
+++ b/sycl/include/sycl/detail/generic_type_lists.hpp
@@ -432,36 +432,39 @@ using marray_byte_list = type_list<marray<std::byte, 1>, marray<std::byte, 2>,
 #endif
 
 // integer types
-using scalar_signed_integer_list = type_list<
-    conditional_t<std::is_signed<char>::value,
+using scalar_signed_integer_list =
+    type_list<std::conditional_t<
+                  std::is_signed<char>::value,
                   type_list<scalar_default_char_list, scalar_signed_char_list>,
                   scalar_signed_char_list>,
-    scalar_signed_short_list, scalar_signed_int_list, scalar_signed_long_list,
-    scalar_signed_longlong_list>;
+              scalar_signed_short_list, scalar_signed_int_list,
+              scalar_signed_long_list, scalar_signed_longlong_list>;
 
-using vector_signed_integer_list = type_list<
-    conditional_t<std::is_signed<char>::value,
+using vector_signed_integer_list =
+    type_list<std::conditional_t<
+                  std::is_signed<char>::value,
                   type_list<vector_default_char_list, vector_signed_char_list>,
                   vector_signed_char_list>,
-    vector_signed_short_list, vector_signed_int_list, vector_signed_long_list,
-    vector_signed_longlong_list>;
+              vector_signed_short_list, vector_signed_int_list,
+              vector_signed_long_list, vector_signed_longlong_list>;
 
-using marray_signed_integer_list = type_list<
-    conditional_t<std::is_signed<char>::value,
+using marray_signed_integer_list =
+    type_list<std::conditional_t<
+                  std::is_signed<char>::value,
                   type_list<marray_default_char_list, marray_signed_char_list>,
                   marray_signed_char_list>,
-    marray_signed_short_list, marray_signed_int_list, marray_signed_long_list,
-    marray_signed_longlong_list>;
+              marray_signed_short_list, marray_signed_int_list,
+              marray_signed_long_list, marray_signed_longlong_list>;
 
 using signed_integer_list =
     type_list<scalar_signed_integer_list, vector_signed_integer_list,
               marray_signed_integer_list>;
 
 using scalar_unsigned_integer_list =
-    type_list<conditional_t<std::is_unsigned<char>::value,
-                            type_list<scalar_default_char_list,
-                                      scalar_unsigned_char_list>,
-                            scalar_unsigned_char_list>,
+    type_list<std::conditional_t<std::is_unsigned<char>::value,
+                                 type_list<scalar_default_char_list,
+                                           scalar_unsigned_char_list>,
+                                 scalar_unsigned_char_list>,
               scalar_unsigned_short_list, scalar_unsigned_int_list,
               scalar_unsigned_long_list, scalar_unsigned_longlong_list
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
@@ -471,10 +474,10 @@ using scalar_unsigned_integer_list =
               >;
 
 using vector_unsigned_integer_list =
-    type_list<conditional_t<std::is_unsigned<char>::value,
-                            type_list<vector_default_char_list,
-                                      vector_unsigned_char_list>,
-                            vector_unsigned_char_list>,
+    type_list<std::conditional_t<std::is_unsigned<char>::value,
+                                 type_list<vector_default_char_list,
+                                           vector_unsigned_char_list>,
+                                 vector_unsigned_char_list>,
               vector_unsigned_short_list, vector_unsigned_int_list,
               vector_unsigned_long_list, vector_unsigned_longlong_list
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
@@ -484,10 +487,10 @@ using vector_unsigned_integer_list =
               >;
 
 using marray_unsigned_integer_list =
-    type_list<conditional_t<std::is_unsigned<char>::value,
-                            type_list<marray_default_char_list,
-                                      marray_unsigned_char_list>,
-                            marray_unsigned_char_list>,
+    type_list<std::conditional_t<std::is_unsigned<char>::value,
+                                 type_list<marray_default_char_list,
+                                           marray_unsigned_char_list>,
+                                 marray_unsigned_char_list>,
               marray_unsigned_short_list, marray_unsigned_int_list,
               marray_unsigned_long_list, marray_unsigned_longlong_list
 #if (!defined(_HAS_STD_BYTE) || _HAS_STD_BYTE != 0)
diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index a4b37064e4f39..69986aed3bc80 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -60,7 +60,7 @@ template <typename T>
 using is_svgenfloat = is_contained<T, gtl::scalar_vector_floating_list>;
 
 template <typename T>
-using is_mgenfloat = bool_constant<
+using is_mgenfloat = std::bool_constant<
     std::is_same<T, sycl::marray<marray_element_t<T>, T::size()>>::value &&
     is_svgenfloat<marray_element_t<T>>::value>;
 
@@ -237,13 +237,13 @@ template <typename T>
 using is_geninteger64bit = is_gen_based_on_type_sizeof<T, 8, is_geninteger>;
 
 template <typename T>
-using is_genintptr = bool_constant<
+using is_genintptr = std::bool_constant<
     is_pointer<T>::value && is_genint<remove_pointer_t<T>>::value &&
     is_address_space_compliant<T, gvl::nonconst_address_space_list>::value>;
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-using is_genintptr_marray = bool_constant<
+using is_genintptr_marray = std::bool_constant<
     std::is_same<T, sycl::marray<marray_element_t<T>, T::size()>>::value &&
     is_genint<marray_element_t<remove_pointer_t<T>>>::value &&
     is_address_space_compliant<multi_ptr<T, AddressSpace, IsDecorated>,
@@ -252,13 +252,13 @@ using is_genintptr_marray = bool_constant<
      IsDecorated == access::decorated::no)>;
 
 template <typename T>
-using is_genfloatptr = bool_constant<
+using is_genfloatptr = std::bool_constant<
     is_pointer<T>::value && is_genfloat<remove_pointer_t<T>>::value &&
     is_address_space_compliant<T, gvl::nonconst_address_space_list>::value>;
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-using is_genfloatptr_marray = bool_constant<
+using is_genfloatptr_marray = std::bool_constant<
     is_mgenfloat<T>::value &&
     is_address_space_compliant<multi_ptr<T, AddressSpace, IsDecorated>,
                                gvl::nonconst_address_space_list>::value &&
@@ -266,7 +266,7 @@ using is_genfloatptr_marray = bool_constant<
      IsDecorated == access::decorated::no)>;
 
 template <typename T>
-using is_genptr = bool_constant<
+using is_genptr = std::bool_constant<
     is_pointer<T>::value && is_gentype<remove_pointer_t<T>>::value &&
     is_address_space_compliant<T, gvl::nonconst_address_space_list>::value>;
 
@@ -277,22 +277,22 @@ template <typename T, typename Enable = void> struct nan_types;
 
 template <typename T>
 struct nan_types<
-    T, enable_if_t<is_contained<T, gtl::unsigned_short_list>::value, T>> {
+    T, std::enable_if_t<is_contained<T, gtl::unsigned_short_list>::value, T>> {
   using ret_type = change_base_type_t<T, half>;
   using arg_type = find_same_size_type_t<gtl::scalar_unsigned_short_list, half>;
 };
 
 template <typename T>
 struct nan_types<
-    T, enable_if_t<is_contained<T, gtl::unsigned_int_list>::value, T>> {
+    T, std::enable_if_t<is_contained<T, gtl::unsigned_int_list>::value, T>> {
   using ret_type = change_base_type_t<T, float>;
   using arg_type = find_same_size_type_t<gtl::scalar_unsigned_int_list, float>;
 };
 
 template <typename T>
 struct nan_types<
-    T,
-    enable_if_t<is_contained<T, gtl::unsigned_long_integer_list>::value, T>> {
+    T, std::enable_if_t<is_contained<T, gtl::unsigned_long_integer_list>::value,
+                        T>> {
   using ret_type = change_base_type_t<T, double>;
   using arg_type =
       find_same_size_type_t<gtl::scalar_unsigned_long_integer_list, double>;
@@ -317,12 +317,14 @@ template <typename T, typename B, typename Enable = void>
 struct convert_data_type_impl;
 
 template <typename T, typename B>
-struct convert_data_type_impl<T, B, enable_if_t<is_sgentype<T>::value, T>> {
+struct convert_data_type_impl<T, B,
+                              std::enable_if_t<is_sgentype<T>::value, T>> {
   B operator()(T t) { return static_cast<B>(t); }
 };
 
 template <typename T, typename B>
-struct convert_data_type_impl<T, B, enable_if_t<is_vgentype<T>::value, T>> {
+struct convert_data_type_impl<T, B,
+                              std::enable_if_t<is_vgentype<T>::value, T>> {
   vec<B, T::size()> operator()(T t) { return t.template convert<B>(); }
 };
 
@@ -420,9 +422,8 @@ struct PointerConverter<multi_ptr<ElementType, Space, DecorateAddress>> {
   }
 };
 
-template <
-    typename To, typename From,
-    typename = typename detail::enable_if_t<TryToGetPointerT<From>::value>>
+template <typename To, typename From,
+          typename = typename std::enable_if_t<TryToGetPointerT<From>::value>>
 To ConvertNonVectorType(From &t) {
   return PointerConverter<To>::Convert(t);
 }
@@ -432,7 +433,7 @@ template <typename To, typename From> To ConvertNonVectorType(From *t) {
 }
 
 template <typename To, typename From>
-typename detail::enable_if_t<!TryToGetPointerT<From>::value, To>
+typename std::enable_if_t<!TryToGetPointerT<From>::value, To>
 ConvertNonVectorType(From &t) {
   return static_cast<To>(t);
 }
@@ -459,10 +460,10 @@ using mptr_or_vec_elem_type_t = typename mptr_or_vec_elem_type<T>::type;
 // select_apply_cl_scalar_t selects from T8/T16/T32/T64 basing on
 // sizeof(IN).  expected to handle scalar types.
 template <typename T, typename T8, typename T16, typename T32, typename T64>
-using select_apply_cl_scalar_t =
-    conditional_t<sizeof(T) == 1, T8,
-                  conditional_t<sizeof(T) == 2, T16,
-                                conditional_t<sizeof(T) == 4, T32, T64>>>;
+using select_apply_cl_scalar_t = std::conditional_t<
+    sizeof(T) == 1, T8,
+    std::conditional_t<sizeof(T) == 2, T16,
+                       std::conditional_t<sizeof(T) == 4, T32, T64>>>;
 
 // Shortcuts for selecting scalar int/unsigned int/fp type.
 template <typename T>
@@ -490,22 +491,23 @@ using select_cl_scalar_complex_or_T_t = std::conditional_t<
 
 template <typename T>
 using select_cl_scalar_integral_t =
-    conditional_t<std::is_signed<T>::value,
-                  select_cl_scalar_integral_signed_t<T>,
-                  select_cl_scalar_integral_unsigned_t<T>>;
+    std::conditional_t<std::is_signed<T>::value,
+                       select_cl_scalar_integral_signed_t<T>,
+                       select_cl_scalar_integral_unsigned_t<T>>;
 
 // select_cl_scalar_t picks corresponding cl_* type for input
 // scalar T or returns T if T is not scalar.
 template <typename T>
-using select_cl_scalar_t = conditional_t<
+using select_cl_scalar_t = std::conditional_t<
     std::is_integral<T>::value, select_cl_scalar_integral_t<T>,
-    conditional_t<std::is_floating_point<T>::value, select_cl_scalar_float_t<T>,
-                  // half is a special case: it is implemented differently on
-                  // host and device and therefore, might lower to different
-                  // types
-                  conditional_t<std::is_same<T, half>::value,
-                                sycl::detail::half_impl::BIsRepresentationT,
-                                select_cl_scalar_complex_or_T_t<T>>>>;
+    std::conditional_t<
+        std::is_floating_point<T>::value, select_cl_scalar_float_t<T>,
+        // half is a special case: it is implemented differently on
+        // host and device and therefore, might lower to different
+        // types
+        std::conditional_t<std::is_same<T, half>::value,
+                           sycl::detail::half_impl::BIsRepresentationT,
+                           select_cl_scalar_complex_or_T_t<T>>>>;
 
 // select_cl_vector_or_scalar_or_ptr does cl_* type selection for element type
 // of a vector type T, pointer type substitution, and scalar type substitution.
@@ -515,28 +517,29 @@ struct select_cl_vector_or_scalar_or_ptr;
 
 template <typename T>
 struct select_cl_vector_or_scalar_or_ptr<
-    T, typename detail::enable_if_t<is_vgentype<T>::value>> {
+    T, typename std::enable_if_t<is_vgentype<T>::value>> {
   using type =
       // select_cl_scalar_t returns _Float16, so, we try to instantiate vec
       // class with _Float16 DataType, which is not expected there
       // So, leave vector<half, N> as-is
-      vec<conditional_t<std::is_same<mptr_or_vec_elem_type_t<T>, half>::value,
-                        mptr_or_vec_elem_type_t<T>,
-                        select_cl_scalar_t<mptr_or_vec_elem_type_t<T>>>,
+      vec<std::conditional_t<
+              std::is_same<mptr_or_vec_elem_type_t<T>, half>::value,
+              mptr_or_vec_elem_type_t<T>,
+              select_cl_scalar_t<mptr_or_vec_elem_type_t<T>>>,
           T::size()>;
 };
 
 template <typename T>
 struct select_cl_vector_or_scalar_or_ptr<
-    T, typename detail::enable_if_t<!is_vgentype<T>::value &&
-                                    !std::is_pointer<T>::value>> {
+    T, typename std::enable_if_t<!is_vgentype<T>::value &&
+                                 !std::is_pointer<T>::value>> {
   using type = select_cl_scalar_t<T>;
 };
 
 template <typename T>
 struct select_cl_vector_or_scalar_or_ptr<
-    T, typename detail::enable_if_t<!is_vgentype<T>::value &&
-                                    std::is_pointer<T>::value>> {
+    T, typename std::enable_if_t<!is_vgentype<T>::value &&
+                                 std::is_pointer<T>::value>> {
   using elem_ptr_type = typename select_cl_vector_or_scalar_or_ptr<
       std::remove_pointer_t<T>>::type *;
 #ifdef __SYCL_DEVICE_ONLY__
@@ -569,8 +572,8 @@ template <typename T> using type_helper = typename TypeHelper<T>::RetType;
 
 template <typename T>
 struct select_cl_mptr_or_vector_or_scalar_or_ptr<
-    T, typename detail::enable_if_t<is_genptr<T>::value &&
-                                    !std::is_pointer<T>::value>> {
+    T, typename std::enable_if_t<is_genptr<T>::value &&
+                                 !std::is_pointer<T>::value>> {
   using type = multi_ptr<typename select_cl_vector_or_scalar_or_ptr<
                              type_helper<mptr_or_vec_elem_type_t<T>>>::type,
                          T::address_space, access::decorated::yes>;
@@ -578,8 +581,8 @@ struct select_cl_mptr_or_vector_or_scalar_or_ptr<
 
 template <typename T>
 struct select_cl_mptr_or_vector_or_scalar_or_ptr<
-    T, typename detail::enable_if_t<!is_genptr<T>::value ||
-                                    std::is_pointer<T>::value>> {
+    T, typename std::enable_if_t<!is_genptr<T>::value ||
+                                 std::is_pointer<T>::value>> {
   using type = typename select_cl_vector_or_scalar_or_ptr<T>::type;
 };
 
@@ -591,10 +594,10 @@ using SelectMatchingOpenCLType_t =
 // Converts T to OpenCL friendly
 //
 template <typename T /* MatchingOpencCLTypeT */>
-using ConvertToOpenCLTypeImpl_t =
-    conditional_t<TryToGetVectorT<T>::value, typename TryToGetVectorT<T>::type,
-                  conditional_t<TryToGetPointerT<T>::value,
-                                typename TryToGetPointerVecT<T>::type, T>>;
+using ConvertToOpenCLTypeImpl_t = std::conditional_t<
+    TryToGetVectorT<T>::value, typename TryToGetVectorT<T>::type,
+    std::conditional_t<TryToGetPointerT<T>::value,
+                       typename TryToGetPointerVecT<T>::type, T>>;
 template <typename T>
 using ConvertToOpenCLType_t =
     ConvertToOpenCLTypeImpl_t<SelectMatchingOpenCLType_t<T>>;
@@ -602,19 +605,18 @@ using ConvertToOpenCLType_t =
 // convertDataToType() function converts data from FROM type to TO type using
 // 'as' method for vector type and copy otherwise.
 template <typename FROM, typename TO>
-typename detail::enable_if_t<is_vgentype<FROM>::value &&
-                                 is_vgentype<TO>::value &&
-                                 sizeof(TO) == sizeof(FROM),
-                             TO>
+typename std::enable_if_t<is_vgentype<FROM>::value && is_vgentype<TO>::value &&
+                              sizeof(TO) == sizeof(FROM),
+                          TO>
 convertDataToType(FROM t) {
   return t.template as<TO>();
 }
 
 template <typename FROM, typename TO>
-typename detail::enable_if_t<!(is_vgentype<FROM>::value &&
-                               is_vgentype<TO>::value) &&
-                                 sizeof(TO) == sizeof(FROM),
-                             TO>
+typename std::enable_if_t<!(is_vgentype<FROM>::value &&
+                            is_vgentype<TO>::value) &&
+                              sizeof(TO) == sizeof(FROM),
+                          TO>
 convertDataToType(FROM t) {
   return ConvertNonVectorType<TO>(t);
 }
@@ -638,12 +640,12 @@ template <typename T> inline constexpr bool msbIsSet(const T x) {
 // TODO: marray support isn't implemented yet.
 template <typename T>
 using common_rel_ret_t =
-    conditional_t<is_vgentype<T>::value, make_singed_integer_t<T>, bool>;
+    std::conditional_t<is_vgentype<T>::value, make_singed_integer_t<T>, bool>;
 
 // TODO: Remove this when common_rel_ret_t is promoted.
 template <typename T>
 using internal_host_rel_ret_t =
-    conditional_t<is_vgentype<T>::value, make_singed_integer_t<T>, int>;
+    std::conditional_t<is_vgentype<T>::value, make_singed_integer_t<T>, int>;
 #else
 // SYCL 1.2.1 4.13.7 (Relation functions), e.g.
 //
@@ -657,7 +659,7 @@ using internal_host_rel_ret_t =
 // Fixing it would be an ABI-breaking change so isn't done.
 template <typename T>
 using common_rel_ret_t =
-    conditional_t<is_vgentype<T>::value, make_singed_integer_t<T>, int>;
+    std::conditional_t<is_vgentype<T>::value, make_singed_integer_t<T>, int>;
 template <typename T> using internal_host_rel_ret_t = common_rel_ret_t<T>;
 #endif
 
@@ -669,12 +671,12 @@ template <typename T, typename Enable = void> struct TryToGetNumElements;
 
 template <typename T>
 struct TryToGetNumElements<
-    T, typename detail::enable_if_t<TryToGetVectorT<T>::value>> {
+    T, typename std::enable_if_t<TryToGetVectorT<T>::value>> {
   static constexpr int value = T::size();
 };
 template <typename T>
 struct TryToGetNumElements<
-    T, typename detail::enable_if_t<!TryToGetVectorT<T>::value>> {
+    T, typename std::enable_if_t<!TryToGetVectorT<T>::value>> {
   static constexpr int value = 1;
 };
 
@@ -721,8 +723,8 @@ using rel_sign_bit_test_arg_t =
 template <typename T, typename Enable = void> struct RelConverter;
 
 template <typename T>
-struct RelConverter<
-    T, typename detail::enable_if_t<TryToGetElementType<T>::value>> {
+struct RelConverter<T,
+                    typename std::enable_if_t<TryToGetElementType<T>::value>> {
   static const int N = T::size();
 #ifdef __SYCL_DEVICE_ONLY__
   using bool_t = typename Boolean<N>::vector_t;
@@ -746,8 +748,8 @@ struct RelConverter<
 };
 
 template <typename T>
-struct RelConverter<
-    T, typename detail::enable_if_t<!TryToGetElementType<T>::value>> {
+struct RelConverter<T,
+                    typename std::enable_if_t<!TryToGetElementType<T>::value>> {
   using R = internal_rel_ret_t<T>;
 #ifdef __SYCL_DEVICE_ONLY__
   using value_t = bool;
diff --git a/sycl/include/sycl/detail/helpers.hpp b/sycl/include/sycl/detail/helpers.hpp
index ad173f45fa6e6..daa8a2fe0203a 100644
--- a/sycl/include/sycl/detail/helpers.hpp
+++ b/sycl/include/sycl/detail/helpers.hpp
@@ -82,14 +82,14 @@ class Builder {
   }
 
   template <int Dims, bool WithOffset>
-  static detail::enable_if_t<WithOffset, item<Dims, WithOffset>>
+  static std::enable_if_t<WithOffset, item<Dims, WithOffset>>
   createItem(const range<Dims> &Extent, const id<Dims> &Index,
              const id<Dims> &Offset) {
     return item<Dims, WithOffset>(Extent, Index, Offset);
   }
 
   template <int Dims, bool WithOffset>
-  static detail::enable_if_t<!WithOffset, item<Dims, WithOffset>>
+  static std::enable_if_t<!WithOffset, item<Dims, WithOffset>>
   createItem(const range<Dims> &Extent, const id<Dims> &Index) {
     return item<Dims, WithOffset>(Extent, Index);
   }
@@ -140,8 +140,7 @@ class Builder {
   }
 
   template <int Dims, bool WithOffset>
-  static detail::enable_if_t<WithOffset, const item<Dims, WithOffset>>
-  getItem() {
+  static std::enable_if_t<WithOffset, const item<Dims, WithOffset>> getItem() {
     static_assert(is_valid_dimensions<Dims>::value, "invalid dimensions");
     id<Dims> GlobalId{__spirv::initGlobalInvocationId<Dims, id<Dims>>()};
     range<Dims> GlobalSize{__spirv::initGlobalSize<Dims, range<Dims>>()};
@@ -150,8 +149,7 @@ class Builder {
   }
 
   template <int Dims, bool WithOffset>
-  static detail::enable_if_t<!WithOffset, const item<Dims, WithOffset>>
-  getItem() {
+  static std::enable_if_t<!WithOffset, const item<Dims, WithOffset>> getItem() {
     static_assert(is_valid_dimensions<Dims>::value, "invalid dimensions");
     id<Dims> GlobalId{__spirv::initGlobalInvocationId<Dims, id<Dims>>()};
     range<Dims> GlobalSize{__spirv::initGlobalSize<Dims, range<Dims>>()};
diff --git a/sycl/include/sycl/detail/image_accessor_util.hpp b/sycl/include/sycl/detail/image_accessor_util.hpp
index 959293cb4f5a3..ea32edf9d4775 100644
--- a/sycl/include/sycl/detail/image_accessor_util.hpp
+++ b/sycl/include/sycl/detail/image_accessor_util.hpp
@@ -34,19 +34,19 @@ using IsValidCoordType = typename is_contained<
 // The formula for unnormalization coordinates:
 // NormalizedCoords = [UnnormalizedCoords[i] * Range[i] for i in range(0, 3)]
 template <typename T>
-detail::enable_if_t<IsValidCoordType<T>::value, T>
+std::enable_if_t<IsValidCoordType<T>::value, T>
 UnnormalizeCoordinates(const T &Coords, const range<3> &Range) {
   return Coords * Range[0];
 }
 
 template <typename T>
-detail::enable_if_t<IsValidCoordType<T>::value, vec<T, 2>>
+std::enable_if_t<IsValidCoordType<T>::value, vec<T, 2>>
 UnnormalizeCoordinates(const vec<T, 2> &Coords, const range<3> &Range) {
   return {Coords.x() * Range[0], Coords.y() * Range[1]};
 }
 
 template <typename T>
-detail::enable_if_t<IsValidCoordType<T>::value, vec<T, 4>>
+std::enable_if_t<IsValidCoordType<T>::value, vec<T, 4>>
 UnnormalizeCoordinates(const vec<T, 4> &Coords, const range<3> &Range) {
   return {Coords.x() * Range[0], Coords.y() * Range[1], Coords.z() * Range[2],
           0};
@@ -57,20 +57,19 @@ UnnormalizeCoordinates(const vec<T, 4> &Coords, const range<3> &Range) {
 // calculation won't pass 0.
 // Non-valid coordinates are written as 0.
 template <typename T>
-detail::enable_if_t<IsValidCoordType<T>::value, float4>
-convertToFloat4(T Coords) {
+std::enable_if_t<IsValidCoordType<T>::value, float4> convertToFloat4(T Coords) {
   return {static_cast<float>(Coords), 0.5f, 0.5f, 0.f};
 }
 
 template <typename T>
-detail::enable_if_t<IsValidCoordType<T>::value, float4>
+std::enable_if_t<IsValidCoordType<T>::value, float4>
 convertToFloat4(vec<T, 2> Coords) {
   return {static_cast<float>(Coords.x()), static_cast<float>(Coords.y()), 0.5f,
           0.f};
 }
 
 template <typename T>
-detail::enable_if_t<IsValidCoordType<T>::value, float4>
+std::enable_if_t<IsValidCoordType<T>::value, float4>
 convertToFloat4(vec<T, 4> Coords) {
   return {static_cast<float>(Coords.x()), static_cast<float>(Coords.y()),
           static_cast<float>(Coords.z()), 0.f};
@@ -80,20 +79,20 @@ convertToFloat4(vec<T, 4> Coords) {
 // Retured offset is used to find the address location of a pixel from a base
 // ptr.
 template <typename T>
-detail::enable_if_t<std::is_integral<T>::value, size_t>
+std::enable_if_t<std::is_integral<T>::value, size_t>
 getImageOffset(const T &Coords, const id<3>, const uint8_t ElementSize) {
   return Coords * ElementSize;
 }
 
 template <typename T>
-detail::enable_if_t<std::is_integral<T>::value, size_t>
+std::enable_if_t<std::is_integral<T>::value, size_t>
 getImageOffset(const vec<T, 2> &Coords, const id<3> ImgPitch,
                const uint8_t ElementSize) {
   return Coords.x() * ElementSize + Coords.y() * ImgPitch[0];
 }
 
 template <typename T>
-detail::enable_if_t<std::is_integral<T>::value, size_t>
+std::enable_if_t<std::is_integral<T>::value, size_t>
 getImageOffset(const vec<T, 4> &Coords, const id<3> ImgPitch,
                const uint8_t ElementSize) {
   return Coords.x() * ElementSize + Coords.y() * ImgPitch[0] +
diff --git a/sycl/include/sycl/detail/property_list_base.hpp b/sycl/include/sycl/detail/property_list_base.hpp
index d59d6f328fed5..8cccc8bda5dd1 100644
--- a/sycl/include/sycl/detail/property_list_base.hpp
+++ b/sycl/include/sycl/detail/property_list_base.hpp
@@ -32,8 +32,7 @@ class PropertyListBase {
   void ctorHelper() {}
 
   template <typename... PropsT, class PropT>
-  typename detail::enable_if_t<
-      std::is_base_of<DataLessPropertyBase, PropT>::value>
+  typename std::enable_if_t<std::is_base_of<DataLessPropertyBase, PropT>::value>
   ctorHelper(PropT &, PropsT... Props) {
     const int PropKind = static_cast<int>(PropT::getKind());
     MDataLessProps[PropKind] = true;
@@ -41,8 +40,7 @@ class PropertyListBase {
   }
 
   template <typename... PropsT, class PropT>
-  typename detail::enable_if_t<
-      std::is_base_of<PropertyWithDataBase, PropT>::value>
+  typename std::enable_if_t<std::is_base_of<PropertyWithDataBase, PropT>::value>
   ctorHelper(PropT &Prop, PropsT... Props) {
     MPropsWithData.emplace_back(new PropT(Prop));
     ctorHelper(Props...);
@@ -50,7 +48,7 @@ class PropertyListBase {
 
   // Compile-time-constant properties are simply skipped
   template <typename... PropsT, class PropT>
-  typename detail::enable_if_t<
+  typename std::enable_if_t<
       !std::is_base_of<PropertyWithDataBase, PropT>::value &&
       !std::is_base_of<DataLessPropertyBase, PropT>::value>
   ctorHelper(PropT &, PropsT... Props) {
@@ -58,8 +56,8 @@ class PropertyListBase {
   }
 
   template <typename PropT>
-  typename detail::enable_if_t<
-      std::is_base_of<DataLessPropertyBase, PropT>::value, bool>
+  typename std::enable_if_t<std::is_base_of<DataLessPropertyBase, PropT>::value,
+                            bool>
   has_property_helper() const noexcept {
     const int PropKind = static_cast<int>(PropT::getKind());
     if (PropKind > detail::DataLessPropKind::LastKnownDataLessPropKind)
@@ -68,8 +66,8 @@ class PropertyListBase {
   }
 
   template <typename PropT>
-  typename detail::enable_if_t<
-      std::is_base_of<PropertyWithDataBase, PropT>::value, bool>
+  typename std::enable_if_t<std::is_base_of<PropertyWithDataBase, PropT>::value,
+                            bool>
   has_property_helper() const noexcept {
     const int PropKind = static_cast<int>(PropT::getKind());
     for (const std::shared_ptr<PropertyWithDataBase> &Prop : MPropsWithData)
@@ -79,16 +77,16 @@ class PropertyListBase {
   }
 
   template <typename PropT>
-  typename detail::enable_if_t<
-      std::is_base_of<DataLessPropertyBase, PropT>::value, PropT>
+  typename std::enable_if_t<std::is_base_of<DataLessPropertyBase, PropT>::value,
+                            PropT>
   get_property_helper() const {
     // In case of simple property we can just construct it
     return PropT{};
   }
 
   template <typename PropT>
-  typename detail::enable_if_t<
-      std::is_base_of<PropertyWithDataBase, PropT>::value, PropT>
+  typename std::enable_if_t<std::is_base_of<PropertyWithDataBase, PropT>::value,
+                            PropT>
   get_property_helper() const {
     const int PropKind = static_cast<int>(PropT::getKind());
     if (PropKind >= PropWithDataKind::PropWithDataKindSize)
diff --git a/sycl/include/sycl/detail/spirv.hpp b/sycl/include/sycl/detail/spirv.hpp
index 40af0470a749a..b1be5db439aed 100644
--- a/sycl/include/sycl/detail/spirv.hpp
+++ b/sycl/include/sycl/detail/spirv.hpp
@@ -140,22 +140,23 @@ bool GroupAny(ext::oneapi::experimental::ballot_group<ParentGroup> g,
 // types.
 template <typename T>
 using is_native_broadcast =
-    bool_constant<detail::is_arithmetic<T>::value &&
-                  !std::is_same<T, half>::value && !detail::is_vec<T>::value>;
+    std::bool_constant<detail::is_arithmetic<T>::value &&
+                       !std::is_same<T, half>::value &&
+                       !detail::is_vec<T>::value>;
 
 template <typename T, typename IdT = size_t>
-using EnableIfNativeBroadcast = detail::enable_if_t<
+using EnableIfNativeBroadcast = std::enable_if_t<
     is_native_broadcast<T>::value && std::is_integral<IdT>::value, T>;
 
 // Bitcast broadcasts can be implemented using a single SPIR-V GroupBroadcast
 // intrinsic, but require type-punning via an appropriate integer type
 template <typename T>
-using is_bitcast_broadcast = bool_constant<
+using is_bitcast_broadcast = std::bool_constant<
     !is_native_broadcast<T>::value && std::is_trivially_copyable<T>::value &&
     (sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8)>;
 
 template <typename T, typename IdT = size_t>
-using EnableIfBitcastBroadcast = detail::enable_if_t<
+using EnableIfBitcastBroadcast = std::enable_if_t<
     is_bitcast_broadcast<T>::value && std::is_integral<IdT>::value, T>;
 
 template <typename T>
@@ -167,20 +168,21 @@ using ConvertToNativeBroadcastType_t = select_cl_scalar_integral_unsigned_t<T>;
 // - At most one 32-bit, 16-bit and 8-bit chunk left over
 template <typename T>
 using is_generic_broadcast =
-    bool_constant<!is_native_broadcast<T>::value &&
-                  !is_bitcast_broadcast<T>::value &&
-                  std::is_trivially_copyable<T>::value>;
+    std::bool_constant<!is_native_broadcast<T>::value &&
+                       !is_bitcast_broadcast<T>::value &&
+                       std::is_trivially_copyable<T>::value>;
 
 template <typename T, typename IdT = size_t>
-using EnableIfGenericBroadcast = detail::enable_if_t<
+using EnableIfGenericBroadcast = std::enable_if_t<
     is_generic_broadcast<T>::value && std::is_integral<IdT>::value, T>;
 
 // FIXME: Disable widening once all backends support all data types.
 template <typename T>
-using WidenOpenCLTypeTo32_t = conditional_t<
+using WidenOpenCLTypeTo32_t = std::conditional_t<
     std::is_same<T, cl_char>() || std::is_same<T, cl_short>(), cl_int,
-    conditional_t<std::is_same<T, cl_uchar>() || std::is_same<T, cl_ushort>(),
-                  cl_uint, T>>;
+    std::conditional_t<std::is_same<T, cl_uchar>() ||
+                           std::is_same<T, cl_ushort>(),
+                       cl_uint, T>>;
 
 // Broadcast with scalar local index
 // Work-group supports any integral type
@@ -356,7 +358,7 @@ static inline constexpr __spv::Scope::Flag getScope(memory_scope Scope) {
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_integral<T>::value, T>
+inline typename std::enable_if_t<std::is_integral<T>::value, T>
 AtomicCompareExchange(multi_ptr<T, AddressSpace, IsDecorated> MPtr,
                       memory_scope Scope, memory_order Success,
                       memory_order Failure, T Desired, T Expected) {
@@ -370,7 +372,7 @@ AtomicCompareExchange(multi_ptr<T, AddressSpace, IsDecorated> MPtr,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_floating_point<T>::value, T>
+inline typename std::enable_if_t<std::is_floating_point<T>::value, T>
 AtomicCompareExchange(multi_ptr<T, AddressSpace, IsDecorated> MPtr,
                       memory_scope Scope, memory_order Success,
                       memory_order Failure, T Desired, T Expected) {
@@ -388,7 +390,7 @@ AtomicCompareExchange(multi_ptr<T, AddressSpace, IsDecorated> MPtr,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_integral<T>::value, T>
+inline typename std::enable_if_t<std::is_integral<T>::value, T>
 AtomicLoad(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
            memory_order Order) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -399,7 +401,7 @@ AtomicLoad(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_floating_point<T>::value, T>
+inline typename std::enable_if_t<std::is_floating_point<T>::value, T>
 AtomicLoad(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
            memory_order Order) {
   using I = detail::make_unsinged_integer_t<T>;
@@ -412,7 +414,7 @@ AtomicLoad(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_integral<T>::value>
+inline typename std::enable_if_t<std::is_integral<T>::value>
 AtomicStore(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
             memory_order Order, T Value) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -423,7 +425,7 @@ AtomicStore(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_floating_point<T>::value>
+inline typename std::enable_if_t<std::is_floating_point<T>::value>
 AtomicStore(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
             memory_order Order, T Value) {
   using I = detail::make_unsinged_integer_t<T>;
@@ -436,7 +438,7 @@ AtomicStore(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_integral<T>::value, T>
+inline typename std::enable_if_t<std::is_integral<T>::value, T>
 AtomicExchange(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
                memory_order Order, T Value) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -447,7 +449,7 @@ AtomicExchange(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_floating_point<T>::value, T>
+inline typename std::enable_if_t<std::is_floating_point<T>::value, T>
 AtomicExchange(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
                memory_order Order, T Value) {
   using I = detail::make_unsinged_integer_t<T>;
@@ -462,7 +464,7 @@ AtomicExchange(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_integral<T>::value, T>
+inline typename std::enable_if_t<std::is_integral<T>::value, T>
 AtomicIAdd(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
            memory_order Order, T Value) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -473,7 +475,7 @@ AtomicIAdd(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_integral<T>::value, T>
+inline typename std::enable_if_t<std::is_integral<T>::value, T>
 AtomicISub(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
            memory_order Order, T Value) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -484,7 +486,7 @@ AtomicISub(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_floating_point<T>::value, T>
+inline typename std::enable_if_t<std::is_floating_point<T>::value, T>
 AtomicFAdd(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
            memory_order Order, T Value) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -495,7 +497,7 @@ AtomicFAdd(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_integral<T>::value, T>
+inline typename std::enable_if_t<std::is_integral<T>::value, T>
 AtomicAnd(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
           memory_order Order, T Value) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -506,7 +508,7 @@ AtomicAnd(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_integral<T>::value, T>
+inline typename std::enable_if_t<std::is_integral<T>::value, T>
 AtomicOr(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
          memory_order Order, T Value) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -517,7 +519,7 @@ AtomicOr(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_integral<T>::value, T>
+inline typename std::enable_if_t<std::is_integral<T>::value, T>
 AtomicXor(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
           memory_order Order, T Value) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -528,7 +530,7 @@ AtomicXor(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_integral<T>::value, T>
+inline typename std::enable_if_t<std::is_integral<T>::value, T>
 AtomicMin(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
           memory_order Order, T Value) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -539,7 +541,7 @@ AtomicMin(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_floating_point<T>::value, T>
+inline typename std::enable_if_t<std::is_floating_point<T>::value, T>
 AtomicMin(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
           memory_order Order, T Value) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -550,7 +552,7 @@ AtomicMin(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_integral<T>::value, T>
+inline typename std::enable_if_t<std::is_integral<T>::value, T>
 AtomicMax(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
           memory_order Order, T Value) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -561,7 +563,7 @@ AtomicMax(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T, access::address_space AddressSpace,
           access::decorated IsDecorated>
-inline typename detail::enable_if_t<std::is_floating_point<T>::value, T>
+inline typename std::enable_if_t<std::is_floating_point<T>::value, T>
 AtomicMax(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
           memory_order Order, T Value) {
   auto *Ptr = GetMultiPtrDecoratedAs<T>(MPtr);
@@ -581,11 +583,11 @@ AtomicMax(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 
 template <typename T>
 struct TypeIsProhibitedForShuffleEmulation
-    : bool_constant<std::is_same_v<vector_element_t<T>, double>> {};
+    : std::bool_constant<std::is_same_v<vector_element_t<T>, double>> {};
 
 template <typename T>
 struct VecTypeIsProhibitedForShuffleEmulation
-    : bool_constant<
+    : std::bool_constant<
           (detail::get_vec_size<T>::size > 1) &&
           TypeIsProhibitedForShuffleEmulation<vector_element_t<T>>::value> {};
 
@@ -912,13 +914,13 @@ ControlBarrier(Group, memory_scope FenceScope, memory_order Order) {
       Group##Instruction(Group G, T x) {                                       \
     using ConvertedT = detail::ConvertToOpenCLType_t<T>;                       \
                                                                                \
-    using OCLT =                                                               \
-        conditional_t<std::is_same<ConvertedT, cl_char>() ||                   \
-                          std::is_same<ConvertedT, cl_short>(),                \
-                      cl_int,                                                  \
-                      conditional_t<std::is_same<ConvertedT, cl_uchar>() ||    \
-                                        std::is_same<ConvertedT, cl_ushort>(), \
-                                    cl_uint, ConvertedT>>;                     \
+    using OCLT = std::conditional_t<                                           \
+        std::is_same<ConvertedT, cl_char>() ||                                 \
+            std::is_same<ConvertedT, cl_short>(),                              \
+        cl_int,                                                                \
+        std::conditional_t<std::is_same<ConvertedT, cl_uchar>() ||             \
+                               std::is_same<ConvertedT, cl_ushort>(),          \
+                           cl_uint, ConvertedT>>;                              \
     OCLT Arg = x;                                                              \
     OCLT Ret = __spirv_Group##Instruction(group_scope<Group>::value,           \
                                           static_cast<unsigned int>(Op), Arg); \
@@ -930,13 +932,13 @@ ControlBarrier(Group, memory_scope FenceScope, memory_order Order) {
       ext::oneapi::experimental::ballot_group<ParentGroup> g, T x) {           \
     using ConvertedT = detail::ConvertToOpenCLType_t<T>;                       \
                                                                                \
-    using OCLT =                                                               \
-        conditional_t<std::is_same<ConvertedT, cl_char>() ||                   \
-                          std::is_same<ConvertedT, cl_short>(),                \
-                      cl_int,                                                  \
-                      conditional_t<std::is_same<ConvertedT, cl_uchar>() ||    \
-                                        std::is_same<ConvertedT, cl_ushort>(), \
-                                    cl_uint, ConvertedT>>;                     \
+    using OCLT = std::conditional_t<                                           \
+        std::is_same<ConvertedT, cl_char>() ||                                 \
+            std::is_same<ConvertedT, cl_short>(),                              \
+        cl_int,                                                                \
+        std::conditional_t<std::is_same<ConvertedT, cl_uchar>() ||             \
+                               std::is_same<ConvertedT, cl_ushort>(),          \
+                           cl_uint, ConvertedT>>;                              \
     OCLT Arg = x;                                                              \
     /* ballot_group partitions its parent into two groups (0 and 1) */         \
     /* We have to force each group down different control flow */              \
diff --git a/sycl/include/sycl/detail/stl_type_traits.hpp b/sycl/include/sycl/detail/stl_type_traits.hpp
index efa7e7cc73d99..75ea871f4fbb6 100644
--- a/sycl/include/sycl/detail/stl_type_traits.hpp
+++ b/sycl/include/sycl/detail/stl_type_traits.hpp
@@ -17,37 +17,9 @@ namespace sycl {
 __SYCL_INLINE_VER_NAMESPACE(_V1) {
 namespace detail {
 
-// Type traits identical to those in std in newer versions. Can be removed when
-// SYCL requires a newer version of the C++ standard.
-// C++14
-template <bool B, class T = void>
-using enable_if_t = typename std::enable_if<B, T>::type;
-
-template <bool B, class T, class F>
-using conditional_t = typename std::conditional<B, T, F>::type;
-
-template <typename T>
-using remove_const_t = typename std::remove_const<T>::type;
-
-template <typename T> using remove_cv_t = typename std::remove_cv<T>::type;
-
-template <typename T>
-using remove_reference_t = typename std::remove_reference<T>::type;
-
-template <typename T> using add_pointer_t = typename std::add_pointer<T>::type;
-
-// C++17
-template <bool V> using bool_constant = std::integral_constant<bool, V>;
-
-template <class...> using void_t = void;
-
-// Custom type traits
-template <typename T>
-using allocator_value_type_t = typename std::allocator_traits<T>::value_type;
-
-template <typename T>
-using allocator_pointer_t = typename std::allocator_traits<T>::pointer;
-
+// Custom type traits.
+// FIXME: Those doesn't seem to be a part of any published/future C++ standard
+// so should probably be moved to a different place.
 template <typename T>
 using iterator_category_t = typename std::iterator_traits<T>::iterator_category;
 
@@ -65,9 +37,9 @@ using iterator_to_const_type_t =
 // https://en.cppreference.com/w/cpp/named_req/OutputIterator
 template <typename T>
 using output_iterator_requirements =
-    void_t<iterator_category_t<T>,
-           decltype(*std::declval<T>() =
-                        std::declval<iterator_value_type_t<T>>())>;
+    std::void_t<iterator_category_t<T>,
+                decltype(*std::declval<T>() =
+                             std::declval<iterator_value_type_t<T>>())>;
 
 template <typename, typename = void> struct is_output_iterator {
   static constexpr bool value = false;
diff --git a/sycl/include/sycl/detail/sycl_mem_obj_allocator.hpp b/sycl/include/sycl/detail/sycl_mem_obj_allocator.hpp
index 3a4f995a707f7..68532b1b064d1 100644
--- a/sycl/include/sycl/detail/sycl_mem_obj_allocator.hpp
+++ b/sycl/include/sycl/detail/sycl_mem_obj_allocator.hpp
@@ -66,11 +66,11 @@ class SYCLMemObjAllocatorHolder : public SYCLMemObjAllocator {
 
 private:
   template <typename T>
-  using EnableIfDefaultAllocator = enable_if_t<
+  using EnableIfDefaultAllocator = std::enable_if_t<
       std::is_same<T, sycl_memory_object_allocator<OwnerDataT>>::value>;
 
   template <typename T>
-  using EnableIfNonDefaultAllocator = enable_if_t<
+  using EnableIfNonDefaultAllocator = std::enable_if_t<
       !std::is_same<T, sycl_memory_object_allocator<OwnerDataT>>::value>;
 
   template <typename T = AllocatorT>
diff --git a/sycl/include/sycl/detail/type_list.hpp b/sycl/include/sycl/detail/type_list.hpp
index 441e5dfd4ba02..d322c1ee822b4 100644
--- a/sycl/include/sycl/detail/type_list.hpp
+++ b/sycl/include/sycl/detail/type_list.hpp
@@ -26,8 +26,8 @@ using empty_type_list = type_list<>;
 
 template <typename T>
 struct is_empty_type_list
-    : conditional_t<std::is_same<T, empty_type_list>::value, std::true_type,
-                    std::false_type> {};
+    : std::conditional_t<std::is_same<T, empty_type_list>::value,
+                         std::true_type, std::false_type> {};
 
 template <> struct type_list<> {};
 
@@ -46,14 +46,16 @@ struct type_list<type_list<Head, Tail...>, Tail2...> {
 
 public:
   using head = head_t<type_list<Head>>;
-  using tail = conditional_t<has_remainder, with_remainder, without_remainder>;
+  using tail =
+      std::conditional_t<has_remainder, with_remainder, without_remainder>;
 };
 
 // is_contained
 template <typename T, typename TypeList>
 struct is_contained
-    : conditional_t<std::is_same<remove_cv_t<T>, head_t<TypeList>>::value,
-                    std::true_type, is_contained<T, tail_t<TypeList>>> {};
+    : std::conditional_t<
+          std::is_same<std::remove_cv_t<T>, head_t<TypeList>>::value,
+          std::true_type, is_contained<T, tail_t<TypeList>>> {};
 
 template <typename T>
 struct is_contained<T, empty_type_list> : std::false_type {};
@@ -71,8 +73,8 @@ template <typename T> struct value_list<T> {};
 // is_contained_value
 template <typename T, T Value, typename ValueList>
 struct is_contained_value
-    : conditional_t<Value == ValueList::head, std::true_type,
-                    is_contained_value<T, Value, tail_t<ValueList>>> {};
+    : std::conditional_t<Value == ValueList::head, std::true_type,
+                         is_contained_value<T, Value, tail_t<ValueList>>> {};
 
 template <typename T, T Value>
 struct is_contained_value<T, Value, value_list<T>> : std::false_type {};
@@ -87,21 +89,21 @@ using is_one_of_spaces =
 
 // size type predicates
 template <typename T1, typename T2>
-struct is_type_size_equal : bool_constant<(sizeof(T1) == sizeof(T2))> {};
+struct is_type_size_equal : std::bool_constant<(sizeof(T1) == sizeof(T2))> {};
 
 template <typename T1, typename T2>
-struct is_type_size_greater : bool_constant<(sizeof(T1) > sizeof(T2))> {};
+struct is_type_size_greater : std::bool_constant<(sizeof(T1) > sizeof(T2))> {};
 
 template <typename T1, typename T2>
 struct is_type_size_double_of
-    : bool_constant<(sizeof(T1) == (sizeof(T2) * 2))> {};
+    : std::bool_constant<(sizeof(T1) == (sizeof(T2) * 2))> {};
 
 template <typename T1, typename T2>
-struct is_type_size_less : bool_constant<(sizeof(T1) < sizeof(T2))> {};
+struct is_type_size_less : std::bool_constant<(sizeof(T1) < sizeof(T2))> {};
 
 template <typename T1, typename T2>
-struct is_type_size_half_of : bool_constant<(sizeof(T1) == (sizeof(T2) / 2))> {
-};
+struct is_type_size_half_of
+    : std::bool_constant<(sizeof(T1) == (sizeof(T2) / 2))> {};
 
 // find required type
 template <typename TypeList, template <typename, typename> class Comp,
@@ -109,7 +111,7 @@ template <typename TypeList, template <typename, typename> class Comp,
 struct find_type {
   using head = head_t<TypeList>;
   using tail = typename find_type<tail_t<TypeList>, Comp, T>::type;
-  using type = conditional_t<Comp<head, T>::value, head, tail>;
+  using type = std::conditional_t<Comp<head, T>::value, head, tail>;
 };
 
 template <template <typename, typename> class Comp, typename T>
diff --git a/sycl/include/sycl/detail/type_traits.hpp b/sycl/include/sycl/detail/type_traits.hpp
index 4a28aeaca8795..e6a7fd0b4fb29 100644
--- a/sycl/include/sycl/detail/type_traits.hpp
+++ b/sycl/include/sycl/detail/type_traits.hpp
@@ -117,7 +117,8 @@ template <typename T> struct vector_size_impl : int_constant<1> {};
 template <typename T, int N>
 struct vector_size_impl<vec<T, N>> : int_constant<N> {};
 template <typename T>
-struct vector_size : vector_size_impl<remove_cv_t<remove_reference_t<T>>> {};
+struct vector_size
+    : vector_size_impl<std::remove_cv_t<std::remove_reference_t<T>>> {};
 
 // vector_element
 template <typename T> struct vector_element_impl;
@@ -130,7 +131,8 @@ template <typename T, int N> struct vector_element_impl<vec<T, N>> {
   using type = T;
 };
 template <typename T> struct vector_element {
-  using type = copy_cv_qualifiers_t<T, vector_element_impl_t<remove_cv_t<T>>>;
+  using type =
+      copy_cv_qualifiers_t<T, vector_element_impl_t<std::remove_cv_t<T>>>;
 };
 template <class T> using vector_element_t = typename vector_element<T>::type;
 
@@ -168,7 +170,7 @@ struct copy_cv_qualifiers_impl<const volatile T, R> {
 };
 
 template <typename T, typename R> struct copy_cv_qualifiers {
-  using type = typename copy_cv_qualifiers_impl<T, remove_cv_t<R>>::type;
+  using type = typename copy_cv_qualifiers_impl<T, std::remove_cv_t<R>>::type;
 };
 
 // make_signed with support SYCL vec class
@@ -179,13 +181,13 @@ using make_signed_impl_t = typename make_signed_impl<T, T>::type;
 
 template <typename T>
 struct make_signed_impl<
-    T, enable_if_t<is_contained<T, gtl::scalar_integer_list>::value, T>> {
+    T, std::enable_if_t<is_contained<T, gtl::scalar_integer_list>::value, T>> {
   using type = typename std::make_signed<T>::type;
 };
 
 template <typename T>
 struct make_signed_impl<
-    T, enable_if_t<is_contained<T, gtl::vector_integer_list>::value, T>> {
+    T, std::enable_if_t<is_contained<T, gtl::vector_integer_list>::value, T>> {
   using base_type = make_signed_impl_t<vector_element_t<T>>;
   using type = change_base_type_t<T, base_type>;
 };
@@ -194,12 +196,12 @@ struct make_signed_impl<
 // infrastructure.
 template <typename T>
 struct make_signed_impl<
-    T, enable_if_t<!is_contained<T, gtl::integer_list>::value, T>> {
+    T, std::enable_if_t<!is_contained<T, gtl::integer_list>::value, T>> {
   using type = T;
 };
 
 template <typename T> struct make_signed {
-  using new_type_wo_cv_qualifiers = make_signed_impl_t<remove_cv_t<T>>;
+  using new_type_wo_cv_qualifiers = make_signed_impl_t<std::remove_cv_t<T>>;
   using type = copy_cv_qualifiers_t<T, new_type_wo_cv_qualifiers>;
 };
 
@@ -213,13 +215,13 @@ using make_unsigned_impl_t = typename make_unsigned_impl<T, T>::type;
 
 template <typename T>
 struct make_unsigned_impl<
-    T, enable_if_t<is_contained<T, gtl::scalar_integer_list>::value, T>> {
+    T, std::enable_if_t<is_contained<T, gtl::scalar_integer_list>::value, T>> {
   using type = typename std::make_unsigned<T>::type;
 };
 
 template <typename T>
 struct make_unsigned_impl<
-    T, enable_if_t<is_contained<T, gtl::vector_integer_list>::value, T>> {
+    T, std::enable_if_t<is_contained<T, gtl::vector_integer_list>::value, T>> {
   using base_type = make_unsigned_impl_t<vector_element_t<T>>;
   using type = change_base_type_t<T, base_type>;
 };
@@ -228,19 +230,19 @@ struct make_unsigned_impl<
 // infrastructure.
 template <typename T>
 struct make_unsigned_impl<
-    T, enable_if_t<!is_contained<T, gtl::integer_list>::value, T>> {
+    T, std::enable_if_t<!is_contained<T, gtl::integer_list>::value, T>> {
   using type = T;
 };
 
 template <typename T> struct make_unsigned {
-  using new_type_wo_cv_qualifiers = make_unsigned_impl_t<remove_cv_t<T>>;
+  using new_type_wo_cv_qualifiers = make_unsigned_impl_t<std::remove_cv_t<T>>;
   using type = copy_cv_qualifiers_t<T, new_type_wo_cv_qualifiers>;
 };
 
 template <typename T, size_t N> struct make_unsigned<marray<T, N>> {
   using base_type = marray_element_t<marray<T, N>>;
   using new_type_wo_cv_qualifiers =
-      make_unsigned_impl_t<remove_cv_t<base_type>>;
+      make_unsigned_impl_t<std::remove_cv_t<base_type>>;
   using type = marray<copy_cv_qualifiers_t<T, new_type_wo_cv_qualifiers>, N>;
 };
 
@@ -249,7 +251,7 @@ template <typename T> using make_unsigned_t = typename make_unsigned<T>::type;
 // Checks that sizeof base type of T equal N and T satisfies S<T>::value
 template <typename T, int N, template <typename> class S>
 using is_gen_based_on_type_sizeof =
-    bool_constant<S<T>::value && (sizeof(vector_element_t<T>) == N)>;
+    std::bool_constant<S<T>::value && (sizeof(vector_element_t<T>) == N)>;
 
 template <typename> struct is_vec : std::false_type {};
 template <typename T, std::size_t N>
@@ -275,33 +277,35 @@ template <> struct is_floating_point_impl<half> : std::true_type {};
 
 template <typename T>
 struct is_floating_point
-    : is_floating_point_impl<remove_cv_t<vector_element_t<T>>> {};
+    : is_floating_point_impl<std::remove_cv_t<vector_element_t<T>>> {};
 
 // is_arithmetic
 template <typename T>
 struct is_arithmetic
-    : bool_constant<is_integral<T>::value || is_floating_point<T>::value> {};
+    : std::bool_constant<is_integral<T>::value || is_floating_point<T>::value> {
+};
 
 template <typename T>
 struct is_scalar_arithmetic
-    : bool_constant<!is_vec<T>::value && is_arithmetic<T>::value> {};
+    : std::bool_constant<!is_vec<T>::value && is_arithmetic<T>::value> {};
 
 template <typename T>
 struct is_vector_arithmetic
-    : bool_constant<is_vec<T>::value && is_arithmetic<T>::value> {};
+    : std::bool_constant<is_vec<T>::value && is_arithmetic<T>::value> {};
 
 // is_bool
 template <typename T>
 struct is_scalar_bool
-    : bool_constant<std::is_same<remove_cv_t<T>, bool>::value> {};
+    : std::bool_constant<std::is_same<std::remove_cv_t<T>, bool>::value> {};
 
 template <typename T>
 struct is_vector_bool
-    : bool_constant<is_vec<T>::value &&
-                    is_scalar_bool<vector_element_t<T>>::value> {};
+    : std::bool_constant<is_vec<T>::value &&
+                         is_scalar_bool<vector_element_t<T>>::value> {};
 
 template <typename T>
-struct is_bool : bool_constant<is_scalar_bool<vector_element_t<T>>::value> {};
+struct is_bool
+    : std::bool_constant<is_scalar_bool<vector_element_t<T>>::value> {};
 
 // is_pointer
 template <typename T> struct is_pointer_impl : std::false_type {};
@@ -313,7 +317,8 @@ template <typename T, access::address_space Space,
 struct is_pointer_impl<multi_ptr<T, Space, DecorateAddress>> : std::true_type {
 };
 
-template <typename T> struct is_pointer : is_pointer_impl<remove_cv_t<T>> {};
+template <typename T>
+struct is_pointer : is_pointer_impl<std::remove_cv_t<T>> {};
 
 // is_multi_ptr
 template <typename T> struct is_multi_ptr : std::false_type {};
@@ -368,7 +373,7 @@ struct remove_pointer_impl<multi_ptr<T, Space, DecorateAddress>> {
 };
 
 template <typename T>
-struct remove_pointer : remove_pointer_impl<remove_cv_t<T>> {};
+struct remove_pointer : remove_pointer_impl<std::remove_cv_t<T>> {};
 
 template <typename T> using remove_pointer_t = typename remove_pointer<T>::type;
 
@@ -383,11 +388,11 @@ template <typename T, typename SpaceList, access::address_space Space,
           access::decorated DecorateAddress>
 struct is_address_space_compliant_impl<multi_ptr<T, Space, DecorateAddress>,
                                        SpaceList>
-    : bool_constant<is_one_of_spaces<Space, SpaceList>::value> {};
+    : std::bool_constant<is_one_of_spaces<Space, SpaceList>::value> {};
 
 template <typename T, typename SpaceList>
 struct is_address_space_compliant
-    : is_address_space_compliant_impl<remove_cv_t<T>, SpaceList> {};
+    : is_address_space_compliant_impl<std::remove_cv_t<T>, SpaceList> {};
 
 // make_type_t
 template <typename T, typename TL> struct make_type_impl {
@@ -406,21 +411,21 @@ using make_type_t = typename make_type_impl<T, TL>::type;
 template <typename T, typename Enable = void> struct make_larger_impl;
 template <typename T>
 struct make_larger_impl<
-    T, enable_if_t<is_contained<T, gtl::scalar_floating_list>::value, T>> {
+    T, std::enable_if_t<is_contained<T, gtl::scalar_floating_list>::value, T>> {
   using type = find_twice_as_large_type_t<gtl::scalar_floating_list, T>;
 };
 
 template <typename T>
 struct make_larger_impl<
-    T,
-    enable_if_t<is_contained<T, gtl::scalar_signed_integer_list>::value, T>> {
+    T, std::enable_if_t<is_contained<T, gtl::scalar_signed_integer_list>::value,
+                        T>> {
   using type = find_twice_as_large_type_t<gtl::scalar_signed_integer_list, T>;
 };
 
 template <typename T>
 struct make_larger_impl<
-    T,
-    enable_if_t<is_contained<T, gtl::scalar_unsigned_integer_list>::value, T>> {
+    T, std::enable_if_t<
+           is_contained<T, gtl::scalar_unsigned_integer_list>::value, T>> {
   using type = find_twice_as_large_type_t<gtl::scalar_unsigned_integer_list, T>;
 };
 
@@ -429,7 +434,7 @@ template <typename T, int N> struct make_larger_impl<vec<T, N>, vec<T, N>> {
   using upper_type = typename make_larger_impl<base_type, base_type>::type;
   using new_type = vec<upper_type, N>;
   static constexpr bool found = !std::is_same<upper_type, void>::value;
-  using type = conditional_t<found, new_type, void>;
+  using type = std::conditional_t<found, new_type, void>;
 };
 
 template <typename T, size_t N>
@@ -438,7 +443,7 @@ struct make_larger_impl<marray<T, N>, marray<T, N>> {
   using upper_type = typename make_larger_impl<base_type, base_type>::type;
   using new_type = marray<upper_type, N>;
   static constexpr bool found = !std::is_same<upper_type, void>::value;
-  using type = conditional_t<found, new_type, void>;
+  using type = std::conditional_t<found, new_type, void>;
 };
 
 template <typename T> struct make_larger {
diff --git a/sycl/include/sycl/detail/vector_traits.hpp b/sycl/include/sycl/detail/vector_traits.hpp
index dc61c3e470a2c..ac86fb1654a36 100644
--- a/sycl/include/sycl/detail/vector_traits.hpp
+++ b/sycl/include/sycl/detail/vector_traits.hpp
@@ -19,12 +19,12 @@ namespace detail {
 // 4.10.2.6 Memory layout and alignment
 template <typename T, int N>
 struct vector_alignment_impl
-    : conditional_t<N == 3, std::integral_constant<int, sizeof(T) * 4>,
-                    std::integral_constant<int, sizeof(T) * N>> {};
+    : std::conditional_t<N == 3, std::integral_constant<int, sizeof(T) * 4>,
+                         std::integral_constant<int, sizeof(T) * N>> {};
 
 template <typename T, int N>
 struct vector_alignment
-    : vector_alignment_impl<remove_cv_t<remove_reference_t<T>>, N> {};
+    : vector_alignment_impl<std::remove_cv_t<std::remove_reference_t<T>>, N> {};
 } // namespace detail
 } // __SYCL_INLINE_VER_NAMESPACE(_V1)
 } // namespace sycl
diff --git a/sycl/include/sycl/device.hpp b/sycl/include/sycl/device.hpp
index 0501cdf5c4d71..e47ecabd73b9d 100644
--- a/sycl/include/sycl/device.hpp
+++ b/sycl/include/sycl/device.hpp
@@ -241,9 +241,8 @@ class __SYCL_EXPORT device : public detail::OwnerLessBase<device> {
   friend decltype(Obj::impl) detail::getSyclObjImpl(const Obj &SyclObject);
 
   template <class T>
-  friend
-      typename detail::add_pointer_t<typename decltype(T::impl)::element_type>
-      detail::getRawSyclObjImpl(const T &SyclObject);
+  friend typename std::add_pointer_t<typename decltype(T::impl)::element_type>
+  detail::getRawSyclObjImpl(const T &SyclObject);
 
   template <class T>
   friend T detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
diff --git a/sycl/include/sycl/ext/intel/esimd/detail/memory_intrin.hpp b/sycl/include/sycl/ext/intel/esimd/detail/memory_intrin.hpp
index 0c00f0e63c17c..b9e57a4a8a11a 100644
--- a/sycl/include/sycl/ext/intel/esimd/detail/memory_intrin.hpp
+++ b/sycl/include/sycl/ext/intel/esimd/detail/memory_intrin.hpp
@@ -70,7 +70,7 @@ constexpr unsigned int ElemsPerAddrEncoding() {
   else if constexpr (ElemsPerAddr == 4)
     return 2;
 
-  // other cases not needed since enable_if disallows other values
+  // other cases not needed since std::enable_if disallows other values
 }
 
 constexpr unsigned int ElemsPerAddrDecoding(unsigned int ElemsPerAddrEncoded) {
diff --git a/sycl/include/sycl/ext/intel/esimd/detail/simd_obj_impl.hpp b/sycl/include/sycl/ext/intel/esimd/detail/simd_obj_impl.hpp
index 5a3c5783fcfaf..f92ea3285d6f5 100644
--- a/sycl/include/sycl/ext/intel/esimd/detail/simd_obj_impl.hpp
+++ b/sycl/include/sycl/ext/intel/esimd/detail/simd_obj_impl.hpp
@@ -338,7 +338,7 @@ class simd_obj_impl {
   /// Type conversion into a scalar:
   /// <code><simd_obj_impl<RawTy, 1, simd<Ty,1>></code> to \c Ty.
   template <typename T = simd_obj_impl,
-            typename = sycl::detail::enable_if_t<T::length == 1>>
+            typename = std::enable_if_t<T::length == 1>>
   operator Ty() const {
     __esimd_dbg_print(operator Ty());
     return bitcast_to_wrapper_type<Ty>(data()[0]);
diff --git a/sycl/include/sycl/ext/intel/esimd/detail/simd_view_impl.hpp b/sycl/include/sycl/ext/intel/esimd/detail/simd_view_impl.hpp
index 3b5e78fc02fa4..84276e344eb43 100644
--- a/sycl/include/sycl/ext/intel/esimd/detail/simd_view_impl.hpp
+++ b/sycl/include/sycl/ext/intel/esimd/detail/simd_view_impl.hpp
@@ -230,7 +230,7 @@ class simd_view_impl {
   /// @param Offset is the starting element offset.
   /// @return \c simd_view representing the subregion.
   template <int Size, int Stride, typename T = Derived,
-            typename = sycl::detail::enable_if_t<T::is1D()>>
+            typename = std::enable_if_t<T::is1D()>>
   auto select(uint16_t Offset = 0) {
     using TopRegionTy = region1d_t<element_type, Size, Stride>;
     using NewRegionTy = std::pair<TopRegionTy, RegionTy>;
@@ -280,8 +280,7 @@ class simd_view_impl {
   /// @return 2D simd_view of the subregion.
   // clang-format on
   template <int SizeY, int StrideY, int SizeX, int StrideX,
-            typename T = Derived,
-            typename = sycl::detail::enable_if_t<T::is2D()>>
+            typename T = Derived, typename = std::enable_if_t<T::is2D()>>
   auto select(uint16_t OffsetY = 0, uint16_t OffsetX = 0) {
     using TopRegionTy =
         region2d_t<element_type, SizeY, StrideY, SizeX, StrideX>;
@@ -472,8 +471,7 @@ class simd_view_impl {
   /// Reference a row from a 2D region. Available only if this object is 2D.
   /// @param i Row index.
   /// @return A 2D view of a region representing i'th row of the target region.
-  template <typename T = Derived,
-            typename = sycl::detail::enable_if_t<T::is2D()>>
+  template <typename T = Derived, typename = std::enable_if_t<T::is2D()>>
   auto row(int i) {
     return select<1, 1, getSizeX(), 1>(i, 0)
         .template bit_cast_view<element_type>();
@@ -483,8 +481,7 @@ class simd_view_impl {
   /// @param i Column index.
   /// @return A 2D view of a region representing i'th column of the target
   ///   region.
-  template <typename T = Derived,
-            typename = sycl::detail::enable_if_t<T::is2D()>>
+  template <typename T = Derived, typename = std::enable_if_t<T::is2D()>>
   auto column(int i) {
     return select<getSizeY(), 1, 1, 1>(0, i);
   }
@@ -492,8 +489,7 @@ class simd_view_impl {
   /// Read a single element from the target 1D region.
   /// @param i Element index.
   /// @return Element value.
-  template <typename T = Derived,
-            typename = sycl::detail::enable_if_t<T::is1D()>>
+  template <typename T = Derived, typename = std::enable_if_t<T::is1D()>>
   element_type operator[](int i) const {
     const auto v = read();
     return v[i];
@@ -502,8 +498,7 @@ class simd_view_impl {
   /// Return a writeable view of a single element in the target 1D region.
   /// @param i Element index.
   /// @return A new 1D view of the element. Can be used to update it.
-  template <typename T = Derived,
-            typename = sycl::detail::enable_if_t<T::is1D()>>
+  template <typename T = Derived, typename = std::enable_if_t<T::is1D()>>
   auto operator[](int i) {
     return select<1, 1>(i);
   }
diff --git a/sycl/include/sycl/ext/intel/esimd/detail/sycl_util.hpp b/sycl/include/sycl/ext/intel/esimd/detail/sycl_util.hpp
index 51e489cb797d6..ad607c24e927e 100644
--- a/sycl/include/sycl/ext/intel/esimd/detail/sycl_util.hpp
+++ b/sycl/include/sycl/ext/intel/esimd/detail/sycl_util.hpp
@@ -76,7 +76,7 @@ struct is_sycl_accessor_with
 
 template <typename T, accessor_mode_cap_val_t Capability,
           sycl::access::target AccessTarget, typename RetT>
-using EnableIfAccessor = sycl::detail::enable_if_t<
+using EnableIfAccessor = std::enable_if_t<
     detail::is_sycl_accessor_with<T, Capability, AccessTarget>::value, RetT>;
 
 } // namespace ext::intel::esimd::detail
diff --git a/sycl/include/sycl/ext/intel/esimd/memory.hpp b/sycl/include/sycl/ext/intel/esimd/memory.hpp
index 89e0ed450dcf3..16fed7d5e4cc8 100644
--- a/sycl/include/sycl/ext/intel/esimd/memory.hpp
+++ b/sycl/include/sycl/ext/intel/esimd/memory.hpp
@@ -435,9 +435,8 @@ ESIMD_INLINE
                                     detail::uint_type_t<sizeof(T)>>;
     using Treal = __raw_t<T>;
     simd<Tint, N> vals_int = bitcast<Tint, Treal, N>(std::move(vals).data());
-    using PromoT =
-        typename sycl::detail::conditional_t<std::is_signed<Tint>::value,
-                                             int32_t, uint32_t>;
+    using PromoT = typename std::conditional_t<std::is_signed<Tint>::value,
+                                               int32_t, uint32_t>;
     const simd<PromoT, N> promo_vals = convert<PromoT>(std::move(vals_int));
     __esimd_scatter_scaled<PromoT, N, decltype(si), TypeSizeLog2, scale>(
         mask.data(), si, glob_offset, offsets.data(), promo_vals.data());
@@ -473,9 +472,8 @@ gather_impl(AccessorTy acc, simd<uint32_t, N> offsets, uint32_t glob_offset,
     using Treal = __raw_t<T>;
     static_assert(std::is_integral<Tint>::value,
                   "only integral 1- & 2-byte types are supported");
-    using PromoT =
-        typename sycl::detail::conditional_t<std::is_signed<Tint>::value,
-                                             int32_t, uint32_t>;
+    using PromoT = typename std::conditional_t<std::is_signed<Tint>::value,
+                                               int32_t, uint32_t>;
     const simd<PromoT, N> promo_vals =
         __esimd_gather_masked_scaled2<PromoT, N, decltype(si), TypeSizeLog2,
                                       scale>(si, glob_offset, offsets.data(),
diff --git a/sycl/include/sycl/ext/intel/esimd/simd.hpp b/sycl/include/sycl/ext/intel/esimd/simd.hpp
index e48c6e9f74e8a..c6baf95495ff5 100644
--- a/sycl/include/sycl/ext/intel/esimd/simd.hpp
+++ b/sycl/include/sycl/ext/intel/esimd/simd.hpp
@@ -106,8 +106,8 @@ class simd : public detail::simd_obj_impl<
   /// @tparam To the scalar type
   /// @return this object's single element value converted to the result type.
   template <class To, class T = simd,
-            class = sycl::detail::enable_if_t<
-                (T::length == 1) && detail::is_valid_simd_elem_type_v<To>>>
+            class = std::enable_if_t<(T::length == 1) &&
+                                     detail::is_valid_simd_elem_type_v<To>>>
   operator To() const {
     __esimd_dbg_print(operator To());
     return detail::convert_scalar<To, element_type>(base_type::data()[0]);
diff --git a/sycl/include/sycl/ext/intel/experimental/esimd/math.hpp b/sycl/include/sycl/ext/intel/experimental/esimd/math.hpp
index c2f781b23b2ea..9b2049b53f03c 100644
--- a/sycl/include/sycl/ext/intel/experimental/esimd/math.hpp
+++ b/sycl/include/sycl/ext/intel/experimental/esimd/math.hpp
@@ -849,7 +849,7 @@ line(float P, float Q, __ESIMD_NS::simd<T, SZ> src1, Sat sat = {}) {
 // The only input and return types for these APIs are floats.
 // In order to be able to use the old emu code, we keep the template argument
 // for the type, although the type "T" can only be float.
-// We use enable_if to force the float type only.
+// We use std::enable_if to force the float type only.
 // If the gen is not specified we warn the programmer that they are potentially
 // using a less efficient implementation if not on GEN10 or above.
 
@@ -1118,7 +1118,7 @@ __ESIMD_API __ESIMD_NS::simd<float, SZ> lrp(__ESIMD_NS::simd<float, SZ> src0,
 // The only input and return types for these APIs are floats.
 // In order to be able to use the old emu code, we keep the template argument
 // for the type, although the type "T" can only be float.
-// We use enable_if to force the float type only.
+// We use std::enable_if to force the float type only.
 // If the gen is not specified we warn the programmer that they are potentially
 // using less efficient implementation.
 template <typename T, int SZ, typename U, typename V,
diff --git a/sycl/include/sycl/ext/intel/experimental/fpga_utils.hpp b/sycl/include/sycl/ext/intel/experimental/fpga_utils.hpp
index 4656b5322cbeb..fbef746369d7d 100644
--- a/sycl/include/sycl/ext/intel/experimental/fpga_utils.hpp
+++ b/sycl/include/sycl/ext/intel/experimental/fpga_utils.hpp
@@ -28,8 +28,8 @@ template <template <int32_t> class _Type, class... _T> struct _GetValue {
 template <template <int32_t> class _Type, class _T1, class... _T>
 struct _GetValue<_Type, _T1, _T...> {
   static constexpr auto value =
-      sycl::detail::conditional_t<_MatchType<_Type, _T1>::value, _T1,
-                                  _GetValue<_Type, _T...>>::value;
+      std::conditional_t<_MatchType<_Type, _T1>::value, _T1,
+                         _GetValue<_Type, _T...>>::value;
 };
 
 // Get the specified property from the given compile-time property list. If
diff --git a/sycl/include/sycl/ext/oneapi/accessor_property_list.hpp b/sycl/include/sycl/ext/oneapi/accessor_property_list.hpp
index 3e6e157854a76..7083b26f4252f 100644
--- a/sycl/include/sycl/ext/oneapi/accessor_property_list.hpp
+++ b/sycl/include/sycl/ext/oneapi/accessor_property_list.hpp
@@ -61,9 +61,8 @@ class __SYCL_TYPE(accessor_property_list) accessor_property_list
   template <typename PropT> struct ContainsProperty<PropT> : std::false_type {};
   template <typename PropT, typename Head, typename... Tail>
   struct ContainsProperty<PropT, Head, Tail...>
-      : sycl::detail::conditional_t<AreSameTemplate<PropT, Head>::value,
-                                    std::true_type,
-                                    ContainsProperty<PropT, Tail...>> {};
+      : std::conditional_t<AreSameTemplate<PropT, Head>::value, std::true_type,
+                           ContainsProperty<PropT, Tail...>> {};
 
   // PropertyContainer is a helper structure, that holds list of properties.
   // It is used to avoid multiple parameter packs in templates.
@@ -86,7 +85,7 @@ class __SYCL_TYPE(accessor_property_list) accessor_property_list
   template <typename ContainerT, template <auto...> typename PropT,
             auto... Args>
   struct ContainsPropertyInstance
-      : sycl::detail::conditional_t<
+      : std::conditional_t<
             !std::is_same_v<typename ContainerT::Head, void> &&
                 AreSameTemplate<PropT<Args...>,
                                 typename ContainerT::Head>::value,
@@ -102,7 +101,7 @@ class __SYCL_TYPE(accessor_property_list) accessor_property_list
   // skipped.
   template <typename ContainerT, typename... OtherProps>
   struct ContainsSameProperties
-      : sycl::detail::conditional_t<
+      : std::conditional_t<
             !sycl::detail::IsCompileTimePropertyInstance<
                 typename ContainerT::Head>::value ||
                 ContainsProperty<typename ContainerT::Head,
@@ -118,7 +117,7 @@ class __SYCL_TYPE(accessor_property_list) accessor_property_list
   // use void as return type.
   template <typename ContainerT, template <auto...> class PropT, auto... Args>
   struct GetCompileTimePropertyHelper {
-    using type = typename sycl::detail::conditional_t<
+    using type = typename std::conditional_t<
         AreSameTemplate<typename ContainerT::Head, PropT<Args...>>::value,
         typename ContainerT::Head,
         typename GetCompileTimePropertyHelper<typename ContainerT::Rest, PropT,
@@ -126,7 +125,7 @@ class __SYCL_TYPE(accessor_property_list) accessor_property_list
   };
   template <typename Head, template <auto...> class PropT, auto... Args>
   struct GetCompileTimePropertyHelper<PropertyContainer<Head>, PropT, Args...> {
-    using type = typename sycl::detail::conditional_t<
+    using type = typename std::conditional_t<
         AreSameTemplate<Head, PropT<Args...>>::value, Head, void>;
   };
 
@@ -138,7 +137,7 @@ class __SYCL_TYPE(accessor_property_list) accessor_property_list
   template <typename... Tail> struct AllProperties : std::true_type {};
   template <typename T, typename... Tail>
   struct AllProperties<T, Tail...>
-      : sycl::detail::conditional_t<
+      : std::conditional_t<
             std::is_base_of<sycl::detail::DataLessPropertyBase, T>::value ||
                 std::is_base_of<sycl::detail::PropertyWithDataBase, T>::value ||
                 sycl::detail::IsCompileTimePropertyInstance<T>::value,
@@ -152,8 +151,8 @@ class __SYCL_TYPE(accessor_property_list) accessor_property_list
       : sycl::detail::PropertyListBase(DataLessProps, PropsWithData) {}
 
 public:
-  template <typename = typename sycl::detail::enable_if_t<
-                AllProperties<PropsT...>::value>>
+  template <
+      typename = typename std::enable_if_t<AllProperties<PropsT...>::value>>
   accessor_property_list(PropsT... Props)
       : sycl::detail::PropertyListBase(false) {
     ctorHelper(Props...);
@@ -164,7 +163,7 @@ class __SYCL_TYPE(accessor_property_list) accessor_property_list
                                        Props.MPropsWithData) {}
 
   template <typename... OtherProps,
-            typename = typename sycl::detail::enable_if_t<
+            typename = typename std::enable_if_t<
                 ContainsSameProperties<PropertyContainer<PropsT...>,
                                        OtherProps...>::value &&
                 ContainsSameProperties<PropertyContainer<OtherProps...>,
@@ -173,7 +172,7 @@ class __SYCL_TYPE(accessor_property_list) accessor_property_list
       : sycl::detail::PropertyListBase(OtherList.MDataLessProps,
                                        OtherList.MPropsWithData) {}
 
-  template <typename PropT, typename = typename sycl::detail::enable_if_t<
+  template <typename PropT, typename = typename std::enable_if_t<
                                 !is_compile_time_property<PropT>::value>>
   PropT get_property() const {
     if (!has_property<PropT>())
@@ -184,8 +183,7 @@ class __SYCL_TYPE(accessor_property_list) accessor_property_list
   }
 
   template <class PropT>
-  typename sycl::detail::enable_if_t<!is_compile_time_property<PropT>::value,
-                                     bool>
+  typename std::enable_if_t<!is_compile_time_property<PropT>::value, bool>
   has_property() const {
     return has_property_helper<PropT>();
   }
diff --git a/sycl/include/sycl/ext/oneapi/atomic_accessor.hpp b/sycl/include/sycl/ext/oneapi/atomic_accessor.hpp
index 5d4ed982f2de8..c6318468a041a 100644
--- a/sycl/include/sycl/ext/oneapi/atomic_accessor.hpp
+++ b/sycl/include/sycl/ext/oneapi/atomic_accessor.hpp
@@ -80,20 +80,20 @@ class atomic_accessor
 
   // Override subscript operators and conversions to wrap in an atomic_ref
   template <int Dims = Dimensions>
-  operator typename detail::enable_if_t<Dims == 0, reference>() const {
+  operator typename std::enable_if_t<Dims == 0, reference>() const {
     const size_t LinearIndex = getLinearIndex(id<AdjustedDim>());
     return reference(getQualifiedPtr()[LinearIndex]);
   }
 
   template <int Dims = Dimensions>
-  typename detail::enable_if_t<(Dims > 0), reference>
+  typename std::enable_if_t<(Dims > 0), reference>
   operator[](id<Dimensions> Index) const {
     const size_t LinearIndex = getLinearIndex(Index);
     return reference(getQualifiedPtr()[LinearIndex]);
   }
 
   template <int Dims = Dimensions>
-  typename detail::enable_if_t<Dims == 1, reference>
+  typename std::enable_if_t<Dims == 1, reference>
   operator[](size_t Index) const {
     const size_t LinearIndex = getLinearIndex(id<AdjustedDim>(Index));
     return reference(getQualifiedPtr()[LinearIndex]);
diff --git a/sycl/include/sycl/ext/oneapi/atomic_ref.hpp b/sycl/include/sycl/ext/oneapi/atomic_ref.hpp
index ec2a281f580f8..5b181aed58d0a 100644
--- a/sycl/include/sycl/ext/oneapi/atomic_ref.hpp
+++ b/sycl/include/sycl/ext/oneapi/atomic_ref.hpp
@@ -43,16 +43,16 @@ template <typename T> struct IsValidAtomicRefType {
 };
 
 template <sycl::access::address_space AS>
-using IsValidAtomicAddressSpace =
-    bool_constant<AS == access::address_space::global_space ||
-                  AS == access::address_space::local_space ||
-                  AS == access::address_space::ext_intel_global_device_space>;
+using IsValidAtomicAddressSpace = std::bool_constant<
+    AS == access::address_space::global_space ||
+    AS == access::address_space::local_space ||
+    AS == access::address_space::ext_intel_global_device_space>;
 
 // DefaultOrder parameter is limited to read-modify-write orders
 template <memory_order Order>
-using IsValidDefaultOrder = bool_constant<Order == memory_order::relaxed ||
-                                          Order == memory_order::acq_rel ||
-                                          Order == memory_order::seq_cst>;
+using IsValidDefaultOrder = std::bool_constant<Order == memory_order::relaxed ||
+                                               Order == memory_order::acq_rel ||
+                                               Order == memory_order::seq_cst>;
 
 template <memory_order ReadModifyWriteOrder> struct memory_order_traits;
 
@@ -90,7 +90,7 @@ inline constexpr memory_order getLoadOrder(memory_order order) {
 template <typename T, typename = void> struct bit_equal;
 
 template <typename T>
-struct bit_equal<T, typename detail::enable_if_t<std::is_integral<T>::value>> {
+struct bit_equal<T, typename std::enable_if_t<std::is_integral<T>::value>> {
   bool operator()(const T &lhs, const T &rhs) { return lhs == rhs; }
 };
 
@@ -266,7 +266,7 @@ class atomic_ref_impl
 template <typename T, memory_order DefaultOrder, memory_scope DefaultScope,
           access::address_space AddressSpace>
 class atomic_ref_impl<T, DefaultOrder, DefaultScope, AddressSpace,
-                      typename detail::enable_if_t<std::is_integral<T>::value>>
+                      typename std::enable_if_t<std::is_integral<T>::value>>
     : public atomic_ref_base<T, DefaultOrder, DefaultScope, AddressSpace> {
 
 public:
@@ -414,7 +414,7 @@ template <typename T, memory_order DefaultOrder, memory_scope DefaultScope,
           access::address_space AddressSpace>
 class atomic_ref_impl<
     T, DefaultOrder, DefaultScope, AddressSpace,
-    typename detail::enable_if_t<std::is_floating_point<T>::value>>
+    typename std::enable_if_t<std::is_floating_point<T>::value>>
     : public atomic_ref_base<T, DefaultOrder, DefaultScope, AddressSpace> {
 
 public:
diff --git a/sycl/include/sycl/ext/oneapi/backend/level_zero.hpp b/sycl/include/sycl/ext/oneapi/backend/level_zero.hpp
index 9ab4c0ed63d8f..8aab54b7fca41 100644
--- a/sycl/include/sycl/ext/oneapi/backend/level_zero.hpp
+++ b/sycl/include/sycl/ext/oneapi/backend/level_zero.hpp
@@ -40,7 +40,7 @@ __SYCL_EXPORT event make_event(const context &Context,
                                bool keep_ownership = false);
 
 // Construction of SYCL platform.
-template <typename T, typename sycl::detail::enable_if_t<
+template <typename T, typename std::enable_if_t<
                           std::is_same<T, platform>::value> * = nullptr>
 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_platform free function")
 T make(typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
@@ -49,8 +49,8 @@ T make(typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
 }
 
 // Construction of SYCL device.
-template <typename T, typename sycl::detail::enable_if_t<
-                          std::is_same<T, device>::value> * = nullptr>
+template <typename T,
+          typename std::enable_if_t<std::is_same<T, device>::value> * = nullptr>
 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_device free function")
 T make(const platform &Platform,
        typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
@@ -80,8 +80,8 @@ T make(const std::vector<device> &DeviceList,
 }
 
 // Construction of SYCL queue.
-template <typename T, typename sycl::detail::enable_if_t<
-                          std::is_same<T, queue>::value> * = nullptr>
+template <typename T,
+          typename std::enable_if_t<std::is_same<T, queue>::value> * = nullptr>
 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_queue free function")
 T make(const context &Context,
        typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
@@ -93,8 +93,8 @@ T make(const context &Context,
 }
 
 // Construction of SYCL event.
-template <typename T, typename sycl::detail::enable_if_t<
-                          std::is_same<T, event>::value> * = nullptr>
+template <typename T,
+          typename std::enable_if_t<std::is_same<T, event>::value> * = nullptr>
 __SYCL_DEPRECATED("Use SYCL 2020 sycl::make_event free function")
 T make(const context &Context,
        typename sycl::detail::interop<backend::ext_oneapi_level_zero, T>::type
diff --git a/sycl/include/sycl/ext/oneapi/device_global/device_global.hpp b/sycl/include/sycl/ext/oneapi/device_global/device_global.hpp
index 8446a25f48f28..c629f334c3a99 100644
--- a/sycl/include/sycl/ext/oneapi/device_global/device_global.hpp
+++ b/sycl/include/sycl/ext/oneapi/device_global/device_global.hpp
@@ -35,8 +35,8 @@ namespace detail {
 template <typename T, typename = void>
 struct HasArrowOperator : std::false_type {};
 template <typename T>
-struct HasArrowOperator<
-    T, sycl::detail::void_t<decltype(std::declval<T>().operator->())>>
+struct HasArrowOperator<T,
+                        std::void_t<decltype(std::declval<T>().operator->())>>
     : std::true_type {};
 
 // Base class for device_global.
@@ -75,7 +75,7 @@ class device_global_base {
 template <typename T, typename... Props>
 class device_global_base<
     T, properties_t<Props...>,
-    sycl::detail::enable_if_t<properties_t<Props...>::template has_property<
+    std::enable_if_t<properties_t<Props...>::template has_property<
         device_image_scope_key>()>> {
 protected:
   T val{};
diff --git a/sycl/include/sycl/ext/oneapi/device_global/properties.hpp b/sycl/include/sycl/ext/oneapi/device_global/properties.hpp
index 1bd53de9d52aa..da627043807c8 100644
--- a/sycl/include/sycl/ext/oneapi/device_global/properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/device_global/properties.hpp
@@ -42,7 +42,7 @@ struct init_mode_key {
 struct implement_in_csr_key {
   template <bool Enable>
   using value_t =
-      property_value<implement_in_csr_key, sycl::detail::bool_constant<Enable>>;
+      property_value<implement_in_csr_key, std::bool_constant<Enable>>;
 };
 
 inline constexpr device_image_scope_key::value_t device_image_scope;
diff --git a/sycl/include/sycl/ext/oneapi/experimental/builtins.hpp b/sycl/include/sycl/ext/oneapi/experimental/builtins.hpp
index f9d8903286314..92157c07e88cb 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/builtins.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/builtins.hpp
@@ -87,9 +87,9 @@ namespace native {
 // backends we revert to the sycl::tanh impl.
 template <typename T>
 inline __SYCL_ALWAYS_INLINE
-    sycl::detail::enable_if_t<sycl::detail::is_svgenfloatf<T>::value ||
-                                  sycl::detail::is_svgenfloath<T>::value,
-                              T>
+    std::enable_if_t<sycl::detail::is_svgenfloatf<T>::value ||
+                         sycl::detail::is_svgenfloath<T>::value,
+                     T>
     tanh(T x) __NOEXC {
 #if defined(__NVPTX__)
   using _ocl_T = sycl::detail::ConvertToOpenCLType_t<T>;
@@ -139,7 +139,7 @@ inline __SYCL_ALWAYS_INLINE
 // For other backends we revert to the sycl::exp2 impl.
 template <typename T>
 inline __SYCL_ALWAYS_INLINE
-    sycl::detail::enable_if_t<sycl::detail::is_svgenfloath<T>::value, T>
+    std::enable_if_t<sycl::detail::is_svgenfloath<T>::value, T>
     exp2(T x) __NOEXC {
 #if defined(__NVPTX__)
   using _ocl_T = sycl::detail::ConvertToOpenCLType_t<T>;
diff --git a/sycl/include/sycl/ext/oneapi/experimental/group_sort.hpp b/sycl/include/sycl/ext/oneapi/experimental/group_sort.hpp
index 4f310be2a5428..d1b7a4fefd1a5 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/group_sort.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/group_sort.hpp
@@ -25,7 +25,7 @@ namespace detail {
 template <typename T, typename = void> struct has_difference_type {};
 
 template <typename T>
-struct has_difference_type<T, sycl::detail::void_t<typename T::difference_type>>
+struct has_difference_type<T, std::void_t<typename T::difference_type>>
     : std::true_type {};
 
 template <typename T> struct has_difference_type<T *> : std::true_type {};
@@ -49,9 +49,8 @@ struct is_sorter_impl {
 template <typename Sorter, typename Group,
           typename Ptr> // multi_ptr has difference_type and don't have other
                         // iterator's fields
-struct is_sorter_impl<
-    Sorter, Group, Ptr,
-    sycl::detail::void_t<typename has_difference_type<Ptr>::type>> {
+struct is_sorter_impl<Sorter, Group, Ptr,
+                      std::void_t<typename has_difference_type<Ptr>::type>> {
   template <typename G = Group>
   static decltype(std::declval<Sorter>()(std::declval<G>(), std::declval<Ptr>(),
                                          std::declval<Ptr>()),
diff --git a/sycl/include/sycl/ext/oneapi/experimental/spec_constant.hpp b/sycl/include/sycl/ext/oneapi/experimental/spec_constant.hpp
index fd1795ad97a29..3e6cfa0a86a4c 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/spec_constant.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/spec_constant.hpp
@@ -48,7 +48,7 @@ class __SYCL2020_DEPRECATED(
 
 public:
   template <typename V = T>
-  typename sycl::detail::enable_if_t<std::is_arithmetic<V>::value, V>
+  typename std::enable_if_t<std::is_arithmetic<V>::value, V>
   get() const { // explicit access.
 #ifdef __SYCL_DEVICE_ONLY__
     const char *TName = __builtin_sycl_unique_stable_name(ID);
@@ -59,9 +59,8 @@ class __SYCL2020_DEPRECATED(
   }
 
   template <typename V = T>
-  typename sycl::detail::enable_if_t<std::is_class<V>::value &&
-                                         std::is_pod<V>::value,
-                                     V>
+  typename std::enable_if_t<std::is_class<V>::value && std::is_pod<V>::value,
+                            V>
   get() const { // explicit access.
 #ifdef __SYCL_DEVICE_ONLY__
     const char *TName = __builtin_sycl_unique_stable_name(ID);
diff --git a/sycl/include/sycl/ext/oneapi/experimental/user_defined_reductions.hpp b/sycl/include/sycl/ext/oneapi/experimental/user_defined_reductions.hpp
index 5f95cd6c630f5..d2bfe0e573830 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/user_defined_reductions.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/user_defined_reductions.hpp
@@ -61,7 +61,7 @@ reduce_over_group(GroupHelper group_helper, T x, BinaryOperation binary_op) {
 
 template <typename GroupHelper, typename V, typename T,
           typename BinaryOperation>
-sycl::detail::enable_if_t<(is_group_helper_v<GroupHelper>), T>
+std::enable_if_t<(is_group_helper_v<GroupHelper>), T>
 reduce_over_group(GroupHelper group_helper, V x, T init,
                   BinaryOperation binary_op) {
   if constexpr (sycl::detail::is_native_op<V, BinaryOperation>::value &&
@@ -80,9 +80,9 @@ reduce_over_group(GroupHelper group_helper, V x, T init,
 
 // ---- joint_reduce
 template <typename GroupHelper, typename Ptr, typename BinaryOperation>
-sycl::detail::enable_if_t<(is_group_helper_v<GroupHelper> &&
-                           sycl::detail::is_pointer<Ptr>::value),
-                          typename std::iterator_traits<Ptr>::value_type>
+std::enable_if_t<(is_group_helper_v<GroupHelper> &&
+                  sycl::detail::is_pointer<Ptr>::value),
+                 typename std::iterator_traits<Ptr>::value_type>
 joint_reduce(GroupHelper group_helper, Ptr first, Ptr last,
              BinaryOperation binary_op) {
   if constexpr (sycl::detail::is_native_op<
@@ -117,7 +117,7 @@ joint_reduce(GroupHelper group_helper, Ptr first, Ptr last,
 
 template <typename GroupHelper, typename Ptr, typename T,
           typename BinaryOperation>
-sycl::detail::enable_if_t<
+std::enable_if_t<
     (is_group_helper_v<GroupHelper> && sycl::detail::is_pointer<Ptr>::value), T>
 joint_reduce(GroupHelper group_helper, Ptr first, Ptr last, T init,
              BinaryOperation binary_op) {
diff --git a/sycl/include/sycl/ext/oneapi/functional.hpp b/sycl/include/sycl/ext/oneapi/functional.hpp
index 7d8d269fde0fb..d515c30e5c562 100644
--- a/sycl/include/sycl/ext/oneapi/functional.hpp
+++ b/sycl/include/sycl/ext/oneapi/functional.hpp
@@ -38,25 +38,25 @@ struct GroupOpC {};
 template <typename T, typename = void> struct GroupOpTag;
 
 template <typename T>
-struct GroupOpTag<T, detail::enable_if_t<detail::is_sigeninteger<T>::value>> {
+struct GroupOpTag<T, std::enable_if_t<detail::is_sigeninteger<T>::value>> {
   using type = GroupOpISigned;
 };
 
 template <typename T>
-struct GroupOpTag<T, detail::enable_if_t<detail::is_sugeninteger<T>::value>> {
+struct GroupOpTag<T, std::enable_if_t<detail::is_sugeninteger<T>::value>> {
   using type = GroupOpIUnsigned;
 };
 
 template <typename T>
-struct GroupOpTag<T, detail::enable_if_t<detail::is_sgenfloat<T>::value>> {
+struct GroupOpTag<T, std::enable_if_t<detail::is_sgenfloat<T>::value>> {
   using type = GroupOpFP;
 };
 
 template <typename T>
 struct GroupOpTag<
-    T, detail::enable_if_t<std::is_same<T, std::complex<half>>::value ||
-                           std::is_same<T, std::complex<float>>::value ||
-                           std::is_same<T, std::complex<double>>::value>> {
+    T, std::enable_if_t<std::is_same<T, std::complex<half>>::value ||
+                        std::is_same<T, std::complex<float>>::value ||
+                        std::is_same<T, std::complex<double>>::value>> {
   using type = GroupOpC;
 };
 
diff --git a/sycl/include/sycl/ext/oneapi/group_algorithm.hpp b/sycl/include/sycl/ext/oneapi/group_algorithm.hpp
index 6c29b65482067..8b353d349ea2d 100644
--- a/sycl/include/sycl/ext/oneapi/group_algorithm.hpp
+++ b/sycl/include/sycl/ext/oneapi/group_algorithm.hpp
@@ -26,48 +26,48 @@ namespace ext::oneapi {
 // EnableIf shorthands for algorithms that depend only on type
 template <typename T>
 using EnableIfIsScalarArithmetic =
-    sycl::detail::enable_if_t<sycl::detail::is_scalar_arithmetic<T>::value, T>;
+    std::enable_if_t<sycl::detail::is_scalar_arithmetic<T>::value, T>;
 
 template <typename T>
 using EnableIfIsVectorArithmetic =
-    sycl::detail::enable_if_t<sycl::detail::is_vector_arithmetic<T>::value, T>;
+    std::enable_if_t<sycl::detail::is_vector_arithmetic<T>::value, T>;
 
 template <typename Ptr, typename T>
 using EnableIfIsPointer =
-    sycl::detail::enable_if_t<sycl::detail::is_pointer<Ptr>::value, T>;
+    std::enable_if_t<sycl::detail::is_pointer<Ptr>::value, T>;
 
 template <typename T>
 using EnableIfIsTriviallyCopyable =
-    sycl::detail::enable_if_t<std::is_trivially_copyable<T>::value &&
-                                  !sycl::detail::is_vector_arithmetic<T>::value,
-                              T>;
+    std::enable_if_t<std::is_trivially_copyable<T>::value &&
+                         !sycl::detail::is_vector_arithmetic<T>::value,
+                     T>;
 
 // EnableIf shorthands for algorithms that depend on type and an operator
 template <typename T, typename BinaryOperation>
-using EnableIfIsScalarArithmeticNativeOp = sycl::detail::enable_if_t<
-    sycl::detail::is_scalar_arithmetic<T>::value &&
-        sycl::detail::is_native_op<T, BinaryOperation>::value,
-    T>;
+using EnableIfIsScalarArithmeticNativeOp =
+    std::enable_if_t<sycl::detail::is_scalar_arithmetic<T>::value &&
+                         sycl::detail::is_native_op<T, BinaryOperation>::value,
+                     T>;
 
 template <typename T, typename BinaryOperation>
-using EnableIfIsVectorArithmeticNativeOp = sycl::detail::enable_if_t<
-    sycl::detail::is_vector_arithmetic<T>::value &&
-        sycl::detail::is_native_op<T, BinaryOperation>::value,
-    T>;
+using EnableIfIsVectorArithmeticNativeOp =
+    std::enable_if_t<sycl::detail::is_vector_arithmetic<T>::value &&
+                         sycl::detail::is_native_op<T, BinaryOperation>::value,
+                     T>;
 
 // TODO: Lift TriviallyCopyable restriction eventually
 template <typename T, typename BinaryOperation>
-using EnableIfIsNonNativeOp = sycl::detail::enable_if_t<
-    (!sycl::detail::is_scalar_arithmetic<T>::value &&
-     !sycl::detail::is_vector_arithmetic<T>::value &&
-     std::is_trivially_copyable<T>::value) ||
-        !sycl::detail::is_native_op<T, BinaryOperation>::value,
-    T>;
+using EnableIfIsNonNativeOp =
+    std::enable_if_t<(!sycl::detail::is_scalar_arithmetic<T>::value &&
+                      !sycl::detail::is_vector_arithmetic<T>::value &&
+                      std::is_trivially_copyable<T>::value) ||
+                         !sycl::detail::is_native_op<T, BinaryOperation>::value,
+                     T>;
 
 template <typename Group>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::all_of is deprecated. Use all_of_group instead.")
-detail::enable_if_t<detail::is_generic_group<Group>::value, bool> all_of(
+std::enable_if_t<detail::is_generic_group<Group>::value, bool> all_of(
     Group g, bool pred) {
   return all_of_group(g, pred);
 }
@@ -75,7 +75,7 @@ detail::enable_if_t<detail::is_generic_group<Group>::value, bool> all_of(
 template <typename Group, typename T, class Predicate>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::all_of is deprecated. Use all_of_group instead.")
-detail::enable_if_t<detail::is_generic_group<Group>::value, bool> all_of(
+std::enable_if_t<detail::is_generic_group<Group>::value, bool> all_of(
     Group g, T x, Predicate pred) {
   return all_of_group(g, pred(x));
 }
@@ -83,16 +83,16 @@ detail::enable_if_t<detail::is_generic_group<Group>::value, bool> all_of(
 template <typename Group, typename Ptr, class Predicate>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::all_of is deprecated. Use joint_all_of instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_pointer<Ptr>::value),
-                    bool> all_of(Group g, Ptr first, Ptr last, Predicate pred) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_pointer<Ptr>::value),
+                 bool> all_of(Group g, Ptr first, Ptr last, Predicate pred) {
   return joint_all_of(g, first, last, pred);
 }
 
 template <typename Group>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::any_of is deprecated. Use any_of_group instead.")
-detail::enable_if_t<detail::is_generic_group<Group>::value, bool> any_of(
+std::enable_if_t<detail::is_generic_group<Group>::value, bool> any_of(
     Group g, bool pred) {
   return any_of_group(g, pred);
 }
@@ -100,7 +100,7 @@ detail::enable_if_t<detail::is_generic_group<Group>::value, bool> any_of(
 template <typename Group, typename T, class Predicate>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::any_of is deprecated. Use any_of_group instead.")
-detail::enable_if_t<detail::is_generic_group<Group>::value, bool> any_of(
+std::enable_if_t<detail::is_generic_group<Group>::value, bool> any_of(
     Group g, T x, Predicate pred) {
   return any_of_group(g, pred(x));
 }
@@ -108,16 +108,16 @@ detail::enable_if_t<detail::is_generic_group<Group>::value, bool> any_of(
 template <typename Group, typename Ptr, class Predicate>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::any_of is deprecated. Use joint_any_of instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_pointer<Ptr>::value),
-                    bool> any_of(Group g, Ptr first, Ptr last, Predicate pred) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_pointer<Ptr>::value),
+                 bool> any_of(Group g, Ptr first, Ptr last, Predicate pred) {
   return joint_any_of(g, first, last, pred);
 }
 
 template <typename Group>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::none_of is deprecated. Use none_of_group instead.")
-detail::enable_if_t<detail::is_generic_group<Group>::value, bool> none_of(
+std::enable_if_t<detail::is_generic_group<Group>::value, bool> none_of(
     Group g, bool pred) {
   return none_of_group(g, pred);
 }
@@ -125,7 +125,7 @@ detail::enable_if_t<detail::is_generic_group<Group>::value, bool> none_of(
 template <typename Group, typename T, class Predicate>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::none_of is deprecated. Use none_of_group instead.")
-detail::enable_if_t<detail::is_generic_group<Group>::value, bool> none_of(
+std::enable_if_t<detail::is_generic_group<Group>::value, bool> none_of(
     Group g, T x, Predicate pred) {
   return none_of_group(g, pred(x));
 }
@@ -133,21 +133,19 @@ detail::enable_if_t<detail::is_generic_group<Group>::value, bool> none_of(
 template <typename Group, typename Ptr, class Predicate>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::none_of is deprecated. Use joint_none_of instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_pointer<Ptr>::value),
-                    bool> none_of(Group g, Ptr first, Ptr last,
-                                  Predicate pred) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_pointer<Ptr>::value),
+                 bool> none_of(Group g, Ptr first, Ptr last, Predicate pred) {
   return joint_none_of(g, first, last, pred);
 }
 
 template <typename Group, typename T>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::broadcast is deprecated. Use group_broadcast instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     std::is_trivially_copyable<T>::value &&
-                     !detail::is_vector_arithmetic<T>::value),
-                    T> broadcast(Group g, T x,
-                                 typename Group::id_type local_id) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  std::is_trivially_copyable<T>::value &&
+                  !detail::is_vector_arithmetic<T>::value),
+                 T> broadcast(Group g, T x, typename Group::id_type local_id) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::GroupBroadcast(g, x, local_id);
 #else
@@ -161,10 +159,9 @@ detail::enable_if_t<(detail::is_generic_group<Group>::value &&
 template <typename Group, typename T>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::broadcast is deprecated. Use group_broadcast instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_vector_arithmetic<T>::value),
-                    T> broadcast(Group g, T x,
-                                 typename Group::id_type local_id) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_vector_arithmetic<T>::value),
+                 T> broadcast(Group g, T x, typename Group::id_type local_id) {
 #ifdef __SYCL_DEVICE_ONLY__
   T result;
   for (int s = 0; s < x.size(); ++s) {
@@ -183,12 +180,11 @@ detail::enable_if_t<(detail::is_generic_group<Group>::value &&
 template <typename Group, typename T>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::broadcast is deprecated. Use group_broadcast instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     std::is_trivially_copyable<T>::value &&
-                     !detail::is_vector_arithmetic<T>::value),
-                    T> broadcast(Group g, T x,
-                                 typename Group::linear_id_type
-                                     linear_local_id) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  std::is_trivially_copyable<T>::value &&
+                  !detail::is_vector_arithmetic<T>::value),
+                 T> broadcast(Group g, T x,
+                              typename Group::linear_id_type linear_local_id) {
 #ifdef __SYCL_DEVICE_ONLY__
   return broadcast(
       g, x,
@@ -205,11 +201,10 @@ detail::enable_if_t<(detail::is_generic_group<Group>::value &&
 template <typename Group, typename T>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::broadcast is deprecated. Use group_broadcast instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_vector_arithmetic<T>::value),
-                    T> broadcast(Group g, T x,
-                                 typename Group::linear_id_type
-                                     linear_local_id) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_vector_arithmetic<T>::value),
+                 T> broadcast(Group g, T x,
+                              typename Group::linear_id_type linear_local_id) {
 #ifdef __SYCL_DEVICE_ONLY__
   T result;
   for (int s = 0; s < x.size(); ++s) {
@@ -228,10 +223,10 @@ detail::enable_if_t<(detail::is_generic_group<Group>::value &&
 template <typename Group, typename T>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::broadcast is deprecated. Use group_broadcast instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     std::is_trivially_copyable<T>::value &&
-                     !detail::is_vector_arithmetic<T>::value),
-                    T> broadcast(Group g, T x) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  std::is_trivially_copyable<T>::value &&
+                  !detail::is_vector_arithmetic<T>::value),
+                 T> broadcast(Group g, T x) {
 #ifdef __SYCL_DEVICE_ONLY__
   return broadcast(g, x, 0);
 #else
@@ -245,9 +240,9 @@ detail::enable_if_t<(detail::is_generic_group<Group>::value &&
 template <typename Group, typename T>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::broadcast is deprecated. Use group_broadcast instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_vector_arithmetic<T>::value),
-                    T> broadcast(Group g, T x) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_vector_arithmetic<T>::value),
+                 T> broadcast(Group g, T x) {
 #ifdef __SYCL_DEVICE_ONLY__
   T result;
   for (int s = 0; s < x.size(); ++s) {
@@ -265,31 +260,31 @@ detail::enable_if_t<(detail::is_generic_group<Group>::value &&
 template <typename Group, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::reduce is deprecated. Use reduce_over_group instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_scalar_arithmetic<T>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T> reduce(Group g, T x, BinaryOperation binary_op) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_scalar_arithmetic<T>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T> reduce(Group g, T x, BinaryOperation binary_op) {
   return reduce_over_group(g, x, binary_op);
 }
 
 template <typename Group, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::reduce is deprecated. Use reduce_over_group instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_vector_arithmetic<T>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T> reduce(Group g, T x, BinaryOperation binary_op) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_vector_arithmetic<T>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T> reduce(Group g, T x, BinaryOperation binary_op) {
   return reduce_over_group(g, x, binary_op);
 }
 
 template <typename Group, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::reduce is deprecated. Use reduce_over_group instead.")
-detail::enable_if_t<(detail::is_sub_group<Group>::value &&
-                     std::is_trivially_copyable<T>::value &&
-                     (!detail::is_arithmetic<T>::value ||
-                      !detail::is_native_op<T, BinaryOperation>::value)),
-                    T> reduce(Group g, T x, BinaryOperation op) {
+std::enable_if_t<(detail::is_sub_group<Group>::value &&
+                  std::is_trivially_copyable<T>::value &&
+                  (!detail::is_arithmetic<T>::value ||
+                   !detail::is_native_op<T, BinaryOperation>::value)),
+                 T> reduce(Group g, T x, BinaryOperation op) {
   T result = x;
   for (int mask = 1; mask < g.get_max_local_range()[0]; mask *= 2) {
     T tmp = g.shuffle_xor(result, id<1>(mask));
@@ -303,37 +298,37 @@ detail::enable_if_t<(detail::is_sub_group<Group>::value &&
 template <typename Group, typename V, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::reduce is deprecated. Use reduce_over_group instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_scalar_arithmetic<V>::value &&
-                     detail::is_scalar_arithmetic<T>::value &&
-                     detail::is_native_op<V, BinaryOperation>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T> reduce(Group g, V x, T init, BinaryOperation binary_op) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_scalar_arithmetic<V>::value &&
+                  detail::is_scalar_arithmetic<T>::value &&
+                  detail::is_native_op<V, BinaryOperation>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T> reduce(Group g, V x, T init, BinaryOperation binary_op) {
   return reduce_over_group(g, x, init, binary_op);
 }
 
 template <typename Group, typename V, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::reduce is deprecated. Use reduce_over_group instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_vector_arithmetic<V>::value &&
-                     detail::is_vector_arithmetic<T>::value &&
-                     detail::is_native_op<V, BinaryOperation>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T> reduce(Group g, V x, T init, BinaryOperation binary_op) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_vector_arithmetic<V>::value &&
+                  detail::is_vector_arithmetic<T>::value &&
+                  detail::is_native_op<V, BinaryOperation>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T> reduce(Group g, V x, T init, BinaryOperation binary_op) {
   return reduce_over_group(g, x, init, binary_op);
 }
 
 template <typename Group, typename V, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::reduce is deprecated. Use reduce_over_group instead.")
-detail::enable_if_t<(detail::is_sub_group<Group>::value &&
-                     std::is_trivially_copyable<T>::value &&
-                     std::is_trivially_copyable<V>::value &&
-                     (!detail::is_arithmetic<T>::value ||
-                      !detail::is_arithmetic<V>::value ||
-                      !detail::is_native_op<T, BinaryOperation>::value)),
-                    T> reduce(Group g, V x, T init, BinaryOperation op) {
+std::enable_if_t<(detail::is_sub_group<Group>::value &&
+                  std::is_trivially_copyable<T>::value &&
+                  std::is_trivially_copyable<V>::value &&
+                  (!detail::is_arithmetic<T>::value ||
+                   !detail::is_arithmetic<V>::value ||
+                   !detail::is_native_op<T, BinaryOperation>::value)),
+                 T> reduce(Group g, V x, T init, BinaryOperation op) {
   T result = x;
   for (int mask = 1; mask < g.get_max_local_range()[0]; mask *= 2) {
     T tmp = g.shuffle_xor(result, id<1>(mask));
@@ -347,7 +342,7 @@ detail::enable_if_t<(detail::is_sub_group<Group>::value &&
 template <typename Group, typename Ptr, class BinaryOperation>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::reduce is deprecated. Use joint_reduce instead.")
-detail::enable_if_t<
+std::enable_if_t<
     (detail::is_generic_group<Group>::value && detail::is_pointer<Ptr>::value &&
      detail::is_arithmetic<typename detail::remove_pointer<Ptr>::type>::value),
     typename detail::remove_pointer<Ptr>::type> reduce(Group g, Ptr first,
@@ -360,7 +355,7 @@ detail::enable_if_t<
 template <typename Group, typename Ptr, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::reduce is deprecated. Use joint_reduce instead.")
-detail::enable_if_t<
+std::enable_if_t<
     (detail::is_generic_group<Group>::value && detail::is_pointer<Ptr>::value &&
      detail::is_arithmetic<typename detail::remove_pointer<Ptr>::type>::value &&
      detail::is_arithmetic<T>::value &&
@@ -374,46 +369,46 @@ detail::enable_if_t<
 template <typename Group, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED("ext::oneapi::exclusive_scan is deprecated. Use "
                       "exclusive_scan_over_group instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_scalar_arithmetic<T>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T> exclusive_scan(Group g, T x, BinaryOperation binary_op) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_scalar_arithmetic<T>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T> exclusive_scan(Group g, T x, BinaryOperation binary_op) {
   return exclusive_scan_over_group(g, x, binary_op);
 }
 
 template <typename Group, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED("ext::oneapi::exclusive_scan is deprecated. Use "
                       "exclusive_scan_over_group instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_vector_arithmetic<T>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T> exclusive_scan(Group g, T x, BinaryOperation binary_op) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_vector_arithmetic<T>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T> exclusive_scan(Group g, T x, BinaryOperation binary_op) {
   return exclusive_scan_over_group(g, x, binary_op);
 }
 
 template <typename Group, typename V, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED("ext::oneapi::exclusive_scan is deprecated. Use "
                       "exclusive_scan_over_group instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_vector_arithmetic<V>::value &&
-                     detail::is_vector_arithmetic<T>::value &&
-                     detail::is_native_op<V, BinaryOperation>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T> exclusive_scan(Group g, V x, T init,
-                                      BinaryOperation binary_op) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_vector_arithmetic<V>::value &&
+                  detail::is_vector_arithmetic<T>::value &&
+                  detail::is_native_op<V, BinaryOperation>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T> exclusive_scan(Group g, V x, T init,
+                                   BinaryOperation binary_op) {
   return exclusive_scan_over_group(g, x, init, binary_op);
 }
 
 template <typename Group, typename V, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED("ext::oneapi::exclusive_scan is deprecated. Use "
                       "exclusive_scan_over_group instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_scalar_arithmetic<V>::value &&
-                     detail::is_scalar_arithmetic<T>::value &&
-                     detail::is_native_op<V, BinaryOperation>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T> exclusive_scan(Group g, V x, T init,
-                                      BinaryOperation binary_op) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_scalar_arithmetic<V>::value &&
+                  detail::is_scalar_arithmetic<T>::value &&
+                  detail::is_native_op<V, BinaryOperation>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T> exclusive_scan(Group g, V x, T init,
+                                   BinaryOperation binary_op) {
   return exclusive_scan_over_group(g, x, init, binary_op);
 }
 
@@ -421,7 +416,7 @@ template <typename Group, typename InPtr, typename OutPtr, typename T,
           class BinaryOperation>
 __SYCL2020_DEPRECATED("ext::oneapi::exclusive_scan is deprecated. Use "
                       "joint_exclusive_scan instead.")
-detail::enable_if_t<
+std::enable_if_t<
     (detail::is_generic_group<Group>::value &&
      detail::is_pointer<InPtr>::value && detail::is_pointer<OutPtr>::value &&
      detail::is_arithmetic<
@@ -439,7 +434,7 @@ template <typename Group, typename InPtr, typename OutPtr,
           class BinaryOperation>
 __SYCL2020_DEPRECATED("ext::oneapi::exclusive_scan is deprecated. Use "
                       "joint_exclusive_scan instead.")
-detail::enable_if_t<
+std::enable_if_t<
     (detail::is_generic_group<Group>::value &&
      detail::is_pointer<InPtr>::value && detail::is_pointer<OutPtr>::value &&
      detail::is_arithmetic<
@@ -454,46 +449,46 @@ detail::enable_if_t<
 template <typename Group, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED("ext::oneapi::inclusive_scan is deprecated. Use "
                       "inclusive_scan_over_group instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_vector_arithmetic<T>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T> inclusive_scan(Group g, T x, BinaryOperation binary_op) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_vector_arithmetic<T>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T> inclusive_scan(Group g, T x, BinaryOperation binary_op) {
   return inclusive_scan_over_group(g, x, binary_op);
 }
 
 template <typename Group, typename T, class BinaryOperation>
 __SYCL2020_DEPRECATED("ext::oneapi::inclusive_scan is deprecated. Use "
                       "inclusive_scan_over_group instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_scalar_arithmetic<T>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T> inclusive_scan(Group g, T x, BinaryOperation binary_op) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_scalar_arithmetic<T>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T> inclusive_scan(Group g, T x, BinaryOperation binary_op) {
   return inclusive_scan_over_group(g, x, binary_op);
 }
 
 template <typename Group, typename V, class BinaryOperation, typename T>
 __SYCL2020_DEPRECATED("ext::oneapi::inclusive_scan is deprecated. Use "
                       "inclusive_scan_over_group instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_scalar_arithmetic<V>::value &&
-                     detail::is_scalar_arithmetic<T>::value &&
-                     detail::is_native_op<V, BinaryOperation>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T> inclusive_scan(Group g, V x, BinaryOperation binary_op,
-                                      T init) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_scalar_arithmetic<V>::value &&
+                  detail::is_scalar_arithmetic<T>::value &&
+                  detail::is_native_op<V, BinaryOperation>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T> inclusive_scan(Group g, V x, BinaryOperation binary_op,
+                                   T init) {
   return inclusive_scan_over_group(g, x, binary_op, init);
 }
 
 template <typename Group, typename V, class BinaryOperation, typename T>
 __SYCL2020_DEPRECATED("ext::oneapi::inclusive_scan is deprecated. Use "
                       "inclusive_scan_over_group instead.")
-detail::enable_if_t<(detail::is_generic_group<Group>::value &&
-                     detail::is_vector_arithmetic<V>::value &&
-                     detail::is_vector_arithmetic<T>::value &&
-                     detail::is_native_op<V, BinaryOperation>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T> inclusive_scan(Group g, V x, BinaryOperation binary_op,
-                                      T init) {
+std::enable_if_t<(detail::is_generic_group<Group>::value &&
+                  detail::is_vector_arithmetic<V>::value &&
+                  detail::is_vector_arithmetic<T>::value &&
+                  detail::is_native_op<V, BinaryOperation>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T> inclusive_scan(Group g, V x, BinaryOperation binary_op,
+                                   T init) {
   return inclusive_scan_over_group(g, x, binary_op, init);
 }
 
@@ -501,7 +496,7 @@ template <typename Group, typename InPtr, typename OutPtr,
           class BinaryOperation, typename T>
 __SYCL2020_DEPRECATED("ext::oneapi::inclusive_scan is deprecated. Use "
                       "joint_inclusive_scan instead.")
-detail::enable_if_t<
+std::enable_if_t<
     (detail::is_generic_group<Group>::value &&
      detail::is_pointer<InPtr>::value && detail::is_pointer<OutPtr>::value &&
      detail::is_arithmetic<
@@ -519,7 +514,7 @@ template <typename Group, typename InPtr, typename OutPtr,
           class BinaryOperation>
 __SYCL2020_DEPRECATED("ext::oneapi::inclusive_scan is deprecated. Use "
                       "joint_inclusive_scan instead.")
-detail::enable_if_t<
+std::enable_if_t<
     (detail::is_generic_group<Group>::value &&
      detail::is_pointer<InPtr>::value && detail::is_pointer<OutPtr>::value &&
      detail::is_arithmetic<
@@ -535,8 +530,7 @@ template <typename Group>
 __SYCL2020_DEPRECATED(
     "ext::oneapi::leader free function is deprecated. Use member function "
     "leader of the sycl::group/sycl::sub_group instead.")
-detail::enable_if_t<detail::is_generic_group<Group>::value, bool> leader(
-    Group g) {
+std::enable_if_t<detail::is_generic_group<Group>::value, bool> leader(Group g) {
 #ifdef __SYCL_DEVICE_ONLY__
   typename Group::linear_id_type linear_id =
       sycl::detail::get_local_linear_id(g);
diff --git a/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp b/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
index e2cf3f57e1638..aa1814868491d 100644
--- a/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/kernel_properties/properties.hpp
@@ -173,9 +173,10 @@ template <typename T, typename = void>
 struct HasKernelPropertiesGetMethod : std::false_type {};
 
 template <typename T>
-struct HasKernelPropertiesGetMethod<
-    T, sycl::detail::void_t<decltype(std::declval<T>().get(
-           std::declval<properties_tag>()))>> : std::true_type {
+struct HasKernelPropertiesGetMethod<T,
+                                    std::void_t<decltype(std::declval<T>().get(
+                                        std::declval<properties_tag>()))>>
+    : std::true_type {
   using properties_t =
       decltype(std::declval<T>().get(std::declval<properties_tag>()));
 };
diff --git a/sycl/include/sycl/ext/oneapi/properties/properties.hpp b/sycl/include/sycl/ext/oneapi/properties/properties.hpp
index 9cb851a639a21..874ea42ace09f 100644
--- a/sycl/include/sycl/ext/oneapi/properties/properties.hpp
+++ b/sycl/include/sycl/ext/oneapi/properties/properties.hpp
@@ -77,11 +77,10 @@ template <typename... Ts> struct RuntimePropertyStorage<std::tuple<Ts...>> {
 };
 template <typename T, typename... Ts>
 struct RuntimePropertyStorage<std::tuple<T, Ts...>>
-    : sycl::detail::conditional_t<
-          IsRuntimeProperty<T>::value,
-          PrependTuple<
-              T, typename RuntimePropertyStorage<std::tuple<Ts...>>::type>,
-          RuntimePropertyStorage<std::tuple<Ts...>>> {};
+    : std::conditional_t<IsRuntimeProperty<T>::value,
+                         PrependTuple<T, typename RuntimePropertyStorage<
+                                             std::tuple<Ts...>>::type>,
+                         RuntimePropertyStorage<std::tuple<Ts...>>> {};
 
 // Helper class to extract a subset of elements from a tuple.
 // NOTES: This assumes no duplicate properties and that all properties in the
diff --git a/sycl/include/sycl/ext/oneapi/properties/property_utils.hpp b/sycl/include/sycl/ext/oneapi/properties/property_utils.hpp
index fedd815735bfc..64ecd3358e61d 100644
--- a/sycl/include/sycl/ext/oneapi/properties/property_utils.hpp
+++ b/sycl/include/sycl/ext/oneapi/properties/property_utils.hpp
@@ -76,9 +76,9 @@ template <typename... Ts>
 struct AllPropertyValues<std::tuple<Ts...>> : std::true_type {};
 template <typename T, typename... Ts>
 struct AllPropertyValues<std::tuple<T, Ts...>>
-    : sycl::detail::conditional_t<IsPropertyValue<T>::value,
-                                  AllPropertyValues<std::tuple<Ts...>>,
-                                  std::false_type> {};
+    : std::conditional_t<IsPropertyValue<T>::value,
+                         AllPropertyValues<std::tuple<Ts...>>,
+                         std::false_type> {};
 
 //******************************************************************************
 // Property type sorting
@@ -130,9 +130,8 @@ struct IsSorted<std::tuple<Ts...>> : std::true_type {};
 template <typename T> struct IsSorted<std::tuple<T>> : std::true_type {};
 template <typename L, typename R, typename... Rest>
 struct IsSorted<std::tuple<L, R, Rest...>>
-    : sycl::detail::conditional_t<PropertyID<L>::value <= PropertyID<R>::value,
-                                  IsSorted<std::tuple<R, Rest...>>,
-                                  std::false_type> {};
+    : std::conditional_t<PropertyID<L>::value <= PropertyID<R>::value,
+                         IsSorted<std::tuple<R, Rest...>>, std::false_type> {};
 
 // Checks that all types in a sorted tuple have unique PropertyID.
 template <typename T> struct SortedAllUnique {};
@@ -141,9 +140,9 @@ struct SortedAllUnique<std::tuple<Ts...>> : std::true_type {};
 template <typename T> struct SortedAllUnique<std::tuple<T>> : std::true_type {};
 template <typename L, typename R, typename... Rest>
 struct SortedAllUnique<std::tuple<L, R, Rest...>>
-    : sycl::detail::conditional_t<PropertyID<L>::value != PropertyID<R>::value,
-                                  SortedAllUnique<std::tuple<R, Rest...>>,
-                                  std::false_type> {};
+    : std::conditional_t<PropertyID<L>::value != PropertyID<R>::value,
+                         SortedAllUnique<std::tuple<R, Rest...>>,
+                         std::false_type> {};
 
 //******************************************************************************
 // Property merging
diff --git a/sycl/include/sycl/ext/oneapi/properties/property_value.hpp b/sycl/include/sycl/ext/oneapi/properties/property_value.hpp
index ebc1fb94ae86a..9c8996bf76c61 100644
--- a/sycl/include/sycl/ext/oneapi/properties/property_value.hpp
+++ b/sycl/include/sycl/ext/oneapi/properties/property_value.hpp
@@ -65,10 +65,10 @@ template <typename V, typename O, typename = void> struct is_property_value_of {
 };
 // Specialization for compile-time-constant properties
 template <typename V>
-struct is_property_value<V, sycl::detail::void_t<typename V::key_t>>
+struct is_property_value<V, std::void_t<typename V::key_t>>
     : is_property_key<typename V::key_t> {};
 template <typename V, typename O>
-struct is_property_value_of<V, O, sycl::detail::void_t<typename V::key_t>>
+struct is_property_value_of<V, O, std::void_t<typename V::key_t>>
     : is_property_key_of<typename V::key_t, O> {};
 
 namespace detail {
diff --git a/sycl/include/sycl/ext/oneapi/sub_group.hpp b/sycl/include/sycl/ext/oneapi/sub_group.hpp
index 52de964cbbc1e..7aebf0780618b 100644
--- a/sycl/include/sycl/ext/oneapi/sub_group.hpp
+++ b/sycl/include/sycl/ext/oneapi/sub_group.hpp
@@ -40,13 +40,13 @@ using SelectBlockT = select_cl_scalar_integral_unsigned_t<T>;
 
 template <typename T, access::address_space Space>
 using AcceptableForGlobalLoadStore =
-    bool_constant<!std::is_same<void, SelectBlockT<T>>::value &&
-                  Space == access::address_space::global_space>;
+    std::bool_constant<!std::is_same<void, SelectBlockT<T>>::value &&
+                       Space == access::address_space::global_space>;
 
 template <typename T, access::address_space Space>
 using AcceptableForLocalLoadStore =
-    bool_constant<!std::is_same<void, SelectBlockT<T>>::value &&
-                  Space == access::address_space::local_space>;
+    std::bool_constant<!std::is_same<void, SelectBlockT<T>>::value &&
+                       Space == access::address_space::local_space>;
 
 #ifdef __SYCL_DEVICE_ONLY__
 template <typename T, access::address_space Space,
diff --git a/sycl/include/sycl/ext/oneapi/sub_group_mask.hpp b/sycl/include/sycl/ext/oneapi/sub_group_mask.hpp
index 44cc1ab2cfc8d..8e20cf892c106 100644
--- a/sycl/include/sycl/ext/oneapi/sub_group_mask.hpp
+++ b/sycl/include/sycl/ext/oneapi/sub_group_mask.hpp
@@ -40,8 +40,8 @@ namespace ext::oneapi {
 // need to forward declare sub_group_mask first
 struct sub_group_mask;
 template <typename Group>
-sycl::detail::enable_if_t<std::is_same<std::decay_t<Group>, sub_group>::value,
-                          sub_group_mask>
+std::enable_if_t<std::is_same<std::decay_t<Group>, sub_group>::value,
+                 sub_group_mask>
 group_ballot(Group g, bool predicate = true);
 
 struct sub_group_mask {
@@ -117,7 +117,7 @@ struct sub_group_mask {
   }
 
   template <typename Type,
-            typename = sycl::detail::enable_if_t<std::is_integral<Type>::value>>
+            typename = std::enable_if_t<std::is_integral<Type>::value>>
   void insert_bits(Type bits, id<1> pos = 0) {
     size_t insert_size = sizeof(Type) * CHAR_BIT;
     BitsType insert_data = (BitsType)bits;
@@ -136,7 +136,7 @@ struct sub_group_mask {
   bit id    |7   ..    0|15   ..   8|23   ..  16|31  ..   24|...
   */
   template <typename Type, size_t Size,
-            typename = sycl::detail::enable_if_t<std::is_integral<Type>::value>>
+            typename = std::enable_if_t<std::is_integral<Type>::value>>
   void insert_bits(const marray<Type, Size> &bits, id<1> pos = 0) {
     size_t cur_pos = pos.get(0);
     for (auto elem : bits) {
@@ -148,7 +148,7 @@ struct sub_group_mask {
   }
 
   template <typename Type,
-            typename = sycl::detail::enable_if_t<std::is_integral<Type>::value>>
+            typename = std::enable_if_t<std::is_integral<Type>::value>>
   void extract_bits(Type &bits, id<1> pos = 0) const {
     auto Res = Bits;
     Res &= valuable_bits(bits_num);
@@ -167,7 +167,7 @@ struct sub_group_mask {
   }
 
   template <typename Type, size_t Size,
-            typename = sycl::detail::enable_if_t<std::is_integral<Type>::value>>
+            typename = std::enable_if_t<std::is_integral<Type>::value>>
   void extract_bits(marray<Type, Size> &bits, id<1> pos = 0) const {
     size_t cur_pos = pos.get(0);
     for (auto &elem : bits) {
@@ -238,8 +238,8 @@ struct sub_group_mask {
       : Bits(rhs.Bits), bits_num(rhs.bits_num) {}
 
   template <typename Group>
-  friend sycl::detail::enable_if_t<
-      std::is_same<std::decay_t<Group>, sub_group>::value, sub_group_mask>
+  friend std::enable_if_t<std::is_same<std::decay_t<Group>, sub_group>::value,
+                          sub_group_mask>
   group_ballot(Group g, bool predicate);
 
   friend sub_group_mask operator&(const sub_group_mask &lhs,
@@ -281,8 +281,8 @@ struct sub_group_mask {
 };
 
 template <typename Group>
-sycl::detail::enable_if_t<std::is_same<std::decay_t<Group>, sub_group>::value,
-                          sub_group_mask>
+std::enable_if_t<std::is_same<std::decay_t<Group>, sub_group>::value,
+                 sub_group_mask>
 group_ballot(Group g, bool predicate) {
   (void)g;
 #ifdef __SYCL_DEVICE_ONLY__
diff --git a/sycl/include/sycl/group.hpp b/sycl/include/sycl/group.hpp
index 357ee9a33c003..c73df624bec87 100644
--- a/sycl/include/sycl/group.hpp
+++ b/sycl/include/sycl/group.hpp
@@ -277,10 +277,10 @@ template <int Dimensions = 1> class __SYCL_TYPE(group) group {
   /// space, global address space or both based on the value of \p accessSpace.
   template <access::mode accessMode = access::mode::read_write>
   void mem_fence(
-      typename detail::enable_if_t<accessMode == access::mode::read ||
-                                       accessMode == access::mode::write ||
-                                       accessMode == access::mode::read_write,
-                                   access::fence_space>
+      typename std::enable_if_t<accessMode == access::mode::read ||
+                                    accessMode == access::mode::write ||
+                                    accessMode == access::mode::read_write,
+                                access::fence_space>
           accessSpace = access::fence_space::global_and_local) const {
     uint32_t flags = detail::getSPIRVMemorySemanticsMask(accessSpace);
     // TODO: currently, there is no good way in SPIR-V to set the memory
@@ -300,7 +300,7 @@ template <int Dimensions = 1> class __SYCL_TYPE(group) group {
   /// device_event which can be used to wait on the completion of the copy.
   /// Permitted types for dataT are all scalar and vector types, except boolean.
   template <typename dataT>
-  detail::enable_if_t<!detail::is_bool<dataT>::value, device_event>
+  std::enable_if_t<!detail::is_bool<dataT>::value, device_event>
   async_work_group_copy(local_ptr<dataT> dest, global_ptr<dataT> src,
                         size_t numElements, size_t srcStride) const {
     using DestT = detail::ConvertToOpenCLType_t<decltype(dest)>;
@@ -318,7 +318,7 @@ template <int Dimensions = 1> class __SYCL_TYPE(group) group {
   /// device_event which can be used to wait on the completion of the copy.
   /// Permitted types for dataT are all scalar and vector types, except boolean.
   template <typename dataT>
-  detail::enable_if_t<!detail::is_bool<dataT>::value, device_event>
+  std::enable_if_t<!detail::is_bool<dataT>::value, device_event>
   async_work_group_copy(global_ptr<dataT> dest, local_ptr<dataT> src,
                         size_t numElements, size_t destStride) const {
     using DestT = detail::ConvertToOpenCLType_t<decltype(dest)>;
@@ -337,7 +337,7 @@ template <int Dimensions = 1> class __SYCL_TYPE(group) group {
   /// which can be used to wait on the completion of the copy.
   template <typename T, access::address_space DestS, access::address_space SrcS,
             access::decorated DestIsDecorated, access::decorated SrcIsDecorated>
-  detail::enable_if_t<detail::is_scalar_bool<T>::value, device_event>
+  std::enable_if_t<detail::is_scalar_bool<T>::value, device_event>
   async_work_group_copy(multi_ptr<T, DestS, DestIsDecorated> Dest,
                         multi_ptr<T, SrcS, SrcIsDecorated> Src,
                         size_t NumElements, size_t Stride) const {
@@ -357,7 +357,7 @@ template <int Dimensions = 1> class __SYCL_TYPE(group) group {
   /// which can be used to wait on the completion of the copy.
   template <typename T, access::address_space DestS, access::address_space SrcS,
             access::decorated DestIsDecorated, access::decorated SrcIsDecorated>
-  detail::enable_if_t<detail::is_vector_bool<T>::value, device_event>
+  std::enable_if_t<detail::is_vector_bool<T>::value, device_event>
   async_work_group_copy(multi_ptr<T, DestS, DestIsDecorated> Dest,
                         multi_ptr<T, SrcS, SrcIsDecorated> Src,
                         size_t NumElements, size_t Stride) const {
@@ -418,21 +418,21 @@ template <int Dimensions = 1> class __SYCL_TYPE(group) group {
   id<Dimensions> index;
 
   template <int dims = Dimensions>
-  typename detail::enable_if_t<(dims == 1), size_t>
+  typename std::enable_if_t<(dims == 1), size_t>
   get_local_linear_id_impl() const {
     id<Dimensions> localId = get_local_id();
     return localId[0];
   }
 
   template <int dims = Dimensions>
-  typename detail::enable_if_t<(dims == 2), size_t>
+  typename std::enable_if_t<(dims == 2), size_t>
   get_local_linear_id_impl() const {
     id<Dimensions> localId = get_local_id();
     return localId[0] * localRange[1] + localId[1];
   }
 
   template <int dims = Dimensions>
-  typename detail::enable_if_t<(dims == 3), size_t>
+  typename std::enable_if_t<(dims == 3), size_t>
   get_local_linear_id_impl() const {
     id<Dimensions> localId = get_local_id();
     return (localId[0] * localRange[1] * localRange[2]) +
@@ -440,55 +440,55 @@ template <int Dimensions = 1> class __SYCL_TYPE(group) group {
   }
 
   template <int dims = Dimensions>
-  typename detail::enable_if_t<(dims == 1), size_t>
+  typename std::enable_if_t<(dims == 1), size_t>
   get_local_linear_range_impl() const {
     auto localRange = get_local_range();
     return localRange[0];
   }
 
   template <int dims = Dimensions>
-  typename detail::enable_if_t<(dims == 2), size_t>
+  typename std::enable_if_t<(dims == 2), size_t>
   get_local_linear_range_impl() const {
     auto localRange = get_local_range();
     return localRange[0] * localRange[1];
   }
 
   template <int dims = Dimensions>
-  typename detail::enable_if_t<(dims == 3), size_t>
+  typename std::enable_if_t<(dims == 3), size_t>
   get_local_linear_range_impl() const {
     auto localRange = get_local_range();
     return localRange[0] * localRange[1] * localRange[2];
   }
 
   template <int dims = Dimensions>
-  typename detail::enable_if_t<(dims == 1), size_t>
+  typename std::enable_if_t<(dims == 1), size_t>
   get_group_linear_range_impl() const {
     auto groupRange = get_group_range();
     return groupRange[0];
   }
 
   template <int dims = Dimensions>
-  typename detail::enable_if_t<(dims == 2), size_t>
+  typename std::enable_if_t<(dims == 2), size_t>
   get_group_linear_range_impl() const {
     auto groupRange = get_group_range();
     return groupRange[0] * groupRange[1];
   }
 
   template <int dims = Dimensions>
-  typename detail::enable_if_t<(dims == 3), size_t>
+  typename std::enable_if_t<(dims == 3), size_t>
   get_group_linear_range_impl() const {
     auto groupRange = get_group_range();
     return groupRange[0] * groupRange[1] * groupRange[2];
   }
 
   template <int dims = Dimensions>
-  typename detail::enable_if_t<(dims == 1), size_t>
+  typename std::enable_if_t<(dims == 1), size_t>
   get_group_linear_id_impl() const {
     return index[0];
   }
 
   template <int dims = Dimensions>
-  typename detail::enable_if_t<(dims == 2), size_t>
+  typename std::enable_if_t<(dims == 2), size_t>
   get_group_linear_id_impl() const {
     return index[0] * groupRange[1] + index[1];
   }
@@ -504,7 +504,7 @@ template <int Dimensions = 1> class __SYCL_TYPE(group) group {
   //    Get a linearized version of the work-group id. Calculating a linear
   //    work-group id from a multi-dimensional index follows the equation 4.3.
   template <int dims = Dimensions>
-  typename detail::enable_if_t<(dims == 3), size_t>
+  typename std::enable_if_t<(dims == 3), size_t>
   get_group_linear_id_impl() const {
     return (index[0] * groupRange[1] * groupRange[2]) +
            (index[1] * groupRange[2]) + index[2];
diff --git a/sycl/include/sycl/group_algorithm.hpp b/sycl/include/sycl/group_algorithm.hpp
index 3001ff493cb42..796143bbb91f5 100644
--- a/sycl/include/sycl/group_algorithm.hpp
+++ b/sycl/include/sycl/group_algorithm.hpp
@@ -130,9 +130,9 @@ using is_arithmetic_or_complex =
 
 template <typename T>
 struct is_vector_arithmetic_or_complex
-    : bool_constant<is_vec<T>::value &&
-                    (is_arithmetic<T>::value ||
-                     is_complex<vector_element_t<T>>::value)> {};
+    : std::bool_constant<is_vec<T>::value &&
+                         (is_arithmetic<T>::value ||
+                          is_complex<vector_element_t<T>>::value)> {};
 
 // ---- is_plus_or_multiplies_if_complex
 template <typename T, typename BinaryOperation>
@@ -147,21 +147,21 @@ using is_plus_or_multiplies_if_complex = std::integral_constant<
 // TODO: identiy_for_ga_op should be replaced with known_identity once the other
 // callers of known_identity support complex numbers.
 template <typename T, class BinaryOperation>
-constexpr detail::enable_if_t<
+constexpr std::enable_if_t<
     (is_complex<T>::value && is_plus<T, BinaryOperation>::value), T>
 identity_for_ga_op() {
   return {0, 0};
 }
 
 template <typename T, class BinaryOperation>
-constexpr detail::enable_if_t<
+constexpr std::enable_if_t<
     (is_complex<T>::value && is_multiplies<T, BinaryOperation>::value), T>
 identity_for_ga_op() {
   return {1, 0};
 }
 
 template <typename T, class BinaryOperation>
-constexpr detail::enable_if_t<!is_complex<T>::value, T> identity_for_ga_op() {
+constexpr std::enable_if_t<!is_complex<T>::value, T> identity_for_ga_op() {
   return sycl::known_identity_v<BinaryOperation, T>;
 }
 
@@ -191,12 +191,12 @@ Function for_each(Group g, Ptr first, Ptr last, Function f) {
 //        scalar arithmetic, complex (plus only), and vector arithmetic
 
 template <typename Group, typename T, class BinaryOperation>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     (detail::is_scalar_arithmetic<T>::value ||
-                      (detail::is_complex<T>::value &&
-                       detail::is_multiplies<T, BinaryOperation>::value)) &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  (detail::is_scalar_arithmetic<T>::value ||
+                   (detail::is_complex<T>::value &&
+                    detail::is_multiplies<T, BinaryOperation>::value)) &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T>
 reduce_over_group(Group g, T x, BinaryOperation binary_op) {
   // FIXME: Do not special-case for half precision
   static_assert(
@@ -216,11 +216,11 @@ reduce_over_group(Group g, T x, BinaryOperation binary_op) {
 // complex specialization. T is std::complex<float> or similar.
 //   binary op is  sycl::plus<std::complex<float>>
 template <typename Group, typename T, class BinaryOperation>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     detail::is_complex<T>::value &&
-                     detail::is_native_op<T, sycl::plus<T>>::value &&
-                     detail::is_plus<T, BinaryOperation>::value),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  detail::is_complex<T>::value &&
+                  detail::is_native_op<T, sycl::plus<T>>::value &&
+                  detail::is_plus<T, BinaryOperation>::value),
+                 T>
 reduce_over_group(Group g, T x, BinaryOperation binary_op) {
 #ifdef __SYCL_DEVICE_ONLY__
   T result;
@@ -237,7 +237,7 @@ reduce_over_group(Group g, T x, BinaryOperation binary_op) {
 }
 
 template <typename Group, typename T, int N, class BinaryOperation>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> &&
      detail::is_vector_arithmetic_or_complex<sycl::vec<T, N>>::value &&
      detail::is_native_op<sycl::vec<T, N>, BinaryOperation>::value),
@@ -260,7 +260,7 @@ reduce_over_group(Group g, sycl::vec<T, N> x, BinaryOperation binary_op) {
 //   four argument variant of reduce_over_group specialized twice
 //       (scalar arithmetic || complex), and vector_arithmetic
 template <typename Group, typename V, typename T, class BinaryOperation>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> &&
      (detail::is_scalar_arithmetic<V>::value || detail::is_complex<V>::value) &&
      (detail::is_scalar_arithmetic<T>::value || detail::is_complex<T>::value) &&
@@ -286,12 +286,12 @@ reduce_over_group(Group g, V x, T init, BinaryOperation binary_op) {
 }
 
 template <typename Group, typename V, typename T, class BinaryOperation>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     detail::is_vector_arithmetic_or_complex<V>::value &&
-                     detail::is_vector_arithmetic_or_complex<T>::value &&
-                     detail::is_native_op<V, BinaryOperation>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  detail::is_vector_arithmetic_or_complex<V>::value &&
+                  detail::is_vector_arithmetic_or_complex<T>::value &&
+                  detail::is_native_op<V, BinaryOperation>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T>
 reduce_over_group(Group g, V x, T init, BinaryOperation binary_op) {
   // FIXME: Do not special-case for half precision
   static_assert(
@@ -315,7 +315,7 @@ reduce_over_group(Group g, V x, T init, BinaryOperation binary_op) {
 
 // ---- joint_reduce
 template <typename Group, typename Ptr, typename T, class BinaryOperation>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> && detail::is_pointer<Ptr>::value &&
      detail::is_arithmetic_or_complex<
          typename detail::remove_pointer<Ptr>::type>::value &&
@@ -374,7 +374,7 @@ joint_reduce(Group g, Ptr first, Ptr last, BinaryOperation binary_op) {
 
 // ---- any_of_group
 template <typename Group>
-detail::enable_if_t<is_group_v<std::decay_t<Group>>, bool>
+std::enable_if_t<is_group_v<std::decay_t<Group>>, bool>
 any_of_group(Group g, bool pred) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::GroupAny(g, pred);
@@ -386,14 +386,14 @@ any_of_group(Group g, bool pred) {
 }
 
 template <typename Group, typename T, class Predicate>
-detail::enable_if_t<is_group_v<Group>, bool> any_of_group(Group g, T x,
-                                                          Predicate pred) {
+std::enable_if_t<is_group_v<Group>, bool> any_of_group(Group g, T x,
+                                                       Predicate pred) {
   return any_of_group(g, pred(x));
 }
 
 // ---- joint_any_of
 template <typename Group, typename Ptr, class Predicate>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> && detail::is_pointer<Ptr>::value), bool>
 joint_any_of(Group g, Ptr first, Ptr last, Predicate pred) {
 #ifdef __SYCL_DEVICE_ONLY__
@@ -413,7 +413,7 @@ joint_any_of(Group g, Ptr first, Ptr last, Predicate pred) {
 
 // ---- all_of_group
 template <typename Group>
-detail::enable_if_t<is_group_v<std::decay_t<Group>>, bool>
+std::enable_if_t<is_group_v<std::decay_t<Group>>, bool>
 all_of_group(Group g, bool pred) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::GroupAll(g, pred);
@@ -425,14 +425,14 @@ all_of_group(Group g, bool pred) {
 }
 
 template <typename Group, typename T, class Predicate>
-detail::enable_if_t<is_group_v<std::decay_t<Group>>, bool>
+std::enable_if_t<is_group_v<std::decay_t<Group>>, bool>
 all_of_group(Group g, T x, Predicate pred) {
   return all_of_group(g, pred(x));
 }
 
 // ---- joint_all_of
 template <typename Group, typename Ptr, class Predicate>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> && detail::is_pointer<Ptr>::value), bool>
 joint_all_of(Group g, Ptr first, Ptr last, Predicate pred) {
 #ifdef __SYCL_DEVICE_ONLY__
@@ -452,7 +452,7 @@ joint_all_of(Group g, Ptr first, Ptr last, Predicate pred) {
 
 // ---- none_of_group
 template <typename Group>
-detail::enable_if_t<is_group_v<std::decay_t<Group>>, bool>
+std::enable_if_t<is_group_v<std::decay_t<Group>>, bool>
 none_of_group(Group g, bool pred) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::GroupAll(g, !pred);
@@ -464,14 +464,14 @@ none_of_group(Group g, bool pred) {
 }
 
 template <typename Group, typename T, class Predicate>
-detail::enable_if_t<is_group_v<std::decay_t<Group>>, bool>
+std::enable_if_t<is_group_v<std::decay_t<Group>>, bool>
 none_of_group(Group g, T x, Predicate pred) {
   return none_of_group(g, pred(x));
 }
 
 // ---- joint_none_of
 template <typename Group, typename Ptr, class Predicate>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> && detail::is_pointer<Ptr>::value), bool>
 joint_none_of(Group g, Ptr first, Ptr last, Predicate pred) {
 #ifdef __SYCL_DEVICE_ONLY__
@@ -490,10 +490,10 @@ joint_none_of(Group g, Ptr first, Ptr last, Predicate pred) {
 // TODO: remove check for detail::is_vec<T> once sycl::vec is trivially
 // copyable.
 template <typename Group, typename T>
-detail::enable_if_t<(std::is_same<std::decay_t<Group>, sub_group>::value &&
-                     (std::is_trivially_copyable<T>::value ||
-                      detail::is_vec<T>::value)),
-                    T>
+std::enable_if_t<(std::is_same<std::decay_t<Group>, sub_group>::value &&
+                  (std::is_trivially_copyable<T>::value ||
+                   detail::is_vec<T>::value)),
+                 T>
 shift_group_left(Group, T x, typename Group::linear_id_type delta = 1) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::SubgroupShuffleDown(x, delta);
@@ -509,10 +509,10 @@ shift_group_left(Group, T x, typename Group::linear_id_type delta = 1) {
 // TODO: remove check for detail::is_vec<T> once sycl::vec is trivially
 // copyable.
 template <typename Group, typename T>
-detail::enable_if_t<(std::is_same<std::decay_t<Group>, sub_group>::value &&
-                     (std::is_trivially_copyable<T>::value ||
-                      detail::is_vec<T>::value)),
-                    T>
+std::enable_if_t<(std::is_same<std::decay_t<Group>, sub_group>::value &&
+                  (std::is_trivially_copyable<T>::value ||
+                   detail::is_vec<T>::value)),
+                 T>
 shift_group_right(Group, T x, typename Group::linear_id_type delta = 1) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::SubgroupShuffleUp(x, delta);
@@ -528,10 +528,10 @@ shift_group_right(Group, T x, typename Group::linear_id_type delta = 1) {
 // TODO: remove check for detail::is_vec<T> once sycl::vec is trivially
 // copyable.
 template <typename Group, typename T>
-detail::enable_if_t<(std::is_same<std::decay_t<Group>, sub_group>::value &&
-                     (std::is_trivially_copyable<T>::value ||
-                      detail::is_vec<T>::value)),
-                    T>
+std::enable_if_t<(std::is_same<std::decay_t<Group>, sub_group>::value &&
+                  (std::is_trivially_copyable<T>::value ||
+                   detail::is_vec<T>::value)),
+                 T>
 permute_group_by_xor(Group, T x, typename Group::linear_id_type mask) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::SubgroupShuffleXor(x, mask);
@@ -547,10 +547,10 @@ permute_group_by_xor(Group, T x, typename Group::linear_id_type mask) {
 // TODO: remove check for detail::is_vec<T> once sycl::vec is trivially
 // copyable.
 template <typename Group, typename T>
-detail::enable_if_t<(std::is_same<std::decay_t<Group>, sub_group>::value &&
-                     (std::is_trivially_copyable<T>::value ||
-                      detail::is_vec<T>::value)),
-                    T>
+std::enable_if_t<(std::is_same<std::decay_t<Group>, sub_group>::value &&
+                  (std::is_trivially_copyable<T>::value ||
+                   detail::is_vec<T>::value)),
+                 T>
 select_from_group(Group, T x, typename Group::id_type local_id) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::SubgroupShuffle(x, local_id);
@@ -566,10 +566,10 @@ select_from_group(Group, T x, typename Group::id_type local_id) {
 // TODO: remove check for detail::is_vec<T> once sycl::vec is trivially
 // copyable.
 template <typename Group, typename T>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     (std::is_trivially_copyable<T>::value ||
-                      detail::is_vec<T>::value)),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  (std::is_trivially_copyable<T>::value ||
+                   detail::is_vec<T>::value)),
+                 T>
 group_broadcast(Group g, T x, typename Group::id_type local_id) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::GroupBroadcast(g, x, local_id);
@@ -582,10 +582,10 @@ group_broadcast(Group g, T x, typename Group::id_type local_id) {
 }
 
 template <typename Group, typename T>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     (std::is_trivially_copyable<T>::value ||
-                      detail::is_vec<T>::value)),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  (std::is_trivially_copyable<T>::value ||
+                   detail::is_vec<T>::value)),
+                 T>
 group_broadcast(Group g, T x, typename Group::linear_id_type linear_local_id) {
 #ifdef __SYCL_DEVICE_ONLY__
   return group_broadcast(
@@ -601,10 +601,10 @@ group_broadcast(Group g, T x, typename Group::linear_id_type linear_local_id) {
 }
 
 template <typename Group, typename T>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     (std::is_trivially_copyable<T>::value ||
-                      detail::is_vec<T>::value)),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  (std::is_trivially_copyable<T>::value ||
+                   detail::is_vec<T>::value)),
+                 T>
 group_broadcast(Group g, T x) {
 #ifdef __SYCL_DEVICE_ONLY__
   return group_broadcast(g, x, 0);
@@ -621,12 +621,12 @@ group_broadcast(Group g, T x) {
 //   the three argument version is specialized thrice: scalar, complex, and
 //   vector
 template <typename Group, typename T, class BinaryOperation>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     (detail::is_scalar_arithmetic<T>::value ||
-                      (detail::is_complex<T>::value &&
-                       detail::is_multiplies<T, BinaryOperation>::value)) &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  (detail::is_scalar_arithmetic<T>::value ||
+                   (detail::is_complex<T>::value &&
+                    detail::is_multiplies<T, BinaryOperation>::value)) &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T>
 exclusive_scan_over_group(Group g, T x, BinaryOperation binary_op) {
   // FIXME: Do not special-case for half precision
   static_assert(std::is_same<decltype(binary_op(x, x)), T>::value ||
@@ -645,11 +645,11 @@ exclusive_scan_over_group(Group g, T x, BinaryOperation binary_op) {
 // complex specialization. T is std::complex<float> or similar.
 //   binary op is  sycl::plus<std::complex<float>>
 template <typename Group, typename T, class BinaryOperation>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     detail::is_complex<T>::value &&
-                     detail::is_native_op<T, sycl::plus<T>>::value &&
-                     detail::is_plus<T, BinaryOperation>::value),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  detail::is_complex<T>::value &&
+                  detail::is_native_op<T, sycl::plus<T>>::value &&
+                  detail::is_plus<T, BinaryOperation>::value),
+                 T>
 exclusive_scan_over_group(Group g, T x, BinaryOperation binary_op) {
 #ifdef __SYCL_DEVICE_ONLY__
   T result;
@@ -666,10 +666,10 @@ exclusive_scan_over_group(Group g, T x, BinaryOperation binary_op) {
 }
 
 template <typename Group, typename T, class BinaryOperation>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     detail::is_vector_arithmetic_or_complex<T>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  detail::is_vector_arithmetic_or_complex<T>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T>
 exclusive_scan_over_group(Group g, T x, BinaryOperation binary_op) {
   // FIXME: Do not special-case for half precision
   static_assert(
@@ -688,12 +688,12 @@ exclusive_scan_over_group(Group g, T x, BinaryOperation binary_op) {
 // four argument version of exclusive_scan_over_group is specialized twice
 // once for vector_arithmetic, once for (scalar_arithmetic || complex)
 template <typename Group, typename V, typename T, class BinaryOperation>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     detail::is_vector_arithmetic_or_complex<V>::value &&
-                     detail::is_vector_arithmetic_or_complex<T>::value &&
-                     detail::is_native_op<V, BinaryOperation>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  detail::is_vector_arithmetic_or_complex<V>::value &&
+                  detail::is_vector_arithmetic_or_complex<T>::value &&
+                  detail::is_native_op<V, BinaryOperation>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T>
 exclusive_scan_over_group(Group g, V x, T init, BinaryOperation binary_op) {
   // FIXME: Do not special-case for half precision
   static_assert(
@@ -710,7 +710,7 @@ exclusive_scan_over_group(Group g, V x, T init, BinaryOperation binary_op) {
 }
 
 template <typename Group, typename V, typename T, class BinaryOperation>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> &&
      (detail::is_scalar_arithmetic<V>::value || detail::is_complex<V>::value) &&
      (detail::is_scalar_arithmetic<T>::value || detail::is_complex<T>::value) &&
@@ -746,7 +746,7 @@ exclusive_scan_over_group(Group g, V x, T init, BinaryOperation binary_op) {
 // ---- joint_exclusive_scan
 template <typename Group, typename InPtr, typename OutPtr, typename T,
           class BinaryOperation>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> && detail::is_pointer<InPtr>::value &&
      detail::is_pointer<OutPtr>::value &&
      detail::is_arithmetic_or_complex<
@@ -804,7 +804,7 @@ joint_exclusive_scan(Group g, InPtr first, InPtr last, OutPtr result, T init,
 
 template <typename Group, typename InPtr, typename OutPtr,
           class BinaryOperation>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> && detail::is_pointer<InPtr>::value &&
      detail::is_pointer<OutPtr>::value &&
      detail::is_arithmetic_or_complex<
@@ -834,10 +834,10 @@ joint_exclusive_scan(Group g, InPtr first, InPtr last, OutPtr result,
 //   the three argument version is specialized thrice: vector, scalar, and
 //   complex
 template <typename Group, typename T, class BinaryOperation>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     detail::is_vector_arithmetic_or_complex<T>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  detail::is_vector_arithmetic_or_complex<T>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T>
 inclusive_scan_over_group(Group g, T x, BinaryOperation binary_op) {
   // FIXME: Do not special-case for half precision
   static_assert(
@@ -854,12 +854,12 @@ inclusive_scan_over_group(Group g, T x, BinaryOperation binary_op) {
 }
 
 template <typename Group, typename T, class BinaryOperation>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     (detail::is_scalar_arithmetic<T>::value ||
-                      (detail::is_complex<T>::value &&
-                       detail::is_multiplies<T, BinaryOperation>::value)) &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  (detail::is_scalar_arithmetic<T>::value ||
+                   (detail::is_complex<T>::value &&
+                    detail::is_multiplies<T, BinaryOperation>::value)) &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T>
 inclusive_scan_over_group(Group g, T x, BinaryOperation binary_op) {
   // FIXME: Do not special-case for half precision
   static_assert(std::is_same<decltype(binary_op(x, x)), T>::value ||
@@ -877,11 +877,11 @@ inclusive_scan_over_group(Group g, T x, BinaryOperation binary_op) {
 
 // complex specializaiton
 template <typename Group, typename T, class BinaryOperation>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     detail::is_complex<T>::value &&
-                     detail::is_native_op<T, sycl::plus<T>>::value &&
-                     detail::is_plus<T, BinaryOperation>::value),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  detail::is_complex<T>::value &&
+                  detail::is_native_op<T, sycl::plus<T>>::value &&
+                  detail::is_plus<T, BinaryOperation>::value),
+                 T>
 inclusive_scan_over_group(Group g, T x, BinaryOperation binary_op) {
 #ifdef __SYCL_DEVICE_ONLY__
   T result;
@@ -900,7 +900,7 @@ inclusive_scan_over_group(Group g, T x, BinaryOperation binary_op) {
 // four argument version of inclusive_scan_over_group is specialized twice
 // once for (scalar_arithmetic || complex) and once for vector_arithmetic
 template <typename Group, typename V, class BinaryOperation, typename T>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> &&
      (detail::is_scalar_arithmetic<V>::value || detail::is_complex<V>::value) &&
      (detail::is_scalar_arithmetic<T>::value || detail::is_complex<T>::value) &&
@@ -928,12 +928,12 @@ inclusive_scan_over_group(Group g, V x, BinaryOperation binary_op, T init) {
 }
 
 template <typename Group, typename V, class BinaryOperation, typename T>
-detail::enable_if_t<(is_group_v<std::decay_t<Group>> &&
-                     detail::is_vector_arithmetic_or_complex<V>::value &&
-                     detail::is_vector_arithmetic_or_complex<T>::value &&
-                     detail::is_native_op<V, BinaryOperation>::value &&
-                     detail::is_native_op<T, BinaryOperation>::value),
-                    T>
+std::enable_if_t<(is_group_v<std::decay_t<Group>> &&
+                  detail::is_vector_arithmetic_or_complex<V>::value &&
+                  detail::is_vector_arithmetic_or_complex<T>::value &&
+                  detail::is_native_op<V, BinaryOperation>::value &&
+                  detail::is_native_op<T, BinaryOperation>::value),
+                 T>
 inclusive_scan_over_group(Group g, V x, BinaryOperation binary_op, T init) {
   // FIXME: Do not special-case for half precision
   static_assert(
@@ -951,7 +951,7 @@ inclusive_scan_over_group(Group g, V x, BinaryOperation binary_op, T init) {
 // ---- joint_inclusive_scan
 template <typename Group, typename InPtr, typename OutPtr,
           class BinaryOperation, typename T>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> && detail::is_pointer<InPtr>::value &&
      detail::is_pointer<OutPtr>::value &&
      detail::is_arithmetic_or_complex<
@@ -1008,7 +1008,7 @@ joint_inclusive_scan(Group g, InPtr first, InPtr last, OutPtr result,
 
 template <typename Group, typename InPtr, typename OutPtr,
           class BinaryOperation>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> && detail::is_pointer<InPtr>::value &&
      detail::is_pointer<OutPtr>::value &&
      detail::is_arithmetic_or_complex<
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 1617f8183490e..dac573031c3d1 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -183,8 +183,8 @@ struct GetMergedKernelProperties<
 
 #if __SYCL_ID_QUERIES_FIT_IN_INT__
 template <typename T, typename ValT>
-typename detail::enable_if_t<std::is_same<ValT, size_t>::value ||
-                             std::is_same<ValT, unsigned long long>::value>
+typename std::enable_if_t<std::is_same<ValT, size_t>::value ||
+                          std::is_same<ValT, unsigned long long>::value>
 checkValueRangeImpl(ValT V) {
   static constexpr size_t Limit =
       static_cast<size_t>((std::numeric_limits<int>::max)());
@@ -194,8 +194,8 @@ checkValueRangeImpl(ValT V) {
 #endif
 
 template <int Dims, typename T>
-typename detail::enable_if_t<std::is_same<T, range<Dims>>::value ||
-                             std::is_same<T, id<Dims>>::value>
+typename std::enable_if_t<std::is_same<T, range<Dims>>::value ||
+                          std::is_same<T, id<Dims>>::value>
 checkValueRange(const T &V) {
 #if __SYCL_ID_QUERIES_FIT_IN_INT__
   for (size_t Dim = 0; Dim < Dims; ++Dim)
@@ -232,7 +232,7 @@ void checkValueRange(const range<Dims> &R, const id<Dims> &O) {
 }
 
 template <int Dims, typename T>
-typename detail::enable_if_t<std::is_same<T, nd_range<Dims>>::value>
+typename std::enable_if_t<std::is_same<T, nd_range<Dims>>::value>
 checkValueRange(const T &V) {
 #if __SYCL_ID_QUERIES_FIT_IN_INT__
   checkValueRange<Dims>(V.get_global_range());
@@ -281,7 +281,7 @@ class RoundedRangeKernelWithKH {
   KernelType KernelFunc;
 };
 
-using sycl::detail::enable_if_t;
+using std::enable_if_t;
 using sycl::detail::queue_impl;
 
 } // namespace detail
@@ -341,8 +341,8 @@ class __SYCL_EXPORT handler {
           std::shared_ptr<detail::queue_impl> SecondaryQueue, bool IsHost);
 
   /// Stores copy of Arg passed to the MArgsStorage.
-  template <typename T, typename F = typename detail::remove_const_t<
-                            typename detail::remove_reference_t<T>>>
+  template <typename T, typename F = typename std::remove_const_t<
+                            typename std::remove_reference_t<T>>>
   F *storePlainArg(T &&Arg) {
     MArgsStorage.emplace_back(sizeof(T));
     auto Storage = reinterpret_cast<F *>(MArgsStorage.back().data());
@@ -476,7 +476,7 @@ class __SYCL_EXPORT handler {
   // setArgHelper for non local accessor argument.
   template <typename DataT, int Dims, access::mode AccessMode,
             access::target AccessTarget, access::placeholder IsPlaceholder>
-  typename detail::enable_if_t<AccessTarget != access::target::local, void>
+  typename std::enable_if_t<AccessTarget != access::target::local, void>
   setArgHelper(
       int ArgIndex,
       accessor<DataT, Dims, AccessMode, AccessTarget, IsPlaceholder> &&Arg) {
@@ -767,7 +767,7 @@ class __SYCL_EXPORT handler {
             access::target TargetSrc, typename TDst, int DimDst,
             access::mode ModeDst, access::target TargetDst,
             access::placeholder IsPHSrc, access::placeholder IsPHDst>
-  detail::enable_if_t<(DimSrc > 0) && (DimDst > 0), bool>
+  std::enable_if_t<(DimSrc > 0) && (DimDst > 0), bool>
   copyAccToAccHelper(accessor<TSrc, DimSrc, ModeSrc, TargetSrc, IsPHSrc> Src,
                      accessor<TDst, DimDst, ModeDst, TargetDst, IsPHDst> Dst) {
     if (!MIsHost &&
@@ -798,7 +798,7 @@ class __SYCL_EXPORT handler {
             access::target TargetSrc, typename TDst, int DimDst,
             access::mode ModeDst, access::target TargetDst,
             access::placeholder IsPHSrc, access::placeholder IsPHDst>
-  detail::enable_if_t<DimSrc == 0 || DimDst == 0, bool>
+  std::enable_if_t<DimSrc == 0 || DimDst == 0, bool>
   copyAccToAccHelper(accessor<TSrc, DimSrc, ModeSrc, TargetSrc, IsPHSrc> Src,
                      accessor<TDst, DimDst, ModeDst, TargetDst, IsPHDst> Dst) {
     if (!MIsHost)
@@ -819,7 +819,7 @@ class __SYCL_EXPORT handler {
   /// \param Dst is a pointer to destination memory.
   template <typename TSrc, typename TDst, int Dim, access::mode AccMode,
             access::target AccTarget, access::placeholder IsPH>
-  detail::enable_if_t<(Dim > 0)>
+  std::enable_if_t<(Dim > 0)>
   copyAccToPtrHost(accessor<TSrc, Dim, AccMode, AccTarget, IsPH> Src,
                    TDst *Dst) {
     range<Dim> Range = Src.get_range();
@@ -827,7 +827,7 @@ class __SYCL_EXPORT handler {
         class __copyAcc2Ptr<TSrc, TDst, Dim, AccMode, AccTarget, IsPH>>(
         Range, [=](id<Dim> Index) {
           const size_t LinearIndex = detail::getLinearIndex(Index, Range);
-          using TSrcNonConst = typename detail::remove_const_t<TSrc>;
+          using TSrcNonConst = typename std::remove_const_t<TSrc>;
           (reinterpret_cast<TSrcNonConst *>(Dst))[LinearIndex] = Src[Index];
         });
   }
@@ -839,12 +839,12 @@ class __SYCL_EXPORT handler {
   /// \param Dst is a pointer to destination memory.
   template <typename TSrc, typename TDst, int Dim, access::mode AccMode,
             access::target AccTarget, access::placeholder IsPH>
-  detail::enable_if_t<Dim == 0>
+  std::enable_if_t<Dim == 0>
   copyAccToPtrHost(accessor<TSrc, Dim, AccMode, AccTarget, IsPH> Src,
                    TDst *Dst) {
     single_task<class __copyAcc2Ptr<TSrc, TDst, Dim, AccMode, AccTarget, IsPH>>(
         [=]() {
-          using TSrcNonConst = typename detail::remove_const_t<TSrc>;
+          using TSrcNonConst = typename std::remove_const_t<TSrc>;
           *(reinterpret_cast<TSrcNonConst *>(Dst)) = *(Src.get_pointer());
         });
   }
@@ -855,7 +855,7 @@ class __SYCL_EXPORT handler {
   /// \param Dst is a destination SYCL accessor.
   template <typename TSrc, typename TDst, int Dim, access::mode AccMode,
             access::target AccTarget, access::placeholder IsPH>
-  detail::enable_if_t<(Dim > 0)>
+  std::enable_if_t<(Dim > 0)>
   copyPtrToAccHost(TSrc *Src,
                    accessor<TDst, Dim, AccMode, AccTarget, IsPH> Dst) {
     range<Dim> Range = Dst.get_range();
@@ -874,7 +874,7 @@ class __SYCL_EXPORT handler {
   /// \param Dst is a destination SYCL accessor.
   template <typename TSrc, typename TDst, int Dim, access::mode AccMode,
             access::target AccTarget, access::placeholder IsPH>
-  detail::enable_if_t<Dim == 0>
+  std::enable_if_t<Dim == 0>
   copyPtrToAccHost(TSrc *Src,
                    accessor<TDst, Dim, AccMode, AccTarget, IsPH> Dst) {
     single_task<class __copyPtr2Acc<TSrc, TDst, Dim, AccMode, AccTarget, IsPH>>(
@@ -1467,11 +1467,10 @@ class __SYCL_EXPORT handler {
       const std::shared_ptr<detail::kernel_bundle_impl> &NewKernelBundleImpPtr);
 
   template <typename FuncT>
-  detail::enable_if_t<
-      detail::check_fn_signature<detail::remove_reference_t<FuncT>,
-                                 void()>::value ||
-      detail::check_fn_signature<detail::remove_reference_t<FuncT>,
-                                 void(interop_handle)>::value>
+  std::enable_if_t<detail::check_fn_signature<std::remove_reference_t<FuncT>,
+                                              void()>::value ||
+                   detail::check_fn_signature<std::remove_reference_t<FuncT>,
+                                              void(interop_handle)>::value>
   host_task_impl(FuncT &&Func) {
     throwIfActionIsCreated();
 
@@ -1549,17 +1548,16 @@ class __SYCL_EXPORT handler {
   void depends_on(const std::vector<event> &Events);
 
   template <typename T>
-  using remove_cv_ref_t =
-      typename detail::remove_cv_t<detail::remove_reference_t<T>>;
+  using remove_cv_ref_t = typename std::remove_cv_t<std::remove_reference_t<T>>;
 
   template <typename U, typename T>
   using is_same_type = std::is_same<remove_cv_ref_t<U>, remove_cv_ref_t<T>>;
 
   template <typename T> struct ShouldEnableSetArg {
     static constexpr bool value =
-        std::is_trivially_copyable<detail::remove_reference_t<T>>::value
+        std::is_trivially_copyable<std::remove_reference_t<T>>::value
 #if SYCL_LANGUAGE_VERSION && SYCL_LANGUAGE_VERSION <= 201707
-            && std::is_standard_layout<detail::remove_reference_t<T>>::value
+            && std::is_standard_layout<std::remove_reference_t<T>>::value
 #endif
         || is_same_type<sampler, T>::value // Sampler
         || (!is_same_type<cl_mem, T>::value &&
@@ -1574,7 +1572,7 @@ class __SYCL_EXPORT handler {
   /// \param ArgIndex is a positional number of argument to be set.
   /// \param Arg is an argument value to be set.
   template <typename T>
-  typename detail::enable_if_t<ShouldEnableSetArg<T>::value, void>
+  typename std::enable_if_t<ShouldEnableSetArg<T>::value, void>
   set_arg(int ArgIndex, T &&Arg) {
     setArgHelper(ArgIndex, std::move(Arg));
   }
@@ -1655,11 +1653,10 @@ class __SYCL_EXPORT handler {
 
   /// Enqueues a command to the SYCL runtime to invoke \p Func once.
   template <typename FuncT>
-  detail::enable_if_t<
-      detail::check_fn_signature<detail::remove_reference_t<FuncT>,
-                                 void()>::value ||
-      detail::check_fn_signature<detail::remove_reference_t<FuncT>,
-                                 void(interop_handle)>::value>
+  std::enable_if_t<detail::check_fn_signature<std::remove_reference_t<FuncT>,
+                                              void()>::value ||
+                   detail::check_fn_signature<std::remove_reference_t<FuncT>,
+                                              void(interop_handle)>::value>
   host_task(FuncT &&Func) {
     host_task_impl(Func);
   }
diff --git a/sycl/include/sycl/id.hpp b/sycl/include/sycl/id.hpp
index d89d7c722677f..113dca2a348c3 100644
--- a/sycl/include/sycl/id.hpp
+++ b/sycl/include/sycl/id.hpp
@@ -35,7 +35,7 @@ template <int dimensions = 1> class id : public detail::array<dimensions> {
   static_assert(dimensions >= 1 && dimensions <= 3,
                 "id can only be 1, 2, or 3 dimensional.");
   template <int N, int val, typename T>
-  using ParamTy = detail::enable_if_t<(N == val), T>;
+  using ParamTy = std::enable_if_t<(N == val), T>;
 
 #ifndef __SYCL_DISABLE_ID_TO_INT_CONV__
   /* Helper class for conversion operator. Void type is not suitable. User
@@ -45,9 +45,9 @@ template <int dimensions = 1> class id : public detail::array<dimensions> {
   class __private_class;
 
   template <typename N, typename T>
-  using EnableIfIntegral = detail::enable_if_t<std::is_integral<N>::value, T>;
+  using EnableIfIntegral = std::enable_if_t<std::is_integral<N>::value, T>;
   template <bool B, typename T>
-  using EnableIfT = detail::conditional_t<B, T, __private_class>;
+  using EnableIfT = std::conditional_t<B, T, __private_class>;
 #endif // __SYCL_DISABLE_ID_TO_INT_CONV__
 
 public:
diff --git a/sycl/include/sycl/image.hpp b/sycl/include/sycl/image.hpp
index 1bc001ae0f577..7d40351c89520 100644
--- a/sycl/include/sycl/image.hpp
+++ b/sycl/include/sycl/image.hpp
@@ -86,7 +86,7 @@ using is_validImageDataT = typename detail::is_contained<
 
 template <typename DataT>
 using EnableIfImgAccDataT =
-    typename detail::enable_if_t<is_validImageDataT<DataT>::value, DataT>;
+    typename std::enable_if_t<is_validImageDataT<DataT>::value, DataT>;
 
 // The non-template base for the sycl::image class
 class __SYCL_EXPORT image_plain {
@@ -219,7 +219,7 @@ class image : public detail::image_plain {
   template <bool B = (Dimensions > 1)>
   image(image_channel_order Order, image_channel_type Type,
         const range<Dimensions> &Range,
-        const typename detail::enable_if_t<B, range<Dimensions - 1>> &Pitch,
+        const typename std::enable_if_t<B, range<Dimensions - 1>> &Pitch,
         const property_list &PropList = {})
       : image_plain(Order, Type, detail::convertToArrayOfN<3, 1>(Range),
                     detail::convertToArrayOfN<2, 0>(Pitch),
@@ -231,7 +231,7 @@ class image : public detail::image_plain {
   template <bool B = (Dimensions > 1)>
   image(image_channel_order Order, image_channel_type Type,
         const range<Dimensions> &Range,
-        const typename detail::enable_if_t<B, range<Dimensions - 1>> &Pitch,
+        const typename std::enable_if_t<B, range<Dimensions - 1>> &Pitch,
         AllocatorT Allocator, const property_list &PropList = {})
       : image_plain(
             Order, Type, detail::convertToArrayOfN<3, 1>(Range),
@@ -279,7 +279,7 @@ class image : public detail::image_plain {
   template <bool B = (Dimensions > 1)>
   image(void *HostPointer, image_channel_order Order, image_channel_type Type,
         const range<Dimensions> &Range,
-        const typename detail::enable_if_t<B, range<Dimensions - 1>> &Pitch,
+        const typename std::enable_if_t<B, range<Dimensions - 1>> &Pitch,
         const property_list &PropList = {})
       : image_plain(HostPointer, Order, Type,
                     detail::convertToArrayOfN<3, 1>(Range),
@@ -292,7 +292,7 @@ class image : public detail::image_plain {
   template <bool B = (Dimensions > 1)>
   image(void *HostPointer, image_channel_order Order, image_channel_type Type,
         const range<Dimensions> &Range,
-        const typename detail::enable_if_t<B, range<Dimensions - 1>> &Pitch,
+        const typename std::enable_if_t<B, range<Dimensions - 1>> &Pitch,
         AllocatorT Allocator, const property_list &PropList = {})
       : image_plain(
             HostPointer, Order, Type, detail::convertToArrayOfN<3, 1>(Range),
@@ -323,7 +323,7 @@ class image : public detail::image_plain {
   template <bool B = (Dimensions > 1)>
   image(std::shared_ptr<void> &HostPointer, image_channel_order Order,
         image_channel_type Type, const range<Dimensions> &Range,
-        const typename detail::enable_if_t<B, range<Dimensions - 1>> &Pitch,
+        const typename std::enable_if_t<B, range<Dimensions - 1>> &Pitch,
         const property_list &PropList = {})
       : image_plain(HostPointer, Order, Type,
                     detail::convertToArrayOfN<3, 1>(Range),
@@ -336,7 +336,7 @@ class image : public detail::image_plain {
   template <bool B = (Dimensions > 1)>
   image(std::shared_ptr<void> &HostPointer, image_channel_order Order,
         image_channel_type Type, const range<Dimensions> &Range,
-        const typename detail::enable_if_t<B, range<Dimensions - 1>> &Pitch,
+        const typename std::enable_if_t<B, range<Dimensions - 1>> &Pitch,
         AllocatorT Allocator, const property_list &PropList = {})
       : image_plain(
             HostPointer, Order, Type, detail::convertToArrayOfN<3, 1>(Range),
@@ -385,7 +385,7 @@ class image : public detail::image_plain {
 
   /* Available only when: dimensions >1 */
   template <bool B = (Dimensions > 1)>
-  typename detail::enable_if_t<B, range<Dimensions - 1>> get_pitch() const {
+  typename std::enable_if_t<B, range<Dimensions - 1>> get_pitch() const {
     return detail::convertToArrayOfN<Dimensions - 1, 0>(
         image_plain::get_pitch());
   }
@@ -435,7 +435,7 @@ class image : public detail::image_plain {
   }
 
   template <template <typename WeakT> class WeakPtrT, typename WeakT>
-  detail::enable_if_t<
+  std::enable_if_t<
       std::is_convertible<WeakPtrT<WeakT>, std::weak_ptr<WeakT>>::value>
   set_final_data_internal(WeakPtrT<WeakT> FinalData) {
     std::weak_ptr<WeakT> TempFinalData(FinalData);
diff --git a/sycl/include/sycl/interop_handle.hpp b/sycl/include/sycl/interop_handle.hpp
index 5dad481ead77a..e44d4be65d3fd 100644
--- a/sycl/include/sycl/interop_handle.hpp
+++ b/sycl/include/sycl/interop_handle.hpp
@@ -50,8 +50,8 @@ class interop_handle {
   template <backend Backend = backend::opencl, typename DataT, int Dims,
             access::mode Mode, access::target Target, access::placeholder IsPlh,
             typename PropertyListT = ext::oneapi::accessor_property_list<>>
-  detail::enable_if_t<Target != access::target::image,
-                      backend_return_t<Backend, buffer<DataT, Dims>>>
+  std::enable_if_t<Target != access::target::image,
+                   backend_return_t<Backend, buffer<DataT, Dims>>>
   get_native_mem(const accessor<DataT, Dims, Mode, Target, IsPlh, PropertyListT>
                      &Acc) const {
     static_assert(Target == access::target::device ||
diff --git a/sycl/include/sycl/item.hpp b/sycl/include/sycl/item.hpp
index 51bc7544bec71..fc0f161bee62a 100644
--- a/sycl/include/sycl/item.hpp
+++ b/sycl/include/sycl/item.hpp
@@ -45,7 +45,7 @@ template <int dimensions = 1, bool with_offset = true> class item {
   class __private_class;
 
   template <bool B, typename T>
-  using EnableIfT = detail::conditional_t<B, T, __private_class>;
+  using EnableIfT = std::conditional_t<B, T, __private_class>;
 #endif // __SYCL_DISABLE_ITEM_TO_INT_CONV__
 public:
   item() = delete;
@@ -76,13 +76,13 @@ template <int dimensions = 1, bool with_offset = true> class item {
 #endif // __SYCL_DISABLE_ITEM_TO_INT_CONV__
   template <bool has_offset = with_offset>
   __SYCL2020_DEPRECATED("offsets are deprecated in SYCL2020")
-  detail::enable_if_t<has_offset, id<dimensions>> get_offset() const {
+  std::enable_if_t<has_offset, id<dimensions>> get_offset() const {
     return MImpl.MOffset;
   }
 
   template <bool has_offset = with_offset>
   __SYCL2020_DEPRECATED("offsets are deprecated in SYCL2020")
-  detail::enable_if_t<has_offset, size_t> __SYCL_ALWAYS_INLINE
+  std::enable_if_t<has_offset, size_t> __SYCL_ALWAYS_INLINE
       get_offset(int dimension) const {
     size_t Id = MImpl.MOffset[dimension];
     __SYCL_ASSUME_INT(Id);
@@ -90,7 +90,7 @@ template <int dimensions = 1, bool with_offset = true> class item {
   }
 
   template <bool has_offset = with_offset>
-  operator detail::enable_if_t<!has_offset, item<dimensions, true>>() const {
+  operator std::enable_if_t<!has_offset, item<dimensions, true>>() const {
     return detail::Builder::createItem<dimensions, true>(
         MImpl.MExtent, MImpl.MIndex, /*Offset*/ {});
   }
@@ -115,12 +115,12 @@ template <int dimensions = 1, bool with_offset = true> class item {
 
 protected:
   template <bool has_offset = with_offset>
-  item(detail::enable_if_t<has_offset, const range<dimensions>> &extent,
+  item(std::enable_if_t<has_offset, const range<dimensions>> &extent,
        const id<dimensions> &index, const id<dimensions> &offset)
       : MImpl{extent, index, offset} {}
 
   template <bool has_offset = with_offset>
-  item(detail::enable_if_t<!has_offset, const range<dimensions>> &extent,
+  item(std::enable_if_t<!has_offset, const range<dimensions>> &extent,
        const id<dimensions> &index)
       : MImpl{extent, index} {}
 
diff --git a/sycl/include/sycl/kernel_bundle.hpp b/sycl/include/sycl/kernel_bundle.hpp
index 12651407a537f..55e32c9e23c4f 100644
--- a/sycl/include/sycl/kernel_bundle.hpp
+++ b/sycl/include/sycl/kernel_bundle.hpp
@@ -271,7 +271,7 @@ class kernel_bundle : public detail::kernel_bundle_plain,
   /// \returns a kernel object which represents the kernel identified by
   /// kernel_id passed
   template <bundle_state _State = State,
-            typename = detail::enable_if_t<_State == bundle_state::executable>>
+            typename = std::enable_if_t<_State == bundle_state::executable>>
   kernel get_kernel(const kernel_id &KernelID) const {
     return detail::kernel_bundle_plain::get_kernel(KernelID);
   }
@@ -279,7 +279,7 @@ class kernel_bundle : public detail::kernel_bundle_plain,
   /// \returns a kernel object which represents the kernel identified by
   /// KernelName.
   template <typename KernelName, bundle_state _State = State,
-            typename = detail::enable_if_t<_State == bundle_state::executable>>
+            typename = std::enable_if_t<_State == bundle_state::executable>>
   kernel get_kernel() const {
     return detail::kernel_bundle_plain::get_kernel(get_kernel_id<KernelName>());
   }
@@ -295,7 +295,7 @@ class kernel_bundle : public detail::kernel_bundle_plain,
   /// for this bundle. If the specialization constant’s value was previously set
   /// in this bundle, the value is overwritten.
   template <auto &SpecName, bundle_state _State = State,
-            typename = detail::enable_if_t<_State == bundle_state::input>>
+            typename = std::enable_if_t<_State == bundle_state::input>>
   void set_specialization_constant(
       typename std::remove_reference_t<decltype(SpecName)>::value_type Value) {
     const char *SpecSymName = detail::get_spec_constant_symbolic_ID<SpecName>();
diff --git a/sycl/include/sycl/known_identity.hpp b/sycl/include/sycl/known_identity.hpp
index a5f57e1deaf2b..e4cdadf61e0c6 100644
--- a/sycl/include/sycl/known_identity.hpp
+++ b/sycl/include/sycl/known_identity.hpp
@@ -20,56 +20,57 @@ namespace detail {
 
 template <typename T, class BinaryOperation>
 using IsPlus =
-    bool_constant<std::is_same<BinaryOperation, sycl::plus<T>>::value ||
-                  std::is_same<BinaryOperation, sycl::plus<void>>::value>;
+    std::bool_constant<std::is_same<BinaryOperation, sycl::plus<T>>::value ||
+                       std::is_same<BinaryOperation, sycl::plus<void>>::value>;
 
 template <typename T, class BinaryOperation>
-using IsMultiplies =
-    bool_constant<std::is_same<BinaryOperation, sycl::multiplies<T>>::value ||
-                  std::is_same<BinaryOperation, sycl::multiplies<void>>::value>;
+using IsMultiplies = std::bool_constant<
+    std::is_same<BinaryOperation, sycl::multiplies<T>>::value ||
+    std::is_same<BinaryOperation, sycl::multiplies<void>>::value>;
 
 template <typename T, class BinaryOperation>
-using IsMinimum =
-    bool_constant<std::is_same<BinaryOperation, sycl::minimum<T>>::value ||
-                  std::is_same<BinaryOperation, sycl::minimum<void>>::value>;
+using IsMinimum = std::bool_constant<
+    std::is_same<BinaryOperation, sycl::minimum<T>>::value ||
+    std::is_same<BinaryOperation, sycl::minimum<void>>::value>;
 
 template <typename T, class BinaryOperation>
-using IsMaximum =
-    bool_constant<std::is_same<BinaryOperation, sycl::maximum<T>>::value ||
-                  std::is_same<BinaryOperation, sycl::maximum<void>>::value>;
+using IsMaximum = std::bool_constant<
+    std::is_same<BinaryOperation, sycl::maximum<T>>::value ||
+    std::is_same<BinaryOperation, sycl::maximum<void>>::value>;
 
 template <typename T, class BinaryOperation>
-using IsBitAND =
-    bool_constant<std::is_same<BinaryOperation, sycl::bit_and<T>>::value ||
-                  std::is_same<BinaryOperation, sycl::bit_and<void>>::value>;
+using IsBitAND = std::bool_constant<
+    std::is_same<BinaryOperation, sycl::bit_and<T>>::value ||
+    std::is_same<BinaryOperation, sycl::bit_and<void>>::value>;
 
 template <typename T, class BinaryOperation>
-using IsBitOR =
-    bool_constant<std::is_same<BinaryOperation, sycl::bit_or<T>>::value ||
-                  std::is_same<BinaryOperation, sycl::bit_or<void>>::value>;
+using IsBitOR = std::bool_constant<
+    std::is_same<BinaryOperation, sycl::bit_or<T>>::value ||
+    std::is_same<BinaryOperation, sycl::bit_or<void>>::value>;
 
 template <typename T, class BinaryOperation>
-using IsBitXOR =
-    bool_constant<std::is_same<BinaryOperation, sycl::bit_xor<T>>::value ||
-                  std::is_same<BinaryOperation, sycl::bit_xor<void>>::value>;
+using IsBitXOR = std::bool_constant<
+    std::is_same<BinaryOperation, sycl::bit_xor<T>>::value ||
+    std::is_same<BinaryOperation, sycl::bit_xor<void>>::value>;
 
 template <typename T, class BinaryOperation>
-using IsLogicalAND = bool_constant<
+using IsLogicalAND = std::bool_constant<
     std::is_same<BinaryOperation, sycl::logical_and<T>>::value ||
     std::is_same<BinaryOperation, sycl::logical_and<void>>::value>;
 
 template <typename T, class BinaryOperation>
-using IsLogicalOR =
-    bool_constant<std::is_same<BinaryOperation, sycl::logical_or<T>>::value ||
-                  std::is_same<BinaryOperation, sycl::logical_or<void>>::value>;
+using IsLogicalOR = std::bool_constant<
+    std::is_same<BinaryOperation, sycl::logical_or<T>>::value ||
+    std::is_same<BinaryOperation, sycl::logical_or<void>>::value>;
 
 template <typename T>
-using isComplex = bool_constant<std::is_same<T, std::complex<float>>::value ||
-                                std::is_same<T, std::complex<double>>::value>;
+using isComplex =
+    std::bool_constant<std::is_same<T, std::complex<float>>::value ||
+                       std::is_same<T, std::complex<double>>::value>;
 
 // Identity = 0
 template <typename T, class BinaryOperation>
-using IsZeroIdentityOp = bool_constant<
+using IsZeroIdentityOp = std::bool_constant<
     ((is_genbool<T>::value || is_geninteger<T>::value) &&
      (IsPlus<T, BinaryOperation>::value || IsBitOR<T, BinaryOperation>::value ||
       IsBitXOR<T, BinaryOperation>::value)) ||
@@ -79,47 +80,49 @@ using IsZeroIdentityOp = bool_constant<
 // Identity = 1
 template <typename T, class BinaryOperation>
 using IsOneIdentityOp =
-    bool_constant<(is_genbool<T>::value || is_geninteger<T>::value ||
-                   is_genfloat<T>::value) &&
-                  IsMultiplies<T, BinaryOperation>::value>;
+    std::bool_constant<(is_genbool<T>::value || is_geninteger<T>::value ||
+                        is_genfloat<T>::value) &&
+                       IsMultiplies<T, BinaryOperation>::value>;
 
 // Identity = ~0
 template <typename T, class BinaryOperation>
 using IsOnesIdentityOp =
-    bool_constant<(is_genbool<T>::value || is_geninteger<T>::value) &&
-                  IsBitAND<T, BinaryOperation>::value>;
+    std::bool_constant<(is_genbool<T>::value || is_geninteger<T>::value) &&
+                       IsBitAND<T, BinaryOperation>::value>;
 
 // Identity = <max possible value>
 template <typename T, class BinaryOperation>
 using IsMinimumIdentityOp =
-    bool_constant<(is_genbool<T>::value || is_geninteger<T>::value ||
-                   is_genfloat<T>::value) &&
-                  IsMinimum<T, BinaryOperation>::value>;
+    std::bool_constant<(is_genbool<T>::value || is_geninteger<T>::value ||
+                        is_genfloat<T>::value) &&
+                       IsMinimum<T, BinaryOperation>::value>;
 
 // Identity = <min possible value>
 template <typename T, class BinaryOperation>
 using IsMaximumIdentityOp =
-    bool_constant<(is_genbool<T>::value || is_geninteger<T>::value ||
-                   is_genfloat<T>::value) &&
-                  IsMaximum<T, BinaryOperation>::value>;
+    std::bool_constant<(is_genbool<T>::value || is_geninteger<T>::value ||
+                        is_genfloat<T>::value) &&
+                       IsMaximum<T, BinaryOperation>::value>;
 
 // Identity = false
 template <typename T, class BinaryOperation>
-using IsFalseIdentityOp = bool_constant<IsLogicalOR<T, BinaryOperation>::value>;
+using IsFalseIdentityOp =
+    std::bool_constant<IsLogicalOR<T, BinaryOperation>::value>;
 
 // Identity = true
 template <typename T, class BinaryOperation>
-using IsTrueIdentityOp = bool_constant<IsLogicalAND<T, BinaryOperation>::value>;
+using IsTrueIdentityOp =
+    std::bool_constant<IsLogicalAND<T, BinaryOperation>::value>;
 
 template <typename T, class BinaryOperation>
 using IsKnownIdentityOp =
-    bool_constant<IsZeroIdentityOp<T, BinaryOperation>::value ||
-                  IsOneIdentityOp<T, BinaryOperation>::value ||
-                  IsOnesIdentityOp<T, BinaryOperation>::value ||
-                  IsMinimumIdentityOp<T, BinaryOperation>::value ||
-                  IsMaximumIdentityOp<T, BinaryOperation>::value ||
-                  IsFalseIdentityOp<T, BinaryOperation>::value ||
-                  IsTrueIdentityOp<T, BinaryOperation>::value>;
+    std::bool_constant<IsZeroIdentityOp<T, BinaryOperation>::value ||
+                       IsOneIdentityOp<T, BinaryOperation>::value ||
+                       IsOnesIdentityOp<T, BinaryOperation>::value ||
+                       IsMinimumIdentityOp<T, BinaryOperation>::value ||
+                       IsMaximumIdentityOp<T, BinaryOperation>::value ||
+                       IsFalseIdentityOp<T, BinaryOperation>::value ||
+                       IsTrueIdentityOp<T, BinaryOperation>::value>;
 
 template <typename BinaryOperation, typename AccumulatorT>
 struct has_known_identity_impl
diff --git a/sycl/include/sycl/multi_ptr.hpp b/sycl/include/sycl/multi_ptr.hpp
index fecbfbfed620a..cdd7a31cb3b02 100644
--- a/sycl/include/sycl/multi_ptr.hpp
+++ b/sycl/include/sycl/multi_ptr.hpp
@@ -118,7 +118,7 @@ class multi_ptr {
   template <
       int Dimensions, access::mode Mode, access::placeholder isPlaceholder,
       typename PropertyListT, access::address_space RelaySpace = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           RelaySpace == Space &&
           (Space == access::address_space::generic_space ||
            Space == access::address_space::global_space ||
@@ -133,7 +133,7 @@ class multi_ptr {
   template <int Dimensions, access::mode Mode,
             access::placeholder isPlaceholder, typename PropertyListT,
             access::address_space RelaySpace = Space,
-            typename = typename detail::enable_if_t<
+            typename = typename std::enable_if_t<
                 RelaySpace == Space &&
                 (Space == access::address_space::generic_space ||
                  Space == access::address_space::local_space)>>
@@ -144,7 +144,7 @@ class multi_ptr {
 
   // Only if Space == local_space || generic_space
   template <int Dimensions, access::address_space RelaySpace = Space,
-            typename = typename detail::enable_if_t<
+            typename = typename std::enable_if_t<
                 RelaySpace == Space &&
                 (Space == access::address_space::generic_space ||
                  Space == access::address_space::local_space)>>
@@ -167,17 +167,16 @@ class multi_ptr {
       int Dimensions, access::mode Mode, access::placeholder isPlaceholder,
       typename PropertyListT, access::address_space _Space = Space,
       typename RelayElementType = ElementType,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space &&
           (Space == access::address_space::generic_space ||
            Space == access::address_space::global_space ||
            Space == access::address_space::ext_intel_global_device_space) &&
           std::is_const<RelayElementType>::value &&
           std::is_same<RelayElementType, ElementType>::value>>
-  multi_ptr(
-      accessor<typename detail::remove_const_t<RelayElementType>, Dimensions,
-               Mode, access::target::device, isPlaceholder, PropertyListT>
-          Accessor)
+  multi_ptr(accessor<typename std::remove_const_t<RelayElementType>, Dimensions,
+                     Mode, access::target::device, isPlaceholder, PropertyListT>
+                Accessor)
       : multi_ptr(
             detail::cast_AS<decorated_type *>(Accessor.get_pointer().get())) {}
 
@@ -186,30 +185,29 @@ class multi_ptr {
             access::placeholder isPlaceholder, typename PropertyListT,
             access::address_space RelaySpace = Space,
             typename RelayElementType = ElementType,
-            typename = typename detail::enable_if_t<
+            typename = typename std::enable_if_t<
                 RelaySpace == Space &&
                 (Space == access::address_space::generic_space ||
                  Space == access::address_space::local_space) &&
                 std::is_const<RelayElementType>::value &&
                 std::is_same<RelayElementType, ElementType>::value>>
-  multi_ptr(
-      accessor<typename detail::remove_const_t<RelayElementType>, Dimensions,
-               Mode, access::target::local, isPlaceholder, PropertyListT>
-          Accessor)
+  multi_ptr(accessor<typename std::remove_const_t<RelayElementType>, Dimensions,
+                     Mode, access::target::local, isPlaceholder, PropertyListT>
+                Accessor)
       : multi_ptr(Accessor.get_pointer().get()) {}
 
   // Only if Space == local_space || generic_space and element type is const
   template <int Dimensions, access::address_space RelaySpace = Space,
             typename RelayElementType = ElementType,
-            typename = typename detail::enable_if_t<
+            typename = typename std::enable_if_t<
                 RelaySpace == Space &&
                 (Space == access::address_space::generic_space ||
                  Space == access::address_space::local_space) &&
                 std::is_const<RelayElementType>::value &&
                 std::is_same<RelayElementType, ElementType>::value>>
-  multi_ptr(local_accessor<typename detail::remove_const_t<RelayElementType>,
-                           Dimensions>
-                Accessor)
+  multi_ptr(
+      local_accessor<typename std::remove_const_t<RelayElementType>, Dimensions>
+          Accessor)
       : m_Pointer(detail::cast_AS<decorated_type *>(Accessor.get_pointer())) {}
 
   // Assignment and access operators
@@ -332,7 +330,7 @@ class multi_ptr {
   template <
       access::address_space GlobalSpace = access::address_space::global_space,
       access::address_space RelaySpace = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           RelaySpace == Space &&
           GlobalSpace == access::address_space::global_space &&
           (Space == access::address_space::ext_intel_global_device_space ||
@@ -349,7 +347,7 @@ class multi_ptr {
   // Only if Space == global_space
   template <
       access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && Space == access::address_space::global_space>>
   void prefetch(size_t NumElements) const {
     size_t NumBytes = NumElements * sizeof(ElementType);
@@ -436,7 +434,7 @@ class multi_ptr<const void, Space, DecorateAddress> {
       typename ElementType, int Dimensions, access::mode Mode,
       access::placeholder isPlaceholder, typename PropertyListT,
       access::address_space RelaySpace = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           RelaySpace == Space &&
           (Space == access::address_space::global_space ||
            Space == access::address_space::ext_intel_global_device_space)>>
@@ -451,7 +449,7 @@ class multi_ptr<const void, Space, DecorateAddress> {
       typename ElementType, int Dimensions, access::mode Mode,
       access::placeholder isPlaceholder, typename PropertyListT,
       access::address_space RelaySpace = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           RelaySpace == Space && Space == access::address_space::local_space>>
   multi_ptr(accessor<ElementType, Dimensions, Mode, access::target::local,
                      isPlaceholder, PropertyListT>
@@ -462,7 +460,7 @@ class multi_ptr<const void, Space, DecorateAddress> {
   template <
       typename ElementType, int Dimensions,
       access::address_space RelaySpace = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           RelaySpace == Space && Space == access::address_space::local_space>>
   multi_ptr(local_accessor<ElementType, Dimensions> Accessor)
       : m_Pointer(detail::cast_AS<decorated_type *>(Accessor.get_pointer())) {}
@@ -481,7 +479,7 @@ class multi_ptr<const void, Space, DecorateAddress> {
   operator pointer() const { return get(); }
 
   // Explicit conversion to a multi_ptr<ElementType>
-  template <typename ElementType, typename = typename detail::enable_if_t<
+  template <typename ElementType, typename = typename std::enable_if_t<
                                       std::is_const<ElementType>::value>>
   explicit operator multi_ptr<ElementType, Space, DecorateAddress>() const {
     multi_ptr<ElementType, Space, DecorateAddress>{
@@ -504,7 +502,7 @@ class multi_ptr<const void, Space, DecorateAddress> {
   template <
       access::address_space GlobalSpace = access::address_space::global_space,
       access::address_space RelaySpace = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           RelaySpace == Space &&
           GlobalSpace == access::address_space::global_space &&
           (Space == access::address_space::ext_intel_global_device_space ||
@@ -562,7 +560,7 @@ class multi_ptr<void, Space, DecorateAddress> {
       typename ElementType, int Dimensions, access::mode Mode,
       access::placeholder isPlaceholder, typename PropertyListT,
       access::address_space RelaySpace = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           RelaySpace == Space &&
           (Space == access::address_space::global_space ||
            Space == access::address_space::ext_intel_global_device_space)>>
@@ -577,7 +575,7 @@ class multi_ptr<void, Space, DecorateAddress> {
       typename ElementType, int Dimensions, access::mode Mode,
       access::placeholder isPlaceholder, typename PropertyListT,
       access::address_space RelaySpace = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           RelaySpace == Space && Space == access::address_space::local_space>>
   multi_ptr(accessor<ElementType, Dimensions, Mode, access::target::local,
                      isPlaceholder, PropertyListT>
@@ -588,7 +586,7 @@ class multi_ptr<void, Space, DecorateAddress> {
   template <
       typename ElementType, int Dimensions,
       access::address_space RelaySpace = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           RelaySpace == Space && Space == access::address_space::local_space>>
   multi_ptr(local_accessor<ElementType, Dimensions> Accessor)
       : m_Pointer(detail::cast_AS<decorated_type *>(Accessor.get_pointer())) {}
@@ -629,7 +627,7 @@ class multi_ptr<void, Space, DecorateAddress> {
   template <
       access::address_space GlobalSpace = access::address_space::global_space,
       access::address_space RelaySpace = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           RelaySpace == Space &&
           GlobalSpace == access::address_space::global_space &&
           (Space == access::address_space::ext_intel_global_device_space ||
@@ -651,9 +649,9 @@ template <typename ElementType, access::address_space Space>
 class multi_ptr<ElementType, Space, access::decorated::legacy> {
 public:
   using element_type =
-      detail::conditional_t<std::is_same<ElementType, half>::value,
-                            sycl::detail::half_impl::BIsRepresentationT,
-                            ElementType>;
+      std::conditional_t<std::is_same<ElementType, half>::value,
+                         sycl::detail::half_impl::BIsRepresentationT,
+                         ElementType>;
   using difference_type = std::ptrdiff_t;
 
   // Implementation defined pointer and reference types that correspond to
@@ -680,7 +678,7 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
   // multi_ptr(ElementType *pointer) one, so the check is required.
   template <
       access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && Space != access::address_space::generic_space>>
   multi_ptr(pointer_t pointer) : m_Pointer(pointer) {}
 #endif
@@ -709,7 +707,7 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
   // multi_ptr &operator=(ElementType *pointer) one, so the check is required.
   template <
       access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && Space != access::address_space::generic_space>>
   multi_ptr &operator=(pointer_t pointer) {
     m_Pointer = pointer;
@@ -754,7 +752,7 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
   template <
       int dimensions, access::mode Mode, access::placeholder isPlaceholder,
       typename PropertyListT, access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space &&
           (Space == access::address_space::generic_space ||
            Space == access::address_space::global_space ||
@@ -769,7 +767,7 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
   template <
       int dimensions, access::mode Mode, access::placeholder isPlaceholder,
       typename PropertyListT, access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && (Space == access::address_space::generic_space ||
                               Space == access::address_space::local_space)>>
   multi_ptr(accessor<ElementType, dimensions, Mode, access::target::local,
@@ -786,7 +784,7 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
   template <
       int dimensions, access::mode Mode, access::placeholder isPlaceholder,
       typename PropertyListT, access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && Space == access::address_space::constant_space>>
   multi_ptr(
       accessor<ElementType, dimensions, Mode, access::target::constant_buffer,
@@ -811,13 +809,13 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
       int dimensions, access::mode Mode, access::placeholder isPlaceholder,
       typename PropertyListT, access::address_space _Space = Space,
       typename ET = ElementType,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space &&
           (Space == access::address_space::generic_space ||
            Space == access::address_space::global_space ||
            Space == access::address_space::ext_intel_global_device_space) &&
           std::is_const<ET>::value && std::is_same<ET, ElementType>::value>>
-  multi_ptr(accessor<typename detail::remove_const_t<ET>, dimensions, Mode,
+  multi_ptr(accessor<typename std::remove_const_t<ET>, dimensions, Mode,
                      access::target::device, isPlaceholder, PropertyListT>
                 Accessor)
       : multi_ptr(Accessor.get_pointer()) {}
@@ -827,12 +825,12 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
       int dimensions, access::mode Mode, access::placeholder isPlaceholder,
       typename PropertyListT, access::address_space _Space = Space,
       typename ET = ElementType,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space &&
           (Space == access::address_space::generic_space ||
            Space == access::address_space::local_space) &&
           std::is_const<ET>::value && std::is_same<ET, ElementType>::value>>
-  multi_ptr(accessor<typename detail::remove_const_t<ET>, dimensions, Mode,
+  multi_ptr(accessor<typename std::remove_const_t<ET>, dimensions, Mode,
                      access::target::local, isPlaceholder, PropertyListT>
                 Accessor)
       : multi_ptr(Accessor.get_pointer()) {}
@@ -841,13 +839,13 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
   template <
       int dimensions, access::address_space _Space = Space,
       typename ET = ElementType,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space &&
           (Space == access::address_space::generic_space ||
            Space == access::address_space::local_space) &&
           std::is_const<ET>::value && std::is_same<ET, ElementType>::value>>
   multi_ptr(
-      local_accessor<typename detail::remove_const_t<ET>, dimensions> Accessor)
+      local_accessor<typename std::remove_const_t<ET>, dimensions> Accessor)
       : m_Pointer(detail::cast_AS<pointer_t>(Accessor.get_pointer())) {}
 
   // Only if Space == constant_space and element type is const
@@ -855,11 +853,11 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
       int dimensions, access::mode Mode, access::placeholder isPlaceholder,
       typename PropertyListT, access::address_space _Space = Space,
       typename ET = ElementType,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && Space == access::address_space::constant_space &&
           std::is_const<ET>::value && std::is_same<ET, ElementType>::value>>
   multi_ptr(
-      accessor<typename detail::remove_const_t<ET>, dimensions, Mode,
+      accessor<typename std::remove_const_t<ET>, dimensions, Mode,
                access::target::constant_buffer, isPlaceholder, PropertyListT>
           Accessor)
       : multi_ptr(Accessor.get_pointer()) {}
@@ -873,9 +871,9 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
   //   multi_ptr<ElementType, Space, access::decorated::legacy> ->
   //     multi_ptr<const ElementTYpe, Space, access::decorated::legacy>
   template <typename ET = ElementType>
-  multi_ptr(typename detail::enable_if_t<
+  multi_ptr(typename std::enable_if_t<
             std::is_const<ET>::value && std::is_same<ET, ElementType>::value,
-            const multi_ptr<typename detail::remove_const_t<ET>, Space,
+            const multi_ptr<typename std::remove_const_t<ET>, Space,
                             access::decorated::legacy>> &ETP)
       : m_Pointer(ETP.get()) {}
 
@@ -889,9 +887,9 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
   // Only available when ElementType is not const-qualified
   template <typename ET = ElementType>
   operator multi_ptr<
-      typename detail::enable_if_t<std::is_same<ET, ElementType>::value &&
-                                       !std::is_const<ET>::value,
-                                   void>::type,
+      typename std::enable_if_t<std::is_same<ET, ElementType>::value &&
+                                    !std::is_const<ET>::value,
+                                void>::type,
       Space, access::decorated::legacy>() const {
     using ptr_t = typename detail::DecoratedType<void, Space> *;
     return multi_ptr<void, Space, access::decorated::legacy>(
@@ -902,9 +900,9 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
   // Only available when ElementType is const-qualified
   template <typename ET = ElementType>
   operator multi_ptr<
-      typename detail::enable_if_t<std::is_same<ET, ElementType>::value &&
-                                       std::is_const<ET>::value,
-                                   const void>::type,
+      typename std::enable_if_t<std::is_same<ET, ElementType>::value &&
+                                    std::is_const<ET>::value,
+                                const void>::type,
       Space, access::decorated::legacy>() const {
     using ptr_t = typename detail::DecoratedType<const void, Space> *;
     return multi_ptr<const void, Space, access::decorated::legacy>(
@@ -961,7 +959,7 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
   // Space == address_space::ext_intel_global_host_space
   template <
       access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space &&
           (Space == access::address_space::ext_intel_global_device_space ||
            Space == access::address_space::ext_intel_global_host_space)>>
@@ -978,7 +976,7 @@ class multi_ptr<ElementType, Space, access::decorated::legacy> {
   // Only if Space == global_space
   template <
       access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && Space == access::address_space::global_space>>
   void prefetch(size_t NumElements) const {
     size_t NumBytes = NumElements * sizeof(ElementType);
@@ -1059,7 +1057,7 @@ class multi_ptr<void, Space, access::decorated::legacy> {
   template <
       typename ElementType, int dimensions, access::mode Mode,
       typename PropertyListT, access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space &&
           (Space == access::address_space::generic_space ||
            Space == access::address_space::global_space ||
@@ -1073,7 +1071,7 @@ class multi_ptr<void, Space, access::decorated::legacy> {
   template <
       typename ElementType, int dimensions, access::mode Mode,
       typename PropertyListT, access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && (Space == access::address_space::generic_space ||
                               Space == access::address_space::local_space)>>
   multi_ptr(accessor<ElementType, dimensions, Mode, access::target::local,
@@ -1085,7 +1083,7 @@ class multi_ptr<void, Space, access::decorated::legacy> {
   template <
       typename ElementType, int dimensions,
       access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && (Space == access::address_space::generic_space ||
                               Space == access::address_space::local_space)>>
   multi_ptr(local_accessor<ElementType, dimensions> Accessor)
@@ -1095,7 +1093,7 @@ class multi_ptr<void, Space, access::decorated::legacy> {
   template <
       typename ElementType, int dimensions, access::mode Mode,
       typename PropertyListT, access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && Space == access::address_space::constant_space>>
   multi_ptr(
       accessor<ElementType, dimensions, Mode, access::target::constant_buffer,
@@ -1202,7 +1200,7 @@ class multi_ptr<const void, Space, access::decorated::legacy> {
   template <
       typename ElementType, int dimensions, access::mode Mode,
       typename PropertyListT, access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space &&
           (Space == access::address_space::generic_space ||
            Space == access::address_space::global_space ||
@@ -1216,7 +1214,7 @@ class multi_ptr<const void, Space, access::decorated::legacy> {
   template <
       typename ElementType, int dimensions, access::mode Mode,
       typename PropertyListT, access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && (Space == access::address_space::generic_space ||
                               Space == access::address_space::local_space)>>
   multi_ptr(accessor<ElementType, dimensions, Mode, access::target::local,
@@ -1228,7 +1226,7 @@ class multi_ptr<const void, Space, access::decorated::legacy> {
   template <
       typename ElementType, int dimensions,
       access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && (Space == access::address_space::generic_space ||
                               Space == access::address_space::local_space)>>
   multi_ptr(local_accessor<ElementType, dimensions> Accessor)
@@ -1238,7 +1236,7 @@ class multi_ptr<const void, Space, access::decorated::legacy> {
   template <
       typename ElementType, int dimensions, access::mode Mode,
       typename PropertyListT, access::address_space _Space = Space,
-      typename = typename detail::enable_if_t<
+      typename = typename std::enable_if_t<
           _Space == Space && Space == access::address_space::constant_space>>
   multi_ptr(
       accessor<ElementType, dimensions, Mode, access::target::constant_buffer,
diff --git a/sycl/include/sycl/nd_item.hpp b/sycl/include/sycl/nd_item.hpp
index ecf0e9028cacc..2c2a4d7992e39 100644
--- a/sycl/include/sycl/nd_item.hpp
+++ b/sycl/include/sycl/nd_item.hpp
@@ -121,10 +121,10 @@ template <int dimensions = 1> class nd_item {
   template <access::mode accessMode = access::mode::read_write>
   __SYCL2020_DEPRECATED("use sycl::atomic_fence() free function instead")
   void mem_fence(
-      typename detail::enable_if_t<accessMode == access::mode::read ||
-                                       accessMode == access::mode::write ||
-                                       accessMode == access::mode::read_write,
-                                   access::fence_space>
+      typename std::enable_if_t<accessMode == access::mode::read ||
+                                    accessMode == access::mode::write ||
+                                    accessMode == access::mode::read_write,
+                                access::fence_space>
           accessSpace = access::fence_space::global_and_local) const {
     (void)accessSpace;
     Group.mem_fence();
diff --git a/sycl/include/sycl/property_list.hpp b/sycl/include/sycl/property_list.hpp
index 1e02d391dea50..367b91e7ff463 100644
--- a/sycl/include/sycl/property_list.hpp
+++ b/sycl/include/sycl/property_list.hpp
@@ -27,11 +27,11 @@ class property_list : protected detail::PropertyListBase {
   template <typename... Tail> struct AllProperties : std::true_type {};
   template <typename T, typename... Tail>
   struct AllProperties<T, Tail...>
-      : detail::conditional_t<is_property<T>::value, AllProperties<Tail...>,
-                              std::false_type> {};
+      : std::conditional_t<is_property<T>::value, AllProperties<Tail...>,
+                           std::false_type> {};
 
 public:
-  template <typename... PropsT, typename = typename detail::enable_if_t<
+  template <typename... PropsT, typename = typename std::enable_if_t<
                                     AllProperties<PropsT...>::value>>
   property_list(PropsT... Props) : detail::PropertyListBase(false) {
     ctorHelper(Props...);
diff --git a/sycl/include/sycl/queue.hpp b/sycl/include/sycl/queue.hpp
index 32bcd18197f27..5aed8f1046e6f 100644
--- a/sycl/include/sycl/queue.hpp
+++ b/sycl/include/sycl/queue.hpp
@@ -1522,9 +1522,9 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase<queue> {
   single_task(PropertiesT Properties,
               _KERNELFUNCPARAM(KernelFunc) _CODELOCPARAM(&CodeLoc)) {
     static_assert(
-        (detail::check_fn_signature<detail::remove_reference_t<KernelType>,
+        (detail::check_fn_signature<std::remove_reference_t<KernelType>,
                                     void()>::value ||
-         detail::check_fn_signature<detail::remove_reference_t<KernelType>,
+         detail::check_fn_signature<std::remove_reference_t<KernelType>,
                                     void(kernel_handler)>::value),
         "sycl::queue.single_task() requires a kernel instead of command group. "
         "Use queue.submit() instead");
@@ -1562,9 +1562,9 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase<queue> {
   single_task(event DepEvent, PropertiesT Properties,
               _KERNELFUNCPARAM(KernelFunc) _CODELOCPARAM(&CodeLoc)) {
     static_assert(
-        (detail::check_fn_signature<detail::remove_reference_t<KernelType>,
+        (detail::check_fn_signature<std::remove_reference_t<KernelType>,
                                     void()>::value ||
-         detail::check_fn_signature<detail::remove_reference_t<KernelType>,
+         detail::check_fn_signature<std::remove_reference_t<KernelType>,
                                     void(kernel_handler)>::value),
         "sycl::queue.single_task() requires a kernel instead of command group. "
         "Use queue.submit() instead");
@@ -1606,9 +1606,9 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase<queue> {
   single_task(const std::vector<event> &DepEvents, PropertiesT Properties,
               _KERNELFUNCPARAM(KernelFunc) _CODELOCPARAM(&CodeLoc)) {
     static_assert(
-        (detail::check_fn_signature<detail::remove_reference_t<KernelType>,
+        (detail::check_fn_signature<std::remove_reference_t<KernelType>,
                                     void()>::value ||
-         detail::check_fn_signature<detail::remove_reference_t<KernelType>,
+         detail::check_fn_signature<std::remove_reference_t<KernelType>,
                                     void(kernel_handler)>::value),
         "sycl::queue.single_task() requires a kernel instead of command group. "
         "Use queue.submit() instead");
diff --git a/sycl/include/sycl/range.hpp b/sycl/include/sycl/range.hpp
index f8d8860ba8706..32a976192da57 100644
--- a/sycl/include/sycl/range.hpp
+++ b/sycl/include/sycl/range.hpp
@@ -26,24 +26,24 @@ template <int dimensions = 1> class range : public detail::array<dimensions> {
                 "range can only be 1, 2, or 3 dimensional.");
   using base = detail::array<dimensions>;
   template <typename N, typename T>
-  using IntegralType = detail::enable_if_t<std::is_integral<N>::value, T>;
+  using IntegralType = std::enable_if_t<std::is_integral<N>::value, T>;
 
 public:
   /* The following constructor is only available in the range class
   specialization where: dimensions==1 */
   template <int N = dimensions>
-  range(typename detail::enable_if_t<(N == 1), size_t> dim0) : base(dim0) {}
+  range(typename std::enable_if_t<(N == 1), size_t> dim0) : base(dim0) {}
 
   /* The following constructor is only available in the range class
   specialization where: dimensions==2 */
   template <int N = dimensions>
-  range(typename detail::enable_if_t<(N == 2), size_t> dim0, size_t dim1)
+  range(typename std::enable_if_t<(N == 2), size_t> dim0, size_t dim1)
       : base(dim0, dim1) {}
 
   /* The following constructor is only available in the range class
   specialization where: dimensions==3 */
   template <int N = dimensions>
-  range(typename detail::enable_if_t<(N == 3), size_t> dim0, size_t dim1,
+  range(typename std::enable_if_t<(N == 3), size_t> dim0, size_t dim1,
         size_t dim2)
       : base(dim0, dim1, dim2) {}
 
diff --git a/sycl/include/sycl/reduction.hpp b/sycl/include/sycl/reduction.hpp
index 67bd630ebcc76..a7bcf7217ba66 100644
--- a/sycl/include/sycl/reduction.hpp
+++ b/sycl/include/sycl/reduction.hpp
@@ -81,17 +81,17 @@ namespace detail {
 template <typename T, class BinaryOperation>
 using IsReduOptForFastAtomicFetch =
 #ifdef SYCL_REDUCTION_DETERMINISTIC
-    bool_constant<false>;
+    std::bool_constant<false>;
 #else
-    bool_constant<((is_sgenfloat<T>::value && sizeof(T) == 4) ||
-                   is_sgeninteger<T>::value) &&
-                  IsValidAtomicType<T>::value &&
-                  (IsPlus<T, BinaryOperation>::value ||
-                   IsMinimum<T, BinaryOperation>::value ||
-                   IsMaximum<T, BinaryOperation>::value ||
-                   IsBitOR<T, BinaryOperation>::value ||
-                   IsBitXOR<T, BinaryOperation>::value ||
-                   IsBitAND<T, BinaryOperation>::value)>;
+    std::bool_constant<((is_sgenfloat<T>::value && sizeof(T) == 4) ||
+                        is_sgeninteger<T>::value) &&
+                       IsValidAtomicType<T>::value &&
+                       (IsPlus<T, BinaryOperation>::value ||
+                        IsMinimum<T, BinaryOperation>::value ||
+                        IsMaximum<T, BinaryOperation>::value ||
+                        IsBitOR<T, BinaryOperation>::value ||
+                        IsBitXOR<T, BinaryOperation>::value ||
+                        IsBitAND<T, BinaryOperation>::value)>;
 #endif
 
 // This type trait is used to detect if the atomic operation BinaryOperation
@@ -105,12 +105,12 @@ using IsReduOptForFastAtomicFetch =
 template <typename T, class BinaryOperation>
 using IsReduOptForAtomic64Op =
 #ifdef SYCL_REDUCTION_DETERMINISTIC
-    bool_constant<false>;
+    std::bool_constant<false>;
 #else
-    bool_constant<(IsPlus<T, BinaryOperation>::value ||
-                   IsMinimum<T, BinaryOperation>::value ||
-                   IsMaximum<T, BinaryOperation>::value) &&
-                  is_sgenfloat<T>::value && sizeof(T) == 8>;
+    std::bool_constant<(IsPlus<T, BinaryOperation>::value ||
+                        IsMinimum<T, BinaryOperation>::value ||
+                        IsMaximum<T, BinaryOperation>::value) &&
+                       is_sgenfloat<T>::value && sizeof(T) == 8>;
 #endif
 
 // This type trait is used to detect if the group algorithm reduce() used with
@@ -121,14 +121,14 @@ using IsReduOptForAtomic64Op =
 template <typename T, class BinaryOperation>
 using IsReduOptForFastReduce =
 #ifdef SYCL_REDUCTION_DETERMINISTIC
-    bool_constant<false>;
+    std::bool_constant<false>;
 #else
-    bool_constant<((is_sgeninteger<T>::value &&
-                    (sizeof(T) == 4 || sizeof(T) == 8)) ||
-                   is_sgenfloat<T>::value) &&
-                  (IsPlus<T, BinaryOperation>::value ||
-                   IsMinimum<T, BinaryOperation>::value ||
-                   IsMaximum<T, BinaryOperation>::value)>;
+    std::bool_constant<((is_sgeninteger<T>::value &&
+                         (sizeof(T) == 4 || sizeof(T) == 8)) ||
+                        is_sgenfloat<T>::value) &&
+                       (IsPlus<T, BinaryOperation>::value ||
+                        IsMinimum<T, BinaryOperation>::value ||
+                        IsMaximum<T, BinaryOperation>::value)>;
 #endif
 
 // std::tuple seems to be a) too heavy and b) not copyable to device now
@@ -222,47 +222,47 @@ template <class Reducer> class combiner {
 
 public:
   template <typename _T = Ty, int _Dims = Dims>
-  enable_if_t<(_Dims == 0) && IsPlus<_T, BinaryOp>::value &&
-                  is_geninteger<_T>::value,
-              Reducer &>
+  std::enable_if_t<(_Dims == 0) && IsPlus<_T, BinaryOp>::value &&
+                       is_geninteger<_T>::value,
+                   Reducer &>
   operator++() {
     return static_cast<Reducer *>(this)->combine(static_cast<_T>(1));
   }
 
   template <typename _T = Ty, int _Dims = Dims>
-  enable_if_t<(_Dims == 0) && IsPlus<_T, BinaryOp>::value &&
-                  is_geninteger<_T>::value,
-              Reducer &>
+  std::enable_if_t<(_Dims == 0) && IsPlus<_T, BinaryOp>::value &&
+                       is_geninteger<_T>::value,
+                   Reducer &>
   operator++(int) {
     return static_cast<Reducer *>(this)->combine(static_cast<_T>(1));
   }
 
   template <typename _T = Ty, int _Dims = Dims>
-  enable_if_t<(_Dims == 0) && IsPlus<_T, BinaryOp>::value, Reducer &>
+  std::enable_if_t<(_Dims == 0) && IsPlus<_T, BinaryOp>::value, Reducer &>
   operator+=(const _T &Partial) {
     return static_cast<Reducer *>(this)->combine(Partial);
   }
 
   template <typename _T = Ty, int _Dims = Dims>
-  enable_if_t<(_Dims == 0) && IsMultiplies<_T, BinaryOp>::value, Reducer &>
+  std::enable_if_t<(_Dims == 0) && IsMultiplies<_T, BinaryOp>::value, Reducer &>
   operator*=(const _T &Partial) {
     return static_cast<Reducer *>(this)->combine(Partial);
   }
 
   template <typename _T = Ty, int _Dims = Dims>
-  enable_if_t<(_Dims == 0) && IsBitOR<_T, BinaryOp>::value, Reducer &>
+  std::enable_if_t<(_Dims == 0) && IsBitOR<_T, BinaryOp>::value, Reducer &>
   operator|=(const _T &Partial) {
     return static_cast<Reducer *>(this)->combine(Partial);
   }
 
   template <typename _T = Ty, int _Dims = Dims>
-  enable_if_t<(_Dims == 0) && IsBitXOR<_T, BinaryOp>::value, Reducer &>
+  std::enable_if_t<(_Dims == 0) && IsBitXOR<_T, BinaryOp>::value, Reducer &>
   operator^=(const _T &Partial) {
     return static_cast<Reducer *>(this)->combine(Partial);
   }
 
   template <typename _T = Ty, int _Dims = Dims>
-  enable_if_t<(_Dims == 0) && IsBitAND<_T, BinaryOp>::value, Reducer &>
+  std::enable_if_t<(_Dims == 0) && IsBitAND<_T, BinaryOp>::value, Reducer &>
   operator&=(const _T &Partial) {
     return static_cast<Reducer *>(this)->combine(Partial);
   }
@@ -302,10 +302,10 @@ template <class Reducer> class combiner {
   /// Atomic ADD operation: *ReduVarPtr += MValue;
   template <access::address_space Space = access::address_space::global_space,
             typename _T = Ty, class _BinaryOperation = BinaryOp>
-  enable_if_t<BasicCheck<_T, Space, _BinaryOperation> &&
-              (IsReduOptForFastAtomicFetch<_T, _BinaryOperation>::value ||
-               IsReduOptForAtomic64Op<_T, _BinaryOperation>::value) &&
-              IsPlus<_T, _BinaryOperation>::value>
+  std::enable_if_t<BasicCheck<_T, Space, _BinaryOperation> &&
+                   (IsReduOptForFastAtomicFetch<_T, _BinaryOperation>::value ||
+                    IsReduOptForAtomic64Op<_T, _BinaryOperation>::value) &&
+                   IsPlus<_T, _BinaryOperation>::value>
   atomic_combine(_T *ReduVarPtr) const {
     atomic_combine_impl<Space>(
         ReduVarPtr, [](auto &&Ref, auto Val) { return Ref.fetch_add(Val); });
@@ -314,9 +314,9 @@ template <class Reducer> class combiner {
   /// Atomic BITWISE OR operation: *ReduVarPtr |= MValue;
   template <access::address_space Space = access::address_space::global_space,
             typename _T = Ty, class _BinaryOperation = BinaryOp>
-  enable_if_t<BasicCheck<_T, Space, _BinaryOperation> &&
-              IsReduOptForFastAtomicFetch<_T, _BinaryOperation>::value &&
-              IsBitOR<_T, _BinaryOperation>::value>
+  std::enable_if_t<BasicCheck<_T, Space, _BinaryOperation> &&
+                   IsReduOptForFastAtomicFetch<_T, _BinaryOperation>::value &&
+                   IsBitOR<_T, _BinaryOperation>::value>
   atomic_combine(_T *ReduVarPtr) const {
     atomic_combine_impl<Space>(
         ReduVarPtr, [](auto &&Ref, auto Val) { return Ref.fetch_or(Val); });
@@ -325,9 +325,9 @@ template <class Reducer> class combiner {
   /// Atomic BITWISE XOR operation: *ReduVarPtr ^= MValue;
   template <access::address_space Space = access::address_space::global_space,
             typename _T = Ty, class _BinaryOperation = BinaryOp>
-  enable_if_t<BasicCheck<_T, Space, _BinaryOperation> &&
-              IsReduOptForFastAtomicFetch<_T, _BinaryOperation>::value &&
-              IsBitXOR<_T, _BinaryOperation>::value>
+  std::enable_if_t<BasicCheck<_T, Space, _BinaryOperation> &&
+                   IsReduOptForFastAtomicFetch<_T, _BinaryOperation>::value &&
+                   IsBitXOR<_T, _BinaryOperation>::value>
   atomic_combine(_T *ReduVarPtr) const {
     atomic_combine_impl<Space>(
         ReduVarPtr, [](auto &&Ref, auto Val) { return Ref.fetch_xor(Val); });
@@ -336,11 +336,11 @@ template <class Reducer> class combiner {
   /// Atomic BITWISE AND operation: *ReduVarPtr &= MValue;
   template <access::address_space Space = access::address_space::global_space,
             typename _T = Ty, class _BinaryOperation = BinaryOp>
-  enable_if_t<std::is_same<remove_decoration_t<_T>, _T>::value &&
-              IsReduOptForFastAtomicFetch<_T, _BinaryOperation>::value &&
-              IsBitAND<_T, _BinaryOperation>::value &&
-              (Space == access::address_space::global_space ||
-               Space == access::address_space::local_space)>
+  std::enable_if_t<std::is_same<remove_decoration_t<_T>, _T>::value &&
+                   IsReduOptForFastAtomicFetch<_T, _BinaryOperation>::value &&
+                   IsBitAND<_T, _BinaryOperation>::value &&
+                   (Space == access::address_space::global_space ||
+                    Space == access::address_space::local_space)>
   atomic_combine(_T *ReduVarPtr) const {
     atomic_combine_impl<Space>(
         ReduVarPtr, [](auto &&Ref, auto Val) { return Ref.fetch_and(Val); });
@@ -349,10 +349,10 @@ template <class Reducer> class combiner {
   /// Atomic MIN operation: *ReduVarPtr = sycl::minimum(*ReduVarPtr, MValue);
   template <access::address_space Space = access::address_space::global_space,
             typename _T = Ty, class _BinaryOperation = BinaryOp>
-  enable_if_t<BasicCheck<_T, Space, _BinaryOperation> &&
-              (IsReduOptForFastAtomicFetch<_T, _BinaryOperation>::value ||
-               IsReduOptForAtomic64Op<_T, _BinaryOperation>::value) &&
-              IsMinimum<_T, _BinaryOperation>::value>
+  std::enable_if_t<BasicCheck<_T, Space, _BinaryOperation> &&
+                   (IsReduOptForFastAtomicFetch<_T, _BinaryOperation>::value ||
+                    IsReduOptForAtomic64Op<_T, _BinaryOperation>::value) &&
+                   IsMinimum<_T, _BinaryOperation>::value>
   atomic_combine(_T *ReduVarPtr) const {
     atomic_combine_impl<Space>(
         ReduVarPtr, [](auto &&Ref, auto Val) { return Ref.fetch_min(Val); });
@@ -361,10 +361,10 @@ template <class Reducer> class combiner {
   /// Atomic MAX operation: *ReduVarPtr = sycl::maximum(*ReduVarPtr, MValue);
   template <access::address_space Space = access::address_space::global_space,
             typename _T = Ty, class _BinaryOperation = BinaryOp>
-  enable_if_t<BasicCheck<_T, Space, _BinaryOperation> &&
-              (IsReduOptForFastAtomicFetch<_T, _BinaryOperation>::value ||
-               IsReduOptForAtomic64Op<_T, _BinaryOperation>::value) &&
-              IsMaximum<_T, _BinaryOperation>::value>
+  std::enable_if_t<BasicCheck<_T, Space, _BinaryOperation> &&
+                   (IsReduOptForFastAtomicFetch<_T, _BinaryOperation>::value ||
+                    IsReduOptForAtomic64Op<_T, _BinaryOperation>::value) &&
+                   IsMaximum<_T, _BinaryOperation>::value>
   atomic_combine(_T *ReduVarPtr) const {
     atomic_combine_impl<Space>(
         ReduVarPtr, [](auto &&Ref, auto Val) { return Ref.fetch_max(Val); });
diff --git a/sycl/include/sycl/stream.hpp b/sycl/include/sycl/stream.hpp
index fe5ec0bb51474..8b0fab776e7a5 100644
--- a/sycl/include/sycl/stream.hpp
+++ b/sycl/include/sycl/stream.hpp
@@ -61,10 +61,10 @@ constexpr unsigned FLUSH_BUF_OFFSET_SIZE = 2;
 
 template <class F, class T = void>
 using EnableIfFP =
-    typename detail::enable_if_t<std::is_same<F, float>::value ||
-                                     std::is_same<F, double>::value ||
-                                     std::is_same<F, half>::value,
-                                 T>;
+    typename std::enable_if_t<std::is_same<F, float>::value ||
+                                  std::is_same<F, double>::value ||
+                                  std::is_same<F, half>::value,
+                              T>;
 
 using GlobalBufAccessorT = accessor<char, 1, sycl::access::mode::read_write,
                                     sycl::access::target::global_buffer,
@@ -157,7 +157,7 @@ inline char digitToChar(const int Digit) {
 }
 
 template <typename T>
-inline typename detail::enable_if_t<std::is_integral<T>::value, unsigned>
+inline typename std::enable_if_t<std::is_integral<T>::value, unsigned>
 integralToBase(T Val, int Base, char *Digits) {
   unsigned NumDigits = 0;
 
@@ -171,7 +171,7 @@ integralToBase(T Val, int Base, char *Digits) {
 
 // Returns number of symbols written to the buffer
 template <typename T>
-inline typename detail::enable_if_t<std::is_integral<T>::value, unsigned>
+inline typename std::enable_if_t<std::is_integral<T>::value, unsigned>
 ScalarToStr(const T &Val, char *Buf, unsigned Flags, int, int Precision = -1) {
   (void)Precision;
   int Base = 10;
@@ -229,7 +229,7 @@ inline unsigned append(char *Dst, const char *Src) {
 }
 
 template <typename T>
-inline typename detail::enable_if_t<
+inline typename std::enable_if_t<
     std::is_same<T, float>::value || std::is_same<T, double>::value, unsigned>
 checkForInfNan(char *Buf, T Val) {
   if (isnan(Val))
@@ -243,7 +243,7 @@ checkForInfNan(char *Buf, T Val) {
 }
 
 template <typename T>
-inline typename detail::enable_if_t<std::is_same<T, half>::value, unsigned>
+inline typename std::enable_if_t<std::is_same<T, half>::value, unsigned>
 checkForInfNan(char *Buf, T Val) {
   if (Val != Val)
     return append(Buf, "nan");
@@ -401,7 +401,7 @@ ScalarToStr(const T &Val, char *Buf, unsigned Flags, int, int Precision = -1) {
 }
 
 template <typename T>
-inline typename detail::enable_if_t<std::is_integral<T>::value>
+inline typename std::enable_if_t<std::is_integral<T>::value>
 writeIntegral(GlobalBufAccessorT &GlobalFlushBuf, size_t FlushBufferSize,
               unsigned WIOffset, unsigned Flags, int Width, const T &Val) {
   char Digits[MAX_INTEGRAL_DIGITS] = {0};
@@ -462,16 +462,16 @@ inline void flushBuffer(GlobalOffsetAccessorT &GlobalOffset,
 }
 
 template <typename T, int VecLength>
-typename detail::enable_if_t<(VecLength == 1), unsigned>
+typename std::enable_if_t<(VecLength == 1), unsigned>
 VecToStr(const vec<T, VecLength> &Vec, char *VecStr, unsigned Flags, int Width,
          int Precision) {
   return ScalarToStr(static_cast<T>(Vec.x()), VecStr, Flags, Width, Precision);
 }
 
 template <typename T, int VecLength>
-typename detail::enable_if_t<(VecLength == 2 || VecLength == 4 ||
-                              VecLength == 8 || VecLength == 16),
-                             unsigned>
+typename std::enable_if_t<(VecLength == 2 || VecLength == 4 || VecLength == 8 ||
+                           VecLength == 16),
+                          unsigned>
 VecToStr(const vec<T, VecLength> &Vec, char *VecStr, unsigned Flags, int Width,
          int Precision) {
   unsigned Len =
@@ -483,7 +483,7 @@ VecToStr(const vec<T, VecLength> &Vec, char *VecStr, unsigned Flags, int Width,
 }
 
 template <typename T, int VecLength>
-typename detail::enable_if_t<(VecLength == 3), unsigned>
+typename std::enable_if_t<(VecLength == 3), unsigned>
 VecToStr(const vec<T, VecLength> &Vec, char *VecStr, unsigned Flags, int Width,
          int Precision) {
   unsigned Len = VecToStr<T, 2>(Vec.lo(), VecStr, Flags, Width, Precision);
@@ -656,8 +656,8 @@ struct IsSwizzleOp<sycl::detail::SwizzleOp<
 
 template <typename T>
 using EnableIfSwizzleVec =
-    typename detail::enable_if_t<IsSwizzleOp<T>::value,
-                                 typename IsSwizzleOp<T>::Type>;
+    typename std::enable_if_t<IsSwizzleOp<T>::value,
+                              typename IsSwizzleOp<T>::Type>;
 
 } // namespace detail
 
@@ -962,8 +962,8 @@ class __SYCL_EXPORT __SYCL_SPECIAL_CLASS __SYCL_TYPE(stream) stream
   friend const stream &operator<<(const stream &, const char);
   friend const stream &operator<<(const stream &, const char *);
   template <typename ValueType>
-  friend typename detail::enable_if_t<std::is_integral<ValueType>::value,
-                                      const stream &>
+  friend typename std::enable_if_t<std::is_integral<ValueType>::value,
+                                   const stream &>
   operator<<(const stream &, const ValueType &);
   friend const stream &operator<<(const stream &, const float &);
   friend const stream &operator<<(const stream &, const double &);
@@ -1044,8 +1044,8 @@ inline const stream &operator<<(const stream &Out, const bool &RHS) {
 
 // Integral
 template <typename ValueType>
-inline typename detail::enable_if_t<std::is_integral<ValueType>::value,
-                                    const stream &>
+inline typename std::enable_if_t<std::is_integral<ValueType>::value,
+                                 const stream &>
 operator<<(const stream &Out, const ValueType &RHS) {
   detail::writeIntegral(Out.GlobalFlushBuf, Out.FlushBufferSize, Out.WIOffset,
                         Out.get_flags(), Out.get_width(), RHS);
diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 84821a36bfde1..2fcddc129e792 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -106,10 +106,10 @@ namespace detail {
 // select_apply_cl_t selects from T8/T16/T32/T64 basing on
 // sizeof(_IN).  expected to handle scalar types in _IN.
 template <typename _IN, typename T8, typename T16, typename T32, typename T64>
-using select_apply_cl_t =
-    conditional_t<sizeof(_IN) == 1, T8,
-                  conditional_t<sizeof(_IN) == 2, T16,
-                                conditional_t<sizeof(_IN) == 4, T32, T64>>>;
+using select_apply_cl_t = std::conditional_t<
+    sizeof(_IN) == 1, T8,
+    std::conditional_t<sizeof(_IN) == 2, T16,
+                       std::conditional_t<sizeof(_IN) == 4, T32, T64>>>;
 
 template <typename T> struct vec_helper {
   using RetType = T;
@@ -139,15 +139,15 @@ template <typename T, int N, typename V = void> struct VecStorage;
 
 // Element type for relational operator return value.
 template <typename DataT>
-using rel_t = typename detail::conditional_t<
+using rel_t = typename std::conditional_t<
     sizeof(DataT) == sizeof(opencl::cl_char), opencl::cl_char,
-    typename detail::conditional_t<
+    typename std::conditional_t<
         sizeof(DataT) == sizeof(opencl::cl_short), opencl::cl_short,
-        typename detail::conditional_t<
+        typename std::conditional_t<
             sizeof(DataT) == sizeof(opencl::cl_int), opencl::cl_int,
-            typename detail::conditional_t<sizeof(DataT) ==
-                                               sizeof(opencl::cl_long),
-                                           opencl::cl_long, bool>>>>;
+            typename std::conditional_t<sizeof(DataT) ==
+                                            sizeof(opencl::cl_long),
+                                        opencl::cl_long, bool>>>>;
 
 // Special type indicating that SwizzleOp should just read value from vector -
 // not trying to perform any operations. Should not be called.
@@ -282,7 +282,7 @@ using is_standard_type =
 
 template <typename T, typename R, rounding_mode roundingMode, typename OpenCLT,
           typename OpenCLR>
-detail::enable_if_t<std::is_same<T, R>::value, R> convertImpl(T Value) {
+std::enable_if_t<std::is_same<T, R>::value, R> convertImpl(T Value) {
   return Value;
 }
 
@@ -292,11 +292,10 @@ detail::enable_if_t<std::is_same<T, R>::value, R> convertImpl(T Value) {
 // implemented for host that takes care of the precision requirements.
 template <typename T, typename R, rounding_mode roundingMode, typename OpenCLT,
           typename OpenCLR>
-detail::enable_if_t<!std::is_same<T, R>::value &&
-                        (is_int_to_int<T, R>::value ||
-                         is_int_to_float<T, R>::value ||
-                         is_float_to_float<T, R>::value),
-                    R>
+std::enable_if_t<!std::is_same<T, R>::value && (is_int_to_int<T, R>::value ||
+                                                is_int_to_float<T, R>::value ||
+                                                is_float_to_float<T, R>::value),
+                 R>
 convertImpl(T Value) {
   return static_cast<R>(Value);
 }
@@ -304,7 +303,7 @@ convertImpl(T Value) {
 // float to int
 template <typename T, typename R, rounding_mode roundingMode, typename OpenCLT,
           typename OpenCLR>
-detail::enable_if_t<is_float_to_int<T, R>::value, R> convertImpl(T Value) {
+std::enable_if_t<is_float_to_int<T, R>::value, R> convertImpl(T Value) {
   switch (roundingMode) {
     // Round to nearest even is default rounding mode for floating-point types
   case rounding_mode::automatic:
@@ -337,22 +336,22 @@ detail::enable_if_t<is_float_to_int<T, R>::value, R> convertImpl(T Value) {
 #else
 
 template <rounding_mode Mode>
-using RteOrAutomatic = detail::bool_constant<Mode == rounding_mode::automatic ||
-                                             Mode == rounding_mode::rte>;
+using RteOrAutomatic = std::bool_constant<Mode == rounding_mode::automatic ||
+                                          Mode == rounding_mode::rte>;
 
 template <rounding_mode Mode>
-using Rtz = detail::bool_constant<Mode == rounding_mode::rtz>;
+using Rtz = std::bool_constant<Mode == rounding_mode::rtz>;
 
 template <rounding_mode Mode>
-using Rtp = detail::bool_constant<Mode == rounding_mode::rtp>;
+using Rtp = std::bool_constant<Mode == rounding_mode::rtp>;
 
 template <rounding_mode Mode>
-using Rtn = detail::bool_constant<Mode == rounding_mode::rtn>;
+using Rtn = std::bool_constant<Mode == rounding_mode::rtn>;
 
 // convert types with an equal size and diff names
 template <typename T, typename R, rounding_mode roundingMode, typename OpenCLT,
           typename OpenCLR>
-detail::enable_if_t<
+std::enable_if_t<
     !std::is_same<T, R>::value && std::is_same<OpenCLT, OpenCLR>::value, R>
 convertImpl(T Value) {
   return static_cast<R>(Value);
@@ -362,13 +361,12 @@ convertImpl(T Value) {
 #define __SYCL_GENERATE_CONVERT_IMPL(DestType)                                 \
   template <typename T, typename R, rounding_mode roundingMode,                \
             typename OpenCLT, typename OpenCLR>                                \
-  detail::enable_if_t<                                                         \
-      is_sint_to_sint<T, R>::value &&                                          \
-          !std::is_same<OpenCLT, OpenCLR>::value &&                            \
-          (std::is_same<OpenCLR, opencl::cl_##DestType>::value ||              \
-           (std::is_same<OpenCLR, signed char>::value &&                       \
-            std::is_same<DestType, char>::value)),                             \
-      R>                                                                       \
+  std::enable_if_t<is_sint_to_sint<T, R>::value &&                             \
+                       !std::is_same<OpenCLT, OpenCLR>::value &&               \
+                       (std::is_same<OpenCLR, opencl::cl_##DestType>::value || \
+                        (std::is_same<OpenCLR, signed char>::value &&          \
+                         std::is_same<DestType, char>::value)),                \
+                   R>                                                          \
   convertImpl(T Value) {                                                       \
     OpenCLT OpValue = sycl::detail::convertDataToType<T, OpenCLT>(Value);      \
     return __spirv_SConvert##_R##DestType(OpValue);                            \
@@ -385,10 +383,10 @@ __SYCL_GENERATE_CONVERT_IMPL(long)
 #define __SYCL_GENERATE_CONVERT_IMPL(DestType)                                 \
   template <typename T, typename R, rounding_mode roundingMode,                \
             typename OpenCLT, typename OpenCLR>                                \
-  detail::enable_if_t<is_uint_to_uint<T, R>::value &&                          \
-                          !std::is_same<OpenCLT, OpenCLR>::value &&            \
-                          std::is_same<OpenCLR, opencl::cl_##DestType>::value, \
-                      R>                                                       \
+  std::enable_if_t<is_uint_to_uint<T, R>::value &&                             \
+                       !std::is_same<OpenCLT, OpenCLR>::value &&               \
+                       std::is_same<OpenCLR, opencl::cl_##DestType>::value,    \
+                   R>                                                          \
   convertImpl(T Value) {                                                       \
     OpenCLT OpValue = sycl::detail::convertDataToType<T, OpenCLT>(Value);      \
     return __spirv_UConvert##_R##DestType(OpValue);                            \
@@ -404,10 +402,10 @@ __SYCL_GENERATE_CONVERT_IMPL(ulong)
 // unsigned to (from) signed
 template <typename T, typename R, rounding_mode roundingMode, typename OpenCLT,
           typename OpenCLR>
-detail::enable_if_t<is_sint_to_from_uint<T, R>::value &&
-                        is_standard_type<OpenCLT>::value &&
-                        is_standard_type<OpenCLR>::value,
-                    R>
+std::enable_if_t<is_sint_to_from_uint<T, R>::value &&
+                     is_standard_type<OpenCLT>::value &&
+                     is_standard_type<OpenCLR>::value,
+                 R>
 convertImpl(T Value) {
   return static_cast<R>(Value);
 }
@@ -416,11 +414,11 @@ convertImpl(T Value) {
 #define __SYCL_GENERATE_CONVERT_IMPL(SPIRVOp, DestType)                        \
   template <typename T, typename R, rounding_mode roundingMode,                \
             typename OpenCLT, typename OpenCLR>                                \
-  detail::enable_if_t<is_sint_to_float<T, R>::value &&                         \
-                          (std::is_same<OpenCLR, DestType>::value ||           \
-                           (std::is_same<OpenCLR, _Float16>::value &&          \
-                            std::is_same<DestType, half>::value)),             \
-                      R>                                                       \
+  std::enable_if_t<is_sint_to_float<T, R>::value &&                            \
+                       (std::is_same<OpenCLR, DestType>::value ||              \
+                        (std::is_same<OpenCLR, _Float16>::value &&             \
+                         std::is_same<DestType, half>::value)),                \
+                   R>                                                          \
   convertImpl(T Value) {                                                       \
     OpenCLT OpValue = sycl::detail::convertDataToType<T, OpenCLT>(Value);      \
     return __spirv_Convert##SPIRVOp##_R##DestType(OpValue);                    \
@@ -436,11 +434,11 @@ __SYCL_GENERATE_CONVERT_IMPL(SToF, double)
 #define __SYCL_GENERATE_CONVERT_IMPL(SPIRVOp, DestType)                        \
   template <typename T, typename R, rounding_mode roundingMode,                \
             typename OpenCLT, typename OpenCLR>                                \
-  detail::enable_if_t<is_uint_to_float<T, R>::value &&                         \
-                          (std::is_same<OpenCLR, DestType>::value ||           \
-                           (std::is_same<OpenCLR, _Float16>::value &&          \
-                            std::is_same<DestType, half>::value)),             \
-                      R>                                                       \
+  std::enable_if_t<is_uint_to_float<T, R>::value &&                            \
+                       (std::is_same<OpenCLR, DestType>::value ||              \
+                        (std::is_same<OpenCLR, _Float16>::value &&             \
+                         std::is_same<DestType, half>::value)),                \
+                   R>                                                          \
   convertImpl(T Value) {                                                       \
     OpenCLT OpValue = sycl::detail::convertDataToType<T, OpenCLT>(Value);      \
     return __spirv_Convert##SPIRVOp##_R##DestType(OpValue);                    \
@@ -457,13 +455,13 @@ __SYCL_GENERATE_CONVERT_IMPL(UToF, double)
                                      RoundingModeCondition)                    \
   template <typename T, typename R, rounding_mode roundingMode,                \
             typename OpenCLT, typename OpenCLR>                                \
-  detail::enable_if_t<is_float_to_float<T, R>::value &&                        \
-                          !std::is_same<OpenCLT, OpenCLR>::value &&            \
-                          (std::is_same<OpenCLR, DestType>::value ||           \
-                           (std::is_same<OpenCLR, _Float16>::value &&          \
-                            std::is_same<DestType, half>::value)) &&           \
-                          RoundingModeCondition<roundingMode>::value,          \
-                      R>                                                       \
+  std::enable_if_t<is_float_to_float<T, R>::value &&                           \
+                       !std::is_same<OpenCLT, OpenCLR>::value &&               \
+                       (std::is_same<OpenCLR, DestType>::value ||              \
+                        (std::is_same<OpenCLR, _Float16>::value &&             \
+                         std::is_same<DestType, half>::value)) &&              \
+                       RoundingModeCondition<roundingMode>::value,             \
+                   R>                                                          \
   convertImpl(T Value) {                                                       \
     OpenCLT OpValue = sycl::detail::convertDataToType<T, OpenCLT>(Value);      \
     return __spirv_FConvert##_R##DestType##_##RoundingMode(OpValue);           \
@@ -488,13 +486,12 @@ __SYCL_GENERATE_CONVERT_IMPL_FOR_ROUNDING_MODE(rtn, Rtn)
                                      RoundingModeCondition)                    \
   template <typename T, typename R, rounding_mode roundingMode,                \
             typename OpenCLT, typename OpenCLR>                                \
-  detail::enable_if_t<                                                         \
-      is_float_to_int<T, R>::value &&                                          \
-          (std::is_same<OpenCLR, opencl::cl_##DestType>::value ||              \
-           (std::is_same<OpenCLR, signed char>::value &&                       \
-            std::is_same<DestType, char>::value)) &&                           \
-          RoundingModeCondition<roundingMode>::value,                          \
-      R>                                                                       \
+  std::enable_if_t<is_float_to_int<T, R>::value &&                             \
+                       (std::is_same<OpenCLR, opencl::cl_##DestType>::value || \
+                        (std::is_same<OpenCLR, signed char>::value &&          \
+                         std::is_same<DestType, char>::value)) &&              \
+                       RoundingModeCondition<roundingMode>::value,             \
+                   R>                                                          \
   convertImpl(T Value) {                                                       \
     OpenCLT OpValue = sycl::detail::convertDataToType<T, OpenCLT>(Value);      \
     return __spirv_Convert##SPIRVOp##_R##DestType##_##RoundingMode(OpValue);   \
@@ -528,7 +525,7 @@ __SYCL_GENERATE_CONVERT_IMPL_FOR_ROUNDING_MODE(rtn, Rtn)
 // Back up
 template <typename T, typename R, rounding_mode roundingMode, typename OpenCLT,
           typename OpenCLR>
-detail::enable_if_t<
+std::enable_if_t<
     ((!is_standard_type<T>::value && !is_standard_type<OpenCLT>::value) ||
      (!is_standard_type<R>::value && !is_standard_type<OpenCLR>::value)) &&
         !std::is_same<OpenCLT, OpenCLR>::value,
@@ -587,15 +584,14 @@ template <typename Type, int NumElements> class vec {
 
   // SizeChecker is needed for vec(const argTN &... args) ctor to validate args.
   template <int Counter, int MaxValue, class...>
-  struct SizeChecker : detail::conditional_t<Counter == MaxValue,
-                                             std::true_type, std::false_type> {
-  };
+  struct SizeChecker : std::conditional_t<Counter == MaxValue, std::true_type,
+                                          std::false_type> {};
 
   template <int Counter, int MaxValue, typename DataT_, class... tail>
   struct SizeChecker<Counter, MaxValue, DataT_, tail...>
-      : detail::conditional_t<Counter + 1 <= MaxValue,
-                              SizeChecker<Counter + 1, MaxValue, tail...>,
-                              std::false_type> {};
+      : std::conditional_t<Counter + 1 <= MaxValue,
+                           SizeChecker<Counter + 1, MaxValue, tail...>,
+                           std::false_type> {};
 
   // Utility trait for creating an std::array from an vector argument.
   template <typename DataT_, typename T, std::size_t... Is>
@@ -652,7 +648,7 @@ template <typename Type, int NumElements> class vec {
 #define __SYCL_ALLOW_VECTOR_SIZES(num_elements)                                \
   template <int Counter, int MaxValue, typename DataT_, class... tail>         \
   struct SizeChecker<Counter, MaxValue, vec<DataT_, num_elements>, tail...>    \
-      : detail::conditional_t<                                                 \
+      : std::conditional_t<                                                    \
             Counter + (num_elements) <= MaxValue,                              \
             SizeChecker<Counter + (num_elements), MaxValue, tail...>,          \
             std::false_type> {};                                               \
@@ -663,7 +659,7 @@ template <typename Type, int NumElements> class vec {
       Counter, MaxValue,                                                       \
       detail::SwizzleOp<vec<DataT_, num_elements>, T2, T3, T4, T5...>,         \
       tail...>                                                                 \
-      : detail::conditional_t<                                                 \
+      : std::conditional_t<                                                    \
             Counter + sizeof...(T5) <= MaxValue,                               \
             SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
             std::false_type> {};                                               \
@@ -674,7 +670,7 @@ template <typename Type, int NumElements> class vec {
       Counter, MaxValue,                                                       \
       detail::SwizzleOp<const vec<DataT_, num_elements>, T2, T3, T4, T5...>,   \
       tail...>                                                                 \
-      : detail::conditional_t<                                                 \
+      : std::conditional_t<                                                    \
             Counter + sizeof...(T5) <= MaxValue,                               \
             SizeChecker<Counter + sizeof...(T5), MaxValue, tail...>,           \
             std::false_type> {};
@@ -690,7 +686,7 @@ template <typename Type, int NumElements> class vec {
   template <class...> struct conjunction : std::true_type {};
   template <class B1, class... tail>
   struct conjunction<B1, tail...>
-      : detail::conditional_t<bool(B1::value), conjunction<tail...>, B1> {};
+      : std::conditional_t<bool(B1::value), conjunction<tail...>, B1> {};
 
   // TypeChecker is needed for vec(const argTN &... args) ctor to validate args.
   template <typename T, typename DataT_>
@@ -729,12 +725,12 @@ template <typename Type, int NumElements> class vec {
 
   // Shortcuts for args validation in vec(const argTN &... args) ctor.
   template <typename... argTN>
-  using EnableIfSuitableTypes = typename detail::enable_if_t<
+  using EnableIfSuitableTypes = typename std::enable_if_t<
       conjunction<TypeChecker<argTN, DataT>...>::value>;
 
   template <typename... argTN>
-  using EnableIfSuitableNumElements = typename detail::enable_if_t<
-      SizeChecker<0, NumElements, argTN...>::value>;
+  using EnableIfSuitableNumElements =
+      typename std::enable_if_t<SizeChecker<0, NumElements, argTN...>::value>;
 
   template <size_t... Is>
   constexpr vec(const std::array<vec_data_t<DataT>, NumElements> &Arr,
@@ -765,7 +761,7 @@ template <typename Type, int NumElements> class vec {
 
   // W/o this, things like "vec<char,*> = vec<signed char, *>" doesn't work.
   template <typename Ty = DataT>
-  typename detail::enable_if_t<
+  typename std::enable_if_t<
       !std::is_same<Ty, rel_t>::value &&
           std::is_convertible<vec_data_t<Ty>, rel_t>::value,
       vec &>
@@ -776,13 +772,13 @@ template <typename Type, int NumElements> class vec {
 
 #ifdef __SYCL_USE_EXT_VECTOR_TYPE__
   template <typename T = void>
-  using EnableIfNotHostHalf = typename detail::enable_if_t<
+  using EnableIfNotHostHalf = typename std::enable_if_t<
       !std::is_same<DataT, sycl::detail::half_impl::half>::value ||
           !std::is_same<sycl::detail::half_impl::StorageT,
                         sycl::detail::host_half_impl::half>::value,
       T>;
   template <typename T = void>
-  using EnableIfHostHalf = typename detail::enable_if_t<
+  using EnableIfHostHalf = typename std::enable_if_t<
       std::is_same<DataT, sycl::detail::half_impl::half>::value &&
           std::is_same<sycl::detail::half_impl::StorageT,
                        sycl::detail::host_half_impl::half>::value,
@@ -793,9 +789,9 @@ template <typename Type, int NumElements> class vec {
       : m_Data{DataType(vec_data<Ty>::get(arg))} {}
 
   template <typename Ty = DataT>
-  typename detail::enable_if_t<
+  typename std::enable_if_t<
       std::is_fundamental<vec_data_t<Ty>>::value ||
-          std::is_same<typename detail::remove_const_t<Ty>, half>::value,
+          std::is_same<typename std::remove_const_t<Ty>, half>::value,
       vec &>
   operator=(const EnableIfNotHostHalf<Ty> &Rhs) {
     m_Data = (DataType)vec_data<Ty>::get(Rhs);
@@ -809,9 +805,9 @@ template <typename Type, int NumElements> class vec {
             std::make_index_sequence<NumElements>()} {}
 
   template <typename Ty = DataT>
-  typename detail::enable_if_t<
+  typename std::enable_if_t<
       std::is_fundamental<vec_data_t<Ty>>::value ||
-          std::is_same<typename detail::remove_const_t<Ty>, half>::value,
+          std::is_same<typename std::remove_const_t<Ty>, half>::value,
       vec &>
   operator=(const EnableIfHostHalf<Ty> &Rhs) {
     for (int i = 0; i < NumElements; ++i) {
@@ -826,9 +822,9 @@ template <typename Type, int NumElements> class vec {
             std::make_index_sequence<NumElements>()} {}
 
   template <typename Ty = DataT>
-  typename detail::enable_if_t<
+  typename std::enable_if_t<
       std::is_fundamental<vec_data_t<Ty>>::value ||
-          std::is_same<typename detail::remove_const_t<Ty>, half>::value,
+          std::is_same<typename std::remove_const_t<Ty>, half>::value,
       vec &>
   operator=(const DataT &Rhs) {
     for (int i = 0; i < NumElements; ++i) {
@@ -845,7 +841,7 @@ template <typename Type, int NumElements> class vec {
   // Helper type to make specific constructors available only for specific
   // number of elements.
   template <int IdxNum, typename T = void>
-  using EnableIfMultipleElems = typename detail::enable_if_t<
+  using EnableIfMultipleElems = typename std::enable_if_t<
       std::is_convertible<T, DataT>::value && NumElements == IdxNum, DataT>;
   template <typename Ty = DataT>
   constexpr vec(const EnableIfMultipleElems<2, Ty> Arg0,
@@ -909,7 +905,7 @@ template <typename Type, int NumElements> class vec {
 
 #ifdef __SYCL_DEVICE_ONLY__
   template <typename vector_t_ = vector_t,
-            typename = typename detail::enable_if_t<
+            typename = typename std::enable_if_t<
                 std::is_same<vector_t_, vector_t>::value &&
                 !std::is_same<vector_t_, DataT>::value>>
   constexpr vec(vector_t openclVector) : m_Data(openclVector) {}
@@ -918,7 +914,7 @@ template <typename Type, int NumElements> class vec {
 
   // Available only when: NumElements == 1
   template <int N = NumElements>
-  operator typename detail::enable_if_t<N == 1, DataT>() const {
+  operator typename std::enable_if_t<N == 1, DataT>() const {
     return vec_data<DataT>::get(m_Data);
   }
 
@@ -1084,10 +1080,10 @@ template <typename Type, int NumElements> class vec {
     return Ret;                                                                \
   }                                                                            \
   template <typename T>                                                        \
-  typename detail::enable_if_t<                                                \
+  typename std::enable_if_t<                                                   \
       std::is_convertible<DataT, T>::value &&                                  \
           (std::is_fundamental<vec_data_t<T>>::value ||                        \
-           std::is_same<typename detail::remove_const_t<T>, half>::value),     \
+           std::is_same<typename std::remove_const_t<T>, half>::value),        \
       vec>                                                                     \
   operator BINOP(const T &Rhs) const {                                         \
     return *this BINOP vec(static_cast<const DataT &>(Rhs));                   \
@@ -1097,7 +1093,7 @@ template <typename Type, int NumElements> class vec {
     return *this;                                                              \
   }                                                                            \
   template <int Num = NumElements>                                             \
-  typename detail::enable_if_t<Num != 1, vec &> operator OPASSIGN(             \
+  typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(                \
       const DataT &Rhs) {                                                      \
     *this = *this BINOP vec(Rhs);                                              \
     return *this;                                                              \
@@ -1112,10 +1108,10 @@ template <typename Type, int NumElements> class vec {
     return Ret;                                                                \
   }                                                                            \
   template <typename T>                                                        \
-  typename detail::enable_if_t<                                                \
+  typename std::enable_if_t<                                                   \
       std::is_convertible<DataT, T>::value &&                                  \
           (std::is_fundamental<vec_data_t<T>>::value ||                        \
-           std::is_same<typename detail::remove_const_t<T>, half>::value),     \
+           std::is_same<typename std::remove_const_t<T>, half>::value),        \
       vec>                                                                     \
   operator BINOP(const T &Rhs) const {                                         \
     return *this BINOP vec(static_cast<const DataT &>(Rhs));                   \
@@ -1125,7 +1121,7 @@ template <typename Type, int NumElements> class vec {
     return *this;                                                              \
   }                                                                            \
   template <int Num = NumElements>                                             \
-  typename detail::enable_if_t<Num != 1, vec &> operator OPASSIGN(             \
+  typename std::enable_if_t<Num != 1, vec &> operator OPASSIGN(                \
       const DataT &Rhs) {                                                      \
     *this = *this BINOP vec(Rhs);                                              \
     return *this;                                                              \
@@ -1171,11 +1167,10 @@ template <typename Type, int NumElements> class vec {
     return Ret;                                                                \
   }                                                                            \
   template <typename T>                                                        \
-  typename detail::enable_if_t<                                                \
-      std::is_convertible<T, DataT>::value &&                                  \
-          (std::is_fundamental<vec_data_t<T>>::value ||                        \
-           std::is_same<T, half>::value),                                      \
-      vec<rel_t, NumElements>>                                                 \
+  typename std::enable_if_t<std::is_convertible<T, DataT>::value &&            \
+                                (std::is_fundamental<vec_data_t<T>>::value ||  \
+                                 std::is_same<T, half>::value),                \
+                            vec<rel_t, NumElements>>                           \
   operator RELLOGOP(const T &Rhs) const {                                      \
     return *this RELLOGOP vec(static_cast<const DataT &>(Rhs));                \
   }
@@ -1190,11 +1185,10 @@ template <typename Type, int NumElements> class vec {
     return Ret;                                                                \
   }                                                                            \
   template <typename T>                                                        \
-  typename detail::enable_if_t<                                                \
-      std::is_convertible<T, DataT>::value &&                                  \
-          (std::is_fundamental<vec_data_t<T>>::value ||                        \
-           std::is_same<T, half>::value),                                      \
-      vec<rel_t, NumElements>>                                                 \
+  typename std::enable_if_t<std::is_convertible<T, DataT>::value &&            \
+                                (std::is_fundamental<vec_data_t<T>>::value ||  \
+                                 std::is_same<T, half>::value),                \
+                            vec<rel_t, NumElements>>                           \
   operator RELLOGOP(const T &Rhs) const {                                      \
     return *this RELLOGOP vec(static_cast<const DataT &>(Rhs));                \
   }
@@ -1232,7 +1226,7 @@ template <typename Type, int NumElements> class vec {
   // Available only when: dataT != cl_float && dataT != cl_double
   // && dataT != cl_half
   template <typename T = DataT>
-  typename detail::enable_if_t<std::is_integral<vec_data_t<T>>::value, vec>
+  typename std::enable_if_t<std::is_integral<vec_data_t<T>>::value, vec>
   operator~() const {
 // Use __SYCL_DEVICE_ONLY__ macro because cast to OpenCL vector type is defined
 // by SYCL device compiler only.
@@ -1336,51 +1330,51 @@ template <typename Type, int NumElements> class vec {
 // types: enum cl_float#N , builtin vector float#N, builtin type float.
 #ifdef __SYCL_USE_EXT_VECTOR_TYPE__
   template <int Num = NumElements, typename Ty = int,
-            typename = typename detail::enable_if_t<1 != Num>>
+            typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(EnableIfNotHostHalf<Ty> Index, const DataT &Value,
                           int) {
     m_Data[Index] = vec_data<DataT>::get(Value);
   }
 
   template <int Num = NumElements, typename Ty = int,
-            typename = typename detail::enable_if_t<1 != Num>>
+            typename = typename std::enable_if_t<1 != Num>>
   constexpr DataT getValue(EnableIfNotHostHalf<Ty> Index, int) const {
     return vec_data<DataT>::get(m_Data[Index]);
   }
 
   template <int Num = NumElements, typename Ty = int,
-            typename = typename detail::enable_if_t<1 != Num>>
+            typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(EnableIfHostHalf<Ty> Index, const DataT &Value, int) {
     m_Data.s[Index] = vec_data<DataT>::get(Value);
   }
 
   template <int Num = NumElements, typename Ty = int,
-            typename = typename detail::enable_if_t<1 != Num>>
+            typename = typename std::enable_if_t<1 != Num>>
   constexpr DataT getValue(EnableIfHostHalf<Ty> Index, int) const {
     return vec_data<DataT>::get(m_Data.s[Index]);
   }
 #else  // __SYCL_USE_EXT_VECTOR_TYPE__
   template <int Num = NumElements,
-            typename = typename detail::enable_if_t<1 != Num>>
+            typename = typename std::enable_if_t<1 != Num>>
   constexpr void setValue(int Index, const DataT &Value, int) {
     m_Data.s[Index] = vec_data<DataT>::get(Value);
   }
 
   template <int Num = NumElements,
-            typename = typename detail::enable_if_t<1 != Num>>
+            typename = typename std::enable_if_t<1 != Num>>
   constexpr DataT getValue(int Index, int) const {
     return vec_data<DataT>::get(m_Data.s[Index]);
   }
 #endif // __SYCL_USE_EXT_VECTOR_TYPE__
 
   template <int Num = NumElements,
-            typename = typename detail::enable_if_t<1 == Num>>
+            typename = typename std::enable_if_t<1 == Num>>
   constexpr void setValue(int, const DataT &Value, float) {
     m_Data = vec_data<DataT>::get(Value);
   }
 
   template <int Num = NumElements,
-            typename = typename detail::enable_if_t<1 == Num>>
+            typename = typename std::enable_if_t<1 == Num>>
   DataT getValue(int, float) const {
     return vec_data<DataT>::get(m_Data);
   }
@@ -1417,7 +1411,7 @@ template <typename Type, int NumElements> class vec {
 #ifdef __cpp_deduction_guides
 // all compilers supporting deduction guides also support fold expressions
 template <class T, class... U,
-          class = detail::enable_if_t<(std::is_same<T, U>::value && ...)>>
+          class = std::enable_if_t<(std::is_same<T, U>::value && ...)>>
 vec(T, U...) -> vec<T, sizeof...(U) + 1>;
 #endif
 
@@ -1460,24 +1454,24 @@ class SwizzleOp {
                             OperationCurrentT_, Idx_...>;
 
   template <int IdxNum, typename T = void>
-  using EnableIfOneIndex = typename detail::enable_if_t<
+  using EnableIfOneIndex = typename std::enable_if_t<
       1 == IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
 
   template <int IdxNum, typename T = void>
-  using EnableIfMultipleIndexes = typename detail::enable_if_t<
+  using EnableIfMultipleIndexes = typename std::enable_if_t<
       1 != IdxNum && SwizzleOp::getNumElements() == IdxNum, T>;
 
   template <typename T>
-  using EnableIfScalarType = typename detail::enable_if_t<
+  using EnableIfScalarType = typename std::enable_if_t<
       std::is_convertible<DataT, T>::value &&
       (std::is_fundamental<vec_data_t<T>>::value ||
-       std::is_same<typename detail::remove_const_t<T>, half>::value)>;
+       std::is_same<typename std::remove_const_t<T>, half>::value)>;
 
   template <typename T>
-  using EnableIfNoScalarType = typename detail::enable_if_t<
+  using EnableIfNoScalarType = typename std::enable_if_t<
       !std::is_convertible<DataT, T>::value ||
       !(std::is_fundamental<vec_data_t<T>>::value ||
-        std::is_same<typename detail::remove_const_t<T>, half>::value)>;
+        std::is_same<typename std::remove_const_t<T>, half>::value)>;
 
   template <int... Indices>
   using Swizzle =
@@ -1590,7 +1584,7 @@ class SwizzleOp {
 #undef __SYCL_UOP
 
   template <typename T = DataT>
-  typename detail::enable_if_t<std::is_integral<vec_data_t<T>>::value, vec_t>
+  typename std::enable_if_t<std::is_integral<vec_data_t<T>>::value, vec_t>
   operator~() {
     vec_t Tmp = *this;
     return ~Tmp;
@@ -1762,10 +1756,10 @@ class SwizzleOp {
     return NewLHOp<RhsOperation, LShift, Indexes...>(m_Vector, *this, Rhs);
   }
 
-  template <typename T1, typename T2, typename T3, template <typename> class T4,
-            int... T5,
-            typename =
-                typename detail::enable_if_t<sizeof...(T5) == getNumElements()>>
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
   SwizzleOp &operator=(const SwizzleOp<T1, T2, T3, T4, T5...> &Rhs) {
     std::array<int, getNumElements()> Idxs{Indexes...};
     for (size_t I = 0; I < Idxs.size(); ++I) {
@@ -1774,10 +1768,10 @@ class SwizzleOp {
     return *this;
   }
 
-  template <typename T1, typename T2, typename T3, template <typename> class T4,
-            int... T5,
-            typename =
-                typename detail::enable_if_t<sizeof...(T5) == getNumElements()>>
+  template <
+      typename T1, typename T2, typename T3, template <typename> class T4,
+      int... T5,
+      typename = typename std::enable_if_t<sizeof...(T5) == getNumElements()>>
   SwizzleOp &operator=(SwizzleOp<T1, T2, T3, T4, T5...> &&Rhs) {
     std::array<int, getNumElements()> Idxs{Indexes...};
     for (size_t I = 0; I < Idxs.size(); ++I) {
@@ -2025,9 +2019,9 @@ class SwizzleOp {
 #endif
 #define __SYCL_BINOP(BINOP)                                                    \
   template <typename T, int Num>                                               \
-  typename detail::enable_if_t<                                                \
+  typename std::enable_if_t<                                                   \
       std::is_fundamental<vec_data_t<T>>::value ||                             \
-          std::is_same<typename detail::remove_const_t<T>, half>::value,       \
+          std::is_same<typename std::remove_const_t<T>, half>::value,          \
       vec<T, Num>>                                                             \
   operator BINOP(const T &Lhs, const vec<T, Num> &Rhs) {                       \
     return vec<T, Num>(Lhs) BINOP Rhs;                                         \
@@ -2036,10 +2030,10 @@ class SwizzleOp {
             template <typename> class OperationCurrentT, int... Indexes,       \
             typename T, typename T1 = typename VecT::element_type,             \
             int Num = sizeof...(Indexes)>                                      \
-  typename detail::enable_if_t<                                                \
+  typename std::enable_if_t<                                                   \
       std::is_convertible<T, T1>::value &&                                     \
           (std::is_fundamental<vec_data_t<T>>::value ||                        \
-           std::is_same<typename detail::remove_const_t<T>, half>::value),     \
+           std::is_same<typename std::remove_const_t<T>, half>::value),        \
       vec<T1, Num>>                                                            \
   operator BINOP(                                                              \
       const T &Lhs,                                                            \
@@ -2079,10 +2073,10 @@ __SYCL_BINOP(<<)
 #endif
 #define __SYCL_RELLOGOP(RELLOGOP)                                              \
   template <typename T, typename DataT, int Num>                               \
-  typename detail::enable_if_t<                                                \
+  typename std::enable_if_t<                                                   \
       std::is_convertible<T, DataT>::value &&                                  \
           (std::is_fundamental<vec_data_t<T>>::value ||                        \
-           std::is_same<typename detail::remove_const_t<T>, half>::value),     \
+           std::is_same<typename std::remove_const_t<T>, half>::value),        \
       vec<detail::rel_t<DataT>, Num>>                                          \
   operator RELLOGOP(const T &Lhs, const vec<DataT, Num> &Rhs) {                \
     return vec<T, Num>(static_cast<T>(Lhs)) RELLOGOP Rhs;                      \
@@ -2091,10 +2085,10 @@ __SYCL_BINOP(<<)
             template <typename> class OperationCurrentT, int... Indexes,       \
             typename T, typename T1 = typename VecT::element_type,             \
             int Num = sizeof...(Indexes)>                                      \
-  typename detail::enable_if_t<                                                \
+  typename std::enable_if_t<                                                   \
       std::is_convertible<T, T1>::value &&                                     \
           (std::is_fundamental<vec_data_t<T>>::value ||                        \
-           std::is_same<typename detail::remove_const_t<T>, half>::value),     \
+           std::is_same<typename std::remove_const_t<T>, half>::value),        \
       vec<detail::rel_t<T1>, Num>>                                             \
   operator RELLOGOP(                                                           \
       const T &Lhs,                                                            \
@@ -2290,8 +2284,8 @@ template <typename T1, typename T2>
 struct is_device_copyable<
     std::pair<T1, T2>,
     std::enable_if_t<!std::is_trivially_copyable<std::pair<T1, T2>>::value>>
-    : detail::bool_constant<is_device_copyable<T1>::value &&
-                            is_device_copyable<T2>::value> {};
+    : std::bool_constant<is_device_copyable<T1>::value &&
+                         is_device_copyable<T2>::value> {};
 
 // std::tuple<> is implicitly device copyable type.
 template <> struct is_device_copyable<std::tuple<>> : std::true_type {};
@@ -2302,8 +2296,8 @@ template <typename T, typename... Ts>
 struct is_device_copyable<
     std::tuple<T, Ts...>,
     std::enable_if_t<!std::is_trivially_copyable<std::tuple<T, Ts...>>::value>>
-    : detail::bool_constant<is_device_copyable<T>::value &&
-                            is_device_copyable<std::tuple<Ts...>>::value> {};
+    : std::bool_constant<is_device_copyable<T>::value &&
+                         is_device_copyable<std::tuple<Ts...>>::value> {};
 
 // std::variant<> is implicitly device copyable type
 template <> struct is_device_copyable<std::variant<>> : std::true_type {};
diff --git a/sycl/source/detail/buffer_impl.hpp b/sycl/source/detail/buffer_impl.hpp
index 1d34ce3e5c95c..db2d7554f6e4f 100644
--- a/sycl/source/detail/buffer_impl.hpp
+++ b/sycl/source/detail/buffer_impl.hpp
@@ -114,7 +114,7 @@ class __SYCL_EXPORT buffer_impl final : public SYCLMemObjT {
 
   template <typename T>
   using EnableIfNotConstIterator =
-      enable_if_t<!iterator_to_const_type_t<T>::value, T>;
+      std::enable_if_t<!iterator_to_const_type_t<T>::value, T>;
 
   buffer_impl(cl_mem MemObject, const context &SyclContext,
               std::unique_ptr<SYCLMemObjAllocator> Allocator,
diff --git a/sycl/source/detail/builtins_geometric.cpp b/sycl/source/detail/builtins_geometric.cpp
index 4e1166cd7adbf..f67902c69b852 100644
--- a/sycl/source/detail/builtins_geometric.cpp
+++ b/sycl/source/detail/builtins_geometric.cpp
@@ -68,47 +68,44 @@ template <typename T> inline T __FMul(T p0, T p1) {
 }
 
 template <typename T>
-inline typename sycl::detail::enable_if_t<d::is_sgengeo<T>::value, T>
-__length(T t) {
+inline typename std::enable_if_t<d::is_sgengeo<T>::value, T> __length(T t) {
   return std::sqrt(__FMul(t, t));
 }
 
 template <typename T>
-inline typename sycl::detail::enable_if_t<d::is_vgengeo<T>::value,
-                                          typename T::element_type>
-__length(T t) {
+inline
+    typename std::enable_if_t<d::is_vgengeo<T>::value, typename T::element_type>
+    __length(T t) {
   return std::sqrt(sycl_host_Dot(t, t));
 }
 
 template <typename T>
-inline typename sycl::detail::enable_if_t<d::is_sgengeo<T>::value, T>
-__normalize(T t) {
+inline typename std::enable_if_t<d::is_sgengeo<T>::value, T> __normalize(T t) {
   T r = __length(t);
   return t / T(r);
 }
 
 template <typename T>
-inline typename sycl::detail::enable_if_t<d::is_vgengeo<T>::value, T>
-__normalize(T t) {
+inline typename std::enable_if_t<d::is_vgengeo<T>::value, T> __normalize(T t) {
   typename T::element_type r = __length(t);
   return t / T(r);
 }
 
 template <typename T>
-inline typename sycl::detail::enable_if_t<d::is_sgengeo<T>::value, T>
+inline typename std::enable_if_t<d::is_sgengeo<T>::value, T>
 __fast_length(T t) {
   return std::sqrt(__FMul(t, t));
 }
 
 template <typename T>
-inline typename sycl::detail::enable_if_t<d::is_vgengeo<T>::value,
-                                          typename T::element_type>
-__fast_length(T t) {
+inline
+    typename std::enable_if_t<d::is_vgengeo<T>::value, typename T::element_type>
+    __fast_length(T t) {
   return std::sqrt(sycl_host_Dot(t, t));
 }
 
 template <typename T>
-inline typename sycl::detail::enable_if_t<d::is_vgengeo<T>::value, T>
+inline typename std::enable_if_t<d::is_vgengeo<T>::value, T>
 __fast_normalize(T t) {
   if (sycl_host_All(t == T(0.0f)))
     return t;
diff --git a/sycl/source/detail/builtins_relational.cpp b/sycl/source/detail/builtins_relational.cpp
index 8d64e1379733f..ae9087ef810de 100644
--- a/sycl/source/detail/builtins_relational.cpp
+++ b/sycl/source/detail/builtins_relational.cpp
@@ -90,7 +90,7 @@ template <typename T> inline T __sUnordered(T x, T y) {
 }
 
 template <typename T>
-inline typename sycl::detail::enable_if_t<d::is_sgeninteger<T>::value, T>
+inline typename std::enable_if_t<d::is_sgeninteger<T>::value, T>
 __sycl_host_bitselect(T a, T b, T c) {
   return (a & ~c) | (b & c);
 }
@@ -121,9 +121,8 @@ template <> union databitset<s::cl_half> {
 };
 
 template <typename T>
-typename sycl::detail::enable_if_t<d::is_sgenfloat<T>::value,
-                                   T> inline __sycl_host_bitselect(T a, T b,
-                                                                   T c) {
+typename std::enable_if_t<d::is_sgenfloat<T>::value,
+                          T> inline __sycl_host_bitselect(T a, T b, T c) {
   databitset<T> ba;
   ba.f = a;
   databitset<T> bb;
diff --git a/sycl/source/detail/pi.cpp b/sycl/source/detail/pi.cpp
index bee44054cb2fc..dca5e04650fa0 100644
--- a/sycl/source/detail/pi.cpp
+++ b/sycl/source/detail/pi.cpp
@@ -637,7 +637,7 @@ RT::PiDeviceBinaryType getBinaryImageFormat(const unsigned char *ImgData,
               {PI_DEVICE_BINARY_TYPE_NATIVE, 0x43544E49}};
 
   if (ImgSize >= sizeof(Fmts[0].Magic)) {
-    detail::remove_const_t<decltype(Fmts[0].Magic)> Hdr = 0;
+    std::remove_const_t<decltype(Fmts[0].Magic)> Hdr = 0;
     std::copy(ImgData, ImgData + sizeof(Hdr), reinterpret_cast<char *>(&Hdr));
 
     // Check headers for direct formats.
diff --git a/sycl/source/detail/sycl_mem_obj_t.hpp b/sycl/source/detail/sycl_mem_obj_t.hpp
index 5c0a6beb08994..488720d2422ba 100644
--- a/sycl/source/detail/sycl_mem_obj_t.hpp
+++ b/sycl/source/detail/sycl_mem_obj_t.hpp
@@ -43,11 +43,11 @@ class __SYCL_EXPORT SYCLMemObjT : public SYCLMemObjI {
   // TODO: Align these checks with the SYCL specification when the behaviour
   // with void * is clarified.
   template <typename T>
-  using EnableIfOutputPointerT = enable_if_t<
+  using EnableIfOutputPointerT = std::enable_if_t<
       /*is_output_iterator<T>::value &&*/ std::is_pointer<T>::value>;
 
   template <typename T>
-  using EnableIfOutputIteratorT = enable_if_t<
+  using EnableIfOutputIteratorT = std::enable_if_t<
       /*is_output_iterator<T>::value &&*/ !std::is_pointer<T>::value>;
 
 public:

From e134bfd60608af559dd8909094516bd55cd599be Mon Sep 17 00:00:00 2001
From: Andrei Elovikov <andrei.elovikov@intel.com>
Date: Fri, 21 Apr 2023 12:43:46 -0700
Subject: [PATCH 2/2] More fixes

---
 .../sycl/ext/oneapi/experimental/user_defined_reductions.hpp    | 2 +-
 sycl/include/sycl/group_algorithm.hpp                           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/sycl/include/sycl/ext/oneapi/experimental/user_defined_reductions.hpp b/sycl/include/sycl/ext/oneapi/experimental/user_defined_reductions.hpp
index d2bfe0e573830..728479efe2a68 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/user_defined_reductions.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/user_defined_reductions.hpp
@@ -44,7 +44,7 @@ T reduce_over_group_impl(GroupHelper group_helper, T x, size_t num_elements,
 
 // ---- reduce_over_group
 template <typename GroupHelper, typename T, typename BinaryOperation>
-sycl::detail::enable_if_t<(is_group_helper_v<GroupHelper>), T>
+std::enable_if_t<(is_group_helper_v<GroupHelper>), T>
 reduce_over_group(GroupHelper group_helper, T x, BinaryOperation binary_op) {
   if constexpr (sycl::detail::is_native_op<T, BinaryOperation>::value) {
     return sycl::reduce_over_group(group_helper.get_group(), x, binary_op);
diff --git a/sycl/include/sycl/group_algorithm.hpp b/sycl/include/sycl/group_algorithm.hpp
index 796143bbb91f5..60b55655b913a 100644
--- a/sycl/include/sycl/group_algorithm.hpp
+++ b/sycl/include/sycl/group_algorithm.hpp
@@ -350,7 +350,7 @@ joint_reduce(Group g, Ptr first, Ptr last, T init, BinaryOperation binary_op) {
 }
 
 template <typename Group, typename Ptr, class BinaryOperation>
-detail::enable_if_t<
+std::enable_if_t<
     (is_group_v<std::decay_t<Group>> && detail::is_pointer<Ptr>::value &&
      detail::is_arithmetic_or_complex<
          typename detail::remove_pointer<Ptr>::type>::value &&