diff --git a/libdevice/cmake/modules/SYCLLibdevice.cmake b/libdevice/cmake/modules/SYCLLibdevice.cmake
index 080e2e575e540..022f5e077cb03 100644
--- a/libdevice/cmake/modules/SYCLLibdevice.cmake
+++ b/libdevice/cmake/modules/SYCLLibdevice.cmake
@@ -32,6 +32,15 @@ set(compile_opts
   -sycl-std=2020
   )
 
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  # If we use non-system GCC, need to pass its location when using
+  # freshly built clang. The system one might be very old.
+  get_filename_component(gcc_bin_dir ${CMAKE_CXX_COMPILER} DIRECTORY)
+  get_filename_component(gcc_install_dir ${gcc_bin_dir} DIRECTORY)
+  list(APPEND compile_opts
+    "--gcc-toolchain=${gcc_install_dir}")
+endif()
+
 if ("NVPTX" IN_LIST LLVM_TARGETS_TO_BUILD)
   string(APPEND sycl_targets_opt ",nvptx64-nvidia-cuda")
   list(APPEND compile_opts
diff --git a/sycl/include/CL/__spirv/spirv_ops.hpp b/sycl/include/CL/__spirv/spirv_ops.hpp
index 7eaa886c74328..a25e4cec28c95 100644
--- a/sycl/include/CL/__spirv/spirv_ops.hpp
+++ b/sycl/include/CL/__spirv/spirv_ops.hpp
@@ -338,7 +338,7 @@ extern SYCL_EXTERNAL TempRetT __spirv_ImageSampleExplicitLod(SampledType,
 // 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,           \
@@ -346,7 +346,7 @@ extern SYCL_EXTERNAL TempRetT __spirv_ImageSampleExplicitLod(SampledType,
     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,           \
@@ -354,7 +354,7 @@ extern SYCL_EXTERNAL TempRetT __spirv_ImageSampleExplicitLod(SampledType,
     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 42a2c262b5b17..95bb33aa71554 100644
--- a/sycl/include/sycl/accessor.hpp
+++ b/sycl/include/sycl/accessor.hpp
@@ -346,30 +346,28 @@ 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 && IsAccessAnyWrite>>
+              typename = std::enable_if_t<CurDims == 1 && IsAccessAnyWrite>>
     RefType 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];
     }
 
     template <int CurDims = SubDims,
-              typename = detail::enable_if_t<CurDims == 1 && IsAccessReadOnly>>
+              typename = std::enable_if_t<CurDims == 1 && IsAccessReadOnly>>
     ConstRefType operator[](size_t Index) const {
       MIDs[Dims - SubDims] = Index;
       return MAccessor[MIDs];
@@ -700,7 +698,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__
   {
@@ -726,9 +724,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__
@@ -782,17 +779,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 {
     cl_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 {
     cl_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 {
     cl_int3 Range = getRangeInternal();
     return range<3>(Range[0], Range[1], Range[2]);
@@ -803,7 +800,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());
   }
@@ -815,7 +812,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) ||
@@ -835,7 +832,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))>>
@@ -859,7 +856,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) ||
@@ -915,22 +912,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);
   }
@@ -940,12 +937,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 {
     cl_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 {
     cl_int3 Count = MBaseAcc.getRangeInternal();
     return range<2>(Count.x(), Count.y());
@@ -960,7 +957,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());
   }
@@ -1269,7 +1266,7 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
 
 public:
   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 &&
                 ((!IsPlaceH && IsHostBuf) ||
@@ -1301,7 +1298,7 @@ class __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 &&
                 ((!IsPlaceH && IsHostBuf) ||
@@ -1333,7 +1330,7 @@ class __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) &&
                 (!IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf))>>
@@ -1365,7 +1362,7 @@ class __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) &&
                 (!IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf))>>
@@ -1397,7 +1394,7 @@ class __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 &&
                 ((!IsPlaceH && IsHostBuf) ||
@@ -1431,7 +1428,7 @@ class __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 &&
                 ((!IsPlaceH && IsHostBuf) ||
@@ -1468,7 +1465,7 @@ class __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 &&
                 IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf)>>
@@ -1482,7 +1479,7 @@ class __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 &&
                 IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf)>>
@@ -1497,7 +1494,7 @@ class __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 &&
                 (!IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf))>>
@@ -1530,7 +1527,7 @@ class __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 &&
                 (!IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf))>>
@@ -1566,7 +1563,7 @@ class __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 &&
                 !IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf)>>
@@ -1580,7 +1577,7 @@ class __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 &&
                 !IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf)>>
@@ -1597,7 +1594,7 @@ class __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 &&
                 ((!IsPlaceH && IsHostBuf) ||
@@ -1610,7 +1607,7 @@ class __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 &&
                 ((!IsPlaceH && IsHostBuf) ||
@@ -1626,7 +1623,7 @@ class __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 &&
                 IsPlaceH && (IsGlobalBuf || IsConstantBuf)>>
@@ -1640,7 +1637,7 @@ class __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 &&
                 IsPlaceH && (IsGlobalBuf || IsConstantBuf)>>
@@ -1656,7 +1653,7 @@ class __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 &&
                 (!IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf))>>
@@ -1669,7 +1666,7 @@ class __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 &&
                 (!IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf))>>
@@ -1686,7 +1683,7 @@ class __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 &&
                 !IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf)>>
@@ -1702,7 +1699,7 @@ class __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 &&
                 !IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf)>>
@@ -1719,7 +1716,7 @@ class __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 &&
                 ((!IsPlaceH && IsHostBuf) ||
@@ -1760,7 +1757,7 @@ class __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 &&
                 ((!IsPlaceH && IsHostBuf) ||
@@ -1805,7 +1802,7 @@ class __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 &&
                 IsPlaceH && (IsGlobalBuf || IsConstantBuf)>>
@@ -1819,7 +1816,7 @@ class __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 &&
                 IsPlaceH && (IsGlobalBuf || IsConstantBuf)>>
@@ -1835,7 +1832,7 @@ class __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 &&
                 (!IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf))>>
@@ -1876,7 +1873,7 @@ class __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 &&
                 (!IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf))>>
@@ -1920,7 +1917,7 @@ class __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 &&
                 !IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf)>>
@@ -1936,7 +1933,7 @@ class __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 &&
                 !IsPlaceH && (IsGlobalBuf || IsConstantBuf || IsHostBuf)>>
@@ -1997,12 +1994,12 @@ class __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 {
 #if __cplusplus >= 201703L
     static_assert(
@@ -2014,51 +2011,51 @@ class __SYCL_SPECIAL_CLASS __SYCL_TYPE(accessor) accessor :
   }
 
   template <int Dims = Dimensions, typename RefT = RefType,
-            typename = detail::enable_if_t<Dims == 0 && IsAccessAnyWrite &&
-                                           !std::is_const<RefT>::value>>
+            typename = std::enable_if_t<Dims == 0 && IsAccessAnyWrite &&
+                                        !std::is_const<RefT>::value>>
   operator RefType() const {
     const size_t LinearIndex = getLinearIndex(id<AdjustedDim>());
     return *(getQualifiedPtr() + LinearIndex);
   }
 
   template <int Dims = Dimensions,
-            typename = detail::enable_if_t<Dims == 0 && IsAccessReadOnly>>
+            typename = std::enable_if_t<Dims == 0 && IsAccessReadOnly>>
   operator ConstRefType() const {
     const size_t LinearIndex = getLinearIndex(id<AdjustedDim>());
     return *(getQualifiedPtr() + LinearIndex);
   }
 
   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 > 0) && IsAccessReadOnly, ConstRefType>
+  typename std::enable_if_t<(Dims > 0) && IsAccessReadOnly, ConstRefType>
   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>(
@@ -2066,35 +2063,35 @@ class __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<AccessTarget_ ==
-                                           access::target::host_buffer>>
+  template <
+      access::target AccessTarget_ = AccessTarget,
+      typename = std::enable_if_t<AccessTarget_ == access::target::host_buffer>>
   DataT *get_pointer() const {
     return getPointerAdjusted();
   }
 
   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());
   }
@@ -2103,7 +2100,7 @@ class __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__
@@ -2117,7 +2114,7 @@ class __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__
@@ -2506,7 +2503,7 @@ 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__
@@ -2519,8 +2516,7 @@ 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(handler &, const property_list &propList,
                             const detail::code_location CodeLoc =
                                 detail::code_location::current())
@@ -2537,7 +2533,7 @@ 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())
@@ -2553,7 +2549,7 @@ class __SYCL_SPECIAL_CLASS local_accessor_base :
 #endif
 
         template <int Dims = Dimensions,
-                  typename = detail::enable_if_t<(Dims > 0)>>
+                  typename = std::enable_if_t<(Dims > 0)>>
         local_accessor_base(range<Dimensions> AllocationSize, handler &,
                             const property_list &propList,
                             const detail::code_location CodeLoc =
@@ -2577,32 +2573,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>(
@@ -2610,8 +2606,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>(
@@ -2619,14 +2615,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>>
@@ -2993,7 +2989,7 @@ class 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,
@@ -3002,7 +2998,7 @@ class 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 = {},
@@ -3012,7 +3008,7 @@ class host_accessor
 #if __cplusplus >= 201703L
 
   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<DataT, Dimensions, AllocatorT> &BufferRef, mode_tag_t<AccessMode>,
       const property_list &PropertyList = {},
@@ -3022,7 +3018,7 @@ class host_accessor
 #endif
 
   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 = {},
@@ -3032,7 +3028,7 @@ class host_accessor
 #if __cplusplus >= 201703L
 
   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<DataT, Dimensions, AllocatorT> &BufferRef,
       handler &CommandGroupHandler, mode_tag_t<AccessMode>,
@@ -3043,7 +3039,7 @@ class host_accessor
 #endif
 
   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<DataT, Dimensions, AllocatorT> &BufferRef,
       range<Dimensions> AccessRange, const property_list &PropertyList = {},
@@ -3053,7 +3049,7 @@ class host_accessor
 #if __cplusplus >= 201703L
 
   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<DataT, Dimensions, AllocatorT> &BufferRef,
       range<Dimensions> AccessRange, mode_tag_t<AccessMode>,
@@ -3064,7 +3060,7 @@ class host_accessor
 #endif
 
   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<DataT, Dimensions, AllocatorT> &BufferRef,
       handler &CommandGroupHandler, range<Dimensions> AccessRange,
@@ -3076,7 +3072,7 @@ class host_accessor
 #if __cplusplus >= 201703L
 
   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<DataT, Dimensions, AllocatorT> &BufferRef,
       handler &CommandGroupHandler, range<Dimensions> AccessRange,
@@ -3088,7 +3084,7 @@ class host_accessor
 #endif
 
   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<DataT, Dimensions, AllocatorT> &BufferRef,
       range<Dimensions> AccessRange, id<Dimensions> AccessOffset,
@@ -3100,7 +3096,7 @@ class host_accessor
 #if __cplusplus >= 201703L
 
   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<DataT, Dimensions, AllocatorT> &BufferRef,
       range<Dimensions> AccessRange, id<Dimensions> AccessOffset,
@@ -3112,7 +3108,7 @@ class host_accessor
 #endif
 
   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<DataT, Dimensions, AllocatorT> &BufferRef,
       handler &CommandGroupHandler, range<Dimensions> AccessRange,
@@ -3124,7 +3120,7 @@ class host_accessor
 #if __cplusplus >= 201703L
 
   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<DataT, Dimensions, AllocatorT> &BufferRef,
       handler &CommandGroupHandler, range<Dimensions> AccessRange,
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 cbae52de9d7c7..f20549f847e58 100644
--- a/sycl/include/sycl/atomic_ref.hpp
+++ b/sycl/include/sycl/atomic_ref.hpp
@@ -89,7 +89,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/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 6152cd596fa60..5e115c4f3643a 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::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]}; }
@@ -579,7 +579,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 aa1e1c2e85409..8f5a565005983 100644
--- a/sycl/include/sycl/builtins.hpp
+++ b/sycl/include/sycl/builtins.hpp
@@ -196,206 +196,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>();
@@ -404,7 +401,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>();
@@ -413,14 +410,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);
 }
@@ -429,22 +425,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);
@@ -452,13 +446,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>();
@@ -467,58 +461,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>();
@@ -526,7 +518,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));
@@ -534,20 +526,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>();
@@ -556,20 +548,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>();
@@ -578,13 +570,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>();
@@ -593,25 +585,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>();
@@ -620,57 +612,57 @@ 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);
 }
 
 /* --------------- 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);
 }
 
@@ -678,7 +670,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));
@@ -686,20 +678,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);
 }
 
@@ -707,14 +699,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);
 }
 
@@ -722,15 +714,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);
 }
 
@@ -738,22 +730,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);
 }
 
@@ -761,14 +752,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);
 }
@@ -777,7 +768,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);
@@ -785,99 +776,93 @@ 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);
 }
 
 /* --------------- 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);
 }
 
 // ugeninteger abs (geninteger x)
 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(T x) __NOEXC {
   return __sycl_std::__invoke_s_abs<detail::make_unsigned_t<T>>(x);
 }
 
 // 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));
@@ -885,7 +870,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));
@@ -893,13 +878,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);
 }
 
@@ -909,8 +894,7 @@ namespace 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 intel
@@ -922,136 +906,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);
@@ -1059,17 +1035,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);
@@ -1077,17 +1053,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);
@@ -1095,37 +1071,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);
 }
 
@@ -1137,8 +1113,7 @@ mul24(T x, T y) __NOEXC {
 // 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);
 }
 
@@ -1146,131 +1121,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);
 }
@@ -1279,21 +1252,21 @@ fast_normalize(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,
@@ -1301,7 +1274,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>>(
@@ -1309,14 +1282,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,
@@ -1324,56 +1297,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));
@@ -1389,14 +1362,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, detail::anyall_ret_t>
+std::enable_if_t<detail::is_vigeninteger<T>::value, detail::anyall_ret_t>
 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>>(
@@ -1405,14 +1378,14 @@ 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, detail::anyall_ret_t>
+std::enable_if_t<detail::is_vigeninteger<T>::value, detail::anyall_ret_t>
 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>>(
@@ -1421,21 +1394,21 @@ 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 {
   return __sycl_std::__invoke_select<T>(a, b, static_cast<int>(c));
 }
 
 // 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>();
@@ -1444,7 +1417,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>();
@@ -1453,7 +1426,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>();
@@ -1462,7 +1435,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>();
@@ -1471,9 +1444,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);
@@ -1481,9 +1454,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);
@@ -1491,9 +1464,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);
@@ -1501,9 +1474,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);
@@ -1567,87 +1540,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);
 }
 
@@ -1708,87 +1679,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);
 }
 
@@ -1827,74 +1796,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/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 7505be44d5e84..1399ab6033d11 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))
diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index 0bf929978e0b2..0e0fae60049ab 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -249,22 +249,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>;
@@ -289,12 +289,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>(); }
 };
 
@@ -384,9 +386,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);
 }
@@ -396,7 +397,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);
 }
@@ -470,7 +471,7 @@ 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
@@ -483,15 +484,15 @@ 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 &&
-                                    !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__
@@ -524,8 +525,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>;
@@ -533,8 +534,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;
 };
 
@@ -557,19 +558,18 @@ using ConvertToOpenCLType_t = conditional_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);
 }
@@ -624,12 +624,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;
 };
 
@@ -676,8 +676,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;
@@ -701,8 +701,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 8ab015674e499..5a0553768a42c 100644
--- a/sycl/include/sycl/detail/helpers.hpp
+++ b/sycl/include/sycl/detail/helpers.hpp
@@ -88,14 +88,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);
   }
@@ -146,8 +146,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>>()};
@@ -156,8 +155,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 e0482544ba3c3..85d1a76bb1f22 100644
--- a/sycl/include/sycl/detail/image_accessor_util.hpp
+++ b/sycl/include/sycl/detail/image_accessor_util.hpp
@@ -33,19 +33,19 @@ using IsValidCoordType =
 // 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};
@@ -56,20 +56,20 @@ 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, cl_float4>
+std::enable_if_t<IsValidCoordType<T>::value, cl_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, cl_float4>
+std::enable_if_t<IsValidCoordType<T>::value, cl_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, cl_float4>
+std::enable_if_t<IsValidCoordType<T>::value, cl_float4>
 convertToFloat4(vec<T, 4> Coords) {
   return {static_cast<float>(Coords.x()), static_cast<float>(Coords.y()),
           static_cast<float>(Coords.z()), 0.f};
@@ -79,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 3e2587c4131e1..50de456ee52d5 100644
--- a/sycl/include/sycl/detail/spirv.hpp
+++ b/sycl/include/sycl/detail/spirv.hpp
@@ -109,7 +109,7 @@ using is_native_broadcast = bool_constant<detail::is_arithmetic<T>::value &&
                                           !std::is_same<T, half>::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
@@ -120,7 +120,7 @@ using is_bitcast_broadcast = bool_constant<
     (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>
@@ -137,7 +137,7 @@ using is_generic_broadcast =
                   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.
@@ -283,7 +283,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) {
@@ -297,7 +297,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) {
@@ -315,7 +315,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);
@@ -326,7 +326,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>;
@@ -339,7 +339,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);
@@ -350,7 +350,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>;
@@ -363,7 +363,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);
@@ -374,7 +374,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>;
@@ -389,7 +389,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);
@@ -400,7 +400,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);
@@ -411,7 +411,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);
@@ -422,7 +422,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);
@@ -433,7 +433,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);
@@ -444,7 +444,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);
@@ -455,7 +455,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);
@@ -466,7 +466,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);
@@ -477,7 +477,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);
@@ -488,7 +488,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);
@@ -504,15 +504,15 @@ AtomicMax(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 #ifndef __NVPTX__
 template <typename T>
 using EnableIfNativeShuffle =
-    detail::enable_if_t<detail::is_arithmetic<T>::value, T>;
+    std::enable_if_t<detail::is_arithmetic<T>::value, T>;
 #else
 template <typename T>
-using EnableIfNativeShuffle = detail::enable_if_t<
+using EnableIfNativeShuffle = std::enable_if_t<
     std::is_integral<T>::value && (sizeof(T) <= sizeof(int32_t)), T>;
 
 template <typename T>
 using EnableIfVectorShuffle =
-    detail::enable_if_t<detail::is_vector_arithmetic<T>::value, T>;
+    std::enable_if_t<detail::is_vector_arithmetic<T>::value, T>;
 #endif
 
 #ifdef __NVPTX__
@@ -608,19 +608,20 @@ EnableIfVectorShuffle<T> SubgroupShuffleUp(T x, uint32_t delta) {
 #ifndef __NVPTX__
 template <typename T>
 using EnableIfBitcastShuffle =
-    detail::enable_if_t<!detail::is_arithmetic<T>::value &&
-                            (std::is_trivially_copyable<T>::value &&
-                             (sizeof(T) == 1 || sizeof(T) == 2 ||
-                              sizeof(T) == 4 || sizeof(T) == 8)),
-                        T>;
+    std::enable_if_t<!detail::is_arithmetic<T>::value &&
+                         (std::is_trivially_copyable<T>::value &&
+                          (sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 ||
+                           sizeof(T) == 8)),
+                     T>;
 #else
 template <typename T>
-using EnableIfBitcastShuffle = detail::enable_if_t<
-    !(std::is_integral<T>::value && (sizeof(T) <= sizeof(int32_t))) &&
-        !detail::is_vector_arithmetic<T>::value &&
-        (std::is_trivially_copyable<T>::value &&
-         (sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4)),
-    T>;
+using EnableIfBitcastShuffle =
+    std::enable_if_t<!(std::is_integral<T>::value &&
+                       (sizeof(T) <= sizeof(int32_t))) &&
+                         !detail::is_vector_arithmetic<T>::value &&
+                         (std::is_trivially_copyable<T>::value &&
+                          (sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4)),
+                     T>;
 #endif
 
 template <typename T>
@@ -686,14 +687,14 @@ EnableIfBitcastShuffle<T> SubgroupShuffleUp(T x, uint32_t delta) {
 #ifndef __NVPTX__
 template <typename T>
 using EnableIfGenericShuffle =
-    detail::enable_if_t<!detail::is_arithmetic<T>::value &&
-                            !(std::is_trivially_copyable<T>::value &&
-                              (sizeof(T) == 1 || sizeof(T) == 2 ||
-                               sizeof(T) == 4 || sizeof(T) == 8)),
-                        T>;
+    std::enable_if_t<!detail::is_arithmetic<T>::value &&
+                         !(std::is_trivially_copyable<T>::value &&
+                           (sizeof(T) == 1 || sizeof(T) == 2 ||
+                            sizeof(T) == 4 || sizeof(T) == 8)),
+                     T>;
 #else
 template <typename T>
-using EnableIfGenericShuffle = detail::enable_if_t<
+using EnableIfGenericShuffle = std::enable_if_t<
     !(std::is_integral<T>::value && (sizeof(T) <= sizeof(int32_t))) &&
         !detail::is_vector_arithmetic<T>::value &&
         !(std::is_trivially_copyable<T>::value &&
diff --git a/sycl/include/sycl/detail/stl_type_traits.hpp b/sycl/include/sycl/detail/stl_type_traits.hpp
index efa7e7cc73d99..152a0b08dcd74 100644
--- a/sycl/include/sycl/detail/stl_type_traits.hpp
+++ b/sycl/include/sycl/detail/stl_type_traits.hpp
@@ -20,9 +20,6 @@ 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;
 
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_traits.hpp b/sycl/include/sycl/detail/type_traits.hpp
index 67208e55723d1..9ce47a24cdb9c 100644
--- a/sycl/include/sycl/detail/type_traits.hpp
+++ b/sycl/include/sycl/detail/type_traits.hpp
@@ -164,13 +164,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>;
 };
@@ -179,7 +179,7 @@ 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;
 };
 
@@ -198,13 +198,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>;
 };
@@ -213,7 +213,7 @@ 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;
 };
 
@@ -339,21 +339,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>;
 };
 
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 115812d2ea1ae..721623d9f07b1 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
@@ -329,7 +329,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 dd64b3593f95f..51acefad05173 100644
--- a/sycl/include/sycl/ext/intel/esimd/detail/sycl_util.hpp
+++ b/sycl/include/sycl/ext/intel/esimd/detail/sycl_util.hpp
@@ -79,7 +79,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 detail
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 0d2429fa0a6ab..4f2892c244ad6 100644
--- a/sycl/include/sycl/ext/intel/experimental/esimd/math.hpp
+++ b/sycl/include/sycl/ext/intel/experimental/esimd/math.hpp
@@ -763,7 +763,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.
 
@@ -1032,7 +1032,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/oneapi/accessor_property_list.hpp b/sycl/include/sycl/ext/oneapi/accessor_property_list.hpp
index 4b0e384f7a378..c20659cb7ef92 100644
--- a/sycl/include/sycl/ext/oneapi/accessor_property_list.hpp
+++ b/sycl/include/sycl/ext/oneapi/accessor_property_list.hpp
@@ -157,8 +157,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...);
@@ -169,7 +169,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...>,
@@ -178,7 +178,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>())
@@ -189,8 +189,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 975da2fb4c8c8..5631c36f307ad 100644
--- a/sycl/include/sycl/ext/oneapi/atomic_accessor.hpp
+++ b/sycl/include/sycl/ext/oneapi/atomic_accessor.hpp
@@ -89,20 +89,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 dc7768fa51d9a..7823975187b90 100644
--- a/sycl/include/sycl/ext/oneapi/atomic_ref.hpp
+++ b/sycl/include/sycl/ext/oneapi/atomic_ref.hpp
@@ -91,7 +91,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; }
 };
 
@@ -267,7 +267,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:
@@ -415,7 +415,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 51d1065f83dbd..f1b15ec866159 100644
--- a/sycl/include/sycl/ext/oneapi/backend/level_zero.hpp
+++ b/sycl/include/sycl/ext/oneapi/backend/level_zero.hpp
@@ -38,7 +38,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
@@ -47,8 +47,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
@@ -78,8 +78,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
@@ -90,8 +90,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 96f5980103ec8..fd8f106a2736f 100644
--- a/sycl/include/sycl/ext/oneapi/device_global/device_global.hpp
+++ b/sycl/include/sycl/ext/oneapi/device_global/device_global.hpp
@@ -54,7 +54,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/experimental/builtins.hpp b/sycl/include/sycl/ext/oneapi/experimental/builtins.hpp
index 479ca9032d5f1..148cbe47115c1 100755
--- a/sycl/include/sycl/ext/oneapi/experimental/builtins.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/builtins.hpp
@@ -89,9 +89,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>;
@@ -140,7 +140,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/spec_constant.hpp b/sycl/include/sycl/ext/oneapi/experimental/spec_constant.hpp
index 27bd83f3e1ff5..ff2ededc46383 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/spec_constant.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/spec_constant.hpp
@@ -50,7 +50,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);
@@ -61,9 +61,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/sycl_complex.hpp b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
index d4f936be7a115..5273066c07f51 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/sycl_complex.hpp
@@ -814,16 +814,15 @@ arg(const complex<_Tp> &__c) {
 }
 
 template <class _Tp>
-SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY
-    typename enable_if<is_integral<_Tp>::value || is_same<_Tp, double>::value,
-                       double>::type
-    arg(_Tp __re) {
+SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if<
+    is_integral<_Tp>::value || is_same<_Tp, double>::value, double>::type
+arg(_Tp __re) {
   return sycl::atan2(0., __re);
 }
 
 template <class _Tp>
 SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY
-    typename enable_if<is_same<_Tp, float>::value, float>::type
+    typename std::enable_if<is_same<_Tp, float>::value, float>::type
     arg(_Tp __re) {
   return sycl::atan2(0.F, __re);
 }
@@ -877,7 +876,7 @@ proj(const complex<_Tp> &__c) {
 }
 
 template <class _Tp>
-SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY typename enable_if<
+SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if<
     is_floating_point<_Tp>::value,
     typename __libcpp_complex_overload_traits<_Tp>::_ComplexType>::type
 proj(_Tp __re) {
@@ -887,7 +886,7 @@ proj(_Tp __re) {
 }
 
 template <class _Tp>
-SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY typename enable_if<
+SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY typename std::enable_if<
     is_integral<_Tp>::value,
     typename __libcpp_complex_overload_traits<_Tp>::_ComplexType>::type
 proj(_Tp __re) {
@@ -998,8 +997,8 @@ SYCL_EXTERNAL
 template <class _Tp, class _Up,
           class = std::enable_if<is_gencomplex<_Tp>::value>>
 SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY
-    typename enable_if<is_genfloat<_Up>::value,
-                       complex<typename __promote<_Tp, _Up>::type>>::type
+    typename std::enable_if<is_genfloat<_Up>::value,
+                            complex<typename __promote<_Tp, _Up>::type>>::type
     pow(const complex<_Tp> &__x, const _Up &__y) {
   typedef complex<typename __promote<_Tp, _Up>::type> result_type;
   return sycl::ext::oneapi::experimental::pow(result_type(__x),
@@ -1009,8 +1008,8 @@ SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY
 template <class _Tp, class _Up,
           class = std::enable_if<is_gencomplex<_Tp>::value>>
 SYCL_EXTERNAL _SYCL_EXT_CPLX_INLINE_VISIBILITY
-    typename enable_if<is_genfloat<_Up>::value,
-                       complex<typename __promote<_Tp, _Up>::type>>::type
+    typename std::enable_if<is_genfloat<_Up>::value,
+                            complex<typename __promote<_Tp, _Up>::type>>::type
     pow(const _Tp &__x, const complex<_Up> &__y) {
   typedef complex<typename __promote<_Tp, _Up>::type> result_type;
   return sycl::ext::oneapi::experimental::pow(result_type(__x),
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 a9fe4764849ac..09559cfd53ba6 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/user_defined_reductions.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/user_defined_reductions.hpp
@@ -17,7 +17,7 @@ namespace ext::oneapi::experimental {
 
 // ---- 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);
@@ -44,7 +44,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 &&
@@ -63,9 +63,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<
@@ -97,7 +97,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 597385ef541a6..bea06c09ed40a 100644
--- a/sycl/include/sycl/ext/oneapi/functional.hpp
+++ b/sycl/include/sycl/ext/oneapi/functional.hpp
@@ -37,17 +37,17 @@ struct GroupOpFP {};
 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;
 };
 
diff --git a/sycl/include/sycl/ext/oneapi/group_algorithm.hpp b/sycl/include/sycl/ext/oneapi/group_algorithm.hpp
index 63229a5db1c3b..2d163363cfbc0 100644
--- a/sycl/include/sycl/ext/oneapi/group_algorithm.hpp
+++ b/sycl/include/sycl/ext/oneapi/group_algorithm.hpp
@@ -27,48 +27,48 @@ namespace 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);
 }
@@ -76,7 +76,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));
 }
@@ -84,16 +84,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);
 }
@@ -101,7 +101,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));
 }
@@ -109,16 +109,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);
 }
@@ -126,7 +126,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));
 }
@@ -134,20 +134,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, 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, T x, typename Group::id_type local_id) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::GroupBroadcast<Group>(x, local_id);
 #else
@@ -161,10 +160,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 +181,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 +202,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 +224,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 +241,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 +261,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 +299,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 +343,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 +356,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 +370,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 +417,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 +435,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 +450,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 +497,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 +515,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<
@@ -532,8 +528,7 @@ detail::enable_if_t<
 }
 
 template <typename Group>
-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/sub_group_mask.hpp b/sycl/include/sycl/ext/oneapi/sub_group_mask.hpp
index 4c2fbad0de4f7..6cc45593396a0 100644
--- a/sycl/include/sycl/ext/oneapi/sub_group_mask.hpp
+++ b/sycl/include/sycl/ext/oneapi/sub_group_mask.hpp
@@ -103,7 +103,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;
@@ -122,7 +122,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) {
@@ -134,7 +134,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);
@@ -153,7 +153,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) {
@@ -224,8 +224,8 @@ struct sub_group_mask {
       : Bits(rhs.Bits), bits_num(rhs.bits_num) {}
 
   template <typename Group>
-  friend 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,
@@ -266,8 +266,8 @@ struct sub_group_mask {
 };
 
 template <typename Group>
-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 607b03d091ac7..4097928ba5108 100644
--- a/sycl/include/sycl/group.hpp
+++ b/sycl/include/sycl/group.hpp
@@ -281,10 +281,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
@@ -304,7 +304,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)>;
@@ -322,7 +322,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)>;
@@ -341,7 +341,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 {
@@ -361,7 +361,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 {
@@ -422,21 +422,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] * groupRange[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] * groupRange[1] * groupRange[2]) +
@@ -444,55 +444,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];
   }
@@ -508,7 +508,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 05e335cb9200a..e521e624a6820 100644
--- a/sycl/include/sycl/group_algorithm.hpp
+++ b/sycl/include/sycl/group_algorithm.hpp
@@ -134,14 +134,14 @@ using is_plus_if_complex =
 // 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<!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>;
 }
 
@@ -171,10 +171,10 @@ 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_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_native_op<T, BinaryOperation>::value),
+                 T>
 reduce_over_group(Group, T x, BinaryOperation binary_op) {
   // FIXME: Do not special-case for half precision
   static_assert(
@@ -195,11 +195,11 @@ reduce_over_group(Group, 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;
@@ -216,10 +216,10 @@ reduce_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<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<T>::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(
@@ -238,7 +238,7 @@ reduce_over_group(Group g, T 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) &&
@@ -264,12 +264,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<V>::value &&
-                     detail::is_vector_arithmetic<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<V>::value &&
+                  detail::is_vector_arithmetic<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(
@@ -293,7 +293,7 @@ reduce_over_group(Group g, V x, T init, BinaryOperation binary_op) {
 
 // ---- joint_reduce
 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 &&
@@ -316,7 +316,7 @@ joint_reduce(Group g, Ptr first, Ptr last, BinaryOperation binary_op) {
 }
 
 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 &&
@@ -352,7 +352,7 @@ joint_reduce(Group g, Ptr first, Ptr last, T init, 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, bool pred) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::GroupAny<Group>(pred);
@@ -364,14 +364,14 @@ any_of_group(Group, 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__
@@ -391,7 +391,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, bool pred) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::GroupAll<Group>(pred);
@@ -403,14 +403,14 @@ all_of_group(Group, 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__
@@ -430,7 +430,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, bool pred) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::GroupAll<Group>(!pred);
@@ -442,14 +442,14 @@ none_of_group(Group, 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__
@@ -468,10 +468,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);
@@ -487,10 +487,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);
@@ -506,10 +506,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);
@@ -525,10 +525,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);
@@ -544,10 +544,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, T x, typename Group::id_type local_id) {
 #ifdef __SYCL_DEVICE_ONLY__
   return sycl::detail::spirv::GroupBroadcast<Group>(x, local_id);
@@ -560,10 +560,10 @@ group_broadcast(Group, 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(
@@ -579,10 +579,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);
@@ -599,10 +599,10 @@ 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_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_native_op<T, BinaryOperation>::value),
+                 T>
 exclusive_scan_over_group(Group, 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 ||
@@ -622,11 +622,11 @@ exclusive_scan_over_group(Group, 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;
@@ -643,10 +643,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<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<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(
@@ -665,12 +665,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<V>::value &&
-                     detail::is_vector_arithmetic<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<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_over_group(Group g, V x, T init, BinaryOperation binary_op) {
   // FIXME: Do not special-case for half precision
   static_assert(
@@ -687,7 +687,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) &&
@@ -723,7 +723,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<
@@ -780,7 +780,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<
@@ -810,10 +810,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<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<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(
@@ -830,10 +830,10 @@ 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_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_native_op<T, BinaryOperation>::value),
+                 T>
 inclusive_scan_over_group(Group, 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 ||
@@ -852,11 +852,11 @@ inclusive_scan_over_group(Group, 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;
@@ -875,7 +875,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) &&
@@ -903,12 +903,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<V>::value &&
-                     detail::is_vector_arithmetic<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<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_over_group(Group g, V x, BinaryOperation binary_op, T init) {
   // FIXME: Do not special-case for half precision
   static_assert(
@@ -926,7 +926,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<
@@ -982,7 +982,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 f679f64db82fa..5456b36721a9b 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -171,8 +171,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)());
@@ -182,8 +182,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)
@@ -220,7 +220,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());
@@ -269,7 +269,7 @@ class RoundedRangeKernelWithKH {
   KernelType KernelFunc;
 };
 
-using sycl::detail::enable_if_t;
+using std::enable_if_t;
 using sycl::detail::queue_impl;
 
 } // namespace detail
@@ -464,7 +464,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) {
@@ -734,7 +734,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 &&
@@ -765,7 +765,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)
@@ -786,7 +786,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();
@@ -806,7 +806,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) {
     single_task<class __copyAcc2Ptr<TSrc, TDst, Dim, AccMode, AccTarget, IsPH>>(
@@ -822,7 +822,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();
@@ -841,7 +841,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>>(
@@ -1410,11 +1410,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<detail::remove_reference_t<FuncT>,
+                                              void()>::value ||
+                   detail::check_fn_signature<detail::remove_reference_t<FuncT>,
+                                              void(interop_handle)>::value>
   host_task_impl(FuncT &&Func) {
     throwIfActionIsCreated();
 
@@ -1520,7 +1519,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));
   }
@@ -1594,11 +1593,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<detail::remove_reference_t<FuncT>,
+                                              void()>::value ||
+                   detail::check_fn_signature<detail::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 eb78bc69b9b1a..281f10d67e649 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,7 +45,7 @@ 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>;
 #endif // __SYCL_DISABLE_ID_TO_INT_CONV__
diff --git a/sycl/include/sycl/image.hpp b/sycl/include/sycl/image.hpp
index 682291eb06f54..9334e476cdd2a 100644
--- a/sycl/include/sycl/image.hpp
+++ b/sycl/include/sycl/image.hpp
@@ -75,7 +75,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 {
@@ -201,7 +201,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),
@@ -213,7 +213,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),
@@ -261,7 +261,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),
@@ -274,7 +274,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),
@@ -305,7 +305,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),
@@ -318,7 +318,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),
@@ -367,7 +367,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());
   }
@@ -417,7 +417,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/item.hpp b/sycl/include/sycl/item.hpp
index 100250567ab03..152545704baee 100644
--- a/sycl/include/sycl/item.hpp
+++ b/sycl/include/sycl/item.hpp
@@ -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 44ab6995fdfb4..f182b84e4cc7b 100644
--- a/sycl/include/sycl/kernel_bundle.hpp
+++ b/sycl/include/sycl/kernel_bundle.hpp
@@ -256,7 +256,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);
   }
@@ -276,7 +276,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/multi_ptr.hpp b/sycl/include/sycl/multi_ptr.hpp
index e852330f8a5b1..db61c79e4ad98 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 ||
@@ -132,7 +132,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)>>
@@ -143,7 +143,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)>>
@@ -166,7 +166,7 @@ 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 ||
@@ -184,7 +184,7 @@ 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) &&
@@ -199,7 +199,7 @@ class multi_ptr {
   // 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) &&
@@ -330,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 ||
@@ -347,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);
@@ -434,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)>>
@@ -448,7 +448,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>
@@ -459,7 +459,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)
       : multi_ptr(Accessor.get_pointer().get()) {}
@@ -478,7 +478,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>{
@@ -501,7 +501,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 ||
@@ -559,7 +559,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)>>
@@ -573,7 +573,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>
@@ -584,7 +584,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)
       : multi_ptr(Accessor.get_pointer().get()) {}
@@ -625,7 +625,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 ||
@@ -676,7 +676,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
@@ -705,7 +705,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;
@@ -750,7 +750,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 ||
@@ -765,7 +765,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,
@@ -782,7 +782,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,
@@ -807,7 +807,7 @@ 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 ||
@@ -823,7 +823,7 @@ 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) &&
@@ -837,7 +837,7 @@ 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) &&
@@ -851,7 +851,7 @@ 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(
@@ -869,7 +869,7 @@ 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,
                             access::decorated::legacy>> &ETP)
@@ -885,9 +885,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>(
@@ -898,9 +898,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>(
@@ -957,7 +957,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)>>
@@ -974,7 +974,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);
@@ -1055,7 +1055,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 ||
@@ -1069,7 +1069,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,
@@ -1081,7 +1081,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)
@@ -1091,7 +1091,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,
@@ -1198,7 +1198,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 ||
@@ -1212,7 +1212,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,
@@ -1224,7 +1224,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)
@@ -1234,7 +1234,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 4ede2121255d6..9f19e91220ab4 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 e364edc3ce481..1cd6f5fd81543 100644
--- a/sycl/include/sycl/property_list.hpp
+++ b/sycl/include/sycl/property_list.hpp
@@ -33,7 +33,7 @@ class property_list : protected detail::PropertyListBase {
                               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/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 9916cd5c8ffd9..4547c4958ed47 100644
--- a/sycl/include/sycl/reduction.hpp
+++ b/sycl/include/sycl/reduction.hpp
@@ -178,45 +178,45 @@ 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>
+  std::enable_if_t<(_Dims == 0) && IsPlus<_T, BinaryOp>::value &&
+                   is_geninteger<_T>::value>
   operator++() {
     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>
+  std::enable_if_t<(_Dims == 0) && IsPlus<_T, BinaryOp>::value &&
+                   is_geninteger<_T>::value>
   operator++(int) {
     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>
+  std::enable_if_t<(_Dims == 0) && IsPlus<_T, BinaryOp>::value>
   operator+=(const _T &Partial) {
     static_cast<Reducer *>(this)->combine(Partial);
   }
 
   template <typename _T = Ty, int _Dims = Dims>
-  enable_if_t<(_Dims == 0) && IsMultiplies<_T, BinaryOp>::value>
+  std::enable_if_t<(_Dims == 0) && IsMultiplies<_T, BinaryOp>::value>
   operator*=(const _T &Partial) {
     static_cast<Reducer *>(this)->combine(Partial);
   }
 
   template <typename _T = Ty, int _Dims = Dims>
-  enable_if_t<(_Dims == 0) && IsBitOR<_T, BinaryOp>::value>
+  std::enable_if_t<(_Dims == 0) && IsBitOR<_T, BinaryOp>::value>
   operator|=(const _T &Partial) {
     static_cast<Reducer *>(this)->combine(Partial);
   }
 
   template <typename _T = Ty, int _Dims = Dims>
-  enable_if_t<(_Dims == 0) && IsBitXOR<_T, BinaryOp>::value>
+  std::enable_if_t<(_Dims == 0) && IsBitXOR<_T, BinaryOp>::value>
   operator^=(const _T &Partial) {
     static_cast<Reducer *>(this)->combine(Partial);
   }
 
   template <typename _T = Ty, int _Dims = Dims>
-  enable_if_t<(_Dims == 0) && IsBitAND<_T, BinaryOp>::value>
+  std::enable_if_t<(_Dims == 0) && IsBitAND<_T, BinaryOp>::value>
   operator&=(const _T &Partial) {
     static_cast<Reducer *>(this)->combine(Partial);
   }
@@ -250,10 +250,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); });
@@ -262,9 +262,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); });
@@ -273,9 +273,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); });
@@ -284,11 +284,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); });
@@ -297,10 +297,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); });
@@ -309,10 +309,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); });
@@ -478,14 +478,14 @@ template <typename T, class BinaryOperation> class reduction_impl_common {
 public:
   /// Returns the statically known identity value.
   template <typename _T = T, class _BinaryOperation = BinaryOperation>
-  enable_if_t<IsKnownIdentityOp<_T, _BinaryOperation>::value,
-              _T> constexpr getIdentity() {
+  std::enable_if_t<IsKnownIdentityOp<_T, _BinaryOperation>::value,
+                   _T> constexpr getIdentity() {
     return known_identity_impl<_BinaryOperation, _T>::value;
   }
 
   /// Returns the identity value given by user.
   template <typename _T = T, class _BinaryOperation = BinaryOperation>
-  enable_if_t<!IsKnownIdentityOp<_T, _BinaryOperation>::value, _T>
+  std::enable_if_t<!IsKnownIdentityOp<_T, _BinaryOperation>::value, _T>
   getIdentity() {
     return MIdentity;
   }
@@ -745,8 +745,8 @@ class reduction_impl
   static_assert(Dims <= 1, "Multi-dimensional reductions are not supported.");
 
   /// Constructs reduction_impl when the identity value is statically known.
-  template <typename _self = self,
-            enable_if_t<_self::is_known_identity && !_self::is_usm> * = nullptr>
+  template <typename _self = self, std::enable_if_t<_self::is_known_identity &&
+                                                    !_self::is_usm> * = nullptr>
   reduction_impl(RedOutVar &Acc)
       : algo(reducer_type::getIdentity(), BinaryOperation(), false, Acc) {
     if (Acc.size() != 1)
@@ -759,8 +759,8 @@ class reduction_impl
   /// The \param VarPtr is a USM pointer to memory, to where the computed
   /// reduction value is added using BinaryOperation, i.e. it is expected that
   /// the memory is pre-initialized with some meaningful value.
-  template <typename _self = self,
-            enable_if_t<_self::is_known_identity && _self::is_usm> * = nullptr>
+  template <typename _self = self, std::enable_if_t<_self::is_known_identity &&
+                                                    _self::is_usm> * = nullptr>
   reduction_impl(RedOutVar VarPtr, bool InitializeToIdentity = false)
       : algo(reducer_type::getIdentity(), BinaryOperation(),
              InitializeToIdentity, VarPtr) {}
@@ -780,7 +780,7 @@ class reduction_impl
   }
 
   /// Constructs reduction_impl when the identity value is unknown.
-  template <typename _self = self, enable_if_t<!_self::is_usm> * = nullptr>
+  template <typename _self = self, std::enable_if_t<!_self::is_usm> * = nullptr>
   reduction_impl(RedOutVar &Acc, const T &Identity, BinaryOperation BOp)
       : algo(chooseIdentity(Identity), BOp, false, Acc) {
     if (Acc.size() != 1)
@@ -792,13 +792,13 @@ class reduction_impl
   /// The \param VarPtr is a USM pointer to memory, to where the computed
   /// reduction value is added using BinaryOperation, i.e. it is expected that
   /// the memory is pre-initialized with some meaningful value.
-  template <typename _self = self, enable_if_t<_self::is_usm> * = nullptr>
+  template <typename _self = self, std::enable_if_t<_self::is_usm> * = nullptr>
   reduction_impl(RedOutVar VarPtr, const T &Identity, BinaryOperation BOp,
                  bool InitializeToIdentity = false)
       : algo(chooseIdentity(Identity), BOp, InitializeToIdentity, VarPtr) {}
 
   /// For placeholder accessor.
-  template <typename _self = self, enable_if_t<!_self::is_usm> * = nullptr>
+  template <typename _self = self, std::enable_if_t<!_self::is_usm> * = nullptr>
   reduction_impl(RedOutVar &Acc, handler &CGH, const T &Identity,
                  BinaryOperation BOp, bool InitializeToIdentity)
       : algo(chooseIdentity(Identity), BOp, InitializeToIdentity, Acc) {
diff --git a/sycl/include/sycl/stream.hpp b/sycl/include/sycl/stream.hpp
index b7ddd879ce1f8..8be8a998290b5 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
 
@@ -918,8 +918,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 &);
@@ -1000,8 +1000,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 836aa303f0b7c..7ceb1cb20041d 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -263,7 +263,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;
 }
 
@@ -273,11 +273,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);
 }
@@ -285,7 +284,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:
@@ -333,7 +332,7 @@ using Rtn = detail::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);
@@ -343,12 +342,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, 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, 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);                            \
@@ -365,10 +364,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, 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, cl_##DestType>::value,            \
+                   R>                                                          \
   convertImpl(T Value) {                                                       \
     OpenCLT OpValue = sycl::detail::convertDataToType<T, OpenCLT>(Value);      \
     return __spirv_UConvert##_R##DestType(OpValue);                            \
@@ -384,10 +383,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);
 }
@@ -396,11 +395,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);                    \
@@ -416,11 +415,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);                    \
@@ -437,13 +436,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);           \
@@ -468,12 +467,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, 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, 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);   \
@@ -507,7 +506,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,
@@ -657,12 +656,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>;
 
 public:
   using element_type = DataT;
@@ -688,7 +687,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 &>
@@ -699,13 +698,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,
@@ -717,7 +716,7 @@ template <typename Type, int NumElements> class vec {
   }
 
   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,
       vec &>
@@ -734,7 +733,7 @@ template <typename Type, int NumElements> class vec {
   }
 
   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,
       vec &>
@@ -752,7 +751,7 @@ template <typename Type, int NumElements> class vec {
   }
 
   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,
       vec &>
@@ -771,7 +770,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,
@@ -835,7 +834,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) {}
@@ -844,7 +843,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);
   }
 
@@ -1000,7 +999,7 @@ 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),     \
@@ -1013,7 +1012,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;                                                              \
@@ -1028,7 +1027,7 @@ 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),     \
@@ -1041,7 +1040,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;                                                              \
@@ -1087,11 +1086,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));                \
   }
@@ -1106,11 +1104,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));                \
   }
@@ -1148,7 +1145,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.
@@ -1252,51 +1249,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>>
   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>>
   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>>
   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);
   }
@@ -1386,7 +1383,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
 
@@ -1429,21 +1426,21 @@ 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)>;
 
   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)>;
@@ -1546,7 +1543,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;
@@ -1718,10 +1715,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) {
@@ -1730,10 +1727,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) {
@@ -1981,7 +1978,7 @@ 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,       \
       vec<T, Num>>                                                             \
@@ -1992,7 +1989,7 @@ 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),     \
@@ -2035,7 +2032,7 @@ __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),     \
@@ -2047,7 +2044,7 @@ __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),     \
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 5105b7a263e3a..960a023c71ddb 100644
--- a/sycl/source/detail/builtins_geometric.cpp
+++ b/sycl/source/detail/builtins_geometric.cpp
@@ -58,47 +58,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/scheduler/graph_builder.cpp b/sycl/source/detail/scheduler/graph_builder.cpp
index 531c416642b03..79f7f1c2f8346 100644
--- a/sycl/source/detail/scheduler/graph_builder.cpp
+++ b/sycl/source/detail/scheduler/graph_builder.cpp
@@ -841,7 +841,7 @@ void Scheduler::GraphBuilder::markModifiedIfWrite(MemObjRecord *Record,
 }
 
 template <typename T>
-typename detail::enable_if_t<
+typename std::enable_if_t<
     std::is_same<typename std::remove_cv_t<T>, Requirement>::value,
     EmptyCommand *>
 Scheduler::GraphBuilder::addEmptyCmd(Command *Cmd, const std::vector<T *> &Reqs,
diff --git a/sycl/source/detail/scheduler/scheduler.hpp b/sycl/source/detail/scheduler/scheduler.hpp
index a09a79c846f88..b6c4fb94be809 100644
--- a/sycl/source/detail/scheduler/scheduler.hpp
+++ b/sycl/source/detail/scheduler/scheduler.hpp
@@ -623,7 +623,7 @@ class Scheduler {
                                        const ContextImplPtr &Context);
 
     template <typename T>
-    typename detail::enable_if_t<
+    typename std::enable_if_t<
         std::is_same<typename std::remove_cv_t<T>, Requirement>::value,
         EmptyCommand *>
     addEmptyCmd(Command *Cmd, const std::vector<T *> &Req,
diff --git a/sycl/source/detail/sycl_mem_obj_t.hpp b/sycl/source/detail/sycl_mem_obj_t.hpp
index 69335f5ab72dc..54098bbc019df 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: