diff --git a/sycl/include/sycl/accessor.hpp b/sycl/include/sycl/accessor.hpp
index ad938b2685e07..12e97e37b4729 100644
--- a/sycl/include/sycl/accessor.hpp
+++ b/sycl/include/sycl/accessor.hpp
@@ -24,7 +24,6 @@
 #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...
-#include <sycl/ext/oneapi/weak_object_base.hpp>       // for getSyclWeakObj...
 #include <sycl/id.hpp>                                // for id
 #include <sycl/multi_ptr.hpp>                         // for multi_ptr
 #include <sycl/pointers.hpp>                          // for local_ptr, glo...
diff --git a/sycl/include/sycl/detail/owner_less_base.hpp b/sycl/include/sycl/detail/owner_less_base.hpp
index dfce9a2ed74e2..1ea0feb4c2208 100644
--- a/sycl/include/sycl/detail/owner_less_base.hpp
+++ b/sycl/include/sycl/detail/owner_less_base.hpp
@@ -8,11 +8,20 @@
 
 #pragma once
 
-#include <sycl/detail/impl_utils.hpp>           // for getSyclObjImpl
-#include <sycl/ext/oneapi/weak_object_base.hpp> // for getSyclWeakObjImpl
+#include <sycl/detail/impl_utils.hpp> // for getSyclObjImpl
 
 namespace sycl {
 inline namespace _V1 {
+
+namespace ext::oneapi::detail {
+template <typename SYCLObjT> class weak_object_base;
+
+// Helper function for getting the underlying weak_ptr from a weak_object.
+template <typename SYCLObjT>
+decltype(weak_object_base<SYCLObjT>::MObjWeakPtr)
+getSyclWeakObjImpl(const weak_object_base<SYCLObjT> &WeakObj);
+} // namespace ext::oneapi::detail
+
 namespace detail {
 
 // Common CRTP base class supplying a common definition of owner-before ordering
diff --git a/sycl/include/sycl/ext/oneapi/weak_object.hpp b/sycl/include/sycl/ext/oneapi/weak_object.hpp
index 686b242b0d29c..d7a0da8d9d236 100644
--- a/sycl/include/sycl/ext/oneapi/weak_object.hpp
+++ b/sycl/include/sycl/ext/oneapi/weak_object.hpp
@@ -8,26 +8,97 @@
 
 #pragma once
 
-#include <sycl/access/access.hpp>               // for target, mode
-#include <sycl/accessor.hpp>                    // for accessor
-#include <sycl/buffer.hpp>                      // for buffer
-#include <sycl/detail/impl_utils.hpp>           // for createSyc...
-#include <sycl/detail/memcpy.hpp>               // for detail
-#include <sycl/exception.hpp>                   // for make_erro...
-#include <sycl/ext/oneapi/weak_object_base.hpp> // for weak_obje...
-#include <sycl/range.hpp>                       // for range
-#include <sycl/stream.hpp>                      // for stream
-
-#include <memory>   // for shared_ptr
-#include <optional> // for optional
-#include <stddef.h> // for size_t
+#include <memory>
+#include <optional>
+#include <stddef.h>
+#include <sycl/access/access.hpp>
+#include <sycl/accessor.hpp>
+#include <sycl/buffer.hpp>
+#include <sycl/detail/impl_utils.hpp>
+#include <sycl/detail/memcpy.hpp>
+#include <sycl/exception.hpp>
+#include <sycl/range.hpp>
+#include <sycl/stream.hpp>
 
 namespace sycl {
 inline namespace _V1 {
 namespace ext::oneapi {
+template <typename SYCLObjT> class weak_object;
 namespace detail {
-// Import from detail:: into ext::oneapi::detail:: to improve readability later
-using namespace ::sycl::detail;
+using namespace sycl::detail;
+template <typename SYCLObjT> class weak_object_base;
+
+// Helper function for getting the underlying weak_ptr from a weak_object.
+template <typename SYCLObjT>
+decltype(weak_object_base<SYCLObjT>::MObjWeakPtr)
+getSyclWeakObjImpl(const weak_object_base<SYCLObjT> &WeakObj) {
+  return WeakObj.MObjWeakPtr;
+}
+
+// Common base class for weak_object.
+template <typename SYCLObjT> class weak_object_base {
+public:
+  using object_type = SYCLObjT;
+
+  constexpr weak_object_base() noexcept : MObjWeakPtr() {}
+  weak_object_base(const SYCLObjT &SYCLObj) noexcept
+#ifndef __SYCL_DEVICE_ONLY__
+      : MObjWeakPtr(getSyclObjImpl(SYCLObj))
+#endif
+  {
+    (void)SYCLObj;
+  }
+  weak_object_base(const weak_object_base &Other) noexcept = default;
+  weak_object_base(weak_object_base &&Other) noexcept = default;
+
+  weak_object_base &operator=(const weak_object_base &Other) noexcept = default;
+  weak_object_base &operator=(weak_object_base &&Other) noexcept = default;
+
+  void reset() noexcept { MObjWeakPtr.reset(); }
+  void swap(weak_object_base &Other) noexcept {
+    MObjWeakPtr.swap(Other.MObjWeakPtr);
+  }
+
+  bool expired() const noexcept { return MObjWeakPtr.expired(); }
+
+#ifndef __SYCL_DEVICE_ONLY__
+  bool owner_before(const SYCLObjT &Other) const noexcept {
+    return MObjWeakPtr.owner_before(getSyclObjImpl(Other));
+  }
+  bool owner_before(const weak_object_base &Other) const noexcept {
+    return MObjWeakPtr.owner_before(Other.MObjWeakPtr);
+  }
+  SYCLObjT lock() const {
+    std::optional<SYCLObjT> OptionalObj =
+        static_cast<const weak_object<SYCLObjT> *>(this)->try_lock();
+    if (!OptionalObj)
+      throw sycl::exception(sycl::make_error_code(sycl::errc::invalid),
+                            "Referenced object has expired.");
+    return *std::move(OptionalObj);
+  }
+#else
+  // On device calls to these functions are disallowed, so declare them but
+  // don't define them to avoid compilation failures.
+  bool owner_before(const SYCLObjT &Other) const noexcept;
+  bool owner_before(const weak_object_base &Other) const noexcept;
+  std::optional<SYCLObjT> try_lock() const noexcept;
+  SYCLObjT lock() const;
+#endif // __SYCL_DEVICE_ONLY__
+
+protected:
+#ifndef __SYCL_DEVICE_ONLY__
+  // Store a weak variant of the impl in the SYCLObjT.
+  typename std::remove_reference_t<decltype(getSyclObjImpl(
+      std::declval<SYCLObjT>()))>::weak_type MObjWeakPtr;
+#else
+  // On device we may not have an impl, so we pad with an unused void pointer.
+  std::weak_ptr<void> MObjWeakPtr;
+#endif // __SYCL_DEVICE_ONLY__
+
+  template <class Obj>
+  friend decltype(weak_object_base<Obj>::MObjWeakPtr)
+  getSyclWeakObjImpl(const weak_object_base<Obj> &WeakObj);
+};
 
 // Helper for creating ranges for empty weak_objects.
 template <int Dims> static range<Dims> createDummyRange() {
@@ -50,19 +121,18 @@ template <int Dims> static range<Dims> createDummyRange() {
 // weak_object_base class.
 template <typename SYCLObjT>
 class weak_object : public detail::weak_object_base<SYCLObjT> {
+  using weak_object_base = detail::weak_object_base<SYCLObjT>;
+
 public:
-  using object_type = typename detail::weak_object_base<SYCLObjT>::object_type;
+  using object_type = typename weak_object_base::object_type;
 
   constexpr weak_object() noexcept = default;
-  weak_object(const SYCLObjT &SYCLObj) noexcept
-      : detail::weak_object_base<SYCLObjT>(SYCLObj) {}
+  weak_object(const SYCLObjT &SYCLObj) noexcept : weak_object_base(SYCLObj) {}
   weak_object(const weak_object &Other) noexcept = default;
   weak_object(weak_object &&Other) noexcept = default;
 
   weak_object &operator=(const SYCLObjT &SYCLObj) noexcept {
-    // Create weak_ptr from the shared_ptr to SYCLObj's implementation object.
-    this->MObjWeakPtr =
-        detail::weak_object_base<SYCLObjT>::GetWeakImpl(SYCLObj);
+    weak_object_base::operator=(SYCLObj);
     return *this;
   }
   weak_object &operator=(const weak_object &Other) noexcept = default;
@@ -73,20 +143,8 @@ class weak_object : public detail::weak_object_base<SYCLObjT> {
     auto MObjImplPtr = this->MObjWeakPtr.lock();
     if (!MObjImplPtr)
       return std::nullopt;
-    return sycl::detail::createSyclObjFromImpl<SYCLObjT>(MObjImplPtr);
-  }
-  SYCLObjT lock() const {
-    std::optional<SYCLObjT> OptionalObj = try_lock();
-    if (!OptionalObj)
-      throw sycl::exception(sycl::make_error_code(sycl::errc::invalid),
-                            "Referenced object has expired.");
-    return *OptionalObj;
+    return detail::createSyclObjFromImpl<SYCLObjT>(std::move(MObjImplPtr));
   }
-#else
-  // On device calls to these functions are disallowed, so declare them but
-  // don't define them to avoid compilation failures.
-  std::optional<SYCLObjT> try_lock() const noexcept;
-  SYCLObjT lock() const;
 #endif // __SYCL_DEVICE_ONLY__
 };
 
@@ -95,19 +153,18 @@ class weak_object : public detail::weak_object_base<SYCLObjT> {
 template <typename T, int Dimensions, typename AllocatorT>
 class weak_object<buffer<T, Dimensions, AllocatorT>>
     : public detail::weak_object_base<buffer<T, Dimensions, AllocatorT>> {
-private:
+  using weak_object_base =
+      detail::weak_object_base<buffer<T, Dimensions, AllocatorT>>;
   using buffer_type = buffer<T, Dimensions, AllocatorT>;
 
 public:
-  using object_type =
-      typename detail::weak_object_base<buffer_type>::object_type;
+  using object_type = typename weak_object_base::object_type;
 
   constexpr weak_object() noexcept
-      : detail::weak_object_base<buffer_type>(),
-        MRange{detail::createDummyRange<Dimensions>()}, MOffsetInBytes{0},
+      : MRange{detail::createDummyRange<Dimensions>()}, MOffsetInBytes{0},
         MIsSubBuffer{false} {}
   weak_object(const buffer_type &SYCLObj) noexcept
-      : detail::weak_object_base<buffer_type>(SYCLObj), MRange{SYCLObj.Range},
+      : weak_object_base(SYCLObj), MRange{SYCLObj.Range},
         MOffsetInBytes{SYCLObj.OffsetInBytes},
         MIsSubBuffer{SYCLObj.IsSubBuffer} {}
   weak_object(const weak_object &Other) noexcept = default;
@@ -115,8 +172,7 @@ class weak_object<buffer<T, Dimensions, AllocatorT>>
 
   weak_object &operator=(const buffer_type &SYCLObj) noexcept {
     // Create weak_ptr from the shared_ptr to SYCLObj's implementation object.
-    this->MObjWeakPtr = detail::weak_object_base<
-        buffer<T, Dimensions, AllocatorT>>::GetWeakImpl(SYCLObj);
+    weak_object_base::operator=(SYCLObj);
     this->MRange = SYCLObj.Range;
     this->MOffsetInBytes = SYCLObj.OffsetInBytes;
     this->MIsSubBuffer = SYCLObj.IsSubBuffer;
@@ -126,7 +182,7 @@ class weak_object<buffer<T, Dimensions, AllocatorT>>
   weak_object &operator=(weak_object &&Other) noexcept = default;
 
   void swap(weak_object &Other) noexcept {
-    this->MObjWeakPtr.swap(Other.MObjWeakPtr);
+    weak_object_base::swap(Other);
     std::swap(MRange, Other.MRange);
     std::swap(MOffsetInBytes, Other.MOffsetInBytes);
     std::swap(MIsSubBuffer, Other.MIsSubBuffer);
@@ -138,20 +194,9 @@ class weak_object<buffer<T, Dimensions, AllocatorT>>
     if (!MObjImplPtr)
       return std::nullopt;
     // To reconstruct the buffer we use the reinterpret constructor.
-    return buffer_type{MObjImplPtr, MRange, MOffsetInBytes, MIsSubBuffer};
+    return buffer_type{std::move(MObjImplPtr), MRange, MOffsetInBytes,
+                       MIsSubBuffer};
   }
-  buffer_type lock() const {
-    std::optional<buffer_type> OptionalObj = try_lock();
-    if (!OptionalObj)
-      throw sycl::exception(sycl::make_error_code(sycl::errc::invalid),
-                            "Referenced object has expired.");
-    return *OptionalObj;
-  }
-#else
-  // On device calls to these functions are disallowed, so declare them but
-  // don't define them to avoid compilation failures.
-  std::optional<buffer_type> try_lock() const noexcept;
-  buffer_type lock() const;
 #endif // __SYCL_DEVICE_ONLY__
 
 private:
@@ -165,8 +210,10 @@ class weak_object<buffer<T, Dimensions, AllocatorT>>
 // to reconstruct the original stream.
 template <>
 class weak_object<stream> : public detail::weak_object_base<stream> {
+  using weak_object_base = detail::weak_object_base<stream>;
+
 public:
-  using object_type = typename detail::weak_object_base<stream>::object_type;
+  using object_type = typename weak_object_base::object_type;
 
   constexpr weak_object() noexcept : detail::weak_object_base<stream>() {}
   weak_object(const stream &SYCLObj) noexcept
@@ -178,8 +225,7 @@ class weak_object<stream> : public detail::weak_object_base<stream> {
   weak_object(weak_object &&Other) noexcept = default;
 
   weak_object &operator=(const stream &SYCLObj) noexcept {
-    // Create weak_ptr from the shared_ptr to SYCLObj's implementation object.
-    this->MObjWeakPtr = detail::weak_object_base<stream>::GetWeakImpl(SYCLObj);
+    weak_object_base::operator=(SYCLObj);
     MWeakGlobalBuf = SYCLObj.GlobalBuf;
     MWeakGlobalOffset = SYCLObj.GlobalOffset;
     MWeakGlobalFlushBuf = SYCLObj.GlobalFlushBuf;
@@ -189,7 +235,7 @@ class weak_object<stream> : public detail::weak_object_base<stream> {
   weak_object &operator=(weak_object &&Other) noexcept = default;
 
   void swap(weak_object &Other) noexcept {
-    this->MObjWeakPtr.swap(Other.MObjWeakPtr);
+    weak_object_base::swap(Other);
     MWeakGlobalBuf.swap(Other.MWeakGlobalBuf);
     MWeakGlobalOffset.swap(Other.MWeakGlobalOffset);
     MWeakGlobalFlushBuf.swap(Other.MWeakGlobalFlushBuf);
@@ -210,20 +256,9 @@ class weak_object<stream> : public detail::weak_object_base<stream> {
     auto GlobalFlushBuf = MWeakGlobalFlushBuf.try_lock();
     if (!ObjImplPtr || !GlobalBuf || !GlobalOffset || !GlobalFlushBuf)
       return std::nullopt;
-    return stream{ObjImplPtr, *GlobalBuf, *GlobalOffset, *GlobalFlushBuf};
+    return stream{std::move(ObjImplPtr), *std::move(GlobalBuf),
+                  *std::move(GlobalOffset), *std::move(GlobalFlushBuf)};
   }
-  stream lock() const {
-    std::optional<stream> OptionalObj = try_lock();
-    if (!OptionalObj)
-      throw sycl::exception(sycl::make_error_code(sycl::errc::invalid),
-                            "Referenced object has expired.");
-    return *OptionalObj;
-  }
-#else
-  // On device calls to these functions are disallowed, so declare them but
-  // don't define them to avoid compilation failures.
-  std::optional<stream> try_lock() const noexcept;
-  stream lock() const;
 #endif // __SYCL_DEVICE_ONLY__
 
 private:
diff --git a/sycl/include/sycl/ext/oneapi/weak_object_base.hpp b/sycl/include/sycl/ext/oneapi/weak_object_base.hpp
deleted file mode 100644
index 0a037d31f5fe8..0000000000000
--- a/sycl/include/sycl/ext/oneapi/weak_object_base.hpp
+++ /dev/null
@@ -1,85 +0,0 @@
-//==------- weak_object_base.hpp --- SYCL weak objects base class ----------==//
-//
-// 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/detail/impl_utils.hpp> // for getSyclObjImpl
-
-#include <memory>  // for weak_ptr
-#include <utility> // for declval
-
-namespace sycl {
-inline namespace _V1 {
-namespace ext::oneapi::detail {
-template <typename SYCLObjT> class weak_object_base;
-
-// Helper function for getting the underlying weak_ptr from a weak_object.
-template <typename SYCLObjT>
-decltype(weak_object_base<SYCLObjT>::MObjWeakPtr)
-getSyclWeakObjImpl(const weak_object_base<SYCLObjT> &WeakObj) {
-  return WeakObj.MObjWeakPtr;
-}
-
-// Common base class for weak_object.
-template <typename SYCLObjT> class weak_object_base {
-public:
-  using object_type = SYCLObjT;
-
-  constexpr weak_object_base() noexcept : MObjWeakPtr() {}
-  weak_object_base(const SYCLObjT &SYCLObj) noexcept
-      : MObjWeakPtr(GetWeakImpl(SYCLObj)) {}
-  weak_object_base(const weak_object_base &Other) noexcept = default;
-  weak_object_base(weak_object_base &&Other) noexcept = default;
-
-  weak_object_base &operator=(const weak_object_base &Other) noexcept = default;
-  weak_object_base &operator=(weak_object_base &&Other) noexcept = default;
-
-  void reset() noexcept { MObjWeakPtr.reset(); }
-  void swap(weak_object_base &Other) noexcept {
-    MObjWeakPtr.swap(Other.MObjWeakPtr);
-  }
-
-  bool expired() const noexcept { return MObjWeakPtr.expired(); }
-
-#ifndef __SYCL_DEVICE_ONLY__
-  bool owner_before(const SYCLObjT &Other) const noexcept {
-    return MObjWeakPtr.owner_before(GetWeakImpl(Other));
-  }
-  bool owner_before(const weak_object_base &Other) const noexcept {
-    return MObjWeakPtr.owner_before(Other.MObjWeakPtr);
-  }
-#else
-  // On device calls to these functions are disallowed, so declare them but
-  // don't define them to avoid compilation failures.
-  bool owner_before(const SYCLObjT &Other) const noexcept;
-  bool owner_before(const weak_object_base &Other) const noexcept;
-#endif // __SYCL_DEVICE_ONLY__
-
-protected:
-#ifndef __SYCL_DEVICE_ONLY__
-  // Store a weak variant of the impl in the SYCLObjT.
-  typename std::remove_reference<decltype(sycl::detail::getSyclObjImpl(
-      std::declval<SYCLObjT>()))>::type::weak_type MObjWeakPtr;
-  // relies on <type_traits> from impl_utils.h
-
-  static decltype(MObjWeakPtr) GetWeakImpl(const SYCLObjT &SYCLObj) {
-    return sycl::detail::getSyclObjImpl(SYCLObj);
-  }
-#else
-  // On device we may not have an impl, so we pad with an unused void pointer.
-  std::weak_ptr<void> MObjWeakPtr;
-  static std::weak_ptr<void> GetWeakImpl(const SYCLObjT &) { return {}; }
-#endif // __SYCL_DEVICE_ONLY__
-
-  template <class Obj>
-  friend decltype(weak_object_base<Obj>::MObjWeakPtr)
-  detail::getSyclWeakObjImpl(const weak_object_base<Obj> &WeakObj);
-};
-} // namespace ext::oneapi::detail
-} // namespace _V1
-} // namespace sycl
diff --git a/sycl/test/include_deps/sycl_accessor.hpp.cpp b/sycl/test/include_deps/sycl_accessor.hpp.cpp
index dd840412208fe..c798e9e61594a 100644
--- a/sycl/test/include_deps/sycl_accessor.hpp.cpp
+++ b/sycl/test/include_deps/sycl_accessor.hpp.cpp
@@ -22,7 +22,6 @@
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/property_helper.hpp
 // CHECK-NEXT: detail/stl_type_traits.hpp
 // CHECK-NEXT: detail/sycl_mem_obj_allocator.hpp
diff --git a/sycl/test/include_deps/sycl_buffer.hpp.cpp b/sycl/test/include_deps/sycl_buffer.hpp.cpp
index 12d211f8d4c78..c03e8f2bf54b2 100644
--- a/sycl/test/include_deps/sycl_buffer.hpp.cpp
+++ b/sycl/test/include_deps/sycl_buffer.hpp.cpp
@@ -21,7 +21,6 @@
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/property_helper.hpp
 // CHECK-NEXT: detail/stl_type_traits.hpp
 // CHECK-NEXT: detail/sycl_mem_obj_allocator.hpp
diff --git a/sycl/test/include_deps/sycl_detail_core.hpp.cpp b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
index 2544bc16485d5..d7a7ef1df6977 100644
--- a/sycl/test/include_deps/sycl_detail_core.hpp.cpp
+++ b/sycl/test/include_deps/sycl_detail_core.hpp.cpp
@@ -23,7 +23,6 @@
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/property_helper.hpp
 // CHECK-NEXT: detail/stl_type_traits.hpp
 // CHECK-NEXT: detail/sycl_mem_obj_allocator.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_accessor.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_accessor.hpp.cpp
index a1a38799db472..f432dda6e120f 100644
--- a/sycl/test/include_deps/sycl_khr_includes_accessor.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_accessor.hpp.cpp
@@ -25,7 +25,6 @@
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/property_helper.hpp
 // CHECK-NEXT: detail/stl_type_traits.hpp
 // CHECK-NEXT: detail/sycl_mem_obj_allocator.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_buffer.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_buffer.hpp.cpp
index dfc7660cef8a6..fa1bc92da4eab 100644
--- a/sycl/test/include_deps/sycl_khr_includes_buffer.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_buffer.hpp.cpp
@@ -24,7 +24,6 @@
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/property_helper.hpp
 // CHECK-NEXT: detail/stl_type_traits.hpp
 // CHECK-NEXT: detail/sycl_mem_obj_allocator.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_context.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_context.hpp.cpp
index c8988bfcf3ee3..fe0a8480b614f 100644
--- a/sycl/test/include_deps/sycl_khr_includes_context.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_context.hpp.cpp
@@ -55,7 +55,6 @@
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
 // CHECK-NEXT: __spirv/spirv_vars.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: property_list.hpp
 // CHECK-NEXT: detail/property_helper.hpp
 // CHECK-NEXT: detail/property_list_base.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_device.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_device.hpp.cpp
index 2350e00e05679..2eb64477da672 100644
--- a/sycl/test/include_deps/sycl_khr_includes_device.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_device.hpp.cpp
@@ -54,7 +54,6 @@
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
 // CHECK-NEXT: __spirv/spirv_vars.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/string.hpp
 // CHECK-NEXT: detail/string_view.hpp
 // CHECK-NEXT: detail/util.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_event.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_event.hpp.cpp
index f3666f1f6f5c5..99c6c12fffc12 100644
--- a/sycl/test/include_deps/sycl_khr_includes_event.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_event.hpp.cpp
@@ -54,5 +54,4 @@
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
 // CHECK-NEXT: __spirv/spirv_vars.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-EMPTY:
diff --git a/sycl/test/include_deps/sycl_khr_includes_handler.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_handler.hpp.cpp
index 94b3cbf15d8d1..87677acc750b6 100644
--- a/sycl/test/include_deps/sycl_khr_includes_handler.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_handler.hpp.cpp
@@ -26,7 +26,6 @@
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/property_helper.hpp
 // CHECK-NEXT: detail/stl_type_traits.hpp
 // CHECK-NEXT: detail/sycl_mem_obj_allocator.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_images.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_images.hpp.cpp
index f02b4c715939c..5c4ae6c18a224 100644
--- a/sycl/test/include_deps/sycl_khr_includes_images.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_images.hpp.cpp
@@ -26,7 +26,6 @@
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/property_helper.hpp
 // CHECK-NEXT: detail/stl_type_traits.hpp
 // CHECK-NEXT: detail/sycl_mem_obj_allocator.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_interop_handle.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_interop_handle.hpp.cpp
index 6525fc0698526..4204838c5efbb 100644
--- a/sycl/test/include_deps/sycl_khr_includes_interop_handle.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_interop_handle.hpp.cpp
@@ -26,7 +26,6 @@
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/property_helper.hpp
 // CHECK-NEXT: detail/stl_type_traits.hpp
 // CHECK-NEXT: detail/sycl_mem_obj_allocator.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_kernel_bundle.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_kernel_bundle.hpp.cpp
index a1ebb06b56591..88abb84172b02 100644
--- a/sycl/test/include_deps/sycl_khr_includes_kernel_bundle.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_kernel_bundle.hpp.cpp
@@ -54,7 +54,6 @@
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
 // CHECK-NEXT: __spirv/spirv_vars.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/util.hpp
 // CHECK-NEXT: detail/string.hpp
 // CHECK-NEXT: kernel_bundle_enums.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_platform.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_platform.hpp.cpp
index 817134cc3ceee..2cb58efd1f318 100644
--- a/sycl/test/include_deps/sycl_khr_includes_platform.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_platform.hpp.cpp
@@ -54,7 +54,6 @@
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
 // CHECK-NEXT: __spirv/spirv_vars.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/string.hpp
 // CHECK-NEXT: detail/string_view.hpp
 // CHECK-NEXT: detail/util.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_queue.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_queue.hpp.cpp
index cf2ff1ec5bbac..33b72df1eb7d4 100644
--- a/sycl/test/include_deps/sycl_khr_includes_queue.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_queue.hpp.cpp
@@ -30,7 +30,6 @@
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/stl_type_traits.hpp
 // CHECK-NEXT: detail/sycl_mem_obj_allocator.hpp
 // CHECK-NEXT: detail/aligned_allocator.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_reduction.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_reduction.hpp.cpp
index 53e1da9695d09..ea1a20dfecf1e 100644
--- a/sycl/test/include_deps/sycl_khr_includes_reduction.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_reduction.hpp.cpp
@@ -29,7 +29,6 @@
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/stl_type_traits.hpp
 // CHECK-NEXT: detail/sycl_mem_obj_allocator.hpp
 // CHECK-NEXT: detail/aligned_allocator.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_stream.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_stream.hpp.cpp
index 7feda0438dee3..8931397378402 100644
--- a/sycl/test/include_deps/sycl_khr_includes_stream.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_stream.hpp.cpp
@@ -26,7 +26,6 @@
 // CHECK-NEXT: detail/is_device_copyable.hpp
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/property_helper.hpp
 // CHECK-NEXT: detail/stl_type_traits.hpp
 // CHECK-NEXT: detail/sycl_mem_obj_allocator.hpp
diff --git a/sycl/test/include_deps/sycl_khr_includes_usm.hpp.cpp b/sycl/test/include_deps/sycl_khr_includes_usm.hpp.cpp
index 7b0becee030d4..c181cfd5dca2a 100644
--- a/sycl/test/include_deps/sycl_khr_includes_usm.hpp.cpp
+++ b/sycl/test/include_deps/sycl_khr_includes_usm.hpp.cpp
@@ -78,7 +78,6 @@
 // CHECK-NEXT: info/ext_oneapi_kernel_queue_specific_traits.def
 // CHECK-NEXT: detail/owner_less_base.hpp
 // CHECK-NEXT: detail/impl_utils.hpp
-// CHECK-NEXT: ext/oneapi/weak_object_base.hpp
 // CHECK-NEXT: detail/string.hpp
 // CHECK-NEXT: detail/string_view.hpp
 // CHECK-NEXT: detail/util.hpp