diff --git a/sycl/include/sycl/accessor.hpp b/sycl/include/sycl/accessor.hpp
index 485753e2af549..5ff42e386699a 100644
--- a/sycl/include/sycl/accessor.hpp
+++ b/sycl/include/sycl/accessor.hpp
@@ -22,7 +22,6 @@
 #include <sycl/detail/owner_less_base.hpp>            // for OwnerLessBase
 #include <sycl/detail/property_helper.hpp>            // for PropWithDataKind
 #include <sycl/detail/property_list_base.hpp>         // for PropertyListBase
-#include <sycl/detail/type_list.hpp>                  // for is_contained
 #include <sycl/detail/type_traits.hpp>                // for const_if_const_AS
 #include <sycl/exception.hpp>                         // for make_error_code
 #include <sycl/ext/oneapi/accessor_property_list.hpp> // for accessor_prope...
diff --git a/sycl/include/sycl/builtins_utils_scalar.hpp b/sycl/include/sycl/builtins_utils_scalar.hpp
index ff567bfea2b15..7e1c992ad073f 100644
--- a/sycl/include/sycl/builtins_utils_scalar.hpp
+++ b/sycl/include/sycl/builtins_utils_scalar.hpp
@@ -12,7 +12,6 @@
 #include <sycl/aliases.hpp>
 #include <sycl/detail/defines_elementary.hpp>
 #include <sycl/detail/generic_type_traits.hpp>
-#include <sycl/detail/type_list.hpp>
 #include <sycl/detail/type_traits.hpp>
 #include <sycl/half_type.hpp>
 #include <sycl/multi_ptr.hpp>
diff --git a/sycl/include/sycl/detail/generic_type_traits.hpp b/sycl/include/sycl/detail/generic_type_traits.hpp
index 6d00a39304d0c..d8ac96e240e9b 100644
--- a/sycl/include/sycl/detail/generic_type_traits.hpp
+++ b/sycl/include/sycl/detail/generic_type_traits.hpp
@@ -11,7 +11,6 @@
 #include <sycl/access/access.hpp>             // for decorated, address_space
 #include <sycl/aliases.hpp>                   // for half, cl_char, cl_double
 #include <sycl/detail/helpers.hpp>            // for marray
-#include <sycl/detail/type_list.hpp>          // for is_contained, find_sam...
 #include <sycl/detail/type_traits.hpp>        // for is_gen_based_on_type_s...
 #include <sycl/half_type.hpp>                 // for BIsRepresentationT
 #include <sycl/multi_ptr.hpp>                 // for multi_ptr, address_spa...
diff --git a/sycl/include/sycl/detail/image_accessor_util.hpp b/sycl/include/sycl/detail/image_accessor_util.hpp
index 49dacd704a748..d87038a8c9ce3 100644
--- a/sycl/include/sycl/detail/image_accessor_util.hpp
+++ b/sycl/include/sycl/detail/image_accessor_util.hpp
@@ -18,7 +18,6 @@
 #include <sycl/detail/array.hpp>               // for array
 #include <sycl/detail/export.hpp>              // for __SYCL_EXPORT
 #include <sycl/detail/generic_type_traits.hpp> // for max_v, min_v, TryToGe...
-#include <sycl/detail/type_list.hpp>           // for is_contained, type_list
 #include <sycl/exception.hpp>
 #include <sycl/id.hpp>                         // for id
 #include <sycl/image.hpp>                      // for image_channel_type
@@ -35,26 +34,25 @@ inline namespace _V1 {
 namespace detail {
 
 template <typename T>
-using IsValidCoordType = typename is_contained<
-    T, boost::mp11::mp_unique<type_list<opencl::cl_int, opencl::cl_float,
-                                        std::int32_t, float>>>::type;
+inline constexpr bool is_valid_coord_type_v =
+    check_type_in_v<T, opencl::cl_int, opencl::cl_float, std::int32_t, float>;
 
 // The formula for unnormalization coordinates:
 // NormalizedCoords = [UnnormalizedCoords[i] * Range[i] for i in range(0, 3)]
 template <typename T>
-std::enable_if_t<IsValidCoordType<T>::value, T>
+std::enable_if_t<is_valid_coord_type_v<T>, T>
 UnnormalizeCoordinates(const T &Coords, const range<3> &Range) {
   return Coords * Range[0];
 }
 
 template <typename T>
-std::enable_if_t<IsValidCoordType<T>::value, vec<T, 2>>
+std::enable_if_t<is_valid_coord_type_v<T>, 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>
-std::enable_if_t<IsValidCoordType<T>::value, vec<T, 4>>
+std::enable_if_t<is_valid_coord_type_v<T>, 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};
@@ -65,19 +63,19 @@ UnnormalizeCoordinates(const vec<T, 4> &Coords, const range<3> &Range) {
 // calculation won't pass 0.
 // Non-valid coordinates are written as 0.
 template <typename T>
-std::enable_if_t<IsValidCoordType<T>::value, float4> convertToFloat4(T Coords) {
+std::enable_if_t<is_valid_coord_type_v<T>, float4> convertToFloat4(T Coords) {
   return {static_cast<float>(Coords), 0.5f, 0.5f, 0.f};
 }
 
 template <typename T>
-std::enable_if_t<IsValidCoordType<T>::value, float4>
+std::enable_if_t<is_valid_coord_type_v<T>, float4>
 convertToFloat4(vec<T, 2> Coords) {
   return {static_cast<float>(Coords.x()), static_cast<float>(Coords.y()), 0.5f,
           0.f};
 }
 
 template <typename T>
-std::enable_if_t<IsValidCoordType<T>::value, float4>
+std::enable_if_t<is_valid_coord_type_v<T>, float4>
 convertToFloat4(vec<T, 4> Coords) {
   return {static_cast<float>(Coords.x()), static_cast<float>(Coords.y()),
           static_cast<float>(Coords.z()), 0.f};
diff --git a/sycl/include/sycl/detail/spirv.hpp b/sycl/include/sycl/detail/spirv.hpp
index 32d87c7562b77..ad59d129622b9 100644
--- a/sycl/include/sycl/detail/spirv.hpp
+++ b/sycl/include/sycl/detail/spirv.hpp
@@ -796,13 +796,11 @@ AtomicMax(multi_ptr<T, AddressSpace, IsDecorated> MPtr, memory_scope Scope,
 //   variants for all scalar types
 #ifndef __NVPTX__
 
-using ProhibitedTypesForShuffleEmulation =
-    type_list<double, long, long long, unsigned long, unsigned long long, half>;
-
 template <typename T>
 struct TypeIsProhibitedForShuffleEmulation
-    : std::bool_constant<is_contained<
-          vector_element_t<T>, ProhibitedTypesForShuffleEmulation>::value> {};
+    : std::bool_constant<
+          check_type_in_v<vector_element_t<T>, double, long, long long,
+                          unsigned long, unsigned long long, half>> {};
 
 template <typename T>
 struct VecTypeIsProhibitedForShuffleEmulation
diff --git a/sycl/include/sycl/detail/type_list.hpp b/sycl/include/sycl/detail/type_list.hpp
deleted file mode 100644
index 86d83b296ff93..0000000000000
--- a/sycl/include/sycl/detail/type_list.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//==----------- type_list.hpp - SYCL list of types utils -------------------==//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include <sycl/access/access.hpp> // for address_space
-
-#include <type_traits> // for bool_constant, conditional_t, fals...
-
-#include <sycl/detail/boost/mp11/algorithm.hpp>
-#include <sycl/detail/boost/mp11/set.hpp>
-
-namespace sycl {
-inline namespace _V1 {
-namespace detail {
-
-template <class... T> using type_list = boost::mp11::mp_list<T...>;
-
-using empty_type_list = type_list<>;
-
-template <typename T>
-using is_empty_type_list = std::is_same<T, empty_type_list>;
-
-// is_contained
-template <typename T, typename TypeList>
-using is_contained =
-    boost::mp11::mp_set_contains<TypeList, std::remove_cv_t<T>>;
-template <typename T, typename TypeList>
-inline constexpr bool is_contained_v = is_contained<T, TypeList>::value;
-
-// type list append
-template <class... L> using tl_append = boost::mp11::mp_append<L...>;
-
-// value_list
-template <typename T, T... Values> struct value_list;
-
-template <typename T, T Head, T... Tail> struct value_list<T, Head, Tail...> {
-  static constexpr T head = Head;
-  using tail = value_list<T, Tail...>;
-};
-
-template <typename T> struct value_list<T> {};
-
-template <typename T> using tail_t = typename T::tail;
-
-// is_contained_value
-template <typename T, T Value, typename ValueList>
-struct is_contained_value
-    : std::conditional_t<Value == ValueList::head, std::true_type,
-                         is_contained_value<T, Value, tail_t<ValueList>>> {};
-
-template <typename T, T Value>
-struct is_contained_value<T, Value, value_list<T>> : std::false_type {};
-
-//  address_space_list
-template <access::address_space... Values>
-using address_space_list = value_list<access::address_space, Values...>;
-
-template <access::address_space AddressSpace, typename ValueList>
-using is_one_of_spaces =
-    is_contained_value<access::address_space, AddressSpace, ValueList>;
-
-// size type predicates
-template <typename T1, typename T2>
-struct is_type_size_equal : std::bool_constant<(sizeof(T1) == sizeof(T2))> {};
-
-// find required type
-template <typename TypeList, template <typename, typename> class Comp,
-          typename T>
-struct find_type {
-  template <class T2> using C = Comp<T2, T>; // bind back
-  using l = boost::mp11::mp_copy_if<TypeList, C>;
-  using type = boost::mp11::mp_eval_if<is_empty_type_list<l>, void,
-                                       boost::mp11::mp_front, l>;
-};
-
-template <typename TypeList, template <typename, typename> class Comp,
-          typename T>
-using find_type_t = typename find_type<TypeList, Comp, T>::type;
-
-template <typename TypeList, typename T>
-using find_same_size_type_t = find_type_t<TypeList, is_type_size_equal, T>;
-
-} // namespace detail
-} // namespace _V1
-} // namespace sycl
diff --git a/sycl/include/sycl/detail/type_traits.hpp b/sycl/include/sycl/detail/type_traits.hpp
index df5f9ea53a045..63bdc88ff4ba1 100644
--- a/sycl/include/sycl/detail/type_traits.hpp
+++ b/sycl/include/sycl/detail/type_traits.hpp
@@ -10,8 +10,7 @@
 
 #include <sycl/detail/type_traits/vec_marray_traits.hpp>
 
-#include <sycl/access/access.hpp>             // for decorated, address_space
-#include <sycl/detail/type_list.hpp>          // for is_contained, find_twi...
+#include <sycl/access/access.hpp> // for decorated, address_space
 
 #include <array>       // for array
 #include <cstddef>     // for size_t
diff --git a/sycl/include/sycl/detail/vector_arith.hpp b/sycl/include/sycl/detail/vector_arith.hpp
index 4267febad8e30..d592c4a7e0b68 100644
--- a/sycl/include/sycl/detail/vector_arith.hpp
+++ b/sycl/include/sycl/detail/vector_arith.hpp
@@ -10,7 +10,6 @@
 
 #include <sycl/aliases.hpp>                    // for half, cl_char, cl_int
 #include <sycl/detail/generic_type_traits.hpp> // for is_sigeninteger, is_s...
-#include <sycl/detail/type_list.hpp>           // for is_contained
 #include <sycl/detail/type_traits.hpp>         // for is_floating_point
 
 #include <sycl/ext/oneapi/bfloat16.hpp> // bfloat16
diff --git a/sycl/include/sycl/group_algorithm.hpp b/sycl/include/sycl/group_algorithm.hpp
index ed373a95eef41..e3192a481bdb1 100644
--- a/sycl/include/sycl/group_algorithm.hpp
+++ b/sycl/include/sycl/group_algorithm.hpp
@@ -11,7 +11,6 @@
 #include <sycl/detail/array.hpp>       // for array
 #include <sycl/detail/helpers.hpp>     // for loop
 #include <sycl/detail/item_base.hpp>   // for id, range
-#include <sycl/detail/type_list.hpp>   // for is_contained, type_list
 #include <sycl/detail/type_traits.hpp> // for remove_pointer, is_pointer
 #include <sycl/exception.hpp>          // for make_error_code, errc, exception
 #include <sycl/functional.hpp>         // for plus, multiplies, maximum
@@ -82,19 +81,18 @@ template <typename Group> inline auto get_local_linear_id(Group g) {
 }
 
 // ---- is_native_op
-template <typename T>
-using native_op_list =
-    type_list<sycl::plus<T>, sycl::bit_or<T>, sycl::bit_xor<T>,
-              sycl::bit_and<T>, sycl::maximum<T>, sycl::minimum<T>,
-              sycl::multiplies<T>, sycl::logical_or<T>, sycl::logical_and<T>>;
+template <typename BinaryOperation, typename T>
+inline constexpr bool is_native_binop_on_v =
+    check_type_in_v<BinaryOperation, sycl::plus<T>, sycl::bit_or<T>,
+                    sycl::bit_xor<T>, sycl::bit_and<T>, sycl::maximum<T>,
+                    sycl::minimum<T>, sycl::multiplies<T>, sycl::logical_or<T>,
+                    sycl::logical_and<T>>;
 
 template <typename T, typename BinaryOperation> struct is_native_op {
   static constexpr bool value =
-      is_contained<BinaryOperation,
-                   native_op_list<std::remove_const_t<T>>>::value ||
-      is_contained<BinaryOperation,
-                   native_op_list<std::add_const_t<T>>>::value ||
-      is_contained<BinaryOperation, native_op_list<void>>::value;
+      is_native_binop_on_v<BinaryOperation, std::remove_const_t<T>> ||
+      is_native_binop_on_v<BinaryOperation, std::add_const_t<T>> ||
+      is_native_binop_on_v<BinaryOperation, void>;
 };
 
 // ---- is_plus
diff --git a/sycl/include/sycl/image.hpp b/sycl/include/sycl/image.hpp
index 386fe93d3e41d..45cfb884dae3f 100644
--- a/sycl/include/sycl/image.hpp
+++ b/sycl/include/sycl/image.hpp
@@ -22,7 +22,6 @@
 #include <sycl/detail/owner_less_base.hpp>            // for OwnerLessBase
 #include <sycl/detail/stl_type_traits.hpp>            // for iterator_value...
 #include <sycl/detail/sycl_mem_obj_allocator.hpp>     // for SYCLMemObjAllo...
-#include <sycl/detail/type_list.hpp>                  // for is_contained
 #include <sycl/event.hpp>                             // for event
 #include <sycl/exception.hpp>                         // for make_error_code
 #include <sycl/ext/oneapi/accessor_property_list.hpp> // for accessor_prope...
@@ -112,15 +111,12 @@ namespace detail {
 
 class image_impl;
 
-// validImageDataT: cl_int4, cl_uint4, cl_float4, cl_half4
-template <typename T>
-using is_validImageDataT = typename detail::is_contained<
-    T, type_list<vec<opencl::cl_int, 4>, vec<opencl::cl_uint, 4>,
-                 vec<opencl::cl_float, 4>, vec<opencl::cl_half, 4>>>::type;
-
+// Valid image DataT: cl_int4, cl_uint4, cl_float4, cl_half4
 template <typename DataT>
-using EnableIfImgAccDataT =
-    typename std::enable_if_t<is_validImageDataT<DataT>::value, DataT>;
+using EnableIfImgAccDataT = typename std::enable_if_t<
+    check_type_in_v<DataT, vec<opencl::cl_int, 4>, vec<opencl::cl_uint, 4>,
+                    vec<opencl::cl_float, 4>, vec<opencl::cl_half, 4>>,
+    DataT>;
 
 inline image_channel_type FormatChannelType(image_format Format) {
   switch (Format) {
diff --git a/sycl/include/sycl/types.hpp b/sycl/include/sycl/types.hpp
index 599ba89819241..ed5432a912af1 100644
--- a/sycl/include/sycl/types.hpp
+++ b/sycl/include/sycl/types.hpp
@@ -14,7 +14,6 @@
 #include <sycl/detail/defines_elementary.hpp>  // for __SYCL2020_DEPRECATED
 #include <sycl/detail/generic_type_traits.hpp> // for is_sigeninteger, is_s...
 #include <sycl/detail/is_device_copyable.hpp>
-#include <sycl/detail/type_list.hpp>           // for is_contained
 #include <sycl/detail/type_traits.hpp>         // for is_floating_point
 #include <sycl/exception.hpp>                  // for make_error_code, errc
 #include <sycl/half_type.hpp>                  // for StorageT, half, Vec16...
diff --git a/sycl/test/include_deps/sycl_accessor.hpp.cpp b/sycl/test/include_deps/sycl_accessor.hpp.cpp
index 46979fdd721b2..6f961731eebfe 100644
--- a/sycl/test/include_deps/sycl_accessor.hpp.cpp
+++ b/sycl/test/include_deps/sycl_accessor.hpp.cpp
@@ -25,42 +25,14 @@
 // CHECK-NEXT: info/aspects_deprecated.def
 // CHECK-NEXT: detail/type_traits.hpp
 // CHECK-NEXT: detail/type_traits/vec_marray_traits.hpp
-// CHECK-NEXT: detail/type_list.hpp
-// CHECK-NEXT: detail/boost/mp11/algorithm.hpp
-// CHECK-NEXT: detail/boost/mp11/list.hpp
-// CHECK-NEXT: detail/boost/mp11/integral.hpp
-// CHECK-NEXT: detail/boost/mp11/version.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_value.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/config.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_list.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_list_v.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_is_list.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_is_value_list.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_front.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_rename.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_defer.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_append.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_count.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_plus.hpp
-// CHECK-NEXT: detail/boost/mp11/utility.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_fold.hpp
-// CHECK-NEXT: detail/boost/mp11/set.hpp
-// CHECK-NEXT: detail/boost/mp11/function.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_min_element.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_void.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_copy_if.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_remove_if.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_map_find.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_with_index.hpp
-// CHECK-NEXT: stl_wrappers/cassert
-// CHECK-NEXT: stl_wrappers/assert.h
-// CHECK-NEXT: detail/boost/mp11/integer_sequence.hpp
 // CHECK-NEXT: buffer.hpp
 // CHECK-NEXT: backend_types.hpp
 // CHECK-NEXT: detail/array.hpp
 // CHECK-NEXT: exception.hpp
 // CHECK-NEXT: detail/string.hpp
 // CHECK-NEXT: detail/common.hpp
+// CHECK-NEXT: stl_wrappers/cassert
+// CHECK-NEXT: stl_wrappers/assert.h
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
diff --git a/sycl/test/include_deps/sycl_detail_core.hpp.cpp b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
index c7f905b222dd9..4abe5f39073c7 100644
--- a/sycl/test/include_deps/sycl_detail_core.hpp.cpp
+++ b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
@@ -26,42 +26,14 @@
 // CHECK-NEXT: info/aspects_deprecated.def
 // CHECK-NEXT: detail/type_traits.hpp
 // CHECK-NEXT: detail/type_traits/vec_marray_traits.hpp
-// CHECK-NEXT: detail/type_list.hpp
-// CHECK-NEXT: detail/boost/mp11/algorithm.hpp
-// CHECK-NEXT: detail/boost/mp11/list.hpp
-// CHECK-NEXT: detail/boost/mp11/integral.hpp
-// CHECK-NEXT: detail/boost/mp11/version.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_value.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/config.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_list.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_list_v.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_is_list.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_is_value_list.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_front.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_rename.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_defer.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_append.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_count.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_plus.hpp
-// CHECK-NEXT: detail/boost/mp11/utility.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_fold.hpp
-// CHECK-NEXT: detail/boost/mp11/set.hpp
-// CHECK-NEXT: detail/boost/mp11/function.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_min_element.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_void.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_copy_if.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_remove_if.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_map_find.hpp
-// CHECK-NEXT: detail/boost/mp11/detail/mp_with_index.hpp
-// CHECK-NEXT: stl_wrappers/cassert
-// CHECK-NEXT: stl_wrappers/assert.h
-// CHECK-NEXT: detail/boost/mp11/integer_sequence.hpp
 // CHECK-NEXT: buffer.hpp
 // CHECK-NEXT: backend_types.hpp
 // CHECK-NEXT: detail/array.hpp
 // CHECK-NEXT: exception.hpp
 // CHECK-NEXT: detail/string.hpp
 // CHECK-NEXT: detail/common.hpp
+// CHECK-NEXT: stl_wrappers/cassert
+// CHECK-NEXT: stl_wrappers/assert.h
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
@@ -138,6 +110,33 @@
 // CHECK-NEXT: ext/oneapi/properties/property_value.hpp
 // CHECK-NEXT: ext/oneapi/properties/properties.hpp
 // CHECK-NEXT: ext/oneapi/properties/property_utils.hpp
+// CHECK-NEXT: detail/boost/mp11/algorithm.hpp
+// CHECK-NEXT: detail/boost/mp11/list.hpp
+// CHECK-NEXT: detail/boost/mp11/integral.hpp
+// CHECK-NEXT: detail/boost/mp11/version.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_value.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/config.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_list.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_list_v.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_is_list.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_is_value_list.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_front.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_rename.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_defer.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_append.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_count.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_plus.hpp
+// CHECK-NEXT: detail/boost/mp11/utility.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_fold.hpp
+// CHECK-NEXT: detail/boost/mp11/set.hpp
+// CHECK-NEXT: detail/boost/mp11/function.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_min_element.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_void.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_copy_if.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_remove_if.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_map_find.hpp
+// CHECK-NEXT: detail/boost/mp11/detail/mp_with_index.hpp
+// CHECK-NEXT: detail/boost/mp11/integer_sequence.hpp
 // CHECK-NEXT: ext/oneapi/experimental/graph.hpp
 // CHECK-NEXT: handler.hpp
 // CHECK-NEXT: detail/cl.h
diff --git a/sycl/test/type_traits/type_list.cpp b/sycl/test/type_traits/type_list.cpp
deleted file mode 100644
index 90702d4d90858..0000000000000
--- a/sycl/test/type_traits/type_list.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-// RUN: %clangxx -fsycl -fsyntax-only %s
-//==---------------- type_list.cpp - SYCL type_list test -------------------==//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include <sycl/sycl.hpp>
-
-#include <type_traits>
-
-using namespace std;
-
-namespace s = sycl;
-namespace d = sycl::detail;
-
-template <template <typename, typename> class Predicate, typename T,
-          typename T2, bool Expected = true>
-void test_predicate() {
-  static_assert(Predicate<T, T2>::value == Expected, "");
-}
-
-template <template <typename, typename> class Trait, typename TL, typename T,
-          typename ExpectedT, bool Expected = true>
-void test_trait() {
-  static_assert(is_same<Trait<TL, T>, ExpectedT>::value == Expected, "");
-}
-
-int main() {
-  // test list of types
-  using scalar_float = d::type_list<float>;
-  using vector_float = d::type_list<s::vec<float, 1>, s::vec<float, 2>>;
-  using float_list = d::tl_append<scalar_float, vector_float>;
-  using scalar_double = d::type_list<double>;
-  using vector_double = d::type_list<s::vec<double, 1>, s::vec<double, 2>>;
-  using double_list = d::tl_append<scalar_double, vector_double>;
-  using floating_list = d::tl_append<float_list, double_list>;
-
-  using scalar_int = d::type_list<int>;
-  using scalar_long = d::type_list<long>;
-  using vector_int = d::type_list<s::vec<int, 1>, s::vec<int, 2>>;
-  using vector_long = d::type_list<s::vec<long, 1>, s::vec<long, 2>>;
-  using int_list = d::tl_append<scalar_int, vector_int>;
-  using long_list = d::tl_append<scalar_long, vector_long>;
-  using integer_list = d::tl_append<int_list, long_list>;
-
-  using types = d::tl_append<floating_list, integer_list>;
-
-  static_assert(d::is_contained<float, scalar_float>::value, "");
-  static_assert(d::is_contained<s::vec<float, 2>, scalar_float>::value == false,
-                "");
-  static_assert(d::is_contained<float, vector_float>::value == false, "");
-  static_assert(d::is_contained<s::vec<float, 2>, vector_float>::value, "");
-  static_assert(d::is_contained<float, types>::value, "");
-  static_assert(d::is_contained<s::vec<float, 2>, types>::value, "");
-  static_assert(d::is_contained<bool, types>::value == false, "");
-
-  // test list of non-type
-  using my_int_list = d::value_list<int, 3, 1, -2>;
-  static_assert(my_int_list::head == 3, "");
-  static_assert(my_int_list::tail::head == 1, "");
-  static_assert(my_int_list::tail::tail::head == -2, "");
-
-  using my_bool_list = d::value_list<bool, false, true, false>;
-  static_assert(my_bool_list::head == false, "");
-  static_assert(my_bool_list::tail::head == true, "");
-  static_assert(my_bool_list::tail::tail::head == false, "");
-
-  static_assert(d::is_contained_value<int, 4, my_int_list>::value == false, "");
-  static_assert(d::is_contained_value<int, 1, my_int_list>::value, "");
-  static_assert(d::is_contained_value<bool, false, my_bool_list>::value, "");
-  static_assert(d::is_contained_value<bool, true, my_bool_list>::value, "");
-
-  test_predicate<d::is_type_size_equal, int8_t, s::opencl::cl_char>();
-  test_predicate<d::is_type_size_equal, int16_t, s::opencl::cl_char, false>();
-
-  // if void is found, the required type is not found
-  test_trait<d::find_same_size_type_t, d::type_list<int8_t>, s::opencl::cl_char,
-             int8_t>();
-  test_trait<d::find_same_size_type_t, d::type_list<int16_t>,
-             s::opencl::cl_char, void>();
-
-  return 0;
-}